edition - Configuración elegante del registro de Python en Django

configurar pycharm para django

Question

Todavía tengo que encontrar una forma de configurar el registro de Python con Django con lo que estoy contento. Mis requisitos son bastante simples:

• Diferentes controladores de registro para diferentes eventos, es decir, quiero poder registrarme en diferentes archivos
• Fácil acceso a los registradores en mis módulos. El módulo debería poder encontrar su registrador con poco esfuerzo.
• Debería ser fácilmente aplicable a los módulos de línea de comandos. Partes del sistema son procesos independientes de línea de comando o daemon. El registro debe ser fácilmente utilizable con estos módulos.

Mi configuración actual es usar un archivo logging.conf e iniciar sesión en cada módulo desde el que inicio sesión. No se siente bien.

¿Tiene una configuración de registro que le guste? Por favor, detalla: cómo configurar la configuración (¿usas logging.conf o logging.conf en el código), dónde / cuándo logging.conf los registradores, y cómo obtienes acceso a ellos en tus módulos, etc.

Answer 1

Actualmente estoy usando un sistema de registro, que creé yo mismo. Utiliza el formato CSV para el registro.

django-csvlog

Este proyecto aún no tiene documentación completa, pero estoy trabajando en ello.

Answer 2

Inicializamos el registro en el urls.py nivel urls.py utilizando un archivo logging.ini .

La ubicación de logging.ini se proporciona en settings.py , pero eso es todo.

Cada módulo luego hace

logger = logging.getLogger(__name__)

Para distinguir instancias de prueba, desarrollo y producción, tenemos diferentes archivos logging.ini. En su mayor parte, tenemos un "registro de la consola" que va a stderr solo con errores. Tenemos un "registro de aplicación" que utiliza un archivo de registro continuo que va a un directorio de registros.

Answer 3

La mejor forma que he encontrado hasta ahora es inicializar la configuración de inicio de sesión en settings.py - en ninguna otra parte. Puede usar un archivo de configuración o hacerlo mediante programación paso a paso; solo depende de sus requisitos. La clave es que normalmente agrego los manejadores que quiero al registrador de raíz, usando niveles y algunas veces registrando. Filtros para obtener los eventos que quiero en los archivos apropiados, consola, syslogs, etc. Por supuesto, puede agregar manejadores a cualquier otro registrador también, pero no hay una necesidad común de esto en mi experiencia.

En cada módulo, defino un registrador usando

logger = logging.getLogger(__name__)

y lo uso para registrar eventos en el módulo (y, si quiero diferenciarlo más) usar un registrador que es hijo del registrador creado anteriormente.

Si mi aplicación va a ser potencialmente utilizada en un sitio que no configura el registro en settings.py, defino un NullHandler en alguna parte de la siguiente manera:

#someutils.py

class NullHandler(logging.Handler):
    def emit(self, record):
        pass

null_handler = NullHandler()

y asegúrese de que una instancia de este se agregue a todos los registradores creados en los módulos de mis aplicaciones que usan el registro. (Nota: NullHandler ya está en el paquete de registro para Python 3.1, y estará en Python 2.7.) Entonces:

logger = logging.getLogger(__name__)
logger.addHandler(someutils.null_handler)

Esto se hace para garantizar que los módulos funcionen correctamente en un sitio que no configura el inicio de sesión en settings.py, y que no obtiene ningún mensaje molesto "No se encontraron controladores para el registrador XYZ" (que son advertencias sobre posibles errores). registro desconfigurado).

Hacerlo de esta manera cumple con los requisitos establecidos:

• Puede configurar diferentes controladores de registro para diferentes eventos, como lo hace actualmente.
• Fácil acceso a los registradores en sus módulos: use getLogger(__name__) .
• Fácilmente aplicable a los módulos de línea de comandos: también importan settings.py .

Actualización: Tenga en cuenta que a partir de la versión 1.3, Django ahora incorpora soporte para el registro .

Answer 4

Sé que esta es una respuesta resuelta, pero según django> = 1.3 hay una nueva configuración de registro.

Pasar de viejo a nuevo no es automático, así que pensé que lo escribiría aquí.

Y por supuesto, revise el django doc por más.

Esta es la configuración básica, creada por defecto con django-admin createproject v1.3 - el kilometraje puede cambiar con las últimas versiones de django:

LOGGING = {
    ''version'': 1,
    ''disable_existing_loggers'': False,
    ''handlers'': {
        ''mail_admins'': {
            ''level'': ''ERROR'',
            ''class'': ''django.utils.log.AdminEmailHandler'',
        }
    },
    ''loggers'': {
        ''django.request'': {
            ''handlers'': [''mail_admins''],
            ''level'': ''ERROR'',
            ''propagate'': True,
        }
    }
}

Esta estructura se basa en el registro de Python estándar dictConfig , que dicta los siguientes bloques:

