Configurer Error Reporting sur Compute Engine

Error Reporting vous permet d'agréger les plantages et de diagnostiquer les exceptions d'exécution de vos applications Compute Engine. Vous pouvez envoyer des données d'erreur en diffusant des journaux vers Cloud Logging ou en appelant directement l'API Error Reporting. Si vous utilisez Logging, vos entrées de journal doivent respecter les exigences de mise en forme.

Utiliser Logging pour signaler des erreurs

Attention : Depuis le 28 septembre 2026, l'ancien agent Logging n'est plus compatible. La maintenance standard et les corrections de bugs ne sont plus fournies. Nous vous recommandons vivement de migrer vers l'une des alternatives compatibles. Pour en savoir plus sur cet arrêt, consultez Fin de la compatibilité avec les anciens agents Monitoring et Logging.

Pour connecter vos applications Compute Engine à Error Reporting, envoyez vos exceptions ou autres erreurs à Logging à l'aide de l'un des agents suivants :

• Agent Ops
• Ancien agent Logging

Agent Ops

Pour configurer Error Reporting de manière à utiliser l'agent Ops, procédez comme suit :

1. Installez l'agent Ops en fonction de votre environnement. Pour obtenir des instructions, consultez Installer l'agent Ops.

2. Configurez l'agent Ops pour qu'il collecte les journaux de votre application et les mette en forme correctement.

   • Pour les applications tierces compatibles : l'agent Ops fournit des récepteurs de journaux préconfigurés qui capturent et analysent automatiquement les entrées de journaux dans des formats structurés reconnus par Error Reporting. Pour en savoir plus sur les applications tierces compatibles, consultez Surveiller des applications tierces.

   • Pour les applications personnalisées : configurez un récepteur de journaux pour spécifier l'emplacement de vos fichiers journaux, puis associez-le à l'un des processeurs suivants :

     • Utilisez un processeur parse_multiline si votre application écrit des traces de pile en texte brut sur plusieurs lignes.
     • Utilisez un processeur parse_json si votre application écrit des journaux sous forme de chaînes JSON.

     Pour obtenir des instructions détaillées, consultez Configurer l'agent Ops.

3. Si votre application ne génère pas de traces de pile standards, modifiez-la pour qu'elle enregistre les exceptions et leurs traces de pile dans Cloud Logging.

   Vous devez inclure toutes les informations concernant une seule erreur ou exception dans la même entrée de journal, y compris tous les frames d'une trace de pile. Si toutes les informations ne sont pas regroupées, il est possible qu'Error Reporting ne détecte pas l'erreur. Vous pouvez utiliser le format JSON structuré pour les charges utiles d'entrée de journal afin d'inclure différents types d'informations pour chaque erreur.

Ancien agent Logging

Pour configurer Error Reporting afin qu'il utilise l'ancien agent Logging, procédez comme suit :

1. Installez l'agent Logging google-fluentd comme il convient pour votre environnement. Pour obtenir des instructions, consultez Installer l'agent Logging.

2. Modifiez votre application pour qu'elle enregistre les exceptions et leurs traces de pile dans Logging.

   Vous devez inclure toutes les informations relatives à une seule erreur ou exception dans la même entrée de journal, y compris toutes les frames de toute trace de pile. Si toutes les informations ne sont pas regroupées, il est possible qu'Error Reporting ne détecte pas l'erreur. Vous pouvez utiliser le format JSON structuré pour les charges utiles des entrée de journal afin d'inclure différents types d'informations pour chaque erreur.

Java

Ajoutez le code ci-dessous à votre fichier pom.xml :

<dependency>
  <groupId>org.fluentd</groupId>
  <artifactId>fluent-logger</artifactId>
  <version>0.3.4</version>
</dependency>

Exécutez ensuite le code suivant pour envoyer les données relatives aux exceptions :

public class ExceptionUtil {
  private static FluentLogger ERRORS = FluentLogger.getLogger("myapp");

  public static void main(String[] args) {
    try {
      throw new Exception("Generic exception for testing Stackdriver");
    } catch (Exception e) {
      report(e);
    }
  }

  public static void report(Throwable ex) {
    StringWriter exceptionWriter = new StringWriter();
    ex.printStackTrace(new PrintWriter(exceptionWriter));
    Map<String, Object> data = new HashMap<>();
    data.put("message", exceptionWriter.toString());
    Map<String, String> serviceContextData = new HashMap<>();
    serviceContextData.put("service", "myapp");
    data.put("serviceContext", serviceContextData);
    // ... add more metadata
    ERRORS.log("errors", data);
  }
}

Python

Commencez par installer la bibliothèque fluent-logger-python :

