Logs contextualizados do agente Go

Com nosso agente de linguagem Go, você pode obter o logs in context, que permite ver o registro do seu aplicativo no contexto de outros dados New Relic . Para informações gerais sobre este recurso, consulte logs contextualizados APM.

Dica

Tem muito log do Go? Confira nosso tutorial sobre como otimizá-los e gerenciá-los.

Biblioteca de logs compatível

Biblioteca	Suporta cobrança de atributo?
Logpadrão da biblioteca	Não
Trabalho árduo	Sim
Logrus	Sim
Zap	Sim
ZeroLog	Em breve

Configurando o logs contextualizados no agente

Modificações nas opções de configuração do agente Go são necessárias para utilizar o seguinte recurso logs contextualizados.

Para a maioria dos usuários, usar o encaminhamento automático de logs embutido no agente Go é a melhor solução. É fácil de configurar e funciona muito bem na maioria dos casos de uso. Saiba mais sobre as limitações de encaminhamento de logs.

O encaminhamento automático de log do aplicativo agora está habilitado por padrão no agente Go versão 3.20.0 ou mais alto. Se o seu aplicativo usa essas versões do agente Go, você não precisa alterar suas opções de configuração para ativar o encaminhamento automático de logs.

Se estiver usando uma versão mais antiga do agente Go, você precisará modificar sua configuração para ativar o encaminhamento de log do aplicativo:

app, err := newrelic.NewApplication(
  newrelic.ConfigAppLogForwardingEnabled(true),
)

Para usuários com necessidades de log mais personalizadas, ou usuários que desejam enviar mais de 10.000 logs por ciclo de 60 segundos, ou 833 logs por ciclo de 5 segundos, para New Relic recomendamos que você configure manualmente os encaminhamentos de logs. Depois de ter um direcionador de logs configurado para enviar log para New Relic, permita que o agente Go enriqueça seu log para encaminhamento, modificando sua configuração para incluir esta configuração:

app, err := newrelic.NewApplication(
  newrelic.ConfigAppLogDecoratingEnabled(true),
)

Se você estiver usando o agente Go versão v3.20.0 ou superior, será necessário desabilitar o encaminhamento de log do aplicativo para evitar a duplicação do log coletado pelo New Relic.

app, err := newrelic.NewApplication(
  newrelic.ConfigAppLogDecoratingEnabled(true),
  newrelic.ConfigAppLogForwardingEnabled(false),
)

Depois que seu agente estiver configurado para enviar log para New Relic, instale um plug-in de logs contextualizados para instrumentar sua biblioteca de log.

A biblioteca logWriter é um io.Writer que integra automaticamente o recurso New Relic Logs in Context mais recente ao agente da biblioteca padrão go. Siga estas etapas para instalá-lo em seu aplicativo. Esta biblioteca requer que a versão instalada do agente Go seja 3.19.1 ou superior.

Adicione o pacote logWriter ao seu módulo.
bash
```
$go get github.com/newrelic/go-agent/v3/integrations/logcontext-v2/logWriter
```

Importe o pacote logWriter no arquivo onde você inicializa seu agente.

import (
  "log"

  "github.com/newrelic/go-agent/v3/integrations/logcontext-v2/logWriter"
)

Crie um objeto logWriter. Deve ser passado um io.Writer válido, onde será gravado o log, e um aplicativo go-agente inicializado. O exemplo a seguir grava na saída padrão.
```
writer := logWriter.New(os.Stdout, newRelicApp)
```
Crie um objeto agente com seu novo objeto logWriter como destino de saída do agente.
```
logger := log.New(&writer, "", log.Default().Flags())
```
Neste ponto, qualquer log gravado com o agente criado será tratado pelo go-agente com base nas configurações de registro.
Transação
Caso queira capturar o contexto de uma transação, um novo objeto logWriter e um novo objeto agente deverão ser criados. Para criar um novo objeto logWriter para sua transação, use as funções WithTransaction() ou WithContext() dependendo de como a transação é passada para sua função. Estas funções farão uma nova cópia do objeto logWriter original com o contexto da transação incluído.
Se sua função receber um contexto encapsulado em uma transação, use a função WithContext():
```
txnWriter := writer.WithContext(myWrappedContext)
```
Se sua função receber um ponteiro de transação, use a função WithTransaction():
```
txnWriter := writer.WithTransaction(myTransaction)
```
Certifique-se de sempre criar um novo agente com um novo logWriter para cada transação. Isso evita a possibilidade de processos assíncronos acessarem o mesmo objeto agente com informações contextuais diferentes.
```
txnLogger := log.New(txnWriter, "", log.Default().Flags())
```
Resolução de problemas
A ferramenta logWriter foi projetada para falhar silenciosamente. Para ativar informações de depuração, chame o método DebugLogging(true) no objeto logWriter. Quando ocorre um erro no logWriter, ele sempre imprimirá sua linha de log não editada na primeira linha. Quando o DebugLogging estiver habilitado, ele imprimirá uma mensagem de erro na linha seguinte se ocorrer um erro.
```
writer.DebugLogging(true)
```

