Cara menambahkan loglevel kustom ke fasilitas logging Python

Saya ingin memiliki loglevel TRACE (5) untuk aplikasi saya, karena menurut saya itu tidak debug()cukup. Selain log(5, msg)itu bukan yang saya inginkan. Bagaimana cara menambahkan loglevel khusus ke logger Python?

Saya punya mylogger.pydengan konten berikut:

import logging

@property
def log(obj):
    myLogger = logging.getLogger(obj.__class__.__name__)
    return myLogger

Dalam kode saya, saya menggunakannya dengan cara berikut:

class ExampleClass(object):
    from mylogger import log

    def __init__(self):
        '''The constructor with the logger'''
        self.log.debug("Init runs")

Sekarang saya ingin menelepon self.log.trace("foo bar")

Terima kasih sebelumnya atas bantuan Anda.

Sunting (8 Des 2016): Saya mengubah jawaban yang diterima menjadi pfa yang, IMHO, solusi luar biasa berdasarkan proposal yang sangat bagus dari Eric S.

@Bayu_joo

Jawaban Eric S. sangat bagus, tetapi saya belajar melalui eksperimen bahwa ini akan selalu menyebabkan pesan yang dicatat di tingkat debug baru untuk dicetak - terlepas dari apa tingkat log yang disetel. Jadi jika Anda membuat nomor tingkat baru 9, jika Anda menelepon setLevel(50), pesan tingkat yang lebih rendah akan dicetak secara keliru.

Untuk mencegah hal itu terjadi, Anda memerlukan baris lain di dalam fungsi "debugv" untuk memeriksa apakah tingkat logging yang dimaksud benar-benar diaktifkan.

Memperbaiki contoh yang memeriksa apakah level logging diaktifkan:

import logging
DEBUG_LEVELV_NUM = 9 
logging.addLevelName(DEBUG_LEVELV_NUM, "DEBUGV")
def debugv(self, message, *args, **kws):
    if self.isEnabledFor(DEBUG_LEVELV_NUM):
        # Yes, logger takes its '*args' as 'args'.
        self._log(DEBUG_LEVELV_NUM, message, args, **kws) 
logging.Logger.debugv = debugv

Jika Anda melihat kode untuk class Loggerdi logging.__init__.pyPython 2.7, inilah yang dilakukan semua fungsi log standar (.critical, .debug, dll.).

Sepertinya saya tidak dapat memposting balasan ke jawaban orang lain karena kurangnya reputasi ... semoga Eric akan memperbarui postingannya jika dia melihat ini. =)

Saya mengambil jawaban "hindari melihat lambda" dan harus memodifikasi di mana log_at_my_log_level ditambahkan. Saya juga melihat masalah yang dilakukan Paul, "Menurut saya ini tidak berhasil. Apakah Anda tidak perlu logger sebagai argumen pertama di log_at_my_log_level?" Ini berhasil untuk saya

import logging
DEBUG_LEVELV_NUM = 9 
logging.addLevelName(DEBUG_LEVELV_NUM, "DEBUGV")
def debugv(self, message, *args, **kws):
    # Yes, logger takes its '*args' as 'args'.
    self._log(DEBUG_LEVELV_NUM, message, args, **kws) 
logging.Logger.debugv = debugv

Menggabungkan semua jawaban yang ada dengan sekumpulan pengalaman penggunaan, saya pikir saya telah membuat daftar semua hal yang perlu dilakukan untuk memastikan penggunaan level baru yang sepenuhnya mulus. Langkah-langkah di bawah ini mengasumsikan bahwa Anda menambahkan level baru TRACEdengan nilai logging.DEBUG - 5 == 5:

1. logging.addLevelName(logging.DEBUG - 5, 'TRACE') perlu dipanggil untuk mendapatkan level baru yang terdaftar secara internal sehingga bisa direferensikan dengan nama.
2. Tingkat baru perlu ditambahkan sebagai atribut untuk loggingdirinya sendiri untuk konsistensi: logging.TRACE = logging.DEBUG - 5.
3. Metode yang dipanggil traceperlu ditambahkan ke loggingmodul. Ini harus bersikap seperti debug, info, dll
4. Metode yang dipanggil traceperlu ditambahkan ke kelas logger yang saat ini dikonfigurasi. Karena ini tidak dijamin 100% logging.Logger, gunakan logging.getLoggerClass()saja.

