Django Logging

Todos los desarrolladores depuran errores. La resolución de esos errores lleva tiempo. En la mayoría de los casos ayuda saber cuándo y dónde se produjo el error. Yo diría que los mensajes de error de Python son bastante útiles. Pero incluso estos mensajes se vuelven inútiles cuando se trata de proyectos con múltiples archivos. Ese problema y muchos otros beneficios vienen con el logging.

Como desarrolladores de Django, es importante que también dominemos el logging. Las tecnologías de backend tienen varias herramientas estupendas para implementar el logging. Django también proporciona soporte para varios frameworks y módulos de logging. Lo implementaremos usando el básico y uno de los populares, el módulo de logging.

En este tutorial, aprenderemos sobre logging. Los contenidos serán:

• ¿Qué es el Logging?
• Módulo de Logging de Python
• Logging en Django

Listos para aprender. Empecemos.

¿Qué es el Logging?

El Logging es una técnica o medio que nos permite rastrear algunos eventos mientras el software se ejecuta. Es una técnica importante para los desarrolladores. Les ayuda a rastrear eventos. El registro es como un par de ojos extra para ellos. Los desarrolladores no sólo son responsables de crear software, sino también de mantenerlo. El registro ayuda con esa parte del mantenimiento inmensamente.

Sigue cada evento que ocurre en todo momento. Eso significa que en lugar de los largos rastreos se obtiene mucho más. Esta vez cuando se produce un error se puede ver en que estaba el sistema. Este método le ayudará a resolver los errores rápidamente. Como usted será capaz de decir donde se produjo el error.

¿Cómo funciona? ¿Cuál es la idea detrás de esto?

El registro es manejado por un programa separado. Ese programa de registro es simplemente un escritor de archivos. Se dice que el registrador registra ciertos eventos en formato de texto. La información registrada se guarda en archivos. Los archivos para esto se llaman logs. Los registros son simples archivos guardados con la extensión log. Contienen los registros de los eventos ocurridos.

Bueno, esta es sólo una de las implementaciones más usadas, como puedes ver. Ya que sólo estamos almacenando la información, puedes idear más formas de tratarla.

Bien, nos queda claro que el registro es importante. ¿Es difícil? No, en absoluto, amigo. El registro no es difícil en absoluto. Cualquiera que conozca un poco la configuración puede usar esto.

Siendo un programador de Python, aquí también tienes características extra. Tenemos todo un módulo que nos permite lograr precisamente eso. En cuanto a otros lenguajes, hay muchos módulos, Java tiene Log4j y JavaScript tiene su propio loglevel. Todas estas son herramientas increíbles también. Bien, aquí trataremos con Python (mi lenguaje favorito).

Módulo de registro en Python

El módulo de registro es un módulo incorporado en Python. Viene preinstalado con Python 3. El módulo de registro se utiliza para mantener un registro de los eventos que ocurren a medida que el programa se ejecuta. Eso se puede extender a cualquier número de programas y por lo tanto para el software, es fácil de configurar y utilizar.

¿Por qué utilizar el módulo de registro?

Como desarrollador, podemos preguntarnos por qué utilizar el módulo de registro. Todo lo que hace el logging es escribir en un archivo o imprimirlo en la consola. Todo eso se puede lograr usando sentencias print. Entonces, ¿cuál es la necesidad de un módulo de registro? Esa es una pregunta válida. La respuesta es que logging es un módulo que da lo que print no puede.

Usamos la función print para imprimir algo en la consola. Así, cuando una función se produce, podemos obtener una declaración de impresión que la función ejecutada. Aunque este enfoque funciona con aplicaciones pequeñas, es ineficiente.

La función print se convierte en parte de su programa y si el software deja de funcionar, no obtendrá el resultado. Además, si ocurre algo y el sistema se reinicia, la consola también se borra. Así que, ¿qué vas a hacer entonces? La respuesta a eso es el módulo de registro.

El módulo de registro es capaz de:

• Ejecución multihilo
• Categorizar los mensajes a través de diferentes niveles de registro
• Es mucho más flexible y configurable
• Da una información más estructurada

Así que, hay 4 partes principales del módulo de registro. Las veremos una a una.

1. Loggers

Los loggers son los objetos con los que tratan los desarrolladores. Se pueden entender como una función que será invocada cuando sean llamados. Los loggers los utilizamos en los archivos de nuestros proyectos. Así, cuando la función es invocada, obtenemos un informe detallado. El logger puede generar múltiples niveles de respuestas. Podemos personalizarlo al máximo.

