Signaler les erreurs

Signaler automatiquement les erreurs

Vous pouvez envoyer une erreur d'une fonction Cloud à Error Reporting comme indiqué ci-dessous :

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

Si vous souhaitez des rapports d'erreurs plus précis, vous pouvez utiliser les bibliothèques clientes Error Reporting .

Vous pouvez afficher les erreurs signalées dans le rapport d'erreurs de la console GCP. Vous pouvez également voir les erreurs signalées par une fonction particulière lorsque vous la sélectionnez dans la liste des fonctions de la console GCP.

Les exceptions non interceptées produites par votre fonction apparaîtront dans le rapport d'erreurs. Notez que certains types d'exceptions non interceptées (telles que celles lancées de manière asynchrone) entraîneront un démarrage à froid lors d'un futur appel de fonction. Cela augmente le temps d'exécution de votre fonction.

Signaler manuellement les erreurs

Pour signaler une erreur à Error Reporting à partir d'une fonction, utilisez l'API Cloud Logging .

Importation de dépendances

Depuis votre répertoire functions , installez la bibliothèque cliente Cloud Logging pour Node.js :

npm install --save @google-cloud/logging

Importez et initialisez la bibliothèque cliente Cloud Logging :

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

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

Envoi vers Cloud Logging

Une entrée de journal correctement formée nécessite un objet MonitoredResource et un objet ErrorEvent .

Cet exemple de fonction reportError illustre les données minimales requises pour signaler une erreur à 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();
    });
  });
}
index.js

La fonction reportError peut être utilisée pour signaler manuellement les erreurs :

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 });
    }
  });
index.js

Vous pouvez transmettre les détails de l'utilisateur via le paramètre ErrorContext . L'interface utilisateur de rapport d'erreurs affiche ces détails et les utilise pour calculer le nombre d'utilisateurs concernés.

ErrorContext peut également recevoir des informations sur une requête 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();
  });
});