How to fix messaging/UNAVAILABLE: Server overloaded in Firebase

// Node.js example with Firebase Admin SDK
const admin = require('firebase-admin');

async function sendWithRetry(message, maxRetries = 5) {
  let retryCount = 0;
  let delay = 1000; // Start with 1 second

  while (retryCount < maxRetries) {
    try {
      const response = await admin.messaging().send(message);
      console.log('Successfully sent message:', response);
      return response;
    } catch (error) {
      if (error.code === 'messaging/unavailable' ||
          error.code === 'messaging/internal-error') {
        retryCount++;

        if (retryCount >= maxRetries) {
          console.error('Max retries reached:', error);
          throw error;
        }

        // Add jitter (randomness) to prevent thundering herd
        const jitter = Math.random() * 1000;
        const waitTime = delay + jitter;

        console.log(`Retry ${retryCount}/${maxRetries} after ${Math.round(waitTime)}ms`);
        await new Promise(resolve => setTimeout(resolve, waitTime));

        // Exponential backoff: double the delay each time
        delay *= 2;
      } else {
        // Different error, don't retry
        throw error;
      }
    }
  }
}

// Usage
const message = {
  notification: {
    title: 'Hello',
    body: 'World'
  },
  token: 'device-token-here'
};

sendWithRetry(message);

async function sendWithRetryAfterHeader(message) {
  try {
    const response = await admin.messaging().send(message);
    return response;
  } catch (error) {
    if (error.code === 'messaging/unavailable') {
      // Check if there's a Retry-After header in the error details
      const retryAfter = error.errorInfo?.retry_after;

      if (retryAfter) {
        const waitMs = parseInt(retryAfter) * 1000;
        console.log(`Server requested retry after ${retryAfter}s`);
        await new Promise(resolve => setTimeout(resolve, waitMs));

        // Retry once after waiting
        return await admin.messaging().send(message);
      }
    }
    throw error;
  }
}

// Example using p-queue for rate limiting
const PQueue = require('p-queue').default;

class FCMSender {
  constructor() {
    // Limit to 100 concurrent requests
    this.queue = new PQueue({
      concurrency: 100,
      interval: 1000, // 1 second
      intervalCap: 500 // Max 500 messages per second
    });
  }

  async sendMessage(message) {
    return this.queue.add(async () => {
      return await admin.messaging().send(message);
    });
  }

  async sendBatch(messages) {
    const promises = messages.map(msg => this.sendMessage(msg));
    return Promise.allSettled(promises);
  }
}

// Usage
const sender = new FCMSender();
await sender.sendBatch(arrayOfMessages);

// Send to multiple devices efficiently
async function sendBatchNotifications(tokens, notification) {
  const messages = tokens.map(token => ({
    notification: notification,
    token: token
  }));

  // Send up to 500 messages at once
  const batchSize = 500;
  const results = [];

  for (let i = 0; i < messages.length; i += batchSize) {
    const batch = messages.slice(i, i + batchSize);

    try {
      const response = await admin.messaging().sendEach(batch);
      results.push(response);

      console.log(`Batch sent: ${response.successCount} succeeded, ${response.failureCount} failed`);

      // Small delay between batches
      if (i + batchSize < messages.length) {
        await new Promise(resolve => setTimeout(resolve, 100));
      }
    } catch (error) {
      console.error('Batch send failed:', error);
      // Implement retry logic here
    }
  }

  return results;
}