Günlük kaydını birden çok modülde kullanma

Aşağıdaki yapıya sahip küçük bir python projem var -

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

Mesajları stdout'a ve bir günlük dosyasına yazdırmak için varsayılan günlük modülünü kullanmayı planlıyorum. Günlük modülünü kullanmak için bir miktar başlatma gerekir -

import logging.config

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

logger.info('testing')

Şu anda, iletileri günlüğe kaydetmeye başlamadan önce her modülde bu başlatmayı gerçekleştiriyorum. Bu başlatmayı, aynı ayarların proje üzerinde oturum açarak yeniden kullanılması için tek bir yerde yalnızca bir kez yapmak mümkün müdür?

En iyi uygulama, her modülde, aşağıdaki gibi bir günlükçünün tanımlanmasıdır:

import logging
logger = logging.getLogger(__name__)

modülün üst kısmına yakın bir yerdeyken modülün diğer kodlarında ör.

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

Günlüğe kaydetme etkinliğini bir modül içinde alt bölümlere ayırmanız gerekiyorsa, örn.

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

ve giriş loggerAve loggerBuygun olarak.

Ana programınızda veya programlarınızda örneğin:

def main():
    "your program code"

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

veya

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

if __name__ == '__main__':
    main()

Birden çok modülden oturum açmak için buraya bakın ve buraya bakın diğer kod tarafından bir kütüphane modül olarak kullanılacak kodu için günlük yapılandırması için.

Güncelleme: Arama yaparken fileConfig(), disable_existing_loggers=FalsePython 2.6 veya üstünü kullanıp kullanmadığınızı belirtmek isteyebilirsiniz ( daha fazla bilgi için dokümanlara bakın ). Varsayılan değer, Truegeriye dönük uyumluluk içindir; bu, varolan tüm günlüklerin fileConfig(), ataları veya atamaları yapılandırmada açıkça adlandırılmadıkça devre dışı bırakılmasına neden olur . Değer olarak ayarlandığında False, varolan günlükçüler yalnız bırakılır. Python 2.7 / Python 3.2 veya daha yenisini kullanıyorsanız , yapılandırma üzerinde daha fazla kontrol sağladığından daha dictConfig()iyi olan API'yı düşünebilirsiniz fileConfig().

Aslında her günlükçü, üst öğenin paket günlükçüsünün bir alt öğesidir (yani package.subpackage.moduleyapılandırmayı kaynağından devralır package.subpackage), bu nedenle yapmanız gereken tek şey yalnızca kök günlükçüyü yapılandırmaktır. Bu logging.config.fileConfig(günlükçüler için kendi yapılandırmanız) veya logging.basicConfig(kök günlükçüyü ayarlar) . Girişiniz modülünde Kur günlük ( __main__.pyya da örneğin, çalıştırmak istediğiniz ne olursa olsun main_script.py. __init__.pyyanısıra çalışır)

basicConfig kullanarak:

# package/__main__.py
import logging
import sys

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

fileConfig kullanarak:

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

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

ve daha sonra aşağıdakileri kullanarak her kaydediciyi oluşturun:

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

log.info("Hello logging!")

Daha fazla bilgi için, bkz. Gelişmiş Günlük Eğitimi .

Her zaman aşağıdaki gibi yaparım.

Günlüğümü ' log_conf.py' adlı tekli desen olarak yapılandırmak için tek bir python dosyası kullan

#-*-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')

Başka bir modülde, yapılandırmayı içe aktarmanız yeterlidir.

from log_conf import Logger

Logger.logr.info("Hello World")

Bu, basit ve verimli bir şekilde kaydedilecek tek bir modeldir.

Bu yanıtların birçoğu, bir modülün üstünde,

import logging
logger = logging.getLogger(__name__)

Anladığım kadarıyla bu çok kötü bir uygulama olarak görülüyor . Bunun nedeni, dosya yapılandırmasının varsayılan olarak mevcut tüm günlükleyicileri devre dışı bırakmasıdır. Örneğin

#my_module
import logging

