Pacote de Golang Logrus

Nesta lição sobre o pacote Logrus em Golang, estudaremos vários exemplos sobre a eficácia do registro. Vamos começar agora.

Começando com Go

Aqui está a estrutura de diretório que fiz para o meu Programa Hello World:

Aqui está o programa que criamos:

Pacote principal
importar "fmt"
func main ()
fmt.Printf ("Olá, mundo.\ n ")

Podemos executar o programa acima com o seguinte comando:

vá correr olá.ir

Depois de executar este comando, aqui está a saída que você verá:

Agora isso parece bom. Vamos mudar para a nossa agenda principal.

Pacote Logrus em Golang

Para começar a usar o pacote Logrus no programa Go, devemos pegar isto. Execute o seguinte comando:

vá buscar -t github.com/sirpsen/Logrus

Quando começamos a usar este pacote no Intellij, vemos esse erro que podemos resolver em um clique:

Depois de obter o pacote, podemos começar a usá -lo. Vamos começar com um programa simples.

Freejo básico com Logrus

Começaremos com um exemplo de log de nível de informação muito básico. O registro pode ser feito com mensagens de string e metadados na forma de pares de valores-chave que parecem os mesmos.

Pacote principal
importação (
Log "Github.com/sirpsen/Logrus "
)
func main ()
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
"Ajuda": 200,
).Info ("Golang Pro")

Quando executamos este programa, podemos ver a seguinte saída:

Agora isso é útil e colorido!

Vários níveis de registro

Agora, tentaremos outro exemplo que mostrará o uso de vários níveis de registro disponíveis no Logrus e em geral. Eles são:

• Informações
• Aviso
• Fatal
• Depurar
• Pânico

Vamos tentar construir um programa e ver como esses níveis de log diferem quando aparecem em nosso programa:

Pacote principal
importação (
Log "Github.com/sirpsen/Logrus "
)
func main ()
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
).Info ("Mensagem do Golang Pro Info")
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
).Warn ("Mensagem do Golang Pro Warn")
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
).Fatal ("Mensagem Golang Pro Fatal")
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
).Panic ("Mensagem do Golang Pro Panic")
registro.Withfields (log.Campos
"Site": "Linuxhint.com ",
"Awesome": 100,
).Debug ("Mensagem de depuração do Golang Pro")

Quando executamos este programa, veremos a seguinte saída:

Notei algo? As declarações de log após a declaração fatal nem aparecem em nossa saída. Isso ocorre porque, assim que um erro fatal é recebido, a execução do programa para em Golang.

Vamos modificar a ordem dessas declarações e verificar se algumas alterações na saída também são observadas:

Desta vez, até o nível de toras de pânico reagiu da mesma maneira, mas a saída foi muito diferente e detalhada.

Com o nível de log de pânico, você garante que informações suficientes sobre a máquina host também impressas na saída no console, para que o trabalho seja deburgável.

Maneira mais simples de fazer toras

Nas chamadas acima, os logs eram bastante detalhados e com metadados também. Há uma maneira mais fácil de registrar suas mensagens. Vamos tentar isso agora:

Pacote principal
importação (
Log "Github.com/sirpsen/Logrus "
)
func main ()
registro.Debug ("Dados de depuração aqui.")
registro.Info ("mensagens para informações comuns")
registro.Warn ("Você deve olhar para este aviso!")
registro.Erro ("algo falhou, mas o programa continuará.")
// chama OS.Saída (1) após o registro
registro.Fatal ("estou saindo.")
// chama o panic () após o registro
registro.Pânico ("Não vou ser impresso :(")

Aqui está a saída para o programa:

O comportamento para a exploração era o mesmo, mas desta vez, eles eram fáceis de fazer em apenas uma linha.

Conclusão

Neste post, estudamos exemplos simples, mas úteis, sobre como podemos registrar mensagens importantes com diferentes gravidade e verbosidade em nossos aplicativos usando o pacote Logrus com Golang.