Semua langkah diilustrasikan dalam metode di bawah ini:

def addLoggingLevel(levelName, levelNum, methodName=None):
    """
    Comprehensively adds a new logging level to the `logging` module and the
    currently configured logging class.

    `levelName` becomes an attribute of the `logging` module with the value
    `levelNum`. `methodName` becomes a convenience method for both `logging`
    itself and the class returned by `logging.getLoggerClass()` (usually just
    `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is
    used.

    To avoid accidental clobberings of existing attributes, this method will
    raise an `AttributeError` if the level name is already an attribute of the
    `logging` module or if the method name is already present 

    Example
    -------
    >>> addLoggingLevel('TRACE', logging.DEBUG - 5)
    >>> logging.getLogger(__name__).setLevel("TRACE")
    >>> logging.getLogger(__name__).trace('that worked')
    >>> logging.trace('so did this')
    >>> logging.TRACE
    5

    """
    if not methodName:
        methodName = levelName.lower()

    if hasattr(logging, levelName):
       raise AttributeError('{} already defined in logging module'.format(levelName))
    if hasattr(logging, methodName):
       raise AttributeError('{} already defined in logging module'.format(methodName))
    if hasattr(logging.getLoggerClass(), methodName):
       raise AttributeError('{} already defined in logger class'.format(methodName))

    # This method was inspired by the answers to Stack Overflow post
    # http://stackoverflow.com/q/2183233/2988730, especially
    # http://stackoverflow.com/a/13638084/2988730
    def logForLevel(self, message, *args, **kwargs):
        if self.isEnabledFor(levelNum):
            self._log(levelNum, message, args, **kwargs)
    def logToRoot(message, *args, **kwargs):
        logging.log(levelNum, message, *args, **kwargs)

    logging.addLevelName(levelNum, levelName)
    setattr(logging, levelName, levelNum)
    setattr(logging.getLoggerClass(), methodName, logForLevel)
    setattr(logging, methodName, logToRoot)

Pertanyaan ini agak lama, tetapi saya hanya membahas topik yang sama dan menemukan cara yang mirip dengan yang telah disebutkan yang tampak sedikit lebih bersih bagi saya. Ini telah diuji pada 3.4, jadi saya tidak yakin apakah metode yang digunakan ada di versi yang lebih lama:

from logging import getLoggerClass, addLevelName, setLoggerClass, NOTSET

VERBOSE = 5

class MyLogger(getLoggerClass()):
    def __init__(self, name, level=NOTSET):
        super().__init__(name, level)

        addLevelName(VERBOSE, "VERBOSE")

    def verbose(self, msg, *args, **kwargs):
        if self.isEnabledFor(VERBOSE):
            self._log(VERBOSE, msg, args, **kwargs)

setLoggerClass(MyLogger)

Siapa yang memulai praktik buruk menggunakan metode internal ( self._log) dan mengapa setiap jawaban didasarkan pada itu ?! Solusi pythonic akan digunakan self.logsehingga Anda tidak perlu mengacaukan hal-hal internal apa pun:

import logging

SUBDEBUG = 5
logging.addLevelName(SUBDEBUG, 'SUBDEBUG')

def subdebug(self, message, *args, **kws):
    self.log(SUBDEBUG, message, *args, **kws) 
logging.Logger.subdebug = subdebug

logging.basicConfig()
l = logging.getLogger()
l.setLevel(SUBDEBUG)
l.subdebug('test')
l.setLevel(logging.DEBUG)
l.subdebug('test')

Saya merasa lebih mudah untuk membuat atribut baru untuk objek logger yang melewati fungsi log (). Saya pikir modul logger menyediakan addLevelName () dan log () karena alasan ini. Jadi tidak diperlukan subclass atau metode baru.

import logging

@property
def log(obj):
    logging.addLevelName(5, 'TRACE')
    myLogger = logging.getLogger(obj.__class__.__name__)
    setattr(myLogger, 'trace', lambda *args: myLogger.log(5, *args))
    return myLogger

sekarang

mylogger.trace('This is a trace message')

harus bekerja seperti yang diharapkan.

