How to fix messaging/UNSPECIFIED_ERROR: No additional information available in Firebase

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

async function sendNotificationWithLogging(token, message) {
  try {
    console.log('Sending FCM message:', {
      token: token.substring(0, 20) + '...',
      timestamp: new Date().toISOString(),
      message: message
    });

    const response = await admin.messaging().send({
      token: token,
      notification: {
        title: message.title,
        body: message.body
      },
      data: message.data || {}
    });

    console.log('FCM send successful:', response);
    return response;

  } catch (error) {
    // Log the ENTIRE error object, not just the message
    console.error('FCM send failed:', {
      code: error.code,
      message: error.message,
      errorInfo: error.errorInfo,
      codePrefix: error.codePrefix,
      fullError: JSON.stringify(error, null, 2),
      stack: error.stack,
      timestamp: new Date().toISOString(),
      tokenHash: hashToken(token),
      messageSize: JSON.stringify(message).length
    });

    // For production, send to error tracking service
    if (process.env.NODE_ENV === 'production') {
      await sendToErrorTracker({
        service: 'fcm',
        errorCode: error.code,
        message: error.message,
        token: hashToken(token),
        context: {
          timestamp: new Date().toISOString(),
          messageSize: JSON.stringify(message).length
        }
      });
    }

    throw error;
  }
}

function hashToken(token) {
  const crypto = require('crypto');
  return crypto.createHash('sha256').update(token).digest('hex');
}

// Set Firebase debug logging to see internal FCM communication
process.env.DEBUG = 'firebase-admin:*';
// or for Firestore/Realtime Database
process.env.DEBUG_SKIP_FRAMEWORK_CHECKS = 'true';

const admin = require('firebase-admin');
admin.initializeApp({
  // config...
});

// Also log all FCM calls
const originalSend = admin.messaging().send;
admin.messaging().send = async function(message) {
  console.log('[FCM SEND]', JSON.stringify(message, null, 2));
  try {
    const result = await originalSend.call(this, message);
    console.log('[FCM SUCCESS]', result);
    return result;
  } catch (error) {
    console.error('[FCM ERROR]', {
      code: error.code,
      message: error.message,
      fullError: error
    });
    throw error;
  }
};

const admin = require('firebase-admin');
const serviceAccount = require('./service-account-key.json');

// Initialize with explicit error handling
try {
  admin.initializeApp({
    credential: admin.credential.cert(serviceAccount),
    projectId: serviceAccount.project_id
  });

  console.log('Firebase initialized successfully');
  console.log('Project ID:', admin.app().options.projectId);

  // Verify Messaging API is available
  const messaging = admin.messaging();
  console.log('Messaging API available:', !!messaging);

  // Test sending to a test token (use a token you know is valid)
  // WARNING: Only use actual valid tokens from real apps
  const testToken = process.env.TEST_FCM_TOKEN;
  if (!testToken) {
    console.warn('No TEST_FCM_TOKEN set. Skipping test send.');
  }

} catch (error) {
  console.error('Firebase initialization failed:', error);
  process.exit(1);
}

TEST_FCM_TOKEN=your_valid_fcm_token_here

