Esta página foi traduzida pela API Cloud Translation.

Configurar o relatório de erros no Amazon EC2

Pode enviar erros das suas aplicações EC2 para o relatório de erros de uma das seguintes formas:

Ao registar no Cloud Logging. Se já estiver a usar o Cloud Logging, o único requisito adicional é que as suas entradas de registo sejam reconhecidas pelo Error Reporting. Para mais informações sobre os requisitos de formatação de erros, leia o artigo Formatar erros no Cloud Logging.
Usar a API Error Reporting. A sua aplicação pode enviar pedidos HTTP através da API REST ou usar bibliotecas experimentais em vários idiomas.

Usar o registo para comunicar erros

Para associar as suas aplicações EC2 ao Relatório de erros, envie as suas exceções ou outros erros para o Registo.

Por exemplo:

Associe o sistema Amazon Web Services (AWS) ao Google Cloud. Para mais informações, consulte o artigo Instalar o agente de registo em VMs individuais.
Instale o agente do Logging google-fluentd conforme adequado para o seu ambiente. Para ver instruções, consulte o artigo Instalar o agente de registo.
Modifique a sua aplicação para que registe exceções e respetivos rastreios de pilha no Logging.

Tem de incluir todas as informações de um único erro ou exceção na mesma entrada do registo, incluindo todos os frames de qualquer rastreio de pilha. Se todas as informações não estiverem juntas, o Relatório de erros pode não detetar o erro. Pode usar o formato JSON estruturado para os payloads de entradas de registo de modo a incluir diferentes tipos de informações para cada erro.

Java

Adicione o seguinte ao ficheiro pom.xml:

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

Em seguida, use um código como o seguinte para enviar os dados de 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:

sudo pip install fluent-logger

Em seguida, use um código como o seguinte para enviar os dados de 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:

npm install fluent-logger

Em seguida, use um código como o seguinte para enviar os dados de 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 fluent-logger-golang pacote:

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

Em seguida, use um código como o seguinte para enviar dados de 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": "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 a API Error Reporting para escrever erros

A API Error Reporting fornece um ponto final report para escrever informações de erro no serviço.

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
Comunique erros à API através da API REST ou de uma biblioteca cliente.
- API REST
  
  Consulte a documentação de referência para obter informações sobre a API.
- Usar bibliotecas de cliente
  
  Existem bibliotecas num número limitado de idiomas para ajudar a chamar a API Error Reporting a partir da sua aplicação:
  - ASP.NET
  - Go
  - Java
  - Node.js
  - Ruby
  - Python
  - PHP

Amostras

ASP.NET

O pacote NuGet do ASP.NET comunica exceções não detetadas de aplicações Web ASP.NET para o Relatório de erros.

Instale o pacote NuGet

Para instalar o pacote NuGet do Stackdriver ASP.NET no Visual Studio:

Clique com o botão direito do rato na sua solução e selecione Gerir pacotes NuGet para a solução.
Selecione a caixa de verificação Incluir versão pré-lançamento.
Pesquise e instale o pacote com o nome Google.Cloud.Diagnostics.AspNet.

Utilização

Depois de instalar o pacote NuGet do Stackdriver ASP.NET, adicione a seguinte declaração ao código da aplicação para começar a enviar erros para o Stackdriver:

using Google.Cloud.Diagnostics.AspNet;

Adicione o seguinte código HttpConfiguration ao método Register da sua app Web .NET (substituindo your-project-id pelo seu ID do projeto real para ativar a comunicação de exceções):

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));
    // ...
}

Depois de adicionar este método à sua aplicação ASP.NET, pode ver todas as exceções não capturadas que ocorrem à medida que são comunicadas à secção Relatório de erros da consola Google Cloud . Google Cloud

C#

Pode encontrar o exemplo seguinte no repositório GoogleCloudPlatform/dotnet-docs-samples. Para o usar, depois de criar o projeto, especifique o seu ID do projeto:

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

Certifique-se de que substitui [YOUR_PROJECT_ID] pelo valor correto da consolaGoogle Cloud .

Em seguida, envie dados de exceção com um código semelhante ao seguinte:

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

Veja grupos de erros

Na Google Cloud consola, aceda à página Error Reporting:

Aceda a Error Reporting

Também pode encontrar esta página através da barra de pesquisa.

Configurar o relatório de erros no Amazon EC2 Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Usar o registo para comunicar erros

Java

Python

Node.js

Go

Usar a API Error Reporting para escrever erros

Amostras

ASP.NET

Instale o pacote NuGet

Utilização

C#

Go

Java

Node.js

Ruby

Python

PHP

Veja grupos de erros

Configurar o relatório de erros no Amazon EC2