PYTHON

logging python

import logging

logging.basicConfig(level=logging.DEBUG)
# logging.basicConfig(filename='app.log', filemode='w', format='%(name)s - %(levelname)s - %(message)s')

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

python logging to file

import logging
import sys

logger = logging.getLogger()
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(message)s', 
                              '%m-%d-%Y %H:%M:%S')

stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setLevel(logging.DEBUG)
stdout_handler.setFormatter(formatter)

file_handler = logging.FileHandler('logs.log')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)

logger.addHandler(file_handler)
logger.addHandler(stdout_handler)

logging python

#!/usr/bin/env python

import logging

logging.basicConfig(filename='test.log', format='%(filename)s: %(message)s',
                    level=logging.DEBUG)

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

python logging format

# Logger setup in python
def get_logger(self) -> logging.RootLogger:
    """instance of logger module, will be used for logging operations"""
    
    # logger config
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)

    # log format
    lg_format = "%(levelname)s|%(filename)s:%(lineno)d|%(asctime)s|%(message)s"
    log_format = logging.Formatter(lg_format)

    # file handler
    file_handler = logging.FileHandler("log/monitor_model.log")
    file_handler.setFormatter(log_format)

    logger.handlers.clear()
    logger.addHandler(file_handler)
    return logger

logger levels python

# Note: Only levels on or above the current chosen level are outputted

Logging Levels  -> Numeric Value

CRITICAL -> 50
ERROR -> 40
WARNING -> 30
INFO -> 20
DEBUG -> 10
NOTSET -> 0

python logging basicConfig+time

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

python logging

# Example usage:
# For now, this is how I like to set up logging in Python:

import logging

# instantiate the root (parent) logger object (this is what gets called
# to create log messages)
root_logger = logging.getLogger()
# remove the default StreamHandler which isn't formatted well
root_logger.handlers = []
# set the lowest-severity log message to be included by the root_logger (this
# doesn't need to be set for each of the handlers that are added to the
# root_logger later because handlers inherit the logging level of their parent
# if their level is left unspecified. The root logger uses WARNING by default
root_logger.setLevel(logging.INFO)

# create the file_handler, which controls log messages which will be written
# to a log file (the default write mode is append)
file_handler = logging.FileHandler('/path/to/logfile.log')
# create the console_handler (which enables log messages to be sent to stdout)
console_handler = logging.StreamHandler()

# create the formatter, which controls the format of the log messages
# I like this format which includes the following information:
# 2022-04-01 14:03:03,446 - script_name.py - function_name - Line: 461 - INFO - Log message.
formatter = logging.Formatter('%(asctime)s - %(filename)s - %(funcName)s - Line: %(lineno)d - %(levelname)s - %(message)s')
# add the formatter to the handlers so they get formatted as desired
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# set the severity level of the console_hander to ERROR so that only messages
# of severity ERROR or higher are printed to the console
console_handler.setLevel(logging.ERROR)

# add the handlers to the root_logger
root_logger.addHandler(file_handler)
root_logger.addHandler(console_handler)


# given the above setup
# running this line will append the info message to the /path/to/logfile.log
# but won't print to the console
root_logger.INFO("A casual message.")
# running this line will append the error message to the /path/to/logfile.log
# and will print it to the console
root_logger.ERROR("A serious issue!")

logging python

# simple logging example
import logging

level = logging.DEBUG
logging_format = "[%(levelname)s] %(asctime)s - %(message)s"
logging.basicConfig(level = level, format=logging_format)

def print_vs_logging():
    logging.debug("What is the value of this variable")
    logging.info("Just FYI")
    logging.error("We found the error")

print_vs_logging()

Python Logging

# importing module
import logging
 
# Create and configure logger
logging.basicConfig(filename="newfile.log",
                    format='%(asctime)s %(message)s',
                    filemode='w')
 
# Creating an object
logger = logging.getLogger()
 
# Setting the threshold of logger to DEBUG
logger.setLevel(logging.DEBUG)
 
# Test messages
logger.debug("Harmless debug Message")
logger.info("Just an information")
logger.warning("Its a Warning")
logger.error("Did you try to divide by zero")
logger.critical("Internet is down")

python logging variables extra

import logging

logger = logging.getLogger(__name__)

FORMAT = '%(MYVAR)s %(asctime)s - %(levelname)s - %(message)s'
logging.basicConfig(format=FORMAT, datefmt='%d/%m/%Y %H:%M:%S')

logger.warning("'Twas brillig, and the slithy toves", extra={'MYVAR': 'Jabberwocky'})

python logging level

# python logging level
Level: NOTSET > DEBUG > INFO > WARNING > ERROR > CRITICAL
Value:   0    >  10   >  20  >    30   >  40   >  50
  
Logger.setLevel() specifies the lowest-severity log message a logger will
handle, where debug is the lowest built-in severity level and critical is
the highest built-in severity. 

For example, if the severity level is INFO, the logger will handle only INFO,
WARNING, ERROR, and CRITICAL messages and will ignore DEBUG messages.

python logging levels

Logging Levels

CRITICAL
ERROR
WARNING
INFO
DEBUG
NOTSET

Exception logging

import logging 
from functools import wraps

# Example from: https://www.geeksforgeeks.org/create-an-exception-logging-decorator-in-python/

def create_logger(): 
	
	# create a logger object 
	logger = logging.getLogger('exc_logger') 
	logger.setLevel(logging.INFO) 
	
	#c reate a file to store all the 
	# logged exceptions 
	logfile = logging.FileHandler('exc_logger.log') 
	
	fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
	formatter = logging.Formatter(fmt) 
	
	logfile.setFormatter(formatter) 
	logger.addHandler(logfile) 
	
	return logger 

logger = create_logger() 

# you will find a log file 
# created in a given path 
print(logger) 

def exception(logger):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except:
                issue = "exception in "+func.__name__+"
"
                issue = issue+"=============
"
                logger.exception(issue)
                raise
        return wrapper
    return decorator 


@exception(logger) 
def divideByZero(): 
	return 12/0

# Driver Code 
if __name__ == '__main__': 
	divideByZero() 

logging python

logging.basicConfig(filename='example.log', filemode='w', level=logging.DEBUG)

logging.basicConfig()

import logging  
  
#Create and configure logger using the basicConfig() function  
logging.basicConfig(filename="newfile.log",  
               format='%(asctime)s %(message)s',  
               filemode='w')  
  
#Creating an object of the logging  
logger=logging.getLogger()  
  
#Setting the threshold of logger to DEBUG  
logger.setLevel(logging.DEBUG)  
  
#Test messages  
logger.debug("This is a harmless debug Message")  
logger.info("This is just an information")  
logger.warning("It is a Warning. Please make changes")  
logger.error("You are trying to divide by zero")  
logger.critical("Internet is down")