Python - Using logging for Debugging and Error tracking

Using Logging for Debugging and Error tracking in Python

Logging is an essential function in Python, for troubleshooting and tracking problems, especially in complicated programs, it makes it simpler to comprehend what happened during execution by providing a means to transmit status, error, and informational messages to a file or another output stream.

Logging

Logging allows you to record information about your application’s execution, which is useful for diagnosing issues.

There are, multiple levels of logging, including DEBUG, INFO, WARNING, ERROR, and CRITICAL, are available in Python's built-in logging module, making it very flexible.

Basic Logging

You can use Python's built-in logging module:

import logging

# Configure logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

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

Logging to a File

To log to a file instead of the console we can use the following code:

logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

Advanced Logging

You can create custom loggers, handlers, and formatters for more complex applications:

logger = logging.getLogger('my_logger')
handler = logging.FileHandler('my_log.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

Debugging

In Python, debugging helps you to identify and fix issues in your code.

Using print Statements

A straightforward method is to insert print statements:

def faulty_function(x):
    print(f"Input value: {x}")
    return 10 / x
faulty_function(0)

Using a Debugger

Python has built-in support for debugging via pdb:

import pdb
def buggy_function(a, b):
    pdb.set_trace() # Set a breakpoint
    return a / b
buggy_function(5, 0)

Error Tracking

Python Error tracking helps us to identify and resolve issues in our code by capturing and analyzing exceptions and logging them for later analysis.

Example

Using various logging levels, configuring logging, and integrating logging into a basic application are all illustrated in this example:

import logging

# Configure the logging system
logging.basicConfig(filename='app.log', # Log to a file named app.log
                    filemode='a', # Append mode, so log file is not overwritten
                    format='%(asctime)s - %(levelname)s - %(message)s',
                    level=logging.DEBUG) # Log messages of all levels DEBUG and above

# Log messages of various levels
logging.debug('This is a debug message')
logging.info('This is an informational message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')

def safe_divide(num1, num2):
    try:
        result = num1 / num2

    except ZeroDivisionError:
        logging.error("Attempted to divide by zero", exc_info=True)
        return None

    else:
        logging.info(f"Division successful: {num1} / {num2} = {result}")
        return result

# Using the function with valid input
valid_division = safe_divide(10, 2)

# Using the function with a divisor of zero
invalid_division = safe_divide(10, 0) # Corrected: no parentheses after the function call

In this example:

• The logging system is configured using the logging.basicConfig method, which also specifies the structure of log messages to be sent to app.log in append mode, together with the timestamp, log level, and message text. The minimal level of messages to log is determined by the level option.
• Emitting various log messages at different levels is possible using logging.debug(), logging.info(), and so forth.
• When a division by zero is attempted, the safe_divide function uses logging to record an error message with stack trace information (exc_info=True) and an informational message upon division success.

When apps and services are used for extended periods, such logging facilitates troubleshooting and helps to comprehend the behavior of the program over time. For troubleshooting and development purposes, logs offer a record of the actions taken by the program as well as the issues it ran into.