sudo pip install fluent-logger

Exécutez ensuite le code suivant pour envoyer les données relatives aux exceptions :

import traceback

import fluent.event
import fluent.sender


def simulate_error():
    fluent.sender.setup("myapp", host="localhost", port=24224)

    def report(ex):
        data = {}
        data["message"] = "{0}".format(ex)
        data["serviceContext"] = {"service": "myapp"}
        # ... add more metadata
        fluent.event.Event("errors", data)

    # report exception data using:
    try:
        # simulate calling a method that's not defined
        raise NameError
    except Exception:
        report(traceback.format_exc())

Node.js

Commencez par installer la bibliothèque fluent-logger-node :

npm install fluent-logger

Exécutez ensuite le code suivant pour envoyer les données relatives aux exceptions :

const structuredLogger = require('fluent-logger').createFluentSender('myapp', {
  host: 'localhost',
  port: 24224,
  timeout: 3.0,
});

const report = (err, req) => {
  const payload = {
    serviceContext: {
      service: 'myapp',
    },
    message: err.stack,
    context: {
      httpRequest: {
        url: req.originalUrl,
        method: req.method,
        referrer: req.header('Referer'),
        userAgent: req.header('User-Agent'),
        remoteIp: req.ip,
        responseStatusCode: 500,
      },
    },
  };
  structuredLogger.emit('errors', payload);
};

// Handle errors (the following uses the Express framework)
// eslint-disable-next-line no-unused-vars
app.use((err, req, res, next) => {
  report(err, req);
  res.status(500).send(err.response || 'Something broke!');
});

Go

Commencez par installer le package fluent-logger-golang :

go get github.com/fluent/fluent-logger-golang/

Exécutez ensuite le code suivant pour envoyer les données relatives aux erreurs :

package main

import (
	"log"
	"net/http"
	"os"
	"runtime"

	"github.com/fluent/fluent-logger-golang/fluent"
)

var logger *fluent.Fluent

