Django Logging

Todos os desenvolvedores depuram os erros. A resolução desses erros leva tempo. Ajuda na maioria dos casos a saber quando e onde o erro ocorreu. Eu diria que as mensagens de erro do Python são bastante úteis. Mas mesmo estas mensagens tornam inúteis quando se fala de projetos com múltiplos arquivos. Esse problema e muitos outros benefícios vêm com o log.

Como desenvolvedores Django, é importante que nós também dominemos o log. As tecnologias backend têm várias grandes ferramentas para implementar o logging. O Django também fornece suporte a vários frameworks e módulos de logging. Vamos implementá-lo usando o básico e um dos populares módulos de logging.

Neste tutorial, vamos aprender sobre logging. O conteúdo será:

• O que é Logging?
• Python Logging Module
• Logging in Django

Pronto para aprender. Vamos começar.

O que é Logging?

Logging é uma técnica ou meio que pode nos deixar acompanhar alguns eventos enquanto o software executa. É uma técnica importante para os desenvolvedores. Ela os ajuda a rastrear os eventos. O Logging é como um conjunto extra de olhos para eles. Os programadores não são apenas responsáveis por fazer software, mas também por mantê-los. O Logging ajuda imensamente com essa parte da manutenção.

Trava todos os eventos que ocorrem em todos os momentos. Isso significa que, em vez dos longos tracebacks, você recebe muito mais. Desta vez quando ocorre um erro, você pode ver em que sistema estava. Este método irá ajudá-lo a resolver os erros rapidamente. Como você será capaz de dizer onde o erro ocorreu.

Como ele funciona? Qual é a ideia por detrás disto?

O registo é tratado por um programa separado. Esse programa de registo é simplesmente um gravador de ficheiros. Diz-se que o logger grava certos eventos em formato texto. A informação gravada é então guardada em ficheiros. Os arquivos para isso são chamados de logs. Os registros são arquivos simples salvos com extensão de registro. Eles contêm os logs dos eventos ocorridos.

Bem, esta é apenas uma das implementações mais usadas, como você pode ver. Como estamos apenas armazenando a informação, você pode encontrar mais maneiras de lidar com ela.

Okay, está claro para nós que o log é importante. É difícil? Não, absolutamente não, amigo. O registo não é difícil de todo. Qualquer um que saiba um pouco sobre a configuração pode usar isto.

Ser um programador Python, você obtém recursos extras aqui também. Nós temos um módulo inteiro que nos permite fazer exatamente isso. Quanto a outras linguagens, existem muitos módulos, Java tem Log4j e JavaScript tem o seu próprio loglevel. Todos eles são ferramentas incríveis também. Ok, então vamos lidar com Python (minha linguagem favorita) aqui.

Módulo de Log em Python

O módulo de log é um módulo Python embutido. Ele vem pré-instalado com o Python 3. O módulo de registo é usado para manter um registo dos eventos que ocorrem à medida que o programa corre. Isso pode ser estendido a qualquer número de programas e assim, para software, é fácil de configurar e usar.

Porquê usar o módulo de registo?

Como desenvolvedor, podemos perguntar porquê usar o módulo de registo. Tudo o que o módulo de registo faz é escrever num ficheiro ou imprimi-lo na consola. Tudo o que pode ser conseguido através da utilização de declarações de impressão. Então, qual é a necessidade de um módulo de registo? Essa é uma pergunta válida. A resposta a isso é o log é um módulo que dá o que a impressão não pode.

Usamos a função de impressão para produzir algo na consola. Então, quando uma função ocorre, podemos obter uma declaração de impressão de que a função foi executada. Enquanto essa abordagem funciona com aplicações menores, ela é ineficiente.

Função de impressão torna-se parte do seu programa e se o software parar de funcionar, você não obterá o resultado. Além disso, se alguma coisa ocorrer e o sistema reiniciar, o console também estará livre. Então, o que você vai fazer? A resposta a isso é o módulo de registo.

O módulo de registo é capaz de:

• Execução de múltiplas leituras
• Categorizar mensagens através de diferentes níveis de registo
• É muito mais flexível e configurável
• Dá-se uma informação mais estruturada

Então, existem 4 partes principais do módulo de registo. Vamos olhar para elas uma a uma.

1. Loggers

Os loggers são os objetos com os quais os desenvolvedores lidam. Eles podem ser entendidos como uma função que será invocada quando eles forem chamados. Nós usamos os loggers nos nossos ficheiros de projecto. Assim, quando a função é invocada, obtemos um relatório detalhado. O logger pode gerar múltiplos níveis de respostas. Podemos customizá-lo em toda a extensão.

