How to fix UNAVAILABLE: The service is experiencing an outage in Firebase

# Test basic internet connectivity
ping google.com

# Test DNS resolution for Firebase
nslookup firebaseio.com
nslookup firestore.googleapis.com

# Test network latency to Firebase
curl -w "%{time_total}\n" -o /dev/null -s https://firebaseio.com

import { getFirestore, collection, getDocs } from "firebase/firestore";

const MAX_RETRIES = 5;
const INITIAL_DELAY_MS = 1000; // Start with 1 second

async function fetchWithRetry(operation, retryCount = 0) {
  try {
    return await operation();
  } catch (error) {
    // Check if error is UNAVAILABLE (code 14 or firestore/unavailable)
    const isUnavailable = 
      error.code === "unavailable" || 
      error.code === "firestore/unavailable" ||
      error.message?.includes("UNAVAILABLE");

    if (isUnavailable && retryCount < MAX_RETRIES) {
      const delayMs = INITIAL_DELAY_MS * Math.pow(2, retryCount);
      console.log(`Retrying in ${delayMs}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`);
      
      // Wait before retrying
      await new Promise(resolve => setTimeout(resolve, delayMs));
      
      // Recursively retry with exponential backoff
      return fetchWithRetry(operation, retryCount + 1);
    } else if (isUnavailable) {
      throw new Error(`Service unavailable after ${MAX_RETRIES} retries. Please try again later.`);
    }
    
    // Re-throw non-UNAVAILABLE errors
    throw error;
  }
}

// Usage example:
async function getUsers() {
  const db = getFirestore();
  const usersRef = collection(db, "users");
  
  return fetchWithRetry(() => getDocs(usersRef));
}

getUsers()
  .then(snapshot => console.log("Success:", snapshot.size))
  .catch(error => console.error("Failed:", error.message));

const admin = require("firebase-admin");

const MAX_RETRIES = 5;
const INITIAL_DELAY_MS = 1000;

async function firebaseOperationWithRetry(operation, retryCount = 0) {
  try {
    return await operation();
  } catch (error) {
    const isUnavailable = 
      error.code === "unavailable" ||
      error.message?.includes("UNAVAILABLE") ||
      error.message?.includes("Could not reach Cloud Firestore");

    if (isUnavailable && retryCount < MAX_RETRIES) {
      const delayMs = INITIAL_DELAY_MS * Math.pow(2, retryCount);
      console.log(`Retrying in ${delayMs}ms...`);
      await new Promise(resolve => setTimeout(resolve, delayMs));
      return firebaseOperationWithRetry(operation, retryCount + 1);
    } else if (isUnavailable) {
      throw new Error(`Firebase unavailable after ${MAX_RETRIES} retries`);
    }
    throw error;
  }
}

// Usage:
const db = admin.firestore();

firebaseOperationWithRetry(() => 
  db.collection("users").doc("user1").get()
)
  .then(doc => console.log("User:", doc.data()))
  .catch(error => console.error("Error:", error.message));

// React Native Firebase
import firestore from '@react-native-firebase/firestore';