logger = logging.getLogger(__name__)

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

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

Ve ana modülünüzde:

#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()

Artık logging.ini dosyasında belirtilen günlük boş olacaktır, çünkü mevcut günlük dosyası fileconfig çağrısı tarafından devre dışı bırakılmıştır.

Bu sorunun üstesinden gelmek kesinlikle mümkün olsa da (ctiv_existing_Loggers = False), kütüphanenizin birçok istemcisi bu davranışı bilmez ve günlüklerinizi almaz. Her zaman yerel olarak logging.getLogger'ı arayarak müşterileriniz için kolaylık sağlayın. Şapka İpucu: Bu davranışı Victor Lin'in Web sitesinden öğrendim .

Bunun yerine her zaman logging.getLogger'ı yerel olarak çağırmak iyi bir uygulamadır. Örneğin

#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')    

Ayrıca, ana dosyanızda fileconfig kullanıyorsanız, kütüphane tasarımcılarınızın modül düzeyinde günlükçü örnekleri kullanmaları durumunda, enable_existing_loggers = False olarak ayarlayın.

Günlük kütüphane kitaplığının bir örneğini benim için birden çok modülde kullanmanın basit bir yolu aşağıdaki çözümü kullanmaktı:

base_logger.py

import logging

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

Diğer dosyalar

from base_logger import logger

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

Başka bir çözeltide fırlatma.

Modülün init .py dosyasında şöyle bir şey var:

# 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

Sonra her modülde bir günlükçüye ihtiyacım var:

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

Günlükler kaçırıldığında, kaynaklarını geldikleri modülle ayırt edebilirsiniz.

Bunun gibi bir şey de bulabilirsin!

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

Yukarıdakiler ayrı bir modülde tanımlanmışsa ve diğer modüllere içe aktarılmışsa, günlüğe kaydetme gerekiyorsa, aynı modülde ve tüm projede birden fazla kaydedici kullanabilirsiniz.

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

@ Yarkee'nin çözümü daha iyi görünüyordu. Bir şey daha eklemek istiyorum -

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)

Dolayısıyla LoggerManager tüm uygulamaya takılabilir. Umarım mantıklı ve değerlidir.

Birkaç cevap var. Bana mantıklı gelen benzer ama farklı bir çözüm buldum, belki de sizin için de mantıklı olacaktır. Benim asıl amacım günlükleri düzeylerine göre işleyicilere aktarabilmekti (hata ayıklama düzeyi günlükleri konsola, uyarıları ve üstünü dosyalara aktarmak):

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)

logger.py adında güzel bir util dosyası oluşturdu:

import logging

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

flask.app, flaskta sabit kodlanmış bir değerdir. uygulama günlüğü her zaman modül adı olarak flask.app ile başlar.

şimdi, her modülde, aşağıdaki modda kullanabilirsiniz:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Bu, minimum çaba ile "app.flask.MODULE_NAME" için yeni bir günlük oluşturacak.

En iyi uygulama, görevi çağıran yönteme bir logger işleyicisi vermek olan tek bir yönteme sahip ayrı bir modül oluşturmak olacaktır. Bu dosyayı m_logger.py kaydedin

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

Şimdi günlükçü işleyicisi gerektiğinde getlogger () yöntemini çağırın.

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

Python için yeni, bu yüzden bu tavsiye edilebilir olup olmadığını bilmiyorum, ama boilerplate yeniden yazma değil için harika çalışıyor.

Bir modül olarak yüklenebilmesi için projenizde bir init .py olmalıdır

# 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)öneri buradan geliyor

Ardından günlükçünüzü başka bir dosyada kullanmak için:

from [your module name here] import logger

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

Uyarılar:

1. Dosyalarınızı modül olarak çalıştırmalısınız, aksi takdirde import [your module]çalışmaz:
   • python -m [your module name].[your filename without .py]
2. Programınızın giriş noktası için günlükçünün adı olacaktır __main__, ancak kullanılan herhangi bir çözümde __name__bu sorun olacaktır.