Usando el registro en múltiples módulos

Tengo un pequeño proyecto de Python que tiene la siguiente estructura:

Project 
 -- pkg01
   -- test01.py
 -- pkg02
   -- test02.py
 -- logging.conf

Planeo usar el módulo de registro predeterminado para imprimir mensajes en stdout y un archivo de registro. Para usar el módulo de registro, se requiere algo de inicialización:

import logging.config

logging.config.fileConfig('logging.conf')
logger = logging.getLogger('pyApp')

logger.info('testing')

Actualmente, realizo esta inicialización en cada módulo antes de comenzar a registrar mensajes. ¿Es posible realizar esta inicialización solo una vez en un lugar, de modo que la misma configuración se reutilice al iniciar sesión en todo el proyecto?

La mejor práctica es, en cada módulo, tener un registrador definido de esta manera:

import logging
logger = logging.getLogger(__name__)

cerca de la parte superior del módulo, y luego en otro código del módulo, p. ej.

logger.debug('My message with %s', 'variable data')

Si necesita subdividir la actividad de registro dentro de un módulo, use p. Ej.

loggerA = logging.getLogger(__name__ + '.A')
loggerB = logging.getLogger(__name__ + '.B')

e inicie sesión en loggerAy loggerBsegún corresponda.

En su programa o programas principales, por ejemplo:

def main():
    "your program code"

if __name__ == '__main__':
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    main()

o

def main():
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    # your program code

if __name__ == '__main__':
    main()

Vea aquí para iniciar sesión desde múltiples módulos, y aquí para registrar la configuración del código que otro código utilizará como módulo de biblioteca.

Actualización: al llamar fileConfig(), es posible que desee especificar disable_existing_loggers=Falsesi está utilizando Python 2.6 o posterior (consulte los documentos para obtener más información). El valor predeterminado es Truepara la compatibilidad con versiones anteriores, lo que hace que todos los registradores existentes se deshabiliten a fileConfig()menos que ellos o sus antepasados ​​se mencionen explícitamente en la configuración. Con el valor establecido en False, los registradores existentes se dejan solos. Si usa Python 2.7 / Python 3.2 o posterior, es posible que desee considerar la dictConfig()API, que es mejor que fileConfig()ya que le da más control sobre la configuración.

En realidad, cada registrador es un elemento secundario del registrador de paquetes del padre (es decir, package.subpackage.modulehereda la configuración package.subpackage), por lo que todo lo que necesita hacer es configurar el registrador raíz. Esto puede lograrse mediante logging.config.fileConfig(su propia configuración para registradores) o logging.basicConfig(establece el registrador raíz) Configurar el registro en su módulo de entrada ( __main__.pyo lo que quiera ejecutar, por ejemplo main_script.py. __init__.pyTambién funciona)

usando basicConfig:

# package/__main__.py
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

usando fileConfig:

# package/__main__.py
import logging
import logging.config

logging.config.fileConfig('logging.conf')

y luego crea cada registrador usando:

# package/submodule.py
# or
# package/subpackage/submodule.py
import logging
log = logging.getLogger(__name__)

log.info("Hello logging!")

Para obtener más información, consulte Tutorial avanzado de registro .

Siempre lo hago como a continuación.

Usar un solo archivo de Python para configurar mi registro como patrón singleton que se llama ' log_conf.py'

#-*-coding:utf-8-*-

import logging.config

def singleton(cls):
    instances = {}
    def get_instance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return get_instance()

@singleton
class Logger():
    def __init__(self):
        logging.config.fileConfig('logging.conf')
        self.logr = logging.getLogger('root')

En otro módulo, solo importa la configuración.

from log_conf import Logger

Logger.logr.info("Hello World")

Este es un patrón singleton para registrar, simple y eficientemente.

Varias de estas respuestas sugieren que en la parte superior de un módulo usted lo hace

import logging
logger = logging.getLogger(__name__)

Tengo entendido que esto se considera una muy mala práctica . La razón es que la configuración del archivo deshabilitará todos los registradores existentes de forma predeterminada. P.ej

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logger.info('Hi, foo')

class Bar(object):
    def bar(self):
        logger.info('Hi, bar')

Y en tu módulo principal:

#main
import logging

# load my module - this now configures the logger
import my_module

# This will now disable the logger in my module by default, [see the docs][1] 
logging.config.fileConfig('logging.ini')

my_module.foo()
bar = my_module.Bar()
bar.bar()

Ahora el registro especificado en logging.ini estará vacío, ya que el registro existente fue deshabilitado por la llamada fileconfig.

Si bien es posible evitar esto (disable_existing_Loggers = False), de manera realista, muchos clientes de su biblioteca no conocerán este comportamiento y no recibirán sus registros. Facilite a sus clientes siempre llamando a logging.getLogger localmente. Sugerencia: aprendí sobre este comportamiento en el sitio web de Victor Lin .

Por lo tanto, una buena práctica es llamar siempre a logging.getLogger localmente. P.ej

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logging.getLogger(__name__).info('Hi, foo')

class Bar(object):
    def bar(self):
        logging.getLogger(__name__).info('Hi, bar')    

Además, si usa fileconfig en su main, configure disable_existing_loggers = False, en caso de que los diseñadores de su biblioteca usen instancias de registrador a nivel de módulo.

Para mí, una forma simple de usar una instancia de la biblioteca de registro en varios módulos fue la siguiente solución:

base_logger.py

import logging

logger = logging
logger.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)

Otros archivos

from base_logger import logger

if __name__ == '__main__':
    logger.info("This is an info message")

Tirando en otra solución.

