In Compute Engine einrichten

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

Logging zum Melden von Fehlern verwenden

Um Ihre Compute Engine-Anwendungen mit Error Reporting zu verbinden, Ihre Ausnahmen oder andere Fehler an Logging senden.

Beispiel:

  1. Logging-Agent google-fluentd unverändert installieren für Ihre Umgebung geeignet. Anweisungen finden Sie unter Logging-Agent installieren
  2. Ändern Sie Ihre Anwendung so, dass sie Ausnahmen und deren Stacktraces in Logging protokolliert.

    Sie müssen alle Informationen zu einem einzelnen Fehler oder einer einzelnen Ausnahme in denselben Logeintrag aufnehmen, einschließlich aller Frames eines Stacktrace. Wenn alle Informationen nicht zusammen verwenden, erkennt Error Reporting den Fehler möglicherweise nicht. Sie können das strukturierte JSON-Format verwenden. die Nutzlasten des Log-Eintrags verschiedene Arten von Informationen Fehler.

  3. 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 --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 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.

    1. Enable the Error Reporting API.

      Enable the 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 ASP.NET NuGet-Paket meldet nicht abgefangene Ausnahmen von ASP.NET-Webanwendungen zu Error Reporting hinzufügen.

    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 der Methode Register Ihrer Datei den folgenden HttpConfiguration-Code hinzu: .NET-Webanwendung (ersetzen Sie your-project-id durch Ihre tatsächliche Projekt-ID um Ausnahmen zu melden:

    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 zu Ihrer ASP.NET-Anwendung hinzugefügt haben, können Sie alle Nicht abgefangene Ausnahmen, die beim Melden an Google Cloud auftreten in der Spalte Error Reporting der Google Cloud Console.

    C#

    Das folgende Beispiel befindet sich in der GoogleCloudPlatform/dotnet-docs-samples Repository. 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 richtigen Wert aus dem Google Cloud Console

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

    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.