Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Configurazione su Compute Engine

Error Reporting consente di aggregare gli arresti anomali e diagnosticare le eccezioni di runtime delle applicazioni Compute Engine. Puoi inviare i dati sugli errori trasmettendo i log in streaming a Cloud Logging o chiamando direttamente l'API Error Reporting. Se utilizzi Logging, le voci di log devono rispettare i requisiti di formattazione.

Utilizzare Logging per segnalare gli errori

Per connettere le tue applicazioni Compute Engine a Error Reporting, invia le tue eccezioni o altri errori a Logging utilizzando uno dei seguenti agenti:

Ops Agent
Agente Logging legacy

Ops Agent

Per configurare Error Reporting in modo che utilizzi Ops Agent, completa i seguenti passaggi:

Installa Ops Agent in base al tuo ambiente. Per istruzioni, consulta Installazione di Ops Agent.
Configura Ops Agent per raccogliere i log delle applicazioni e formattarli correttamente.
- Per l'applicazione di terze parti supportata:Ops Agent fornisce ricevitori di logging preconfigurati che acquisiscono e analizzano automaticamente le voci di log in formati strutturati riconosciuti da Error Reporting. Per informazioni sulle applicazioni di terze parti supportate, consulta Monitoraggio delle applicazioni di terze parti.
- Per le applicazioni personalizzate:configura un ricevitore di logging per specificare le posizioni dei file di log e accoppialo a uno dei seguenti processori:
  - Utilizza un processore parse_multiline se la tua app scrive stack trace di testo normale su più righe.
  - Utilizza un processore parse_json se la tua app scrive i log come stringhe JSON.
  Per istruzioni dettagliate, vedi Configurare Ops Agent.
Se la tua applicazione non genera stack trace standard, modificala in modo che registri le eccezioni e i relativi stack trace in Cloud Logging.

Devi includere tutte le informazioni per un singolo errore o eccezione nella stessa voce di log, inclusi tutti i frame di qualsiasi analisi dello stack. Se tutte le informazioni non sono insieme, Error Reporting potrebbe non rilevare l'errore. Puoi utilizzare il formato JSON strutturato per i payload voce di log in modo da includere diversi tipi di informazioni per ogni errore.

Agente Logging legacy

Per configurare Error Reporting in modo che utilizzi l'agente Logging legacy, completa i seguenti passaggi:

Installa l'agente Logging google-fluentd come appropriato per il tuo ambiente. Per istruzioni, vedi Installazione dell'agente Logging.
Modifica l'applicazione in modo che registri le eccezioni e le relative analisi dello stack in Logging.

Devi includere tutte le informazioni per un singolo errore o eccezione nella stessa voce di log, inclusi tutti i frame di qualsiasi analisi dello stack. Se tutte le informazioni non sono insieme, Error Reporting potrebbe non rilevare l'errore. Puoi utilizzare il formato JSON strutturato per i payload voce di log in modo da includere diversi tipi di informazioni per ogni errore.

Java

Aggiungi quanto segue al tuo file pom.xml:

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

Quindi, utilizza un codice come il seguente per inviare i dati delle eccezioni:

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

Innanzitutto, installa la libreria fluent-logger-python:

sudo pip install fluent-logger

Quindi, utilizza un codice come il seguente per inviare i dati delle eccezioni:

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

Innanzitutto, installa la libreria fluent-logger-node:

npm install fluent-logger

Quindi, utilizza un codice come il seguente per inviare i dati delle eccezioni:

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

Vai

Innanzitutto, installa il pacchetto fluent-logger-golang:

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

Quindi, utilizza un codice simile al seguente per inviare i dati sugli errori:


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

Utilizzo dell'API Error Reporting per scrivere errori

L'API Error Reporting fornisce un endpoint report per scrivere le informazioni sugli errori nel servizio.

Abilita l'API Error Reporting, se non è già abilitata.
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
Abilitare l'API
Segnala gli errori all'API utilizzando l'API REST o una libreria client.
- API REST
  
  Per informazioni sull'API, consulta la documentazione di riferimento.
- Utilizzo delle librerie client
  
  Esistono librerie in un numero limitato di lingue per aiutarti a chiamare l'API Error Reporting dalla tua applicazione:
  - ASP.NET
  - Go
  - Java
  - Node.js
  - Ruby
  - Python
  - PHP

Esempi

ASP.NET

Il pacchetto NuGet ASP.NET segnala le eccezioni non rilevate dalle applicazioni web ASP.NET a Error Reporting.

Installa il pacchetto NuGet

Per installare il pacchetto NuGet Stackdriver ASP.NET in Visual Studio:

Fai clic con il tasto destro del mouse sulla soluzione e seleziona Gestisci pacchetti NuGet per la soluzione.
Seleziona la casella di controllo Includi pre-release.
Cerca e installa il pacchetto denominato Google.Cloud.Diagnostics.AspNet.

Utilizzo

Dopo aver installato il pacchetto NuGet Stackdriver ASP.NET, aggiungi la seguente istruzione al codice dell'applicazione per iniziare a inviare gli errori a Stackdriver:

using Google.Cloud.Diagnostics.AspNet;

Aggiungi il seguente codice HttpConfiguration al metodo Register della tua app web .NET dopo aver sostituito your-project-id con il tuo ID progetto per attivare la segnalazione delle eccezioni:

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

Una volta aggiunto questo metodo all'applicazione ASP.NET, puoi visualizzare eventuali eccezioni non rilevate che si verificano man mano che vengono segnalate a Google Cloudnella sezione Error Reporting della console Google Cloud .

C#

L'esempio seguente è disponibile nel repository GoogleCloudPlatform/dotnet-docs-samples. Per utilizzarlo, dopo aver creato il progetto, specifica il tuo ID progetto:

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

Assicurati di sostituire [YOUR_PROJECT_ID] con il valore corretto della consoleGoogle Cloud .

Poi, invia i dati delle eccezioni con un codice simile al seguente:

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

Visualizza gruppi di errori

Nella console Google Cloud , vai alla pagina Error Reporting:

Vai a Error Reporting

Puoi trovare questa pagina anche utilizzando la barra di ricerca.

Configurazione su Compute Engine Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Utilizzare Logging per segnalare gli errori

Ops Agent

Agente Logging legacy

Java

Python

Node.js

Vai

Utilizzo dell'API Error Reporting per scrivere errori

Esempi

ASP.NET

Installa il pacchetto NuGet

Utilizzo

C#

Vai

Java

Node.js

Ruby

Python

PHP

Visualizza gruppi di errori

Configurazione su Compute Engine