2. Handlers

Handlers são os objetos que emitem a informação. Pense neles como manipuladores de jornais. A sua principal tarefa é transmitir a informação. Isso pode ser conseguido escrevendo a informação em um arquivo de log (O comportamento padrão). Existem vários manipuladores fornecidos pelo módulo de log.

Podemos facilmente configurar vários manipuladores para o mesmo logger. Também existem manipuladores SMTP que lhe enviarão os registros de log. Os manipuladores normalmente contêm lógica empresarial para a informação de registo.

3. Formatadores

Os formatadores são os que formatam os dados. Você vê que os manipuladores não podem enviar a informação porque é um tipo de dados Python. Antes de poder ser enviado para qualquer pessoa, ele precisa ser convertido.

Os logs são por defeito no formato Log Records. Essa é a classe pré-definida pelo framework de logs. Ele dá vários métodos aos desenvolvedores para usar. Esse formato não pode ser enviado diretamente por uma rede ou escrito em um arquivo de texto. Para converter isso ou formatar isso, nós precisamos de formatadores. Existem diferentes formatadores para diferentes manipuladores.

Por defeito, os formatadores irão converter o Registo de Registo em String. Este comportamento pode ser facilmente alterado e você pode personalizá-lo como quiser. Este formato pode ser baseado na lógica de negócio que escrevemos em Handlers.

4. Filtros

A última peça do módulo de registo é os filtros. Os filtros, como o nome sugere, filtram as mensagens. Nem todas as mensagens que passamos precisam ser armazenadas ou transportadas. Ou pode haver diferentes manipuladores para diferentes mensagens. Tudo isso é possível com a ajuda de filtros.

Podemos usar filtros tanto com registradores quanto com manipuladores.

Okay, então agora temos uma idéia básica do módulo de registro de mensagens. Ele também nos fornece níveis de mensagens. Os níveis das mensagens são definidos como:

DEBUG: É informação verbosa do sistema quando tudo está funcionando bem. Ele irá dizer-lhe detalhes mais precisos sobre o estado do sistema. Seu ponto de severidade é 10.

INFO: A informação produzirá menos informação verbosa do sistema, mas é semelhante à depuração. Ela geralmente diz uma visão geral do que o sistema está executando. Seu ponto de severidade é 20.

WARNING: Contém informações sobre problemas de baixo nível. Os problemas podem ser ignorados, pois não causam a parada do sistema. Embora, é recomendado que estes problemas sejam resolvidos.

Its ponto de severidade é 30.

ERROR: Esta mensagem é séria. O erro conterá informações sobre o maior problema que ocorreu. O problema pode ter parado a operação do programa e precisa de atenção imediata.

Its ponto de severidade é 40.

CRÍTICO: A mensagem mais crítica. Esta mensagem é emitida quando o problema fez com que o sistema parasse. Isto significa que a aplicação inteira parou devido a este problema.

Its ponto de severidade é 50.

O ponto de severidade determina a prioridade que deve ser dada. Suponha que definimos o nível de log como 30. Então o logger irá registrar ou armazenar as informações quando o nível for maior ou igual a 30. Então, você só precisa confirmar que nível de log você quer. Aprenderemos mais sobre eles na próxima seção.

Podemos facilmente implementar o registro importando o módulo. Como é um módulo incorporado, não precisamos instalá-lo via pip.

Apenas escreva isto no seu arquivo Python e podemos usar loggers.

Código:

import logginglogging.warning("DataFlair Logging Tutorials")

A saída gerada pelo código está logo abaixo. Como você pode ver, o log é impresso no console, ele tem nível de log, nome de logger e mensagem. root é o logger-name padrão. Nós usaremos estes tipos de funções com nossas views em Django.

Explorar um tutorial completo em Python Logging Module

Logging in Django

Django fornece logging usando o módulo de log do Python. O módulo de registo pode ser facilmente configurado.

Quando queremos usar o registo em Django há certos passos a seguir. O procedimento será o seguinte:

1. Configuraremos nossas configurações.py para vários registradores, manipuladores, filtros.
2. Incluíremos o código dos registradores nas views ou qualquer outro módulo do Django onde for necessário.

Okay, então vamos começar.

Criar um novo Projeto

Criaremos um novo projeto para logging. Você pode então usar o logon em projetos existentes. Então, para criar um novo projeto, execute este comando na linha de comando:

$ django-admin startproject dataflairlogs

Isto irá iniciar o novo projeto. Agora, vamos configurar settings.py do projeto.

Configuring Settings

