Menggunakan masuk dalam banyak modul

Saya memiliki proyek python kecil yang memiliki struktur berikut -

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

Saya berencana untuk menggunakan modul logging standar untuk mencetak pesan ke stdout dan file log. Untuk menggunakan modul logging, diperlukan beberapa inisialisasi -

import logging.config

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

logger.info('testing')

Saat ini, saya melakukan inisialisasi ini di setiap modul sebelum saya mulai mencatat pesan. Apakah mungkin untuk melakukan inisialisasi ini hanya sekali di satu tempat sehingga pengaturan yang sama digunakan kembali dengan masuk ke seluruh proyek?

Praktik terbaik adalah, di setiap modul, untuk memiliki logger yang didefinisikan seperti ini:

import logging
logger = logging.getLogger(__name__)

di dekat bagian atas modul, dan kemudian di kode lain dalam modul lakukan misalnya

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

Jika Anda perlu membagi aktivitas logging di dalam sebuah modul, gunakan mis

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

dan masuk loggerAdan loggerBjika perlu.

Di program atau program utama Anda, lakukan misalnya:

def main():
    "your program code"

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

atau

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

if __name__ == '__main__':
    main()

Lihat di sini untuk login dari beberapa modul, dan di sini untuk konfigurasi logging untuk kode yang akan digunakan sebagai modul perpustakaan dengan kode lain.

Pembaruan: Saat menelepon fileConfig(), Anda mungkin ingin menentukan disable_existing_loggers=Falseapakah Anda menggunakan Python 2.6 atau yang lebih baru (lihat dokumen untuk informasi lebih lanjut). Nilai default adalah Trueuntuk kompatibilitas mundur, yang menyebabkan semua penebang yang ada dinonaktifkan oleh fileConfig()kecuali mereka atau leluhur mereka secara eksplisit disebutkan dalam konfigurasi. Dengan nilai yang disetel False, penebang yang ada dibiarkan sendiri. Jika menggunakan Python 2.7 / Python 3.2 atau yang lebih baru, Anda mungkin ingin mempertimbangkan dictConfig()API yang lebih baik daripada fileConfig()karena memberikan kontrol lebih besar atas konfigurasi.

Sebenarnya setiap logger adalah anak dari paket logger orangtua (yaitu package.subpackage.modulemewarisi konfigurasi dari package.subpackage), jadi yang perlu Anda lakukan hanyalah mengkonfigurasi logger root. Ini dapat dicapai dengan logging.config.fileConfig(konfigurasi Anda sendiri untuk logger) atau logging.basicConfig(set logger root) Setup logging di modul entri Anda ( __main__.pyatau apa pun yang ingin Anda jalankan, misalnya main_script.py. __init__.pyBerfungsi juga)

menggunakan basicConfig:

# package/__main__.py
import logging
import sys

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

menggunakan fileConfig:

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

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

lalu buat setiap logger menggunakan:

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

log.info("Hello logging!")

Untuk informasi lebih lanjut, lihat Tutorial Logging Lanjutan .

Saya selalu melakukannya seperti di bawah ini.

Gunakan file python tunggal untuk mengkonfigurasi log saya sebagai pola tunggal yang bernama ' 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')

Di modul lain, cukup impor konfigurasi.

from log_conf import Logger

Logger.logr.info("Hello World")

Ini adalah pola tunggal untuk dicatat, sederhana dan efisien.

Beberapa jawaban ini menunjukkan bahwa di bagian atas modul Anda melakukannya

import logging
logger = logging.getLogger(__name__)

Ini adalah pemahaman saya bahwa ini dianggap praktik yang sangat buruk . Alasannya adalah bahwa konfigurasi file akan menonaktifkan semua logger yang ada secara default. Misalnya

#my_module
import logging

logger = logging.getLogger(__name__)

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

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

Dan di modul utama Anda:

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

Sekarang log yang ditentukan dalam logging.ini akan kosong, karena logger yang ada dinonaktifkan oleh panggilan fileconfig.

Meskipun dimungkinkan untuk mengatasi hal ini (disable_existing_Loggers = False), secara realistis banyak klien perpustakaan Anda tidak akan tahu tentang perilaku ini, dan tidak akan menerima log Anda. Permudah klien Anda dengan selalu menelepon logging.getLogger secara lokal. Tip Hat: Saya belajar tentang perilaku ini dari Situs Victor Lin .

Jadi praktik yang baik adalah sebaliknya untuk selalu memanggil logging.getLogger secara lokal. Misalnya

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

Juga, jika Anda menggunakan fileconfig di utama Anda, setel disable_existing_loggers = Salah, kalau-kalau perancang perpustakaan Anda menggunakan instance logger level modul.

Cara sederhana menggunakan salah satu contoh pendataan pustaka di banyak modul bagi saya adalah solusi berikut:

base_logger.py

import logging

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

File lainnya

from base_logger import logger

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

Melemparkan solusi lain.

Dalam init modul saya .py Saya punya sesuatu seperti:

# 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

Kemudian di setiap modul saya perlu logger, saya lakukan:

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

Ketika log terjawab, Anda dapat membedakan sumbernya dengan modul asalnya.

Anda juga bisa membuat sesuatu seperti ini!

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

Sekarang Anda dapat menggunakan beberapa penebang dalam modul yang sama dan di seluruh proyek jika yang di atas didefinisikan dalam modul yang terpisah dan diimpor dalam modul-modul lain diperlukan pencatatan.

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

@ Solusi Yarkee tampak lebih baik. Saya ingin menambahkan sesuatu ke sana -

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)

Jadi LoggerManager dapat menjadi pluggable ke seluruh aplikasi. Semoga ini masuk akal dan berharga.

Ada beberapa jawaban. Saya berakhir dengan solusi serupa namun berbeda yang masuk akal bagi saya, mungkin itu akan masuk akal bagi Anda juga. Tujuan utama saya adalah untuk dapat mengirimkan log ke penangan berdasarkan levelnya (debug level log ke konsol, peringatan dan di atas ke file):

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)

membuat file util yang bagus bernama logger.py:

import logging

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

flask.app adalah nilai hardcode dalam flask. logger aplikasi selalu dimulai dengan flask.app sebagai nama modulnya.

sekarang, di setiap modul, saya dapat menggunakannya dalam mode berikut:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Ini akan membuat log baru untuk "app.flask.MODULE_NAME" dengan upaya minimal.

Praktik terbaik adalah membuat modul secara terpisah yang hanya memiliki satu metode yang tugasnya kita berikan penangan logger ke metode pemanggilan. Simpan file ini sebagai 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

Sekarang panggil metode getlogger () setiap kali logger handler diperlukan.

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

Baru menggunakan python, jadi saya tidak tahu apakah ini disarankan, tetapi berfungsi dengan baik untuk tidak menulis ulang boilerplate.

Proyek Anda harus memiliki init .py sehingga dapat dimuat sebagai modul

# 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)saran datang dari sini

Kemudian untuk menggunakan logger Anda di file lain:

from [your module name here] import logger

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

Peringatan:

1. Anda harus menjalankan file sebagai modul, jika import [your module]tidak , tidak akan berfungsi:
   • python -m [your module name].[your filename without .py]
2. Nama logger untuk titik masuk program Anda akan __main__, tetapi solusi apa pun yang menggunakan __name__akan memiliki masalah itu.