Monitorización en Python

Monitorización de aplicaciones en Python

Índice

• Monitorización en Python

  • Monitorización en Django

    • Monitorizar Loggins

    • Avisar de errores automáticamente

    • Avisar de errores customizados en LOGGING

Monitorización en Django

Monitorizar Loggins

1. Configurar el logger en settings.py:

# importar sys:
import sys

# Se habilita la constante logging:
# Se habilita la constante logging:
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False, # Evitar que pise otros loggers como DEFAULT_LOGGING
    'formatters': { # se define el formato de salida
        'default': { # se utiliza el formater estandar de logging:
            'class': 'logging.Formatter',
            # y se define la estructura del mensaje, en este caso TIEMPO - NIVEL - LOGGER - MENSAJE:
            'format': '%(asctime)s - %(levelname)s - %(name)s: %(message)s'
        }
    },
    'handlers': {
        'console': { # se define la salida por consola
            'class': 'logging.StreamHandler', # la clase que controla los logs
            'stream': sys.stdout, # el stream que los manejará
            'formatter': 'default' # formato default
        },
        'error_file': { # aquí saldría por archivo
            'class': 'logging.FileHandler', # se usa el filehandler para guardar archivos
            'filename': 'error.log', # se define el nombre del archivo
            'formatter': 'default',
            # 'level': 'ERROR', Si solo queremos almacenar los mensajes de error
        }
    },
    'loggers': {
        '': { # vamos a coger todos los loggers:
            'level': 'INFO', # Nivel del mensaje.
            'handlers': ['console', 'error_file'] # definir la salida por consola y archivo (o solo una)
        }
    }
}

2. Ir a la vista o viewset que se quiere monitorizar:

# Se importa logging:
import logging


class SerieView(View):

    def get(self, request):
        context = {
            'series': list(Serie.objects.all())
        }

        return render(request, 'series/series.html', context)

class SerieViewSet(viewsets.ModelViewSet):
    queryset = Serie.objects.all()
    serializer_class = SerieSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

    # en el constructor de la clase:
    def __init__(self, *args, **kwargs):
        # se carga el logger en un atributo:
        self.logger = logging.getLogger(__name__)
        super().__init__(*args, **kwargs)

    def get_serializer_class(self):
        # Se monitoriza el método que devuelve las series:
        self.logger.error(self.action)

        serializer = self.serializer_class

        if self.action == 'retrieve':
            serializer = DetailSerieSerializer

        return serializer

• En este caso solo se está monitorizando las series, pero lo ideal es monitorizar cada parte.

• El mensaje que muestra cada acción es: 2022-03-03 08:52:36,241 - ERROR - series.views: list

• Los logs se almacenan en la ruta raiz del proyecto con el nombre que hemos definido antes: error.log

Atención

Si definimos un LOGGING este reemplaza a DEFAULT_LOGGER, es importante que tanto en LOGGING como en DEFAULT_LOGGING se encuentre el valor 'disable_existing_loggers': False

Avisar de errores automáticamente

Para realizar esto hay que habilitar la constante DEFAULT_LOGGING en settings.py:

# Habilitar el logger que se encarga de las queries a la base de datos:
DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False, # no pisar los otros logger
    'filters': { # filtrados:
        'require_debug_false': { # comprobar que no vienen de debug:
            '()': 'django.utils.log.RequireDebugFalse'
        },
        'require_debug_true': { # comprobar que vienen de debug:
            '()': 'django.utils.log.RequireDebugTrue'
        }
    },
    'formatters': {
        'django.server': {
            '()': 'django.utils.log.ServerFormatter',
            'format': '[{server_time}] {message}',
            'style': '{',
        }
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'], # si el modo debug esta en True saldrá por consola.
            'class': 'logging.StreamHandler',
            'formatter': 'django.server'
        },
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'], # si el modo debug esta en False (producción) nos enviará un email.
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'mail_admins'] # saldrá por consola y por email los loggersf
        }
    }
}

# Creamos el listado de administradores que se ocupan de la aplicación:
ADMINS = [('Guillermo', 'guillermo@gggmail.com')]

# Configuramos un email backend de prueba por si no tenemos servidor de email aún configurado:
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

Avisar de errores customizados en LOGGING

Podemos configurar la salida de errores en producción para que los envíe por email:

    import sys

    LOGGING = {
        'version': 1,
        'filters': { # Se van a definir un par de filtros que tienen que ver con el entorno de Desarrollo y producción:
            'require_debug_false': { # comprobar si estamos en Desarrollo:
                '()': 'django.utils.log.RequireDebugFalse'
            },
            'require_debug_true': { # comprobar si estamos en Producción:
                '()': 'django.utils.log.RequireDebugTrue'
            }
        },
        'formatters': {
            'default': {
                'class': 'logging.Formatter',
                'format': '%(asctime)s - %(levelname)s - %(name)s: %(message)s'
            }
        },
        'handlers': {
            'console': {
                'class': 'logging.StreamHandler',
                'stream': sys.stdout,
                'formatter': 'default'
            },
            'error_file': {
                'class': 'logging.FileHandler',
                'filename': 'error.log',
                'formatter': 'default',
                'level': 'ERROR',
            }, # Se carga el mail admins:
            'mail_admins': {
                'level': 'ERROR',
                'filters': ['require_debug_false'], # si el modo debug esta en False (producción) nos enviará un email.
                'class': 'django.utils.log.AdminEmailHandler'
            }
        },
        'loggers': {
            '': {
                'level': 'INFO',
                'handlers': ['console', 'error_file', 'mail_admins'] # se añade el mail_admins para los correos
            }
        }
    }

    # Creamos el listado de administradores que se ocupan de la aplicación:
    ADMINS = [('Guillermo', 'guillermo@gggmail.com')]

    # Configuramos un email backend de prueba por si no tenemos servidor de email aún configurado:
    EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'