Para incluir o login no Django, precisamos configurar suas configurações. Fazendo isso é muito fácil. Ao configurar as configurações de login, queremos definir:

• Loggers
• Handlers
• Filtros
• Formatters

Desde que o Django trabalha com módulos diferentes, portanto, usamos o método dictConfig.

Existem outros métodos em bruto também, mas dictConfig é o comportamento padrão do Django.

Pois copiar este código nas suas configurações.py

Código:

# DataFlair #Logging InformationLOGGING = { 'version': 1, # Version of logging 'disable_existing_loggers': False, #disable logging # Handlers ############################################################# 'handlers': { 'file': { 'level': 'DEBUG', 'class': 'logging.FileHandler', 'filename': 'dataflair-debug.log', },######################################################################## 'console': { 'class': 'logging.StreamHandler', }, }, # Loggers #################################################################### 'loggers': { 'django': { 'handlers': , 'level': 'DEBUG', 'propagate': True, 'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG') }, },}

Entenda o Código:

Eu sei que o código é um pouco grande, mas é muito fácil de entender. Nós obtemos um LOGGING da variável embutida do Django. Os valores padrão do log vem deste dicionário. Já que estamos configurando configurações usando um dicionário, ele é chamado de método dictConfig. Existem algumas chaves importantes dentro do dicionário LOGGING.

1. versão
2. disable_existing_loggers
3. handlers
4. loggers

Discuta-os um por um. A chave da versão diz a versão esquemática. É importante que ela tenha valor. É por defeito 1.

A próxima chave é disable_existing_loggers. Esta chave é para dizer ao Django para não desabilitar os registradores. Por padrão, o Django usa alguns de seus próprios loggers. Estes registradores são conectados com Django ORM e outras partes internas do Django. Esta chave é, por padrão, True. Então, ela irá desabilitar esses loggers.

Existem várias consultas de banco de dados e chamadas de função que os loggers registram. Portanto, é recomendado que você não True esta chave.

Handlers é a terceira chave. Como discutimos, os manipuladores lidam com a mensagem e passam-nas para o console, arquivo, etc. Os manipuladores em si são um dicionário. Esse dicionário – os nomes das teclas serão os nomes dos manipuladores. Há vários manipuladores fornecidos pelo módulo de registro. Estamos usando dois manipuladores aqui.

1. FileHandler: logger-name – filehandler

O FileHandler irá armazenar os logs em um arquivo. Como pode ver, demos o nome do ficheiro como dataflair-debug.log.

O nível define, até que nível o logger deve submeter os logs.

Nota:

Os ficheiros de log são geralmente guardados com a extensão .log. Este ficheiro só pode ser editado com permissões. Só pode ser anexado.

2. StreamHandler: nome do logger – consola

O stream handler irá transmitir o log na consola. Este não é um método recomendado. Há um limite de caracteres até a linha de comando mostrar os logs. Como os logs são muito grandes para serem manipulados pela linha de comando, portanto precisamos de manipuladores de arquivos.

Existem mais manipuladores como manipuladores de e-mail, AdminEmailHandler etc.

O AdminEmailHandler é uma grande adição ao módulo opensource.

Loggers são os que irão registrar as informações do seu servidor ou software. Os registradores também são do tipo dicionário. Ele tem uma arquitetura similar à dos manipuladores. Embora, existem diferentes atributos e outras propriedades.

Django também fornece um conjunto de registradores. Existem vários registradores como django, django.requests. e mais.

Ponha você checando nosso último pedido de Django &Resposta Tutorial

Agora, para implementar o logging, você só precisa seguir estes passos:

Inicie seu servidor.

$ python manage.py runserver

No momento em que você clicar em enter haverá uma série de logs e muito disso. Isto aconteceu porque nós definimos o nível padrão para debug. Todos estes logs são na verdade mensagens dos loggers padrão.

Você pode criar seus loggers personalizados nos arquivos consecutivos. Dessa forma você pode obter logs de arquivos específicos.

Aqui está a saída do arquivo que é gerado após o log.

Estes são os logs. Existem muitos logs mas apenas os níveis de aviso ou acima devem ser notificados.

Sumário

Logging é muito importante. Se for implementado corretamente, então pode economizar muito tempo. Geralmente, o logging é feito após o projeto estar completo.

Módulo de logon é o básico do logon com Django ou outro projeto python. Existem também outras soluções como, aipo, travis, etc. Estes manipuladores de logs também facilitam o manuseio de logs. Eles podem facilitar a tarefa de procurar se os eventos ocorreram ou não e qual foi a causa.