2. Handlers

Los handlers son los objetos que emiten la información. Piensa en ellos como manejadores de periódicos. Su tarea principal es transmitir la información. Eso se puede lograr escribiendo la información en un archivo de registro (El comportamiento por defecto). Hay varios manejadores proporcionados por el módulo de registro.

Podemos fácilmente configurar múltiples manejadores para el mismo registrador. También hay manipuladores SMTP que le enviarán por correo los registros del registro. Los handlers suelen contener lógica de negocio para el registro de información.

3. Formateadores

Los formateadores son los que formatean los datos. Como ves los handlers no pueden enviar la información ya que es un tipo de datos de Python. Antes de enviarla a alguien, hay que convertirla.

Los logs están por defecto en formato Log Records. Esa es la clase predefinida por el marco de registro. Da varios métodos a los desarrolladores para usar. Ese formato no puede ser enviado directamente a través de una red o escrito en un archivo de texto. Para convertirlo o formatearlo, necesitamos formateadores. Hay diferentes formateadores para diferentes manejadores.

Por defecto, los formateadores convertirán el registro de bitácora en cadena. Este comportamiento se puede cambiar fácilmente y usted puede personalizar esto como usted quiere. Este formato puede basarse en la lógica de negocio que escribimos en Handlers.

4. Filtros

La última pieza del módulo de registro son los filtros. Los filtros, como su nombre indica, filtran los mensajes. No todos los mensajes que pasamos tienen que ser almacenados o transportados. O puede haber diferentes manejadores para diferentes mensajes. Todo eso se puede conseguir con la ayuda de los filtros.

Podemos utilizar los filtros tanto con los loggers como con los handlers.

Bien, ahora ya tenemos una idea básica del módulo de logging. También nos proporciona niveles de mensajes. Los niveles de mensajes se definen como:

DEBUG: Es información verbosa del sistema cuando todo está funcionando bien. Te dirá detalles más precisos sobre el estado del sistema. Su punto de severidad es 10.

INFO: El info producirá información del sistema menos verbosa pero es similar al debug. Por lo general, dice una visión general de lo que el sistema está ejecutando. Su punto de severidad es 20.

WARNING: Contiene información sobre problemas de bajo nivel. Los problemas pueden ser ignorados ya que no causan que el sistema se detenga. Sin embargo, se recomienda que estos problemas se resuelvan.

Su punto de gravedad es 30.

ERROR: Este mensaje es grave. El error contendrá información sobre el problema principal que se ha producido. El problema puede haber detenido el funcionamiento del programa y necesita atención inmediata.

Su punto de gravedad es 40.

CRITICAL: El mensaje más crítico. Este mensaje se emite cuando el problema ha provocado la detención del sistema. Esto significa que toda la aplicación se ha detenido debido a este problema.

Su punto de severidad es 50.

El punto de severidad determina qué prioridad se dará. Supongamos que establecemos el nivel de registro en 30. Entonces el logger registrará o almacenará la información cuando el nivel sea mayor o igual a 30. Por lo tanto, sólo tiene que confirmar qué nivel de registro desea. Aprenderemos más sobre ellos en la sección posterior.

Podemos implementar fácilmente el registro importando el módulo. Dado que es un módulo incorporado, no necesitamos instalarlo a través de pip.

Sólo tienes que escribir esto en tu archivo de Python y podremos usar loggers.

Código:

import logginglogging.warning("DataFlair Logging Tutorials")

La salida generada por el código está justo debajo. Como puedes ver, el log se imprime en la consola, tiene log-level, logger-name y message. root es el logger-name por defecto. Utilizaremos este tipo de funciones con nuestras vistas en Django.

Explora un completo tutorial sobre el módulo de logging de Python

Logging en Django

Django proporciona logging utilizando el módulo de logging de Python. El módulo de logging se puede configurar fácilmente.

Cuando queremos utilizar el logging en Django hay que seguir ciertos pasos. El procedimiento será el siguiente:

1. Configuraremos nuestro settings.py para varios loggers, handlers, filters.
2. Incluiremos el código de los loggers en las vistas o en cualquier otro módulo de Django donde sea necesario.

Bien, pues empecemos.

Crear un nuevo Proyecto