Meskipun kami sudah memiliki banyak jawaban yang benar, berikut ini menurut saya lebih pythonic:

import logging

from functools import partial, partialmethod

logging.TRACE = 5
logging.addLevelName(logging.TRACE, 'TRACE')
logging.Logger.trace = partialmethod(logging.Logger.log, logging.TRACE)
logging.trace = partial(logging.log, logging.TRACE)

Jika Anda ingin menggunakan mypykode Anda, disarankan untuk menambahkan # type: ignoreuntuk menyembunyikan peringatan dari menambahkan atribut.

Saya pikir Anda harus membuat subclass Loggerkelas dan menambahkan metode traceyang pada dasarnya memanggil Logger.logdengan level yang lebih rendah dari DEBUG. Saya belum mencoba ini tetapi ini yang ditunjukkan oleh dokumen .

Kiat untuk membuat logger ubahsuaian:

1. Jangan gunakan _log, gunakan log(Anda tidak perlu memeriksa isEnabledFor)
2. modul logging harus menjadi salah satu instance pembuatan logger kustom karena ia melakukan beberapa keajaiban getLogger, jadi Anda perlu mengatur kelas melaluisetLoggerClass
3. Anda tidak perlu mendefinisikan __init__untuk logger, kelas jika Anda tidak menyimpan apapun

# Lower than debug which is 10
TRACE = 5
class MyLogger(logging.Logger):
    def trace(self, msg, *args, **kwargs):
        self.log(TRACE, msg, *args, **kwargs)

Saat memanggil logger ini gunakan setLoggerClass(MyLogger)untuk menjadikan ini logger default darigetLogger

logging.setLoggerClass(MyLogger)
log = logging.getLogger(__name__)
# ...
log.trace("something specific")

Anda akan perlu setFormatter, setHandlerdan setLevel(TRACE)pada handlerdan pada logdirinya sendiri untuk benar-benar se jejak ini tingkat rendah

Ini berhasil untuk saya:

import logging
logging.basicConfig(
    format='  %(levelname)-8.8s %(funcName)s: %(message)s',
)
logging.NOTE = 32  # positive yet important
logging.addLevelName(logging.NOTE, 'NOTE')      # new level
logging.addLevelName(logging.CRITICAL, 'FATAL') # rename existing

log = logging.getLogger(__name__)
log.note = lambda msg, *args: log._log(logging.NOTE, msg, args)
log.note('school\'s out for summer! %s', 'dude')
log.fatal('file not found.')

Masalah lambda / funcName telah diperbaiki dengan logger._log seperti yang ditunjukkan @marqueed. Saya pikir menggunakan lambda terlihat sedikit lebih bersih, tetapi kekurangannya adalah tidak dapat mengambil argumen kata kunci. Aku sendiri belum pernah menggunakannya, jadi bukan masalah besar.

  CATATAN pengaturan: sekolah keluar untuk musim panas! bung
  Setup FATAL: file tidak ditemukan.

Dalam pengalaman saya, ini adalah solusi lengkap dari masalah op ... untuk menghindari melihat "lambda" sebagai fungsi di mana pesan tersebut dipancarkan, masuk lebih dalam:

MY_LEVEL_NUM = 25
logging.addLevelName(MY_LEVEL_NUM, "MY_LEVEL_NAME")
def log_at_my_log_level(self, message, *args, **kws):
    # Yes, logger takes its '*args' as 'args'.
    self._log(MY_LEVEL_NUM, message, args, **kws)
logger.log_at_my_log_level = log_at_my_log_level

Saya belum pernah mencoba bekerja dengan kelas logger mandiri, tapi menurut saya ide dasarnya sama (gunakan _log).

Penambahan contoh Mad Physicists untuk mendapatkan nama file dan nomor baris yang benar:

def logToRoot(message, *args, **kwargs):
    if logging.root.isEnabledFor(levelNum):
        logging.root._log(levelNum, message, args, **kwargs)

Berdasarkan jawaban yang disematkan, saya menulis sedikit metode yang secara otomatis membuat tingkat logging baru

