How to add a custom loglevel to Python's logging facility

@Eric S.

Eric S.'s answer is excellent, but I learned by experimentation that this will always cause messages logged at the new debug level to be printed -- regardless of what the log level is set to. So if you make a new level number of 9, if you call setLevel(50), the lower level messages will erroneously be printed.

To prevent that from happening, you need another line inside the "debugv" function to check if the logging level in question is actually enabled.

Fixed example that checks if the logging level is enabled:

import loggingDEBUG_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

If you look at the code for class Logger in logging.__init__.py for Python 2.7, this is what all the standard log functions do (.critical, .debug, etc.).

I apparently can't post replies to others' answers for lack of reputation... hopefully Eric will update his post if he sees this. =)

Combining all of the existing answers with a bunch of usage experience, I think that I have come up with a list of all the things that need to be done to ensure completely seamless usage of the new level. The steps below assume that you are adding a new level TRACE with value logging.DEBUG - 5 == 5:

1. logging.addLevelName(logging.DEBUG - 5, 'TRACE') needs to be invoked to get the new level registered internally so that it can be referenced by name.
2. The new level needs to be added as an attribute to logging itself for consistency: logging.TRACE = logging.DEBUG - 5.
3. A method called trace needs to be added to the logging module. It should behave just like debug, info, etc.
4. A method called trace needs to be added to the currently configured logger class. Since this is not 100% guaranteed to be logging.Logger, use logging.getLoggerClass() instead.

All the steps are illustrated in the method below:

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)

I took the avoid seeing "lambda" answer and had to modify where the log_at_my_log_level was being added. I too saw the problem that Paul did – I don't think this works. Don't you need logger as the first arg in log_at_my_log_level? This worked for me

import loggingDEBUG_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