Crearemos un nuevo proyecto para el logging. A continuación, puede utilizar el registro en los proyectos existentes. Así que, para crear un nuevo proyecto, ejecuta este comando en la línea de comandos:

$ django-admin startproject dataflairlogs

Esto iniciará el nuevo proyecto. Ahora, configuraremos settings.py del proyecto.

Configuración de ajustes

Para incluir el registro en Django, necesitamos configurar sus ajustes. Hacerlo es bastante fácil. Por configurar los ajustes de logging, nos referimos a definir:

• Loggers
• Handlers
• Filters
• Formatters

Como Django trabaja con diferentes módulos por lo tanto, utilizamos el método dictConfig.

Hay otros métodos en bruto también, pero dictConfig es lo que el comportamiento por defecto de Django.

Sólo tienes que copiar este código en tu settings.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') }, },}

Entiende el código:

Sé que el código es un poco grande pero es muy fácil de entender. Obtenemos una variable incorporada LOGGING de Django. Los valores por defecto del logging provienen de este diccionario. Como estamos configurando los valores usando un diccionario se llama el método dictConfig. Hay algunas claves importantes dentro del diccionario LOGGING.

1. versión
2. disable_existing_loggers
3. handlers
4. loggers

Vamos a discutirlas una por una. La clave de versión indica la versión del esquema. Es importante que tenga valor. Es por defecto 1.

La siguiente clave es disable_existing_loggers. Esta clave es para decirle a Django que no desactive los loggers. Por defecto, Django utiliza algunos de sus propios loggers. Estos registradores están conectados con Django ORM y otras partes internas de Django. Esta clave es por defecto True. Por lo tanto, desactivará esos registradores.

Hay varias consultas a la base de datos y llamadas a funciones que los registradores registran. Por lo tanto, se recomienda que no True esta clave.

Handlers es la tercera clave. Como hemos comentado, los handlers manejan los mensajes y los pasan a consola, archivo, etc. Los handlers en sí son un diccionario. Los nombres de la clave del diccionario serán los nombres de los manejadores. Hay varios manejadores proporcionados por el módulo de registro. Aquí usamos dos manejadores.

1. FileHandler: logger-name – filehandler

El FileHandler almacenará los registros en un archivo. Como se puede ver, hemos dado el nombre de archivo como dataflair-debug.log.

El nivel define, hasta qué nivel el registrador deberá comprometer los registros.

Nota:

Los archivos de registro se almacenan generalmente con extensión .log. Este archivo sólo puede ser editado con permisos. Sólo se puede anexar.

2. StreamHandler: nombre del logger – console

El stream handler transmitirá el log en consola. Este no es un método recomendado. Hay un límite de caracteres hasta que la línea de comandos muestra los logs. Dado que los registros son demasiado grandes para manejarlos por línea de comandos, necesitamos manejadores de archivos.

Hay más manejadores como mailhandlers, AdminEmailHandler etc.

El AdminEmailHandler es una gran adición al módulo opensource.

Loggers son los que registrarán la información de su servidor o software. Los loggers son también un tipo de diccionario. Tiene una arquitectura similar a la de los handlers. Aunque, hay diferentes atributos y otras propiedades.

Django también proporciona un conjunto de loggers. Hay varios loggers como django, django.requests. y más.

¿Has consultado nuestro último Tutorial de respuesta a peticiones de Django &

Ahora, para implementar el logging, sólo tienes que seguir estos pasos:

Inicia tu servidor.

$ python manage.py runserver

En el momento que le des a enter habrá una serie de logs y mucho. Esto ocurre porque hemos puesto el nivel por defecto en debug. Todos estos logs son en realidad mensajes de los loggers por defecto.

Puedes crear tus loggers personalizados en los archivos consecutivos. De esta manera puedes obtener los logs de archivos específicos.

Aquí está la salida del archivo que se genera después del logging.

Estos son los logs. Hay un montón de registros, pero sólo los niveles de advertencia o superiores serán notificados.

Resumen

El registro es bastante importante. Si se implementa correctamente, entonces puede ahorrarte mucho tiempo. Generalmente, el registro se hace después de que el proyecto está completo.

El módulo de registro es lo básico para el registro con Django u otro proyecto de python. Hay otras soluciones también como, celery, travis etc. Estos manejadores de registro también facilitan el manejo de los registros. Pueden facilitar la tarea de buscar si los eventos ocurrieron o no y cuál fue la causa.