A biblioteca zerologWriter é um io.Writer que integra automaticamente o recurso mais recente New Relic Logs in Context no zerolog. Siga estas etapas para instalá-lo em seu aplicativo. Esta biblioteca requer que a versão instalada do go-agente seja 3.19.1 ou superior.

Adicione o pacote zerologWriter ao seu módulo.

bash

$go get github.com/newrelic/go-agent/v3/integrations/logcontext-v2/zerologWriter

Importe o pacote zerologWriter no arquivo onde você inicializa seu agente zerolog.

import (
  "log"

  "github.com/newrelic/go-agent/v3/integrations/logcontext-v2/zerologWriter"
)

Crie um objeto zerologWriter. Deve ser passado um io.Writer válido, onde será gravado o log, e um aplicativo go-agente inicializado. O exemplo a seguir grava na saída padrão.
```
writer := logWriter.New(os.Stdout, newRelicApp)
```
Crie um objeto agente com seu novo objeto zerologWriter como destino de saída do agente.
```
logger := zerolog.New(writer)
```
Neste ponto, qualquer log gravado com o agente criado será tratado pelo go-agente com base nas configurações de registro.
Transação
Caso queira capturar o contexto de uma transação, um novo objeto zerologWriter e um novo objeto agente deverão ser criados. Para criar um novo objeto zerologWriter para sua transação, use as funções WithTransaction() ou WithContext() dependendo de como a transação é passada para sua função. Essas funções farão uma nova cópia do objeto zerologWriter original com o contexto da transação incluído.
Se sua função receber um contexto encapsulado em uma transação, use a função WithContext():
```
txnWriter := writer.WithContext(myWrappedContext)
```
Se sua função receber um ponteiro de transação, use a função WithTransaction():
```
txnWriter := writer.WithTransaction(myTransaction)
```
Certifique-se de sempre criar um novo agente com um novo zerologWriter para cada transação. Isso evita a possibilidade de processos assíncronos acessarem o mesmo objeto agente com informações contextuais diferentes.
```
txnLogger := logger.Output(txnWriter)
```
Resolução de problemas
A ferramenta zerologWriter foi projetada para falhar silenciosamente. Para ativar informações de depuração, chame o método DebugLogging(true) no objeto zerologWriter. Quando ocorre um erro no zerologWriter, ele sempre imprimirá sua linha de log não editada na primeira linha. Quando o DebugLogging estiver habilitado, ele imprimirá uma mensagem de erro na linha seguinte se ocorrer um erro.
```
writer.DebugLogging(true)
```

O plug-in nrlogrus permite o logs contextualizados automático na ingestão com a framework de logging logrus. Depois que seu aplicativo estiver configurado para usá-lo, o agente Go irá ingerir automaticamente qualquer log escrito em logrus. Isso requer o agente Go versão 3.18.0 ou superior.

Adicione o pacote nrlogrus ao seu módulo.

bash

$go get github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrlogrus

Importe o pacote nrlogrus no arquivo onde você inicializa seu agente logrus.

import (
  "github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrlogrus"

  "github.com/sirupsen/logrus"
)

Configure e crie um novo formatador nrlogrus. Deve ser passado um aplicativo válido e qualquer formatador logrus válido. O formatador passado determinará a aparência do log que será gravado.
```
nrlogrusFormatter := nrlogrus.NewFormatter(newRelicApplication, &logrus.TextFormatter{})
```
Defina o formatador do seu agente para o formatador nrlogrus recém-criado.
```
log := logrus.New()
log.SetFormatter(nrlogrusFormatter)
```
Neste ponto, qualquer log gravado com o agente criado será tratado pelo go-agente com base nas configurações de registro.
Transação
Ao logar instrumentado dentro de uma transação, você deve passar essa transação para logrus como um contexto. Isso criará um novo objeto agente para aquela transação que vincula o log tratado pelo agente à transação e aos períodos em que ocorreu.
Se você tiver um contexto que contém uma transação:
```
txnLogger := log.WithContext(yourWrappedContext)
```
Caso contrário, você pode criar um contexto e passá-lo para o logrus:
```
txnLogger := log.WithContext(newrelic.NewContext(context.Background(), txn))
```

O plug-in nrzap permite o logs contextualizados automático na ingestão com a framework de log Zap. Assim que seu aplicativo estiver configurado para utilizá-lo, o go-agente irá ingerir automaticamente qualquer log escrito no Zap. Isso requer que a versão instalada do go-agente seja 3.22.1 ou superior.

Adicione o pacote nrzap ao seu módulo.

bash

$go get github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrzap

Importe o pacote nrzap no arquivo onde você inicializa seu agente Zap.

