During application development, programmers need to understand what the application is doing, where an error occurred, and which operations completed successfully.

Python provides the built-in logging module for recording application events. It supports severity levels, formatted messages, console output, file output, named loggers, handlers, and exception information.

Prerequisites

What is Logging?

Logging is the process of recording information about events that occur while an application is running.

A log record may contain a message, severity level, timestamp, logger name, module name, function name, or exception details.

Import the Logging Module

The logging module is part of Python's standard library.

import logging

Create Your First Log Message

import logging


logging.warning(
    "The application is using a default configuration."
)

Possible output:

WARNING:root:The application is using a default configuration.

The output identifies the severity level, logger name, and log message.

Logging Levels

Logging levels classify records according to their importance or severity.

Record Different Log Levels

import logging


logging.debug(
    "Preparing diagnostic data."
)

logging.info(
    "Application started successfully."
)

logging.warning(
    "The configuration file was not found."
)

logging.error(
    "The customer record could not be saved."
)

logging.critical(
    "The application cannot continue."
)

Configure Logging with basicConfig()

Use logging.basicConfig() to define introductory logging settings.

import logging


logging.basicConfig(
    level=logging.INFO
)

logging.debug(
    "Debug message"
)

logging.info(
    "Application started"
)

logging.warning(
    "Configuration is incomplete"
)

Possible output:

INFO:root:Application started
WARNING:root:Configuration is incomplete

The configured level allows INFO and higher-severity records to be processed.

Format Log Messages

import logging


logging.basicConfig(
    level=logging.INFO,
    format=(
        "%(asctime)s | "
        "%(levelname)s | "
        "%(name)s | "
        "%(message)s"
    )
)

logging.info(
    "Application started."
)

Possible output:

2026-08-08 10:30:15,125 | INFO | root | Application started.

Common Formatting Fields

Include Variables in Log Messages

import logging


logging.basicConfig(
    level=logging.INFO,
    format=(
        "%(levelname)s | "
        "%(message)s"
    )
)

customer_id = "CUST-101"
order_total = 2500

logging.info(
    "Order processed for customer %s with total %s",
    customer_id,
    order_total
)

Possible output:

INFO | Order processed for customer CUST-101 with total 2500

Create a Named Logger

Application modules commonly create a logger using the module name.

import logging


logger = logging.getLogger(
    __name__
)

logger.warning(
    "A named logger created this message."
)

The __name__ value identifies the module that created the logger.

Use Logging Inside a Function

import logging


logging.basicConfig(
    level=logging.INFO,
    format=(
        "%(levelname)s | "
        "%(name)s | "
        "%(message)s"
    )
)

logger = logging.getLogger(
    __name__
)


def process_order(order_number):
    logger.info(
        "Processing order %s",
        order_number
    )

    logger.info(
        "Order %s processed successfully",
        order_number
    )


process_order(
    "ORD-101"
)

Record Exception Information

Use logger.exception() inside an exception handler when traceback information should be included.

import logging


logging.basicConfig(
    level=logging.ERROR
)

logger = logging.getLogger(
    __name__
)

try:
    result = 100 / 0

except ZeroDivisionError:
    logger.exception(
        "The calculation failed."
    )

The generated record includes the message and exception traceback.

Create a Console Handler

A handler determines where matching log records are sent.

import logging


logger = logging.getLogger(
    "application"
)

logger.setLevel(
    logging.DEBUG
)

console_handler = logging.StreamHandler()

console_handler.setLevel(
    logging.INFO
)

formatter = logging.Formatter(
    "%(levelname)s | %(name)s | %(message)s"
)

console_handler.setFormatter(
    formatter
)

logger.addHandler(
    console_handler
)

logger.debug(
    "Diagnostic message"
)

logger.info(
    "Application is ready"
)

Possible output:

INFO | application | Application is ready

Core Logging Components

print() vs Logging

Practical Example: Order Processing

import logging


logging.basicConfig(
    level=logging.INFO,
    format=(
        "%(asctime)s | "
        "%(levelname)s | "
        "%(message)s"
    )
)

logger = logging.getLogger(
    __name__
)


def process_order(order):
    order_number = order.get(
        "order_number"
    )

    amount = order.get(
        "amount",
        0
    )

    logger.info(
        "Processing order %s",
        order_number
    )

    if amount <= 0:
        logger.error(
            "Order %s has an invalid amount",
            order_number
        )

        return False

    logger.info(
        "Order %s processed successfully",
        order_number
    )

    return True


order = {
    "order_number": "ORD-101",
    "amount": 2500
}

process_order(order)

Common Mistakes

Logging Best Practices

Knowledge Check

logger = logging.getLogger(
    __name__
)

try:
    perform_operation()

except Exception:
    logger.exception(
        "The operation failed."
    )

Logging Quick Reference

import logging


# Configure basic logging
logging.basicConfig(
    level=logging.INFO,
    format=(
        "%(asctime)s | "
        "%(levelname)s | "
        "%(name)s | "
        "%(message)s"
    )
)

# Create a module logger
logger = logging.getLogger(
    __name__
)

# Record messages
logger.debug(
    "Diagnostic details"
)

logger.info(
    "Operation completed"
)

logger.warning(
    "Unexpected condition"
)

logger.error(
    "Operation failed"
)

logger.critical(
    "Application cannot continue"
)

Summary