Ir a la consola

Informa errores

Informa errores automáticamente

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

Si deseas un informe de errores más detallado, puedes usar las bibliotecas cliente de Stackdriver Error Reporting.

En GCP Console, puedes ver los errores informados en Stackdriver Error Reporting. También puedes verlos desde una función en particular cuando lo seleccionas en la lista de funciones de GCP Console.

Las excepciones sin detectar que genera la función aparecerán en Stackdriver Error Reporting. Ten en cuenta que algunas excepciones sin detectar, por ejemplo, las que se muestran de forma asíncrona, pueden causar un inicio en frío en una invocación de función futura. Esta situación reduce el rendimiento de la función.

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

Informa errores manualmente

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

Importa las 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();

Realiza el envío a Stackdriver

Una entrada de registro con el formato correcto requiere un objeto MonitoredResource y un objeto ErrorEvent.

Esta función reportError de ejemplo demuestra 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.firestore.document('stripe_customers/{userId}/charges/{id}').onCreate(async (snap, context) => {
      const val = snap.data();
      try {
        // Look up the Stripe customer id written in createStripeCustomer
        const snapshot = await admin.firestore().collection(`stripe_customers`).doc(context.params.userId).get()
        const snapval = snapshot.data();
        const customer = snapval.customer_id
        // 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;
        }
        const response = await stripe.charges.create(charge, {idempotency_key: idempotencyKey});
        // If the result is successful, write it back to the database
        return snap.ref.set(response, { merge: true });
      } catch(error) {
        // We want to capture errors and render them in a user-friendly way, while
        // still logging an exception with StackDriver
        console.log(error);
        await snap.ref.set({error: userFacingMessage(error)}, { merge: true });
        return reportError(error, {user: context.params.userId});
      }
    });

Puedes pasar la información del usuario a través del parámetro ErrorContext. Esa información se muestra en la IU de Stackdriver y se usa para calcular la cantidad de usuarios afectados.

También se puede pasar información a ErrorContext en una solicitud HTTP de la siguiente manera:

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