const getDataWithRetry = async (collectionPath, maxRetries = 5) => {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const snapshot = await firestore()
        .collection(collectionPath)
        .get()
        .timeout(10000); // 10 second timeout
      
      return snapshot;
    } catch (error) {
      if (error.code === "UNAVAILABLE" && i < maxRetries - 1) {
        const delay = 1000 * Math.pow(2, i);
        console.log(`Retry ${i + 1}/${maxRetries} after ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

import { initializeApp } from "firebase/app";
import { getFirestore, terminate } from "firebase/firestore";

const firebaseConfig = { /* your config */ };
const app = initializeApp(firebaseConfig);
let db = getFirestore(app);

// If encountering UNAVAILABLE errors:
async function resetFirebaseConnection() {
  try {
    console.log("Disconnecting from Firebase...");
    await terminate(db);
    
    // Wait 2 seconds for cleanup
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    console.log("Reconnecting to Firebase...");
    db = getFirestore(app);
    
    // Test the connection
    const testRef = collection(db, "__test__");
    await getDocs(query(testRef, limit(1)));
    
    console.log("Firebase connection re-established");
  } catch (error) {
    console.error("Failed to reset Firebase connection:", error);
  }
}

// Call this function when you detect UNAVAILABLE errors
await resetFirebaseConnection();

const admin = require("firebase-admin");

async function resetFirebaseAdmin() {
  try {
    console.log("Shutting down Firestore instance...");
    await admin.firestore().terminate();
    
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    console.log("Reinitializing Firestore...");
    // Automatically re-initializes on next operation
    const testDoc = await admin.firestore()
      .collection("__test__")
      .limit(1)
      .get();
    
    console.log("Firestore re-initialized successfully");
  } catch (error) {
    console.error("Reset failed:", error);
  }
}

# Web/Node.js
npm install firebase@latest

# Or for specific packages
npm install firebase-admin@latest

# Check installed version
npm list firebase

// Check which version is loaded
import { SDK_VERSION } from "firebase/app";
console.log("Firebase SDK version:", SDK_VERSION);

// Old (v8) - may cause UNAVAILABLE errors
import firebase from "firebase/app";
import "firebase/firestore";
const db = firebase.firestore();

// New (v9+) - better error handling
import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";
const app = initializeApp(config);
const db = getFirestore(app);

# Start emulator with explicit DNS server
firebase emulators:start --import=./exported_data

# If that doesn't work, configure Android emulator DNS:
./emulator @Pixel_4_API_30 -dns-server 8.8.8.8

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  projectId: "demo-project",
  // Other config...
};

if (process.env.NODE_ENV === "development") {
  // When using emulator
  connectFirestoreEmulator(db, "localhost", 8080);
  // Ensure projectId matches FIREBASE_PROJECT_ID env var
}

docker run -p 9000:9000 -p 8080:8080 \
  -e FIREBASE_EMULATOR_HOST=localhost:8080 \
  firebase/firebase-tools:latest \
  emulators:start --import=./data

const admin = require("firebase-admin");
const serviceAccount = require("./path/to/serviceAccountKey.json");

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  databaseURL: "https://your-project.firebaseio.com"
});

// Test connection
admin.firestore()
  .collection("__test__")
  .doc("test")
  .set({ test: true })
  .then(() => console.log("Credentials valid"))
  .catch(error => {
    if (error.message.includes("unavailable")) {
      console.error("Service account valid but Firebase unavailable");
    } else if (error.message.includes("permission")) {
      console.error("Service account lacks permissions");
    }
  });

import { getFirestore, collection, getDocs } from "firebase/firestore";

const errorLog = [];

async function monitoredFirebaseOperation(operationName, operation) {
  const startTime = Date.now();
  
  try {
    const result = await operation();
    console.log(`✓ ${operationName} succeeded in ${Date.now() - startTime}ms`);
    return result;
  } catch (error) {
    const duration = Date.now() - startTime;
    const errorRecord = {
      timestamp: new Date().toISOString(),
      operation: operationName,
      errorCode: error.code,
      errorMessage: error.message,
      duration,
      userAgent: navigator.userAgent,
      networkStatus: navigator.onLine
    };
    
    errorLog.push(errorRecord);
    
    // Log to console with details
    console.error(`✗ ${operationName} failed:", {
      ...errorRecord,
      stack: error.stack
    });
    
    // Send to error tracking service
    if (window.__errorTracker) {
      window.__errorTracker.captureException(error, { 
        contexts: { firebase: errorRecord } 
      });
    }
    
    throw error;
  }
}

// Usage:
async function getUsers() {
  const db = getFirestore();
  return monitoredFirebaseOperation(
    "fetchUsers",
    () => getDocs(collection(db, "users"))
  );
}

// Send error logs to your backend periodically
setInterval(() => {
  if (errorLog.length > 0) {
    fetch("/api/log-errors", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ errors: errorLog.splice(0) }) // Clear log after sending
    }).catch(err => console.error("Failed to send error logs:", err));
  }
}, 60000); // Send every minute