Configura en Google Kubernetes Engine

Puedes enviar errores de tus aplicaciones de Google Kubernetes Engine a Error Reporting de una de estas dos formas:

• Mediante el acceso a 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 errores, consulta Dale formato a errores en Cloud Logging.

• Usa la API de Error Reporting. Tu aplicación puede enviar solicitudes HTTP con la API de REST o puede usar bibliotecas experimentales en varios lenguajes.

Usa Logging para informar sobre errores

Para conectar tus aplicaciones de Google Kubernetes Engine a Error Reporting, envía tus excepciones o cualquier otro error a Logging mediante un nombre de registro dedicado a fin de mantener los errores aparte de los otros registros.

Para supervisar otros registros de Google Kubernetes Engine además de los registros de la aplicación, puedes crear métricas basadas en registros.

Por ejemplo:

1. Habilita la API de Cloud Logging.

   Habilita la API

2. Instala el agente google-fluentd de Logging que sea adecuado para tu entorno. Si deseas obtener instrucciones, consulta Instalación del agente de Logging. Ten en cuenta que google-fluentd se instala de forma automática para las aplicaciones de GKE.

3. Modifica tu aplicación para que registre las excepciones y los seguimientos de pila en Logging. Elige un nombre de registro para tu información de errores con el objetivo de separarla de otra información registrada.

   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 toda la información no está junta, es posible que Error Reporting no recoja la información. 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.

Java

Agrega lo siguiente al archivo pom.xml:

compute/error-reporting/pom.xml

Ver en GitHub

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

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

Ver en GitHub

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:

samples/snippets/fluent_on_compute/main.py

Ver en GitHub Comentarios

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

Luego, usa un código como el siguiente para enviar los datos de excepción:

Ver en GitHub

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:

docs/error-reporting/fluent/main.go

Ver en GitHub

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.

1. Habilita la API de Error Reporting.

   Habilita la API

2. 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 ASP.NET NuGet informa excepciones no detectadas de las aplicaciones web ASP.NET a Error Reporting.

Instala el paquete NuGet

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

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

Uso

Una vez que hayas instalado el paquete Stackdriver ASP.NET NuGet, agrega la siguiente declaración al código de tu 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 aplicación web .NET; para ello, reemplaza your-project-id por tu ID del proyecto real a fin de permitir el informe de excepciones:

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

Ver en GitHub

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 cualquier excepción no detectada a medida que se informa a Google Cloud en la sección Error Reporting de la consola.

C#

El siguiente ejemplo se puede encontrar 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.

Luego, envía datos de excepciones con un código similar al siguiente:

error-reporting/api/ErrorReportingSample.cs

Ver en GitHub

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

Consulta Configura Error Reporting para Go.

Java

Consulta Configura Error Reporting para Java.

Node.js

Consulta Configura Error Reporting para Node.js.

Ruby

Consulta Configura Error Reporting para Ruby.

Python

Consulta Configura Error Reporting para Python.

PHP

Consulta Configura Error Reporting para PHP.