Registrar mensagem no arquivo e no console em Python

1. Use o módulo logging para imprimir a mensagem de log para arquivo e console em Python
2. Use o módulo logging para imprimir a mensagem de log para o console em Python
3. Use o módulo logging para imprimir uma mensagem de registro em um arquivo em Python

Este tutorial irá apresentar alguns métodos para registrar strings de depuração em um arquivo e console em Python.

Use o módulo logging para imprimir a mensagem de log para arquivo e console em Python

Log é o processo de manter registros de vários eventos que acontecem em um sistema. Esses eventos podem ser dados de entrada, processos, threads, dados de saída, informações processadas, erros, avisos, notificações. Os vários eventos são rastreados e armazenados em um arquivo de log. O módulo logging é fornecido pelo Python que facilita aos programadores registrar os vários eventos ocorridos. O módulo possui classes e métodos específicos. Loggers, Handlers, Filters e Formatters são as classes básicas que o módulo logging define.

O método basicConfig() executa a configuração básica. Ele cria um StreamHandler usando um Formatter padrão. Em seguida, ele adiciona ao logger raiz. Os níveis de registro são representados em valores numéricos. Existem seis níveis de registro: CRITICAL, ERROR, WARNING, INFO, DEBUG e NOTSET. Definimos o nível de registro para INFO abaixo. Portanto, INFO, WARNING, ERROR e CRITICAL são exibidos ou armazenados.

Para gravar no console e no arquivo, usaremos logging.basicConfig(), que pode aceitar manipuladores de argumento e simplificar muito a configuração de registro, especialmente ao configurar vários manipuladores com o mesmo formatador. Usamos o método FileHandler() para gravar em um arquivo e usamos debug.log para registrar todas as informações. Da mesma forma, para gravar em um console, usamos StreamHandler(). Por padrão, StreamHandler() grava em stderr. Para escrever em stdout, importamos o módulo sys e passamos sys.stdout explicitamente para StreamHandler().

No exemplo abaixo, os logs são impressos no console e no arquivo debug.log.

# python 3.x
import logging
import sys

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[logging.FileHandler("debug.log"), logging.StreamHandler(sys.stdout)],
)
logging.debug("This message is skipped as a level is set as INFO")
logging.info("So should this")
logging.warning("And this, too")
logging.error("Testing non-ASCII character, Ø and ö")

Produção:

2021-07-28 14:50:01,348 [INFO] So should this
2021-07-28 14:50:01,349 [WARNING] And this, too
2021-07-28 14:50:01,349 [ERROR] Testing non-ASCII character, Ø and ö

Use o módulo logging para imprimir a mensagem de log para o console em Python

Para usar o registro e definir a configuração básica, usamos logging.basicConfig(). Então, em vez de print(), chamamos logging.{level}(message) para mostrar a mensagem no console. Como configuramos o nível como INFO na configuração basicConfig(), chamamos logging.info() posteriormente no programa. E toda a mensagem na string é passada para logging.info(), que é então exibida no console.

Código de exemplo:

# python 3.x
import logging

logging.basicConfig(level=logging.INFO)


def area(l, b):
    """Compute the area of a rectangle"""
    return l * b


logging.info(
    "Area of length: {l} and breadth: {b} is {c}".format(l=3, b=4, c=area(l=3, b=4))
)

Produção:

INFO:root:Area of length: 3 and breadth: 4 is 12

Use o módulo logging para imprimir uma mensagem de registro em um arquivo em Python

Se estivermos usando vários módulos em um programa, o uso do módulo raiz tem limitações severas. É por isso que precisamos criar um novo logger usando o método logger.getLogger(name).

Existe uma convenção para usar a variável __name__ como o nome do registrador. Depois de criar um novo registrador, devemos nos lembrar de registrar todas as nossas mensagens usando o novo logger.info() em vez do método logging.info() da raiz. Um FileHandler() é usado para fazer nosso logger personalizado entrar em um arquivo diferente. Aqui, registramos nossas informações em logfile.log. Da mesma forma, um Formatter() é usado para alterar o formato de nossas mensagens registradas. E o Formatter é definido no objeto FileHandler e não diretamente no logger.

Por exemplo, use getLogger() para criar ou obter um logger. Em seguida, use o método setLogger() para definir o nível de registro. Defina o nível para logging.WARNING. Em seguida, use o método FileHandler() para definir o manipulador e o método Formatter() para definir o formatador. Em seguida, use o método addHandler() para adicionar o manipulador ao logger. Finalmente, escreva algumas mensagens para testar. Podemos ver os logs no arquivo log_file.log.

Código de exemplo:

# python 3.x
import logging

logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
handler = logging.FileHandler("log_file.log")
formatter = logging.Formatter(
    "%(asctime)s : %(name)s  : %(funcName)s : %(levelname)s : %(message)s"
)
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.debug("A debug message")
logger.info("An info message")
logger.warning("There is something wrong")
logger.error("An error has happened.")
logger.critical("Fatal error occured. Cannot continue")

Produção:

2021-07-30 11:55:31,047 : __main__  : <module> : WARNING : There is something wrong
2021-07-30 11:55:31,047 : __main__  : <module> : ERROR : An error has happened.
2021-07-30 11:55:31,047 : __main__  : <module> : CRITICAL : Fatal error occured. Cannot continue