Python Logging Exercises

Python’s built-in logging module provides convenient functions for different logging levels. To log an informational message, you use logging.info(message).

Example:

import logging

logging.basicConfig(level=logging.INFO)
logging.info("This is an info message")

• Option 2 (log_info) and Option 3 (message) do not exist in the logging module.
• Option 4 (print) is a simple print statement and does not integrate with Python’s logging system.

Using logging.info() allows messages to be handled according to configured handlers and levels, making it more flexible and robust than print statements, which is essential for real-world projects.

Python’s logging module defines several levels of severity for log messages: DEBUG, INFO, WARNING, ERROR, and CRITICAL.

• CRITICAL represents the highest severity, used for serious errors that may prevent the program from continuing.
• ERROR is for standard runtime errors.
• WARNING indicates a potential problem.
• INFO is for general informational messages.

Understanding these levels helps developers control which messages are recorded and how they are handled by different logging handlers.

The logging.basicConfig() function is used to configure the default logging behavior in Python. It allows you to set parameters like the logging level, output format, and filename for file logging.

Example:

import logging

logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
logging.info("Logging system configured")

• Option 1 (configure) and Option 4 (init) do not exist in the logging module.
• Option 3 (setLevel) is used to set the logging level on a logger object, not for global configuration.

Using basicConfig() is the simplest way to get started with logging before using more advanced handlers or formatters.

Python’s logging module defaults to showing messages with level WARNING and above (WARNING, ERROR, CRITICAL) if the logging system is not configured.

Example:

import logging

logging.debug("This is debug")   # Not shown
logging.info("This is info")     # Not shown
logging.warning("This is warning")  # Shown
logging.error("This is error")      # Shown

• This default behavior ensures that only potentially problematic messages are displayed, avoiding clutter from informational or debug logs.
• If you need INFO or DEBUG messages, you must configure the logging level using basicConfig().

The logging.exception() method is specifically designed to log an error message along with the full traceback of an exception. It should be called inside an except block.

import logging

logging.basicConfig(level=logging.ERROR)

try:
    1 / 0
except ZeroDivisionError:
    logging.exception("Division by zero occurred")

• Option 2 (traceback=True) is invalid; logging.error does not take a traceback argument.
• Option 3 (warn_exc) and Option 4 (log_exception) do not exist.

Using logging.exception() helps developers quickly identify the source of an error and understand the call stack during debugging.

To log messages to a file, Python’s logging module provides the FileHandler class. You can attach it to a logger to direct all log messages to a specified file.

Example:

import logging

logger = logging.getLogger("my_logger")
file_handler = logging.FileHandler("app.log")
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)

logger.info("This message will go to the file")

• Options 2, 3, and 4 do not exist in the logging module.
• Using FileHandler allows persistent logging, which is useful for debugging and record-keeping in real applications.

A formatter in Python’s logging module defines the structure of log messages. To include timestamp, logger name, level, and message, the formatter string should be:

'%(asctime)s - %(name)s - %(levelname)s - %(message)s'

Example:

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logging.info("Logging with full details")

• Option 1 only shows the log level and message.
• Option 3 shows only the logger name and message.
• Option 4 shows only the message.

Using a detailed formatter is crucial in real-world applications to trace issues with context, especially when multiple loggers or modules are involved.

In Python, you can create a custom named logger using logging.getLogger(name). If a logger with the given name already exists, it returns the existing one; otherwise, it creates a new logger. This approach allows you to have multiple independent loggers with separate configurations.

Example:

import logging

my_logger = logging.getLogger("myLogger")
my_logger.setLevel(logging.INFO)

my_logger.info("This is a custom logger message")

• Option 1 (createLogger) and Option 3 (newLogger) do not exist.
• Option 4 (Logger(...)) is a class constructor, but you usually use getLogger to manage loggers properly.

Custom loggers are useful for separating logs from different modules or components in an application, making debugging and monitoring more organized.

The RotatingFileHandler allows log files to automatically rotate when they reach a specified size. This prevents log files from growing indefinitely and helps manage disk space efficiently.

Example:

import logging
from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler("app.log", maxBytes=1024, backupCount=3)
logger = logging.getLogger("rotatingLogger")
logger.addHandler(handler)
logger.setLevel(logging.INFO)

