Logging é a técnica de manter registros para propósitos futuros no ciclo de desenvolvimento de software. O registro em log é fundamental porque os logs ajudam na depuração, diagnóstico, solução de problemas e monitoramento do projeto.

Você pode usar o log em vários níveis de seus aplicativos para erros, avisos, depuração e muito mais.

Iniciar sessão Ir

A biblioteca padrão Go contém um registro pacote rico em funcionalidades. Ele lida com vários níveis de registro e métodos básicos relacionados ao registro que você precisará para seu aplicativo. No entanto, o registro O pacote pode não ser a melhor escolha se seu aplicativo for complexo e você quiser priorizar a produtividade.

o registro pacote não fornece funcionalidade para logs estruturados. Os pacotes de log estruturados fornecem funcionalidade que simplifica e melhora o processo de log. O ecossistema Go é o lar de muitos desses pacotes.

1. Zap de Uber

Zap é um pacote de log rápido, estruturado e nivelado criado pela equipe de código aberto da Uber para escrever logs em Go. Uber construiu o pacote Zap para fornecer um registro mais eficiente do que outros pacotes no ecossistema Go, incluindo o

instagram viewer
registro pacote.

Existem dois registradores distintos no pacote Zap. o Registrador função lida com casos críticos de desempenho. o Registrador Açucarado oferece mais flexibilidade com sua API no estilo printf, mas vem com uma pequena compensação no desempenho. Mesmo o pacote SugaredLogger mais lento é 4-10 vezes mais rápido do que outros pacotes de log estruturados.

Execute o seguinte em uma linha de comando para instalar o pacote Zap:

vai pegue -u vai.uber.org/zap

Você precisará de uma versão recente do Go para instalar e usar a funcionalidade do pacote Zap com sucesso.

logger, err := zap. NovaProdução() // zap instância do registrador
E se err!= nada {
 fmt. Println (err. Erro())
}


adiar madeireiro. Sincronizar() // libera os buffers, se houver
açúcar := logger. Açúcar() // logger açucarado aqui


açúcar. Infow("falha ao buscar URL",
// Contexto estruturado como pares chave-valor de tipo flexível.
 "url", url,
 "tentar", 3,
 "recuo", tempo. Segundo,
)
açúcar. Infof("Falha ao buscar URL: %s", URL) // usando o formatador de estilo printf

o registrador variável é uma instância da zap registrador, e o Açúcar é uma instância de logger com açúcar.

o Infow método grava na saída, e o Info de é a versão de formatação do Infow método.

2. O pacote Logrus

Logrus é um pacote de log estruturado para aplicativos Go. O Logrus é compatível com o registrador de biblioteca padrão, com funcionalidade semelhante. Se você tem experiência com o uso de registro pacote, você encontrará uma suíte trabalhando com Logrus.

O Logrus não oferece suporte à formatação JSON por padrão. Mas você sempre pode usar uma biblioteca JSON como a built-in json pacote com Logrus' SetFormatter método.

O Logrus suporta o registro em diferentes níveis e, embora não seja tão eficiente quanto a maioria dos pacotes de registro, é rico em recursos e seguro.

Você pode usar este comando para instalar o Logrus em seu diretório de trabalho:

vai obtenha github.com/sirupsen/logrus

Aqui está um exemplo de log com o pacote Logrus.

importar (
 "os"
 log "github.com/sirupsen/logrus" // importação de alias
)
funçãoa Principal {
 registro. SetFormatter(&log. JSONFormatter{}) // configura o formatador para JSON
 registro. SetOutput (os. Stdout) // saída para saída padrão 
 registro. SetLevel (log. Nível de Aviso) // define o nível de aviso
registro. ComCampos (log. Campos{
 "Nome": "John Doe",
 "Era": 40,
 }).Info("Dados biográficos de John")
}

Este código importa a biblioteca Logrus e cria um alias para ela chamado registro. No a Principal função, ele chama o SetFormatter para definir um formatador para os logs. Você pode usar o Definir saída método para especificar onde as mensagens de log devem ir; neste caso, saída padrão.

o Definir nível O método registra avisos no nível especificado ou acima.

3. Pacote ZeroLog

ZeroLog é uma biblioteca rápida, inspirada em Zap e dedicada a JSON para registro, projetada para desempenho. Ele usa uma API de encadeamento exclusiva que permite ao Zerolog gravar eventos JSON e log sem alocações e reflexões.

Zerolog visa fornecer uma API mais fácil de usar e maior desempenho, mantendo a base de código e a API simples. Ele se concentra no registro estruturado e você pode usar o ConsoleWriter método para fazer logon bonito no seu console.

Há baixa alocação, registro nivelado, amostragem, ganchos, campos contextuais e registro de erros com recursos opcionais de rastreamento de pilha no pacote Zerolog. Você também pode integrar o Zerolog com o contexto e http pacotes.

Execute este comando no terminal do seu espaço de trabalho para instalar o Zerolog pacote.

vai get -u [github.com/rs/zerolog/log](http://github.com/rs/zerolog/log)

Aqui está um exemplo simples de usar o pacote Zerolog para uma operação simples.

importar (
 "github.com/rs/zerolog" // zerolog para configurações
 "github.com/rs/zerolog/log" // log para logar
)
funçãoa Principal() {
// UNIX Time é mais rápido e menor que a maioria dos timestamps
 zerolog. TimeFieldFormat = zerolog. TimeFormatUnix
registro. Print("Olá mundo")
}

o Formato de campo de tempo opção está definida para o formato de hora Unix, e a Imprimir O comando grava o argumento de texto na saída padrão.

4. O Pacote Log15

o Registro15 O pacote é um kit de ferramentas simples e opinativo para registro em log legível por humanos e por máquina com as melhores práticas em Go. Log15 modela o io e http pacotes da biblioteca padrão Go como alternativa ao built-in registro pacote.

Os recursos do pacote Log15 incluem:

  • uma API simples e fácil de entender
  • registro estruturado com pares de valores-chave
  • loggers filhos com contexto privado
  • interface do manipulador para construir configurações de registro personalizadas em uma pequena API
  • suporte de terminal colorido
  • suporte integrado para log em arquivos, fluxos, logs do sistema e logs de rede
  • registros de buffer para saída.

Você pode instalar Registro15 aos seus pacotes Go com este comando.

vai obtenha github.com/inconshreveable/log15

É fácil começar com o pacote Log15. Aqui está um exemplo de instanciar um logger e registrar informações e níveis de erro com o pacote.

importar (
 log "github.com/inconshreveable/log15" // alias importa como log
)
funçãoa Principal() {
 serverLog := log. New("repositório", "novo repositório") // instanciando o registrador
 serverLog. Info("verificação de integridade da camada de repositório bem-sucedida") //registro de informações
 serverLog. Error("Falha na verificação de integridade da camada do repositório") //registro de erros
}

o serverLog variável é uma instância do registrador Log15; a Novo retorna um registrador com os argumentos de contexto que você fornece.

o Informações retorna uma mensagem informativa e o Erro método retorna uma mensagem de erro.

Gravar logs úteis e compreensíveis

O registro pode ser tão crítico quanto qualquer outra parte do processo de desenvolvimento. Pode parecer muito fácil nos estágios iniciais, mas manter as práticas essenciais pode complicar o processo. Para lidar com todos os casos extremos e aspectos do registro, você deve usar um pacote de registro para facilitar as coisas.

Use níveis de log, estrutura e contexto para tornar seus logs compreensíveis e adequados aos propósitos pretendidos.