# logging

import logging

​

# log the execution time and a message of an action

logging.basicConfig(filename='fileName.log',

                    level=logging.INFO,

                    format='%(levelname)s:%(asctime)s:%(message)s',

                    datefmt="%Y-%m-%d %H:%M:%S")

​

logging.info('ADD TWO NUMBERS')

print(5+5)

​

# output in console -> 10

# output in fileName.log -> INFO:2021-12-25 17:47:27:ADD TWO NUMBERS

# Logging is a means of tracking events that happen when some software runs. Logging is important for software developing, debugging and running. If you don’t have any logging record and your program crashes, there are very little chances that you detect the cause of the problem.

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

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)

​

########### Simple way #############

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

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") 

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

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

# 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!")

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__+"\n"

                issue = issue+"=============\n"

                logger.exception(issue)

                raise

        return wrapper

    return decorator 

​

​

@exception(logger) 

def divideByZero(): 

    return 12/0

​

# Driver Code 

if __name__ == '__main__': 

    divideByZero() 

# For 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.basicConfig(filename='example.log', filemode='w', level=logging.DEBUG)

​