Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Configura en Compute Engine

Error Reporting te permite agregar fallas y diagnosticar excepciones de tiempo de ejecución de tus aplicaciones de Compute Engine. Puedes enviar datos de errores transmitiendo registros a Cloud Logging o llamando directamente a la API de Error Reporting. Si usas Logging, tus entradas de registro deben cumplir con los requisitos de formato.

Usa Logging para informar sobre errores

Para conectar tus aplicaciones de Compute Engine a Error Reporting, envía tus excepciones o cualquier otro error a Logging con uno de los siguientes agentes:

Agente de operaciones
Agente de Logging heredado

Agente de operaciones

Para configurar Error Reporting para que use el Agente de operaciones, completa los siguientes pasos:

Instala el Agente de operaciones según corresponda a tu entorno. Para obtener instrucciones, consulta Instala el Agente de operaciones.
Configura el Agente de operaciones para recopilar los registros de tu aplicación y darles el formato adecuado.
- Para aplicaciones de terceros compatibles: El Agente de operaciones proporciona receptores de registros preconfigurados que capturan y analizan automáticamente las entradas de registro en formatos estructurados que reconoce Error Reporting. Para obtener información sobre las aplicaciones de terceros compatibles, consulta Supervisa aplicaciones de terceros.
- Para aplicaciones personalizadas: Configura un receptor de registros para especificar las ubicaciones de tus archivos de registro y vincúlalo con uno de los siguientes procesadores:
  - Usa un procesador parse_multiline si tu app escribe seguimientos de pila de texto sin formato en varias líneas.
  - Usa un procesador parse_json si tu app escribe registros como cadenas JSON.
  Si deseas obtener instrucciones detalladas, consulta Configura el agente de operaciones.
Si tu aplicación no genera seguimientos de pila estándar, modifícala para que registre las excepciones y sus seguimientos de pila en Cloud Logging.

Debes 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 Error Reporting no detecte el error. Puedes usar el formato JSON estructurado a fin de que las cargas útiles de tu entrada de registro incluyan diferentes tipos de datos para cada error.

Agente de Logging heredado

Para configurar Error Reporting para que use el agente de Logging heredado, completa los siguientes pasos:

Instala el agente de Logging google-fluentd según corresponda a tu entorno. Para obtener instrucciones, consulta Instala el agente de Logging.
Modifica tu aplicación para que registre las excepciones y sus seguimientos de pila en Logging.

Debes incluir toda la información de un solo error o excepción en la misma entrada de registro, incluidos todos los marcos de cualquier registro de seguimiento de pila. Si no se incluye toda la información, es posible que Error Reporting no detecte el error. Puedes usar el formato JSON estructurado para las cargas útiles de las entrada de registro y, así, incluir diferentes tipos de información para cada error.

Java

Agrega lo siguiente a tu archivo pom.xml:

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

Luego, usa un código como el siguiente para enviar los datos de 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

Luego, usa un código como el siguiente para enviar los datos de 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

Luego, usa un código como el siguiente para enviar los datos de 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/

Luego, usa un código como el siguiente para enviar datos de errores:


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

Usa la API de Error Reporting para escribir errores

La API de Error Reporting proporciona un extremo report para escribir información de error en el servicio.

Habilita la API de Error Reporting si aún no está habilitada.
Roles necesarios para habilitar las APIs
Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.
Habilitar la API
Informa errores a la API con la API de REST o una biblioteca cliente.
- API de REST
  
  Consulta la documentación de referencia para obtener información sobre la API.
- Usa las bibliotecas cliente
  
  Las bibliotecas existen en un número limitado de lenguajes para ayudarte a llamar a la API de 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 las excepciones no detectadas de las aplicaciones web de ASP.NET a Error Reporting.

Instala el paquete NuGet

Para instalar el paquete Stackdriver ASP.NET NuGet en Visual Studio, haz lo siguiente:

Haz clic con el botón derecho en tu solución y selecciona Administrar paquetes de NuGet para la solución.
Selecciona la casilla de verificación Incluir lanzamiento anticipado.
Busca y, luego, instala el paquete llamado Google.Cloud.Diagnostics.AspNet.

Uso

Una vez que hayas instalado el paquete NuGet de Stackdriver ASP.NET, agrega la siguiente sentencia al código de la aplicación para comenzar a enviar errores a Stackdriver:

using Google.Cloud.Diagnostics.AspNet;

Agrega el siguiente código HttpConfiguration al método Register de tu app web de .NET después de reemplazar your-project-id por tu ID del proyecto real para habilitar el registro 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 agregado este método a tu aplicación ASP.NET, podrás ver las excepciones no detectadas que se produzcan a medida que se informen a Google Clouden la sección Error Reporting de la consola de Google Cloud .

C#

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

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

Asegúrate de reemplazar [YOUR_PROJECT_ID] por el valor correcto de la consola deGoogle Cloud .

Luego, envía datos de excepciones 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();
    }
}

Cómo ver grupos de errores

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

Ir a Error Reporting

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

Configura en Compute Engine Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Usa Logging para informar sobre errores

Agente de operaciones

Agente de Logging heredado

Java

Python

Node.js

Go

Usa la API de Error Reporting para escribir errores

Ejemplos

ASP.NET

Instala el paquete NuGet

Uso

C#

Go

Java

Node.js

Ruby

Python

PHP

Cómo ver grupos de errores

Configura en Compute Engine