Esta página se ha traducido con Cloud Translation API.

Configurar Error Reporting en Amazon EC2

Puede enviar errores de sus aplicaciones de EC2 a Error Reporting de dos formas:

Registrando los datos en Cloud Logging. Si ya usas Cloud Logging, el único requisito adicional es que Error Reporting pueda reconocer tus entradas de registro. Para obtener más información sobre los requisitos de formato de los errores, consulta Formatear errores en Cloud Logging.
Usar la API Error Reporting. Tu aplicación puede enviar solicitudes HTTP mediante la API REST o usar bibliotecas experimentales en varios lenguajes.

Usar Logging para informar de errores

Para conectar tus aplicaciones de EC2 a Error Reporting, envía tus excepciones u otros errores a Logging.

Por ejemplo:

Conecta el sistema Amazon Web Services (AWS) a Google Cloud. Para obtener más información, consulta el artículo Instalar el agente de Logging en máquinas virtuales concretas.
Instala el agente de google-fluentd Logging tal como corresponda a tu entorno. Para obtener instrucciones, consulta el artículo sobre cómo instalar el agente de Logging.
Modifica tu aplicación para que registre las excepciones y sus seguimientos de pila en Logging.

Debe incluir toda la información de un solo error o excepción en la misma entrada de registro, incluidos todos los marcos de cualquier seguimiento de pila. Si no se incluye toda la información, es posible que Informes de errores no detecte el error. Puede usar el formato JSON estructurado para las cargas útiles de las entradas de registro con el fin de incluir diferentes tipos de información para cada error.

Java

Añade lo siguiente a tu archivo pom.xml:

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

A continuación, use un código como el siguiente para enviar los datos de la excepción:

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

Primero, instala la biblioteca fluent-logger-python:

sudo pip install fluent-logger

A continuación, use un código como el siguiente para enviar los datos de la excepción:

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

Primero, instala la biblioteca fluent-logger-node:

npm install fluent-logger

A continuación, use un código como el siguiente para enviar los datos de la excepción:

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

Primero, instala el paquete fluent-logger-golang:

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

A continuación, usa un código como el siguiente para enviar datos de error:


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

Usar la API Error Reporting para escribir errores

La API Error Reporting proporciona un endpoint report para escribir información sobre errores en el servicio.

Enable the Error Reporting API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Informa de los errores a la API mediante la API REST o una biblioteca de cliente.
- API REST
  
  Consulta la documentación de referencia para obtener información sobre la API.
- Usar bibliotecas de cliente
  
  Hay bibliotecas en un número limitado de idiomas para ayudarte a llamar a la API Error Reporting desde tu aplicación:
  - ASP.NET
  - Go
  - Java
  - Node.js
  - Ruby
  - Python
  - PHP

Ejemplos

ASP.NET

El paquete NuGet de ASP.NET informa de las excepciones no controladas de las aplicaciones web de ASP.NET a Error Reporting.

Instala el paquete NuGet

Para instalar el paquete NuGet de Stackdriver ASP.NET en Visual Studio, sigue estos pasos:

Haz clic con el botón derecho en tu solución y selecciona Gestionar paquetes NuGet para la solución.
Selecciona la casilla Incluir versión preliminar.
Busca e instala el paquete llamado Google.Cloud.Diagnostics.AspNet.

Uso

Una vez que hayas instalado el paquete NuGet de Stackdriver ASP.NET, añade la siguiente instrucción al código de tu aplicación para empezar a enviar errores a Stackdriver:

using Google.Cloud.Diagnostics.AspNet;

Añade el siguiente código HttpConfiguration al método Register de tu aplicación web .NET (sustituye your-project-id por tu ID de proyecto real) para habilitar la notificación de excepciones:

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 vez que hayas añadido este método a tu aplicación ASP.NET, podrás ver las excepciones no controladas que se produzcan a medida que se registren en Google Cloud en la sección Informes de errores de la consola Google Cloud .

C#

Puedes encontrar el siguiente ejemplo en el repositorio GoogleCloudPlatform/dotnet-docs-samples. Para usarlo, después de compilar el proyecto, especifica el ID del proyecto:

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

Sustituye [YOUR_PROJECT_ID] por el valor correcto de la Google Cloud consola.

A continuación, envía los datos de la excepción con un código similar al siguiente:

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

Ver grupos de errores

En la Google Cloud consola, ve a la página Error Reporting:

Ve a Error Reporting.

También puedes encontrar esta página mediante la barra de búsqueda.

Configurar Error Reporting en Amazon EC2 Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Usar Logging para informar de errores

Java

Python

Node.js

Go

Usar la API Error Reporting para escribir errores

Ejemplos

ASP.NET

Instala el paquete NuGet

Uso

C#

Go

Java

Node.js

Ruby

Python

PHP

Ver grupos de errores

Configurar Error Reporting en Amazon EC2