• formatters - el valor correspondiente será un dict en el cual cada clave es una id del formateador y cada valor es un dict que describe cómo configurar la instancia del formateador correspondiente.
• filters : el valor correspondiente será un dict en el cual cada clave es una identificación de filtro y cada valor es un dict que describe cómo configurar la instancia de filtro correspondiente.

• handlers : el valor correspondiente será un dict en el que cada clave es una identificación de controlador y cada valor es un dict que describe cómo configurar la instancia de controlador correspondiente. Cada controlador tiene las siguientes claves:

  • class (obligatoria). Este es el nombre completo de la clase de controlador.
  • level (opcional). El nivel del controlador.
  • formatter (opcional). La id del formateador para este controlador.
  • filters (opcional). Una lista de identificadores de los filtros para este controlador.

Normalmente hago al menos esto:

• agregue un archivo .log
• configurar mis aplicaciones para escribir en este registro

Lo que se traduce en:

LOGGING = {
    ''version'': 1,
    ''disable_existing_loggers'': False,
    ''formatters'': {
        ''verbose'': {
            ''format'': ''%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s''
        },
        ''simple'': {
            ''format'': ''%(levelname)s %(message)s''
        },
    },
    ''filters'': {
        ''require_debug_false'': {
            ''()'': ''django.utils.log.RequireDebugFalse''
        }
    },
    ''handlers'': {
        ''null'': {
            ''level'':''DEBUG'',
            ''class'':''django.utils.log.NullHandler'',
        },
        ''console'':{
            ''level'': ''DEBUG'',
            ''class'': ''logging.StreamHandler'',
            ''formatter'': ''simple''
        },
        # I always add this handler to facilitate separating loggings
        ''log_file'':{
            ''level'': ''DEBUG'',
            ''class'': ''logging.handlers.RotatingFileHandler'',
            ''filename'': os.path.join(VAR_ROOT, ''logs/django.log''),
            ''maxBytes'': ''16777216'', # 16megabytes
            ''formatter'': ''verbose''
        },
        ''mail_admins'': {
            ''level'': ''ERROR'',
            ''filters'': [''require_debug_false''],
            ''class'': ''django.utils.log.AdminEmailHandler'',
            ''include_html'': True,
        }
    },
    ''loggers'': {
        ''django.request'': {
            ''handlers'': [''mail_admins''],
            ''level'': ''ERROR'',
            ''propagate'': True,
        },
        ''apps'': { # I keep all my of apps under ''apps'' folder, but you can also add them one by one, and this depends on how your virtualenv/paths are set
            ''handlers'': [''log_file''],
            ''level'': ''INFO'',
            ''propagate'': True,
        },
    },
    # you can also shortcut ''loggers'' and just configure logging for EVERYTHING at once
    ''root'': {
        ''handlers'': [''console'', ''mail_admins''],
        ''level'': ''INFO''
    },
}

editar

Ver las excepciones de solicitud ahora están registradas y el ticket # 16288 :

Actualicé la configuración de muestra anterior para incluir explícitamente el filtro correcto para mail_admins para que, de forma predeterminada, los correos electrónicos no se envíen cuando la depuración sea True.

Debe agregar un filtro:

''filters'': {
    ''require_debug_false'': {
        ''()'': ''django.utils.log.RequireDebugFalse''
    }
},

y aplicarlo al controlador mail_admins:

    ''mail_admins'': {
        ''level'': ''ERROR'',
        ''filters'': [''require_debug_false''],
        ''class'': ''django.utils.log.AdminEmailHandler'',
        ''include_html'': True,
    }

De lo contrario, django.core.handers.base.handle_uncaught_exception no pasa errores al registrador ''django.request'' si settings.DEBUG es True.

Si no haces esto en Django 1.5 obtendrás una

Advertencia de depreciación: no tiene filtros definidos en el controlador de registro ''mail_admins'': agregar filtro implícito de depuración-falso-único

pero las cosas seguirán funcionando correctamente tanto en django 1.4 como en django 1.5.

** fin de editar **

Esa conf. Está fuertemente inspirada por la muestra conf en el documento de django, pero agregando la parte del archivo de registro.

A menudo también hago lo siguiente:

LOG_LEVEL = ''DEBUG'' if DEBUG else ''INFO''

...
    ''level'': LOG_LEVEL
...

Luego, en mi código python siempre agrego un NullHandler en caso de que no se defina ninguna función de registro. Esto evita advertencias para ningún controlador especificado. Especialmente útil para libs que no son llamadas necesariamente solo en Django ( ref )

import logging
# Get an instance of a logger
logger = logging.getLogger(__name__)
class NullHandler(logging.Handler): #exists in python 3.1
    def emit(self, record):
        pass
nullhandler = logger.addHandler(NullHandler())

# here you can also add some local logger should you want: to stdout with streamhandler, or to a local file...

[...]

logger.warning(''etc.etc.'')

¡Espero que esto ayude!