Como configurar o Error Reporting no Amazon EC2

Com o Error Reporting, é possível agregar falhas e diagnosticar exceções de tempo de execução dos aplicativos do EC2. É possível enviar dados de erros transmitindo registros para o Cloud Logging ou chamando a API Error Reporting diretamente. Se você usa o Logging, as entradas de registro precisam seguir os requisitos de formatação.

Usar o Logging para relatar erros

Para conectar seus aplicativos do EC2 ao Error Reporting, envie exceções ou outros erros para o Logging.

Exemplo:

  1. Conecte o sistema da Amazon Web Services (AWS) ao Google Cloud. Para mais informações, consulte Instalar o agente do Logging em VMs individuais.
  2. Instale o agente do Logging google-fluentd no estado em que se encontra, conforme apropriado para seu ambiente. Para instruções, consulte Como instalar o agente do Logging.

  3. Modifique o aplicativo para que ele registre exceções e respectivos rastreamentos de pilha no Logging.

    Inclua todas as informações de um único erro ou exceção na mesma entrada de registro, incluindo todos os frames de qualquer stack trace. Se todas as informações não estiverem juntas, o Error Reporting poderá não detectar o erro. É possível usar o formato JSON estruturado nos seus payloads de entrada de registro para incluir diferentes tipos de informações de cada erro.

Java

Adicione a instrução a seguir ao seu arquivo pom.xml:

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

Depois, use o código como o demonstrado a seguir para enviar os dados da exceção:

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

Primeiro, instale a biblioteca fluent-logger-python (em inglês):

sudo pip install fluent-logger

Depois, use o código como o demonstrado a seguir para enviar os dados da exceção:

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

Primeiro, instale a biblioteca fluent-logger-node (em inglês):

npm install fluent-logger

Depois, use o código como o demonstrado a seguir para enviar os dados da exceção:

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

Primeiro, instale o pacote fluent-logger-golang (em inglês):

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

Depois, use o código como o demonstrado a seguir para enviar dados do erro:


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"