Confira tudo que foi anunciado no Firebase Summit e veja como usar o Firebase para acelerar o desenvolvimento de apps e executar os aplicativos com confiança. Saiba mais

Erros de relatório

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Relatando erros automaticamente

Você pode emitir um erro de uma Cloud Function para o Error Reporting conforme mostrado abaixo:

Node.js

// These WILL be reported to Error Reporting
throw new Error('I failed you'); // Will cause a cold start if not caught

// These WILL be reported to Error Reporting
console.error(new Error('I failed you')); // Logging an Error object
console.error('I failed you'); // Logging something other than an Error object
throw 1; // Throwing something other than an Error object
callback('I failed you');
res.status(500).send('I failed you');

Se desejar relatórios de erros mais refinados, você pode usar as bibliotecas de cliente do Error Reporting .

Você pode visualizar os erros relatados no Error Reporting no Console do GCP. Você também pode ver os erros relatados de uma função específica ao selecioná-la na lista de funções no Console do GCP.

Exceções não detectadas produzidas por sua função aparecerão no Error Reporting. Observe que alguns tipos de exceções não detectadas (como aquelas lançadas de forma assíncrona) farão com que ocorra uma inicialização a frio em uma chamada de função futura. Isso aumenta a quantidade de tempo que sua função levará para ser executada.

Relatar erros manualmente

Para relatar um erro ao Error Reporting de uma função, use a API Cloud Logging .

Importando dependências

No diretório de functions , instale a biblioteca cliente do Cloud Logging para Node.js:

npm install --save @google-cloud/logging

Importe e inicialize a biblioteca de cliente do Cloud Logging:

const Logging = require('@google-cloud/logging');

// Instantiates a client
const logging = Logging();

Enviando para o Cloud Logging

Uma entrada de log devidamente formada requer um objeto MonitoredResource e um objeto ErrorEvent .

Este exemplo de função reportError demonstra os dados mínimos necessários para relatar um erro ao Error Reporting.

function reportError(err, context = {}) {
  // This is the name of the log stream that will receive the log
  // entry. This name can be any valid log stream name, but must contain "err"
  // in order for the error to be picked up by Error Reporting.
  const logName = 'errors';
  const log = logging.log(logName);

  // https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/MonitoredResource
  const metadata = {
    resource: {
      type: 'cloud_function',
      labels: { function_name: process.env.FUNCTION_NAME },
    },
  };

  // https://cloud.google.com/error-reporting/reference/rest/v1beta1/ErrorEvent
  const errorEvent = {
    message: err.stack,
    serviceContext: {
      service: process.env.FUNCTION_NAME,
      resourceType: 'cloud_function',
    },
    context: context,
  };

  // Write the error log entry
  return new Promise((resolve, reject) => {
    log.write(log.entry(metadata, errorEvent), (error) => {
      if (error) {
        return reject(error);
      }
      return resolve();
    });
  });
}

A função reportError pode ser usada para relatar erros manualmente:

exports.createStripePayment = functions.firestore
  .document('stripe_customers/{userId}/payments/{pushId}')
  .onCreate(async (snap, context) => {
    const { amount, currency, payment_method } = snap.data();
    try {
      // Look up the Stripe customer id.
      const customer = (await snap.ref.parent.parent.get()).data().customer_id;
      // Create a charge using the pushId as the idempotency key
      // to protect against double charges.
      const idempotencyKey = context.params.pushId;
      const payment = await stripe.paymentIntents.create(
        {
          amount,
          currency,
          customer,
          payment_method,
          off_session: false,
          confirm: true,
          confirmation_method: 'manual',
        },
        { idempotencyKey }
      );
      // If the result is successful, write it back to the database.
      await snap.ref.set(payment);
    } catch (error) {
      // We want to capture errors and render them in a user-friendly way, while
      // still logging an exception to Error Reporting.
      functions.logger.log(error);
      await snap.ref.set({ error: userFacingMessage(error) }, { merge: true });
      await reportError(error, { user: context.params.userId });
    }
  });

Você pode passar detalhes do usuário por meio do parâmetro ErrorContext . A interface do usuário do Error Reporting exibe esses detalhes e os usa para calcular o número de usuários afetados.

ErrorContext também pode receber informações em uma solicitação HTTP :

export.httpError = functions.https.onRequest((request, response) => {
  const error = new Error('Test error');
  const httpRequest = {
    method: request.method,
    url: request.originalUrl,
    userAgent: request.get('user-agent'),
    referrer: '',
    remoteIp: request.ip
  };
  reportError(error, {httpRequest}).then(() => {
    response.end();
  });
});