Comunicar erros

Como relatar erros automaticamente

Você pode informar um erro de uma função do Cloud Functions para o Stackdriver Error Reporting, conforme mostrado abaixo:

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

// These will NOT be reported to Stackdriver Error Reporting
console.info(new Error('I failed you')); // Logging an Error object at the info level
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 você quiser um relatório de erros mais refinado, use as bibliotecas de cliente do Stackdriver Error Reporting.

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

As exceções não identificadas produzidas pela função serão exibidas no Stackdriver Error Reporting. Observe que algumas exceções não identificadas, como aquelas lançadas de maneira assíncrona, podem causar uma inicialização a frio em uma invocação futura. Isso reduz o desempenho da função.

try {
  // Throw an Error object (to simulate a GCP API failure)
  throw new Error('Error object!');
} catch (err) {
  // err is already an Error object
  console.error(err);
}

Como relatar erros manualmente

Para relatar erros em uma função ao Stackdriver Error Reporting, use a API Stackdriver Logging.

Importar dependências

No seu diretório functions, instale a Biblioteca de cliente do Google Stackdriver Logging para Node.js:

npm install --save @google-cloud/logging

Importe a Biblioteca de cliente do Google Cloud para acessar a Logging API:

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

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

Enviar dados para o Stackdriver

Uma entrada de registro formada corretamente requer objetos MonitoredResource e ErrorEvent.

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

function reportError(err, context = {}) {
  // This is the name of the StackDriver 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 StackDriver 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();
    });
  });
}
index.js

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

// Charge the Stripe customer whenever an amount is written to the Realtime database
exports.createStripeCharge = functions.database.ref('/stripe_customers/{userId}/charges/{id}')
    .onCreate((snap, context) => {
      const val = snap.val();
      // Look up the Stripe customer id written in createStripeCustomer
      return admin.database().ref(`/stripe_customers/${context.params.userId}/customer_id`)
          .once('value').then((snapshot) => {
            return snapshot.val();
          }).then((customer) => {
            // Create a charge using the pushId as the idempotency key
            // protecting against double charges
            const amount = val.amount;
            const idempotencyKey = context.params.id;
            const charge = {amount, currency, customer};
            if (val.source !== null) {
              charge.source = val.source;
            }
            return stripe.charges.create(charge, {idempotency_key: idempotencyKey});
          }).then((response) => {
            // If the result is successful, write it back to the database
            return snap.ref.set(response);
          }).catch((error) => {
            // We want to capture errors and render them in a user-friendly way, while
            // still logging an exception with StackDriver
            return snap.ref.child('error').set(userFacingMessage(error));
          }).then(() => {
            return reportError(error, {user: context.params.userId});
          });
        });
index.js

É possível transmitir detalhes do usuário por meio do parâmetro ErrorContext. A IU do Stackdriver exibe esses detalhes e os utiliza para calcular o número de usuários afetados.

O parâmetro ErrorContext também pode receber informações de 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();
  });
});