func main() {
	var err error
	logger, err = fluent.New(fluent.Config{
		FluentHost: "localhost",
		FluentPort: 24224,
	})
	if err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("/demo", demoHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

func report(stackTrace string, r *http.Request) {
	payload := map[string]interface{}{
		"serviceContext": map[string]interface{}{
			"service": "myapp",
		},
		"message": stackTrace,
		"context": map[string]interface{}{
			"httpRequest": map[string]interface{}{
				"method":    r.Method,
				"url":       r.URL.String(),
				"userAgent": r.UserAgent(),
				"referrer":  r.Referer(),
				"remoteIp":  r.RemoteAddr,
			},
		},
	}
	if err := logger.Post("myapp.errors", payload); err != nil {
		log.Print(err)
	}
}

// Handler for the incoming requests.
func demoHandler(w http.ResponseWriter, r *http.Request) {
	// How to handle a panic.
	defer func() {
		if e := recover(); e != nil {
			stack := make([]byte, 1<<16)
			stackSize := runtime.Stack(stack, true)
			report(string(stack[:stackSize]), r)
		}
	}()

	// Panic is triggered.
	x := 0
	log.Println(100500 / x)
}

Utiliser l'API Error Reporting pour écrire des erreurs

L'API Error Reporting fournit un point de terminaison report pour écrire les informations d'erreur à destination du service.

1. Activez l'API Error Reporting, si ce n'est pas déjà fait.

   Rôles requis pour activer les API

   Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

   Activer l'API

2. Signalez les erreurs à l'API à l'aide de l'API REST ou d'une bibliothèque cliente.

   • API REST

     Consultez la documentation de référence pour en savoir plus sur l'API.

   • Bibliothèques clientes

     Les bibliothèques existent dans un nombre limité de langages pour vous aider à appeler l'API Error Reporting depuis votre application.

     • ASP.NET
     • Go
     • Java
     • Node.js
     • Ruby
     • Python
     • PHP

Exemples

ASP.NET

Le package NuGet ASP.NET signale les exceptions non détectées depuis les applications Web ASP.NET à Error Reporting.

Installer le package NuGet

Pour installer le package NuGet ASP.NET Stackdriver dans Visual Studio :

1. Cliquez avec le bouton droit sur votre solution, puis sélectionnez Gérer les packages NuGet pour la solution.
2. Cochez la case Inclure la version préliminaire.
3. Recherchez et installez le package nommé Google.Cloud.Diagnostics.AspNet.

Utilisation

Une fois que vous avez installé le package NuGet ASP.NET Stackdriver, ajoutez la déclaration suivante à votre code d'application pour commencer à envoyer des erreurs à Stackdriver :

using Google.Cloud.Diagnostics.AspNet;

Ajoutez le code HttpConfiguration suivant à la méthode Register de votre application Web .NET après avoir remplacé your-project-id par votre ID de projet réel pour activer le signalement des exceptions :

public static void Register(HttpConfiguration config)
{
    string projectId = "YOUR-PROJECT-ID";
    string serviceName = "NAME-OF-YOUR-SERVICE";
    string version = "VERSION-OF-YOUR-SERVCICE";
    // ...
    // Add a catch all for the uncaught exceptions.
    config.Services.Add(typeof(IExceptionLogger),
        ErrorReportingExceptionLogger.Create(projectId, serviceName, version));
    // ...
}

Une fois que vous avez ajouté cette méthode à votre application ASP.NET, vous pouvez afficher toutes les exceptions non détectées qui se produisent lorsqu'elles sont signalées à Google Clouddans la section Error Reporting de la console Google Cloud .

C#

L'exemple suivant est disponible dans le dépôt GoogleCloudPlatform/dotnet-docs-samples. Pour l'utiliser, après avoir créé le projet, spécifiez votre ID de projet :

C:\...\bin\Debug> set GOOGLE_PROJECT_ID=[YOUR_PROJECT_ID]

Veillez à remplacer [YOUR_PROJECT_ID] par la valeur appropriée de la consoleGoogle Cloud .

Ensuite, envoyez les données d'exception avec le code suivant :

public class ErrorReportingSample
{
    public static void Main(string[] args)
    {
        try
        {
            throw new Exception("Generic exception for testing Stackdriver Error Reporting");
        }
        catch (Exception e)
        {
            report(e);
            Console.WriteLine("Stackdriver Error Report Sent");
        }
    }

    /// <summary>
    /// Create the Error Reporting service (<seealso cref="ClouderrorreportingService"/>)
    /// with the Application Default Credentials and the proper scopes.
    /// See: https://developers.google.com/identity/protocols/application-default-credentials.
    /// </summary>
    private static ClouderrorreportingService CreateErrorReportingClient()
    {
        // Get the Application Default Credentials.
        GoogleCredential credential = GoogleCredential.GetApplicationDefaultAsync().Result;

        // Add the needed scope to the credentials.
        credential.CreateScoped(ClouderrorreportingService.Scope.CloudPlatform);

        // Create the Error Reporting Service.
        ClouderrorreportingService service = new ClouderrorreportingService(new BaseClientService.Initializer
        {
            HttpClientInitializer = credential,
        });
        return service;
    }

    /// <summary>
    /// Creates a <seealso cref="ReportRequest"/> from a given exception.
    /// </summary>
    private static ReportRequest CreateReportRequest(Exception e)
    {
        // Create the service.
        ClouderrorreportingService service = CreateErrorReportingClient();

        // Get the project ID from the environement variables.
        string projectId = Environment.GetEnvironmentVariable("GOOGLE_PROJECT_ID");

        // Format the project id to the format Error Reporting expects. See:
        // https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report
        string formattedProjectId = string.Format("projects/{0}", projectId);

        // Add a service context to the report.  For more details see:
        // https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events#ServiceContext
        ServiceContext serviceContext = new ServiceContext()
        {
            Service = "myapp",
            Version = "8c1917a9eca3475b5a3686d1d44b52908463b989",
        };
        ReportedErrorEvent errorEvent = new ReportedErrorEvent()
        {
            Message = e.ToString(),
            ServiceContext = serviceContext,
        };
        return new ReportRequest(service, errorEvent, formattedProjectId);
    }

    /// <summary>
    /// Report an exception to the Error Reporting service.
    /// </summary>
    private static void report(Exception e)
    {
        // Create the report and execute the request.
        ReportRequest request = CreateReportRequest(e);
        request.Execute();
    }
}

Go

Consultez la page Configurer Error Reporting pour Go.

Java

Consultez la page Configurer Error Reporting pour Java.

Node.js

Consultez la page Configurer Error Reporting pour Node.js.

Ruby

Consultez la page Configurer Error Reporting pour Ruby.

Python

Consultez la page Configurer Error Reporting pour Python.

PHP

Consultez la page Configurer Error Reporting pour PHP.

Afficher les groupes d'erreurs

Dans la console Google Cloud , accédez à la page Error Reporting :

Accéder à Error Reporting

Vous pouvez également accéder à cette page à l'aide de la barre de recherche.

Remarque : Si le message "Configurer Error Reporting" s'affiche sur la page Error Reporting, cela signifie que votre projet Google Cloud ne comporte aucun groupe d'erreurs à afficher.