Learning notes for Python logging module

Module-level function

Logging.getlogger ([name]): returns a logger object, or root logger if no name is specified
Logging.debug (), logging.info(), logging.warning(), logging.error(), logging.critical() : sets the logging level of root logger
Logging.basicconfig (): creates a StreamHandler for the logging system with the default Formatter, sets the underlying configuration, and adds it to the root logger

Example: logging_level_example. Py

import logging
import sys

LEVELS = {'debug': logging.DEBUG,
          'info': logging.INFO,
          'warning': logging.WARNING,
          'error': logging.ERROR,
          'critical': logging.CRITICAL}

if len(sys.argv) > 1:
    level_name = sys.argv[1]
    level = LEVELS.get(level_name, logging.NOTSET)
    logging.basicConfig(level=level)

logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical error message')

Output:

$ python logging_level_example.py debug
DEBUG:root:This is a debug message
INFO:root:This is an info message
WARNING:root:This is a warning message
ERROR:root:This is an error message
CRITICAL:root:This is a critical error message
$ python logging_level_example.py info
INFO:root:This is an info message
WARNING:root:This is a warning message
ERROR:root:This is an error message
CRITICAL:root:This is a critical error message

Loggers

Logger.setLevel(lel): specifies the lowest logging level. Levels below lel are ignored. Debug is the lowest built-in level and critical is the highest
Logger.addFilter(filt), logger. removeFilter(filt): adds or removes the specified filter
Logger.addhandler (HDLR), logger.removehandler (HDLR) : adds or removes the specified handler
Logger.debug(), logger. info(), logger. warning(), logger. error(), logger. critical() : the log level that can be set

Example: simple_logging_module. Py

import logging

# create logger
logger = logging.getLogger("simple_example")
logger.setLevel(logging.DEBUG)

# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# create formatter
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")

# add formatter to ch
ch.setFormatter(formatter)

# add ch to logger
logger.addHandler(ch)

# "application" code
logger.debug("debug message")
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
logger.critical("critical message")

Output:

$ python simple_logging_module.py
2005-03-19 15:10:26,618 - simple_example - DEBUG - debug message
2005-03-19 15:10:26,620 - simple_example - INFO - info message
2005-03-19 15:10:26,695 - simple_example - WARNING - warn message
2005-03-19 15:10:26,697 - simple_example - ERROR - error message
2005-03-19 15:10:26,773 - simple_example - CRITICAL - critical message

Handlers

The handler object is responsible for sending the relevant information to the specified destination. You can add multiple multihandlers through the addHandler() method
Handler.setlevel (lel): specifies the level of information to be processed. Information below lel is ignored
Handler.setformatter () : select a format for this Handler
Handler.addfilter (filt), handler.removefilter (filt) : add or remove a filter object

Formatters

The Formatter object sets the final rules, structure, and content of the log information. The default time format is % y-% m-%d %H:% m :%S

% (name) s

The name of the Logger

% (levelno) s

Log level in digital form

% (levelname) s

Log level in text form

% s (pathname)

The full pathname of the module that calls the log output function, possibly not

% (filename) s

The file name of the module that calls the log output function

% s (module)

The name of the module that calls the log output function

% (funcName) s

The function name of the call to the log output function

% (lineno) d

The line of code that calls the log output function

% f (created)

The current time, expressed in UNIX standard floating points for time

% (relativeCreated) d

Number of milliseconds from Logger created when log information is output

% (asctime) s

The current time as a string. The default format is "2003-07-08 16:49:45,896". After the comma are milliseconds

% d (thread)

The thread ID. There may be no

% (threadName) s

The thread's name. There may be no

% d (process)

The process ID. There may be no

% s (the message)

User output message

Finally, a complete example:

import logging

# set up logging to file - see previous section for more details
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M',
                    filename='/temp/myapp.log',
                    filemode='w')
# define a Handler which writes INFO messages or higher to the sys.stderr
console = logging.StreamHandler()
console.setLevel(logging.INFO)
# set a format which is simpler for console use
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
# tell the handler to use this format
console.setFormatter(formatter)
# add the handler to the root logger
logging.getLogger('').addHandler(console)

# Now, we can log to the root logger, or any other logger. First the root...
logging.info('Jackdaws love my big sphinx of quartz.')

# Now, define a couple of other loggers which might represent areas in your
# application:

logger1 = logging.getLogger('myapp.area1')
logger2 = logging.getLogger('myapp.area2')

logger1.debug('Quick zephyrs blow, vexing daft Jim.')
logger1.info('How quickly daft jumping zebras vex.')
logger2.warning('Jail zesty vixen who grabbed pay from quack.')
logger2.error('The five boxing wizards jump quickly.')

After running, the result is seen in the terminal

root        : INFO     Jackdaws love my big sphinx of quartz.
myapp.area1 : INFO     How quickly daft jumping zebras vex.
myapp.area2 : WARNING  Jail zesty vixen who grabbed pay from quack.
myapp.area2 : ERROR    The five boxing wizards jump quickly.

Results in the log file

10-22 22:19 root         INFO     Jackdaws love my big sphinx of quartz.
10-22 22:19 myapp.area1  DEBUG    Quick zephyrs blow, vexing daft Jim.
10-22 22:19 myapp.area1  INFO     How quickly daft jumping zebras vex.
10-22 22:19 myapp.area2  WARNING  Jail zesty vixen who grabbed pay from quack.
10-22 22:19 myapp.area2  ERROR    The five boxing wizards jump quickly.

The DEBUG information is found only in the file because the setLevel in StreamHandler is INFO, and you can see the difference between logger.setlevel () and handler.setlevel ()

Please refer to http://docs.python.org/library/logging.html for more information