function validateFCMMessage(message) {
  const errors = [];

  // Check required fields
  if (!message.token && !message.topic && !message.condition) {
    errors.push('Message must include token, topic, or condition');
  }

  // Validate token format if present
  if (message.token && typeof message.token !== 'string') {
    errors.push('Token must be a string');
  }
  if (message.token && message.token.length < 100) {
    errors.push('Token appears too short (min ~150 chars)');
  }

  // Check notification structure
  if (message.notification) {
    if (typeof message.notification !== 'object') {
      errors.push('Notification must be an object');
    }
    if (message.notification.title && typeof message.notification.title !== 'string') {
      errors.push('Notification title must be string');
    }
    if (message.notification.title && message.notification.title.length > 4096) {
      errors.push('Notification title exceeds 4096 chars');
    }
    if (message.notification.body && message.notification.body.length > 4096) {
      errors.push('Notification body exceeds 4096 chars');
    }
  }

  // Check data structure
  if (message.data) {
    if (typeof message.data !== 'object' || Array.isArray(message.data)) {
      errors.push('Data must be a key-value object');
    }
    for (const [key, value] of Object.entries(message.data)) {
      if (typeof key !== 'string' || key.length > 1000) {
        errors.push(`Data key "${key}" invalid (max 1000 chars)`);
      }
      if (typeof value !== 'string' || value.length > 1000) {
        errors.push(`Data value for key "${key}" invalid (max 1000 chars)`);
      }
    }
  }

  // Check total payload size
  const totalSize = JSON.stringify(message).length;
  if (totalSize > 4096) {
    errors.push(`Total payload size ${totalSize} exceeds 4096 bytes`);
  }

  // Check for invalid characters in strings
  const messageStr = JSON.stringify(message);
  if (/[\x00-\x1F]\\[^ntrfb]/.test(messageStr)) {
    errors.push('Message contains invalid control characters');
  }

  return {
    isValid: errors.length === 0,
    errors,
    payloadSize: totalSize
  };
}

// Usage
const message = {
  token: userToken,
  notification: {
    title: 'Hello',
    body: 'World'
  },
  data: {
    customKey: 'customValue'
  }
};

const validation = validateFCMMessage(message);
if (!validation.isValid) {
  console.error('Invalid FCM message:', validation.errors);
  throw new Error('FCM message validation failed');
}

console.log('Message valid, size:', validation.payloadSize, 'bytes');

const https = require('https');
const http = require('http');

async function testFirebaseConnectivity() {
  console.log('Testing Firebase connectivity...');

  // Test DNS resolution for FCM endpoint
  const dns = require('dns').promises;
  try {
    const addresses = await dns.resolve4('fcm.googleapis.com');
    console.log('FCM DNS resolves to:', addresses);
  } catch (error) {
    console.error('FCM DNS resolution failed:', error.message);
    return false;
  }

  // Test HTTPS connection to FCM
  return new Promise((resolve) => {
    const options = {
      hostname: 'fcm.googleapis.com',
      path: '/',
      method: 'HEAD',
      timeout: 5000
    };

    https.request(options, (res) => {
      console.log('FCM connectivity test status:', res.statusCode);
      resolve(res.statusCode < 500);
    }).on('error', (err) => {
      console.error('FCM connectivity test failed:', err.message);
      resolve(false);
    }).on('timeout', () => {
      console.error('FCM connectivity test timed out');
      resolve(false);
    }).end();
  });
}

// Test connectivity before production traffic
const isConnected = await testFirebaseConnectivity();
if (!isConnected) {
  console.error('Cannot reach Firebase. Check network/firewall settings.');
  process.exit(1);
}

// For Railway or cloud deployments, also check outbound firewall rules
console.log('Environment:', process.env.NODE_ENV);
console.log('Network interface:', process.env.NETWORK_INTERFACE || 'default');

// Test with actual (minimal) FCM send
const testSend = async () => {
  try {
    // Use a test topic that doesn't require a real token
    const response = await admin.messaging().send({
      topic: 'test-connectivity',
      data: { test: 'message' }
    });
    console.log('Test FCM send succeeded:', response);
    return true;
  } catch (error) {
    if (error.code === 'messaging/invalid-argument') {
      // Topic validation failed, but connectivity worked
      console.log('Connectivity OK (invalid topic expected)');
      return true;
    }
    console.error('Test FCM send failed:', error.code, error.message);
    return false;
  }
};

const canSend = await testSend();
if (!canSend) {
  console.error('Cannot send FCM messages. Check credentials/permissions.');
  process.exit(1);
}

const MAX_RETRIES = 3;
const BASE_DELAY_MS = 1000;
const MAX_DELAY_MS = 10000;

