How to Simultaneously Output and Log Messages in Python

What will you learn?

In this comprehensive guide, you will learn how to efficiently display messages on the console and simultaneously log them into a file while coding in Python. This dual approach is ideal for debugging and monitoring application behavior without losing track of real-time operations.

Introduction to Problem and Solution

When developing software, it is common to require both immediate feedback through printed messages on the console and the ability to log these messages for future reference or analysis. Managing these tasks separately can be tedious and ineffective. By utilizing Python’s logging library, we can streamline this process by customizing our logging setup to display messages on the console while also saving them to a log file.

Code Solution

import logging

# Create logger
logger = logging.getLogger('ourLogger')

# Create console handler and set level to debug
ch = logging.StreamHandler()

# Create file handler which logs even debug messages
fh = logging.FileHandler('app.log')

# Create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Add handlers to logger

# Example usage
logger.debug('This message should go both to the console and the log file.')

# Copyright PHD

In-Depth Explanation

The code snippet above showcases how Python’s logging module can be configured for simultaneous outputting-and-logging purposes:

  • Setting up the Logger: Establish a logger object as an entry point for our logging system.

  • Handlers Configuration: Create handlers for printing messages on the console (StreamHandler) and writing them into a file (FileHandler). Both are set with a DEBUG level.

  • Formatting Messages: Instantiate a formatter with a specific format string applied to both handlers for consistent message presentation.

  • Adding Handlers: Include both configured handlers back into our logger object for utilization.

By calling methods like logger.debug(),, etc., messages are processed by both attached handlers�displaying in the terminal/console while being saved in ‘app.log’.

  1. How do I change the log level?

  2. To change the log level globally across all handlers:

  3. logger.setLevel(logging.INFO)
  4. # Copyright PHD
  5. For individual handlers:

  6. ch.setLevel(logging.ERROR)
  7. # Copyright PHD
  8. Can I log only certain types of logs (e.g., errors) into a separate file?

  9. Yes! Set up another FileHandler with its level adjusted accordingly:

  10. error_handler =  FileHandler('error.log')
  11. # Copyright PHD
  12. Is it possible to rotate log files after they reach a certain size?

  13. Certainly! Use RotatingFileHandler from logging.handlers module instead of simple FileHandler:

  14. from logging.handlers import RotatingFileHandler
    rh = RotatingFileHandler('app.log', maxBytes=1e6, backupCount=5)
  15. # Copyright PHD
  16. How can I include line numbers in my logs?

  17. Adjust your formatter string like so:

  18. formatter=logging.Formatter('%(asctime)s - %(filename)s:%(lineno)d - %(levelname)s - %(message)s')
  19. # Copyright PHD
  20. What if I want different formats for console vs. file logs?

  21. Simply create two separate formatters and assign each one individually:

  22. console_formatter = Formatter(...)
    file_formatter = Formatter(...)
  23. # Copyright PHD

By incorporating simultaneous outputting-and-logging functionality in your Python applications using this guide, you ensure robust monitoring during runtime while maintaining persistent records. This approach significantly enhances debugging processes, troubleshooting efficiency, and overall development workflow.

Leave a Comment