Informar errores

Informe automático de errores

Para emitir un error desde una función de Cloud en Stackdriver Error Reporting, realiza lo siguiente:

Node.js

// These WILL be reported to Stackdriver Error Reporting
console.error(new Error('I failed you'));
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');

Puedes ver los errores informados en Stackdriver Error Reporting en la Consola de API. Además, puedes ver los errores informados desde una función en particular cuando lo seleccionas en la lista de funciones de la Consola de API.

Las excepciones sin detectar que la función genera aparecerán en Stackdriver Error Reporting. Ten en cuenta que algunas excepciones sin detectar, como las que se muestran de forma asíncrona, pueden causar un inicio en frío en invocaciones de función futuras, lo que reduce el rendimiento de las funciones.

Si usas los Servicios de Google a través de una biblioteca que ofrece Google, puedes registrar el error proporcionado de la siguiente manera:

Node.js

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);
}

Informe manual de errores

Para informar un error en Stackdriver Error Reporting desde una función, usa la API de Stackdriver Logging.

Importación de dependencias

Desde el directorio functions, instala la biblioteca cliente de Google Stackdriver Logging para Node.js:

npm install --save @google-cloud/logging

Importa la biblioteca cliente de Google Cloud para acceder a la API de Logging:

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

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

Envío a Stackdriver

Una entrada de registro formada correctamente requiere un objeto MonitoredResource y un objeto ErrorEvent.

Esta función reportError de ejemplo muestra los datos mínimos obligatorios para informar un error a 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();
    });
  });
}

La función reportError puede usarse para informar errores de manera manual:

// 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});
          });
        });

Puedes pasar la información del usuario a través del parámetro ErrorContext. La IU de Stackdriver muestra la información y la usa para calcular el número de usuarios afectados.

Asimismo, se puede pasar información a ErrorContext en una solicitud 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();
  });
});

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.