Auf Google Compute Engine einrichten

Es gibt zwei Möglichkeiten, wie Sie Fehler von Ihren Google Compute Engine-Anwendungen an Stackdriver Error Reporting senden können:

Protokollierung zum Melden von Fehlern verwenden

Ihre Google Compute Engine-Anwendungen verbinden Sie mit Stackdriver Error Reporting mithilfe von Senden strukturierter Daten über Stackdriver Logging an einen dedizierten Log-Stream.

  1. Aktivieren Sie die Stackdriver Logging API.

    Aktivieren Sie die API

  2. Installieren Sie den Stackdriver Logging-Agent google-fluentd auf Ihrer Google Compute Engine-Instanz.

  3. Sie stellen Ihre Anwendung so ein, dass Stacktraces für Ausnahmen in Stackdriver Logging protokolliert werden.

    Frames vom gleichen Stacktrace müssen sich im gleichen Logeintrag befinden, damit die Ausnahme von Error Reporting erfasst wird.

    Weitere Metadaten zu Fehlern können Sie über das strukturierte JSON-Format senden.

Java

Fügen Sie Folgendes zu Ihrer Datei pom.xml hinzu:

<dependency>
  <groupId>org.fluentd</groupId>
  <artifactId>fluent-logger</artifactId>
  <version>0.3.3</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 fluent-logger-python-Bibliothek:

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 fluent-logger-node-Bibliothek:

npm install --save 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 fluent-logger-golang-Paket:

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

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

package main

import (
	"log"
	"net/http"
	"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)
	http.ListenAndServe(":8080", nil)
}

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

Mit einem report-Endpunkt kann die Stackdriver Error Reporting API dem Dienst Informationen zu Fehlern senden.

  1. Aktivieren Sie die Stackdriver 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.

Beispiele

ASP.NET

Das Stackdriver ASP.NET NuGet-Paket meldet nicht erfasste Ausnahmen von ASP.NET-Webanwendungen an Stackdriver 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 und installieren Sie das Paket Google.Cloud.Diagnostics.AspNet.

Verwendung

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;

Damit Ausnahmen gemeldet werden können, fügen Sie der Methode Register Ihrer .NET-Webanwendung folgenden HttpConfiguration-Code hinzu. Dabei ersetzen Sie your-project-id durch Ihre tatsächliche Projekt-ID:

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 GCP Console anzeigen, da sie an Google Cloud gemeldet und dort im Abschnitt Stackdriver 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]

Achten Sie darauf, [YOUR_PROJECT_ID] durch den richtigen Wert aus der GCP Console zu ersetzen.

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

Go

Siehe Stackdriver Error Reporting für Go einrichten.

Java

Siehe Stackdriver Error Reporting für Java einrichten.

Node.js

Siehe Stackdriver Error Reporting für Node.js einrichten.

Ruby

Siehe Stackdriver Error Reporting für Ruby einrichten.

Python

Siehe Stackdriver Error Reporting für Python einrichten.

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

Stackdriver Error Reporting