Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

In Compute Engine einrichten

Mit Error Reporting können Sie Abstürze aggregieren und Laufzeit-Exceptions in Ihren Compute Engine-Anwendungen diagnostizieren. Sie können Fehlerdaten senden, indem Sie Logs an Cloud Logging streamen oder die Error Reporting API direkt aufrufen. Wenn Sie Logging verwenden, müssen Ihre Logeinträge den Formatierungsanforderungen entsprechen.

Logging zum Melden von Fehlern verwenden

Wenn Sie Ihre Compute Engine-Anwendungen mit Error Reporting verbinden möchten, senden Sie Ihre Ausnahmen oder andere Fehler mit einem der folgenden Agents an Logging:

Ops-Agent
Legacy-Logging-Agent

Ops-Agent

So richten Sie Error Reporting für die Verwendung des Ops-Agents ein:

Installieren Sie den Ops-Agent entsprechend Ihrer Umgebung. Eine Anleitung finden Sie unter Ops-Agent installieren.
Konfigurieren Sie den Ops-Agent so, dass er Ihre Anwendungsprotokolle erfasst und richtig formatiert.
- Für unterstützte Drittanbieteranwendungen:Der Ops-Agent bietet vorkonfigurierte Logging-Empfänger, die automatisch Logeinträge in strukturierte Formate erfassen und parsen, die von Error Reporting erkannt werden. Informationen zu den unterstützten Drittanbieteranwendungen finden Sie unter Anwendungen von Drittanbietern überwachen.
- Für benutzerdefinierte Anwendungen:Konfigurieren Sie einen Logging-Empfänger, um die Speicherorte Ihrer Logdateien anzugeben, und koppeln Sie ihn mit einem der folgenden Prozessoren:
  - Verwenden Sie einen parse_multiline-Prozessor, wenn Ihre App Stacktraces im Nur-Text-Format über mehrere Zeilen hinweg schreibt.
  - Verwenden Sie einen parse_json-Prozessor, wenn Ihre App Logs als JSON-Strings schreibt.
  Eine ausführliche Anleitung finden Sie unter Ops-Agent konfigurieren.
Wenn Ihre Anwendung keine Standard-Stacktraces generiert, müssen Sie sie so ändern, dass Ausnahmen und ihre Stacktraces in Cloud Logging protokolliert werden.

Sie müssen alle Informationen zu einem einzelnen Fehler oder einer einzelnen Ausnahme im selben Logeintrag angeben, einschließlich aller Frames eines Stacktrace. Wenn nicht alle Informationen zusammen vorliegen, wird der Fehler möglicherweise nicht von Error Reporting erkannt. Das strukturierte JSON-Format für die Nutzlasten des Log-Eintrags bietet die Möglichkeit, für Fehler unterschiedliche Informationsarten zu verwenden.

Legacy-Logging-Agent

So richten Sie Error Reporting für die Verwendung des alten Logging-Agent ein:

Installieren Sie den Logging-Agenten google-fluentd entsprechend Ihrer Umgebung. Eine Anleitung finden Sie unter Logging-Agent installieren.
Ändern Sie Ihre Anwendung so, dass Ausnahmen und ihre Stacktraces in Logging protokolliert werden.

Sie müssen alle Informationen für einen einzelnen Fehler oder eine einzelne Ausnahme im selben Logeintrag angeben, einschließlich aller Frames eines Stacktrace. Wenn nicht alle Informationen zusammen vorliegen, wird Error Reporting den Fehler möglicherweise nicht erkennen. Sie können das strukturierte JSON-Format für Ihre Logeintrag-Nutzlasten verwenden, um verschiedene Arten von Informationen für jeden Fehler einzuschließen.

Java

Fügen Sie der Datei pom.xml Folgendes hinzu:

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

Verwenden Sie dann Code ähnlich dem folgenden, um Ausnahmedaten zu senden:

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

Installieren Sie zuerst die Bibliothek fluent-logger-python:

sudo pip install fluent-logger

Verwenden Sie dann Code ähnlich dem folgenden, um Ausnahmedaten zu senden:

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

Installieren Sie zuerst die Bibliothek fluent-logger-node:

npm install fluent-logger

Verwenden Sie dann Code ähnlich dem folgenden, um Ausnahmedaten zu senden:

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

Installieren Sie zuerst das Paket fluent-logger-golang:

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

Verwenden Sie dann Code ähnlich dem folgenden, um Fehlerdaten zu senden:


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

Error Reporting-API zum Beschreiben von Fehlern verwenden

Die Error Reporting API bietet einen report-Endpunkt zum Schreiben von Fehlerinformationen in den Dienst.

Aktivieren Sie die Error Reporting API, falls sie noch nicht aktiviert ist.
Rollen, die zum Aktivieren von APIs erforderlich sind
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
API aktivieren
Mithilfe der REST API oder einer Clientbibliothek melden Sie Fehler an die API.
- REST API
  
  Weitere Informationen zur API finden Sie in der Referenzdokumentation.
- Clientbibliotheken verwenden
  
  Bibliotheken verfügen über eine begrenzte Anzahl von Programmiersprachen, mit denen Sie die Error Reporting API aus Ihrer Anwendung aufrufen können.
  - ASP.NET
  - Go
  - Java
  - Node.js
  - Ruby
  - Python
  - PHP

Beispiele

ASP.NET

Das ASP.NET-NuGet-Paket meldet nicht abgefangene Ausnahmen aus ASP.NET-Webanwendungen an Error Reporting.

NuGet-Paket installieren

So installieren Sie das Stackdriver-ASP.NET-NuGet-Paket in Visual Studio:

Klicken Sie mit der rechten Maustaste auf Ihre Lösung und wählen Sie NuGet-Pakete für die Lösung verwalten aus.
Wählen Sie das Kästchen Vorabversion einbeziehen aus.
Suchen Sie nach dem Paket mit dem Namen Google.Cloud.Diagnostics.AspNet und installieren Sie es.

Nutzung

Nachdem Sie das Stackdriver-ASP.NET-NuGet-Paket installiert haben, können Sie die folgende Anweisung zu Ihrem Anwendungscode hinzufügen und Fehler an Stackdriver senden:

using Google.Cloud.Diagnostics.AspNet;

Fügen Sie den folgenden HttpConfiguration-Code in die Methode Register Ihrer .NET-Webanwendung ein. Ersetzen Sie dabei your-project-id durch Ihre tatsächliche Projekt-ID, um das Melden von Ausnahmen zu aktivieren:

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

Nachdem Sie diese Methode Ihrer ASP.NET-Anwendung hinzugefügt haben, können Sie alle nicht abgefangenen Ausnahmen, die auftreten, in der Google CloudConsole im Bereich Error Reporting Google Cloud ansehen.

C#

Das folgende Beispiel finden Sie im Repository GoogleCloudPlatform/dotnet-docs-samples. Geben Sie nach der Projekterstellung Ihre Projekt-ID an, um es zu verwenden:

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

Ersetzen Sie [YOUR_PROJECT_ID] durch den korrekten Wert aus derGoogle Cloud -Konsole.

Senden Sie dann Ausnahmedaten mit Code ähnlich dem folgenden:

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

Fehlergruppen ansehen

Rufen Sie in der Google Cloud Console die Seite Error Reporting auf:

Error Reporting aufrufen

Sie können diese Seite auch über die Suchleiste finden.

In Compute Engine einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Logging zum Melden von Fehlern verwenden

Ops-Agent

Legacy-Logging-Agent

Java

Python

Node.js

Go

Error Reporting-API zum Beschreiben von Fehlern verwenden

Beispiele

ASP.NET

NuGet-Paket installieren

Nutzung

C#

Go

Java

Node.js

Ruby

Python

PHP

Fehlergruppen ansehen

In Compute Engine einrichten