logger.info("This message goes to a rotating log file")

• FileHandler writes to a file but doesn’t rotate it.
• StreamHandler outputs to streams like console.
• SocketHandler sends logs over network sockets.

RotatingFileHandler is essential for long-running applications where logs could grow uncontrollably without rotation.

Logging levels in Python define which messages are allowed to propagate. If the logger level is set higher than the message, the message will be ignored.

Example:

import logging

logging.basicConfig(level=logging.ERROR)
logging.warning("This warning will not appear")
logging.error("This error will appear")

• DEBUG and INFO messages will be ignored.
• WARNING is ignored because the logger level is ERROR.
• Only messages at the set level or higher (ERROR, CRITICAL) are logged.

Understanding logging levels ensures that only relevant messages are recorded, keeping logs concise and meaningful.

Handlers in Python logging determine where log messages are sent. A logger can have multiple handlers, such as a StreamHandler for console output and a FileHandler for writing to a file simultaneously.

Example:

import logging

logger = logging.getLogger("myLogger")

console_handler = logging.StreamHandler()
file_handler = logging.FileHandler("app.log")

logger.addHandler(console_handler)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)

logger.info("Message goes to both console and file")

• Handlers do not only format messages (Option 1).
• They do not replace the logger’s behavior entirely (Option 3).
• They are not limited to files (Option 4) — they can output to console, network sockets, or even email.

Using multiple handlers allows flexible log management for different environments or purposes, like monitoring and debugging simultaneously.

The SocketHandler sends log messages to a remote logging server over TCP or UDP. This is useful for centralizing logs from multiple applications or machines.

Example:

import logging
from logging.handlers import SocketHandler

logger = logging.getLogger("networkLogger")
socket_handler = SocketHandler("localhost", 9999)
logger.addHandler(socket_handler)
logger.setLevel(logging.INFO)

logger.info("This message is sent over the network")

• FileHandler writes logs to a file locally.
• StreamHandler writes to streams like console.
• RotatingFileHandler manages file rotation, not network transmission.

Using SocketHandler allows centralized monitoring of applications running on different servers, which is crucial for distributed systems.

In Python logging, you can create a custom filter class by subclassing logging.Filter and then attach it to a logger using addFilter(). Filters determine whether a log record should be processed by the logger or not.

Example:

import logging

class MyFilter(logging.Filter):
    def filter(self, record):
        return record.name == "my_module"

logger = logging.getLogger("myLogger")
logger.addFilter(MyFilter())
logger.setLevel(logging.INFO)

logger.info("This will only appear if logger name matches my_module")

• Options 2, 3, and 4 are invalid; the logging module does not provide these methods.
• Filters are powerful for controlling log output in complex applications with multiple modules or libraries.

The SMTPHandler in Python’s logging module allows log messages to be sent via email. It is typically used for sending critical alerts to administrators.

Example:

import logging
from logging.handlers import SMTPHandler

logger = logging.getLogger("emailLogger")
smtp_handler = SMTPHandler(
    mailhost=("smtp.example.com", 587),
    fromaddr="app@example.com",
    toaddrs=["admin@example.com"],
    subject="Critical Error"
)
logger.addHandler(smtp_handler)
logger.setLevel(logging.CRITICAL)

logger.critical("A critical error occurred")

• FileHandler writes to files, StreamHandler writes to streams, and RotatingFileHandler manages file rotation.
• SMTPHandler is ideal for alerting administrators automatically in production environments when serious issues occur.

The TimedRotatingFileHandler automatically rotates log files at specified time intervals, such as daily, hourly, or weekly. This is useful for long-running applications to avoid massive log files and to organize logs by date.

Example:

import logging
from logging.handlers import TimedRotatingFileHandler

logger = logging.getLogger("timedLogger")
handler = TimedRotatingFileHandler("timed_app.log", when="midnight", backupCount=7)
logger.addHandler(handler)
logger.setLevel(logging.INFO)

logger.info("This log will rotate daily at midnight")

• FileHandler writes logs to a file but does not rotate automatically.
• StreamHandler writes to streams like console.
• SocketHandler sends logs over the network.

Using TimedRotatingFileHandler allows developers to manage logs efficiently over time, ensuring older logs are archived and new logs are organized automatically.