En init .py de mi módulo tengo algo como:

# mymodule/__init__.py
import logging

def get_module_logger(mod_name):
  logger = logging.getLogger(mod_name)
  handler = logging.StreamHandler()
  formatter = logging.Formatter(
        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
  handler.setFormatter(formatter)
  logger.addHandler(handler)
  logger.setLevel(logging.DEBUG)
  return logger

Luego, en cada módulo necesito un registrador, hago:

# mymodule/foo.py
from [modname] import get_module_logger
logger = get_module_logger(__name__)

Cuando se pierden los registros, puede diferenciar su fuente por el módulo del que provienen.

¡También podrías pensar en algo como esto!

def get_logger(name=None):
    default = "__app__"
    formatter = logging.Formatter('%(levelname)s: %(asctime)s %(funcName)s(%(lineno)d) -- %(message)s',
                              datefmt='%Y-%m-%d %H:%M:%S')
    log_map = {"__app__": "app.log", "__basic_log__": "file1.log", "__advance_log__": "file2.log"}
    if name:
        logger = logging.getLogger(name)
    else:
        logger = logging.getLogger(default)
    fh = logging.FileHandler(log_map[name])
    fh.setFormatter(formatter)
    logger.addHandler(fh)
    logger.setLevel(logging.DEBUG)
    return logger

Ahora podría usar varios registradores en el mismo módulo y en todo el proyecto si lo anterior se define en un módulo separado e importado en otros módulos donde se requiere el registro.

a=get_logger("__app___")
b=get_logger("__basic_log__")
a.info("Starting logging!")
b.debug("Debug Mode")

La solución de @ Yarkee parecía mejor. Me gustaría agregarle algo más:

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances.keys():
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


class LoggerManager(object):
    __metaclass__ = Singleton

    _loggers = {}

    def __init__(self, *args, **kwargs):
        pass

    @staticmethod
    def getLogger(name=None):
        if not name:
            logging.basicConfig()
            return logging.getLogger()
        elif name not in LoggerManager._loggers.keys():
            logging.basicConfig()
            LoggerManager._loggers[name] = logging.getLogger(str(name))
        return LoggerManager._loggers[name]    


log=LoggerManager().getLogger("Hello")
log.setLevel(level=logging.DEBUG)

Por lo tanto, LoggerManager puede conectarse a toda la aplicación. Espero que tenga sentido y valor.

Hay varias respuestas Terminé con una solución similar pero diferente que tiene sentido para mí, tal vez también tenga sentido para usted. Mi objetivo principal era poder pasar los registros a los controladores por su nivel (registros de nivel de depuración a la consola, advertencias y más arriba a los archivos):

from flask import Flask
import logging
from logging.handlers import RotatingFileHandler

app = Flask(__name__)

# make default logger output everything to the console
logging.basicConfig(level=logging.DEBUG)

rotating_file_handler = RotatingFileHandler(filename="logs.log")
rotating_file_handler.setLevel(logging.INFO)

app.logger.addHandler(rotating_file_handler)

creó un buen archivo util llamado logger.py:

import logging

def get_logger(name):
    return logging.getLogger("flask.app." + name)

el flask.app es un valor codificado en el matraz. el registrador de aplicaciones siempre comienza con flask.app como nombre del módulo.

ahora, en cada módulo, puedo usarlo en el siguiente modo:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Esto creará un nuevo registro para "app.flask.MODULE_NAME" con el mínimo esfuerzo.

La mejor práctica sería crear un módulo por separado que tenga un solo método cuya tarea sea asignar un controlador de registro al método de llamada. Guarde este archivo como m_logger.py

import logger, logging

def getlogger():
    # logger
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    # create console handler and set level to debug
    #ch = logging.StreamHandler()
    ch = logging.FileHandler(r'log.txt')
    ch.setLevel(logging.DEBUG)
    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    # add formatter to ch
    ch.setFormatter(formatter)
    # add ch to logger
    logger.addHandler(ch)
    return logger

Ahora llame al método getlogger () siempre que se necesite el controlador del registrador.

from m_logger import getlogger
logger = getlogger()
logger.info('My mssg')

Nuevo en Python, así que no sé si esto es aconsejable, pero funciona muy bien para no volver a escribir repetitivo.

Su proyecto debe tener un init .py para que pueda cargarse como un módulo

# Put this in your module's __init__.py
import logging.config
import sys

# I used this dictionary test, you would put:
# logging.config.fileConfig('logging.conf')
# The "" entry in loggers is the root logger, tutorials always 
# use "root" but I can't get that to work
logging.config.dictConfig({
    "version": 1,
    "formatters": {
        "default": {
            "format": "%(asctime)s %(levelname)s %(name)s %(message)s"
        },
    },
    "handlers": {
        "console": {
            "level": 'DEBUG',
            "class": "logging.StreamHandler",
            "stream": "ext://sys.stdout"
        }
    },
    "loggers": {
        "": {
            "level": "DEBUG",
            "handlers": ["console"]
        }
    }
})

def logger():
    # Get the name from the caller of this function
    return logging.getLogger(sys._getframe(1).f_globals['__name__'])

sys._getframe(1) sugerencia proviene de aquí

Luego, para usar su registrador en cualquier otro archivo:

from [your module name here] import logger

logger().debug("FOOOOOOOOO!!!")

Advertencias:

1. Debe ejecutar sus archivos como módulos, de lo contrario import [your module]no funcionará:
   • python -m [your module name].[your filename without .py]
2. El nombre del registrador para el punto de entrada de su programa será __main__, pero cualquier solución que use __name__tendrá ese problema.