async function sendWithRetry(token, message, retryCount = 0) {
  try {
    const response = await admin.messaging().send({
      token,
      notification: message.notification,
      data: message.data
    });

    console.log('Send successful on attempt', retryCount + 1);
    return response;

  } catch (error) {
    // Don't retry for errors we know won't be fixed by retrying
    if (error.code === 'messaging/invalid-registration-token' ||
        error.code === 'messaging/registration-token-not-registered' ||
        error.code === 'messaging/mismatched-credential') {
      console.error('Non-retryable error:', error.code);
      throw error;
    }

    // Retry for transient errors (including UNSPECIFIED_ERROR)
    if (retryCount < MAX_RETRIES) {
      // Calculate exponential backoff with jitter
      const baseDelay = Math.min(
        BASE_DELAY_MS * Math.pow(2, retryCount),
        MAX_DELAY_MS
      );
      const jitter = Math.random() * 1000;
      const delay = baseDelay + jitter;

      console.warn(`Send failed with ${error.code}. Retrying in ${Math.round(delay)}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));

      return sendWithRetry(token, message, retryCount + 1);
    }

    // All retries exhausted
    console.error('Send failed after', MAX_RETRIES, 'retries:', error.code);
    throw error;
  }
}

// Usage in your send endpoint
app.post('/api/send-notification', async (req, res) => {
  try {
    const response = await sendWithRetry(req.body.token, req.body.message);
    res.json({ success: true, messageId: response });
  } catch (error) {
    console.error('Final send failure:', error.message);
    res.status(500).json({ error: error.message });
  }
});

// For batch sends, implement circuit breaker pattern
const sendBatchWithRetry = async (tokens, message) => {
  const results = {
    succeeded: [],
    failed: [],
    failedWithRetry: []
  };

  for (const token of tokens) {
    try {
      const response = await sendWithRetry(token, message);
      results.succeeded.push({ token, messageId: response });
    } catch (error) {
      results.failed.push({ token, error: error.code });

      // If too many failures, stop sending to avoid cascading errors
      if (results.failed.length > tokens.length * 0.2) {
        console.error('Batch failure rate exceeded 20%. Stopping batch.');
        break;
      }
    }
  }

  return results;
};

# Check current Firebase Admin SDK version
npm list firebase-admin

# Upgrade to latest
npm install firebase-admin@latest

# For Node.js SDK, also check minimum version requirements
npm list

# Verify Node.js version is supported by Firebase
node --version
# Firebase Admin SDK requires Node.js 14+, but 16+ is recommended

// Create a test script
const admin = require('firebase-admin');

async function testFCMAfterUpgrade() {
  const results = {
    sdkVersion: admin.SDK_VERSION,
    tests: []
  };

  // Test 1: Basic initialization
  try {
    const app = admin.app();
    results.tests.push({
      name: 'Firebase initialization',
      status: 'PASS',
      message: app.name
    });
  } catch (error) {
    results.tests.push({
      name: 'Firebase initialization',
      status: 'FAIL',
      message: error.message
    });
  }

  // Test 2: Messaging API availability
  try {
    const messaging = admin.messaging();
    results.tests.push({
      name: 'Messaging API availability',
      status: 'PASS',
      message: 'Messaging API available'
    });
  } catch (error) {
    results.tests.push({
      name: 'Messaging API availability',
      status: 'FAIL',
      message: error.message
    });
  }

  // Test 3: Send to topic (no token required)
  try {
    await admin.messaging().send({
      topic: 'test',
      notification: { title: 'Test' }
    });
    results.tests.push({
      name: 'Send to topic',
      status: 'PASS'
    });
  } catch (error) {
    results.tests.push({
      name: 'Send to topic',
      status: error.code === 'messaging/invalid-argument' ? 'PASS' : 'FAIL',
      message: error.code
    });
  }

  console.log('Firebase Upgrade Test Results:', JSON.stringify(results, null, 2));
  return results;
}

testFCMAfterUpgrade();