import (
  "github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrzap"

  "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

Configure e crie um novo objeto central Zap para o log do seu aplicativo. Como o objeto principal nunca precisa ser alterado e apenas precisa ser empacotado, é uma boa prática manter um ponteiro para esse objeto disponível para que você possa reutilizá-lo para criar núcleos Zap empacotados com mais eficiência.
```
core := zapcore.NewCore(zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), zapcore.AddSync(os.Stdout), zap.InfoLevel)
```
Enrole o objeto central Zap para capturar e enviar log para New Relic. Observe que, desde que a função wrap receba um núcleo Zap válido, o núcleo que ela retorna será válido, mesmo se um erro for retornado. Por esse motivo, é importante verificar o tipo de erro.
```
backgroundCore, err := nrzap.WrapBackgroundCore(core, app)
if err != nil && err != nrzap.ErrNilApp {
  panic(err)
}

backgroundLogger := zap.New(backgroundCore)
```
Transação
Ao logar-se dentro de uma transação, será necessário criar um novo núcleo e agente Zap. Isso pode ser feito chamando a função WrapTransactionCore() .
```
txn := app.StartTransaction("nrzap example transaction")
  txnCore, err := nrzap.WrapTransactionCore(core, txn)
  if err != nil && err != nrzap.ErrNilTxn {
    panic(err)
  }

  txnLogger := zap.New(txnCore)
```

O plug-in nrslog permite o logs contextualizados automático na ingestão com a framework padrão da biblioteca slog. Depois que seu aplicativo estiver configurado para usá-lo, o agente Go irá ingerir automaticamente qualquer log gravado com seu agente de slog empacotado. Isso requer o agente Go versão 3.30.0 ou superior.

Adicione o pacote nrslog ao seu módulo.

bash

$go get github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrslog

Importe o pacote nrslog no arquivo onde você inicializa seu agente slog.

import (
  "github.com/newrelic/go-agent/v3/integrations/logcontext-v2/nrslog"

  "log/slog"
)

Configure e crie um novo manipulador nrslog. Deve ser passado um ponteiro de aplicativo New Relilc válido, um io.Writer e um ponteiro para um objeto slog.HandlerOptions. Funções de conveniência são empacotadas no nrslog para instrumentar automaticamente os manipuladores de texto e json que saem da caixa no slog. Neste exemplo, agruparemos slog.TextHandler.
```
instrumentedTextHandler := nrslog.TextHandler(app, os.Stdout, &slog.HandlerOptions{})
```
Crie um novo agente com seu manipulador instrumentado.
```
logger := slog.New(instrumentedTextHandler)
```
Neste ponto, qualquer log gravado com este novo agente será tratado pelo go-agente com base nas configurações de log.
Transação
Ao instrumentar logs dentro de uma transação, você deve passar essa transação para nrslog. A maneira preferida de fazer isso é passando-o dentro de um contexto para o slog. Se você tiver um contexto que contém uma transação:
```
txnCtx := newrelic.NewContext(context.Background(), txn)
logger.InfoContext(txnCtx, "My log message")
```

Este documento ajudou você na instalação?

Proteja seus dados

Seu registro pode incluir informações confidenciais protegidas pela HIPAA ou outros protocolos de conformidade. Por padrão, ofuscamos padrões numéricos que parecem ser de itens como cartões de crédito ou números de Seguro Social, mas pode ser necessário aplicar hash ou mascarar informações adicionais.

Para mais informações, veja nossa documentação sobre expressão de ofuscação e regras. Você pode aplicar hash ou mascarar seus dados log usando a interface New Relic ou NerdGraph, nossa API GraphQL.

Qual é o próximo?

Depois de configurar o logs contextualizados, aproveite ao máximo seus dados de registro:

Explore os dados de registro em sua plataforma com nossa interface de registro.
Veja seu logs contextualizados do desempenho do seu aplicativo na interfaceAPM . Solucione erros com distributed tracing, rastreamento de pilha, registro de aplicativo e muito mais.
Obtenha visibilidade mais profunda do seu aplicativo e dos dados de desempenho da plataforma encaminhando seu log com nosso agente de infraestrutura. Revise seu log de infraestrutura na interface.
Configure o alerta.
consulte seus dados e crie dashboard.

Esta tradução de máquina é fornecida para sua comodidade.

Dica

Biblioteca de logs compatível

Configurando o logs contextualizados no agente

Decore e encaminhe log com APM

Decore o log com APM e encaminhe o log manualmente

Logpadrão da biblioteca

Transação

Resolução de problemas

Registro zero

Transação

Resolução de problemas

Logrus

Transação

Zap

Transação

Trabalho árduo

Transação

Este documento ajudou você na instalação?

Proteja seus dados

Qual é o próximo?

Esta tradução de máquina é fornecida para sua comodidade.

Logs contextualizados do agente Go

Dica

Biblioteca de logs compatível .css-21sua1{background:none;border:none;width:0;padding:0;}

Configurando o logs contextualizados no agente

Decore o log com APM e encaminhe o log manualmente

Instalando um plug-in de contexto de login

Logpadrão da biblioteca

Registro zero

Logrus

Zap

Trabalho árduo

Este documento ajudou você na instalação?

Proteja seus dados

Qual é o próximo?

Biblioteca de logs compatível