Error Reporting für Amazon EC2 einrichten

Sie haben zwei Möglichkeiten, Fehler von Ihren EC2-Anwendungen an Error Reporting zu senden:

• Durch Logging in Cloud Logging: Wenn Sie Cloud Logging bereits verwenden, besteht die einzige zusätzliche Anforderung darin, dass Ihre Logeinträge von Error Reporting erkannt werden müssen. Weitere Informationen zu den Anforderungen an die Fehlerformatierung finden Sie unter Fehler in Cloud Logging formatieren.

• Durch Verwendung der Error Reporting API: Ihre Anwendung kann HTTP-Anfragen über die REST API senden oder experimentelle Bibliotheken in mehreren Sprachen verwenden.

Logging zum Melden von Fehlern verwenden

Zum Verbinden Ihrer EC2-Anwendungen mit Error Reporting senden Sie Ihre Ausnahmen oder andere Fehler an Logging. Dazu verwenden Sie einen eigenen Log-Namen, um Ihre Fehler von Ihren anderen Logs zu trennen.

Beispiel:

1. Aktivieren Sie die Cloud Logging API.

   Aktivieren Sie die API

2. Installieren Sie den für Ihre Umgebung geeigneten Logging-Agent. Eine Anleitung finden Sie unter Logging-Agent installierengoogle-fluentd.

3. Ändern Sie Ihre Anwendung so, dass sie Ausnahmen und deren Stacktraces in Logging protokolliert. Wählen Sie einen eigenen Log-Namen für Ihre Fehlerinformationen, um sie von anderen protokollierten Informationen zu trennen.

   Sie müssen alle Informationen zu einem einzelnen Fehler oder einer Ausnahme in denselben Log-Eintrag aufnehmen, einschließlich aller Frames eines Stacktrace. Andernfalls können eventuell von Error Reporting die Informationen nicht erfasst werden. Das strukturierte JSON-Format für die Nutzlasten des Log-Eintrags bietet die Möglichkeit, für Fehler unterschiedliche Informationsarten zu verwenden.

Java

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

compute/error-reporting/pom.xml

Auf GitHub ansehen

<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:

compute/error-reporting/src/main/java/com/example/compute/errorreporting/ExceptionUtil.java

Auf GitHub ansehen

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:

samples/snippets/fluent_on_compute/main.py

Auf GitHub ansehen Feedback

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 --save fluent-logger

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

Auf GitHub ansehen

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 -u github.com/fluent/fluent-logger-golang/

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

docs/error-reporting/fluent/main.go

Auf GitHub ansehen

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.

1. Aktivieren Sie die Error Reporting API.

   Aktivieren Sie die API

2. 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 Stackdriver-ASP.NET-NuGet-Paket meldet nicht erfasste Ausnahmen von ASP.NET-Webanwendungen an Error Reporting.

NuGet-Paket installieren

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

1. Klicken Sie mit der rechten Maustaste auf Ihre Lösung und wählen Sie NuGet-Pakete für Lösung verwalten aus.
2. Wählen Sie das Kästchen Vorabversion einbeziehen aus.
3. 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:

error-reporting/api/diagnostics/App_Start/WebApiConfig.cs

Auf GitHub ansehen

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 Ihrer ASP.NET-Anwendung diese Methode hinzugefügt haben, können Sie alle nicht erfassten Ausnahmen in der Cloud Console aufrufen, da sie an Google Cloud gemeldet und dort im Bereich Error Reporting angezeigt werden.

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 der Cloud Console.

Senden Sie dann Ausnahmedaten mit Code ähnlich dem folgenden:

error-reporting/api/ErrorReportingSample.cs

Auf GitHub ansehen

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

Siehe Error Reporting für Go einrichten.

Java

Siehe Error Reporting für Java einrichten.

Node.js

Siehe Error Reporting für Node.js einrichten.

Ruby

Siehe Error Reporting für Ruby einrichten.

Python

Siehe Error Reporting für Python einrichten.

PHP

Siehe Error Reporting für Go einrichten.