def set_custom_logging_levels(config={}):
    """
        Assign custom levels for logging
            config: is a dict, like
            {
                'EVENT_NAME': EVENT_LEVEL_NUM,
            }
        EVENT_LEVEL_NUM can't be like already has logging module
        logging.DEBUG       = 10
        logging.INFO        = 20
        logging.WARNING     = 30
        logging.ERROR       = 40
        logging.CRITICAL    = 50
    """
    assert isinstance(config, dict), "Configuration must be a dict"

    def get_level_func(level_name, level_num):
        def _blank(self, message, *args, **kws):
            if self.isEnabledFor(level_num):
                # Yes, logger takes its '*args' as 'args'.
                self._log(level_num, message, args, **kws) 
        _blank.__name__ = level_name.lower()
        return _blank

    for level_name, level_num in config.items():
        logging.addLevelName(level_num, level_name.upper())
        setattr(logging.Logger, level_name.lower(), get_level_func(level_name, level_num))

config mungkin seperti itu:

new_log_levels = {
    # level_num is in logging.INFO section, that's why it 21, 22, etc..
    "FOO":      21,
    "BAR":      22,
}

Sebagai alternatif untuk menambahkan metode tambahan ke kelas Logger, saya akan merekomendasikan menggunakan Logger.log(level, msg)metode tersebut.

import logging

TRACE = 5
logging.addLevelName(TRACE, 'TRACE')
FORMAT = '%(levelname)s:%(name)s:%(lineno)d:%(message)s'


logging.basicConfig(format=FORMAT)
l = logging.getLogger()
l.setLevel(TRACE)
l.log(TRACE, 'trace message')
l.setLevel(logging.DEBUG)
l.log(TRACE, 'disabled trace message')

Saya bingung; dengan python 3.5, setidaknya, ini berfungsi:

import logging


TRACE = 5
"""more detail than debug"""

logging.basicConfig()
logging.addLevelName(TRACE,"TRACE")
logger = logging.getLogger('')
logger.debug("n")
logger.setLevel(logging.DEBUG)
logger.debug("y1")
logger.log(TRACE,"n")
logger.setLevel(TRACE)
logger.log(TRACE,"y2")
    

keluaran:

DEBUG: root: y1

JEJAK: root: y2

Jika ada yang menginginkan cara otomatis untuk menambahkan level logging baru ke modul logging (atau salinannya) secara dinamis, saya telah membuat fungsi ini, memperluas jawaban @ pfa:

def add_level(log_name,custom_log_module=None,log_num=None,
                log_call=None,
                   lower_than=None, higher_than=None, same_as=None,
              verbose=True):
    '''
    Function to dynamically add a new log level to a given custom logging module.
    <custom_log_module>: the logging module. If not provided, then a copy of
        <logging> module is used
    <log_name>: the logging level name
    <log_num>: the logging level num. If not provided, then function checks
        <lower_than>,<higher_than> and <same_as>, at the order mentioned.
        One of those three parameters must hold a string of an already existent
        logging level name.
    In case a level is overwritten and <verbose> is True, then a message in WARNING
        level of the custom logging module is established.
    '''
    if custom_log_module is None:
        import imp
        custom_log_module = imp.load_module('custom_log_module',
                                            *imp.find_module('logging'))
    log_name = log_name.upper()
    def cust_log(par, message, *args, **kws):
        # Yes, logger takes its '*args' as 'args'.
        if par.isEnabledFor(log_num):
            par._log(log_num, message, args, **kws)
    available_level_nums = [key for key in custom_log_module._levelNames
                            if isinstance(key,int)]

    available_levels = {key:custom_log_module._levelNames[key]
                             for key in custom_log_module._levelNames
                            if isinstance(key,str)}
    if log_num is None:
        try:
            if lower_than is not None:
                log_num = available_levels[lower_than]-1
            elif higher_than is not None:
                log_num = available_levels[higher_than]+1
            elif same_as is not None:
                log_num = available_levels[higher_than]
            else:
                raise Exception('Infomation about the '+
                                'log_num should be provided')
        except KeyError:
            raise Exception('Non existent logging level name')
    if log_num in available_level_nums and verbose:
        custom_log_module.warn('Changing ' +
                                  custom_log_module._levelNames[log_num] +
                                  ' to '+log_name)
    custom_log_module.addLevelName(log_num, log_name)

    if log_call is None:
        log_call = log_name.lower()

    setattr(custom_log_module.Logger, log_call, cust_log)
    return custom_log_module