📘 Logging Levels: DEBUG, INFO, WARNING

🎯 Introduction

Welcome to this exciting tutorial on Python logging levels! 🎉 In this guide, we’ll explore how DEBUG, INFO, and WARNING levels can transform your debugging and monitoring experience.

You’ll discover how proper logging can be your secret weapon for understanding what’s happening inside your applications. Whether you’re building web APIs 🌐, automation scripts 🤖, or data pipelines 📊, mastering logging levels is essential for creating maintainable and debuggable code.

By the end of this tutorial, you’ll confidently use logging levels to track your application’s behavior like a pro! Let’s dive in! 🏊‍♂️

📚 Understanding Logging Levels

🤔 What Are Logging Levels?

Logging levels are like different volumes on your stereo 🎚️. Think of them as filters that control how much information your application shares with you - from whispers (DEBUG) to normal conversation (INFO) to loud warnings (WARNING).

In Python terms, logging levels help you categorize messages by importance and control what gets recorded. This means you can:

✨ Debug issues with detailed trace information
🚀 Monitor normal application flow
🛡️ Catch potential problems before they become errors

💡 Why Use Logging Levels?

Here’s why developers love logging levels:

Flexible Debugging 🔍: Turn on DEBUG in development, off in production
Performance Control ⚡: Less logging = faster execution
Organized Output 📊: Filter noise, focus on what matters
Problem Detection 🎯: Spot issues before users do

Real-world example: Imagine running an online store 🛒. With logging levels, you can track detailed payment processing in DEBUG mode during development, monitor successful orders with INFO in production, and get alerts for WARNING when inventory runs low!

🔧 Basic Syntax and Usage

📝 Simple Example

Let’s start with a friendly example:

import logging

# 👋 Hello, logging!
logging.basicConfig(level=logging.DEBUG)

# 🎨 Creating different level messages
logging.debug("🔍 Detailed information for debugging")
logging.info("📊 General information about program flow")
logging.warning("⚠️ Something unexpected but not critical")

# 🎯 Real example with context
user_balance = 50
purchase_amount = 45

logging.info(f"💰 User balance: ${user_balance}")
logging.debug(f"🛒 Attempting purchase of ${purchase_amount}")

if purchase_amount > user_balance * 0.9:
    logging.warning(f"⚠️ User spending {purchase_amount/user_balance*100:.0f}% of balance!")

💡 Explanation: Notice how each level serves a different purpose! DEBUG gives us the nitty-gritty details, INFO tracks normal operations, and WARNING alerts us to potential issues.

🎯 Common Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Setting up a logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

# 🎨 Pattern 2: Conditional logging
def process_order(order_id, amount):
    logger.info(f"📦 Processing order {order_id}")
    logger.debug(f"💳 Payment amount: ${amount}")
    
    if amount > 1000:
        logger.warning(f"💰 Large transaction detected: ${amount}")
    
    return f"Order {order_id} processed! ✅"

# 🔄 Pattern 3: Dynamic level adjustment
def set_log_level(verbose=False):
    level = logging.DEBUG if verbose else logging.INFO
    logging.getLogger().setLevel(level)
    logger.info(f"📊 Log level set to: {logging.getLevelName(level)}")

💡 Practical Examples

🛒 Example 1: E-Commerce Order Processor

Let’s build something real:

import logging
from datetime import datetime

# 🛍️ Set up our logger
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger("OrderProcessor")

class OrderProcessor:
    def __init__(self):
        self.orders = []
        self.inventory = {"🍕 Pizza": 10, "🍔 Burger": 15, "🥤 Soda": 20}
    
    # 📦 Process an order
    def process_order(self, item, quantity, customer):
        logger.info(f"📥 New order from {customer}")
        logger.debug(f"🔍 Order details: {quantity}x {item}")
        
        # Check inventory
        if item not in self.inventory:
            logger.warning(f"⚠️ Unknown item requested: {item}")
            return False
        
        current_stock = self.inventory[item]
        logger.debug(f"📊 Current stock for {item}: {current_stock}")
        
        if current_stock < quantity:
            logger.warning(f"🚨 Low inventory! Only {current_stock} {item} left")
            return False
        
        # Process the order
        self.inventory[item] -= quantity
        order_id = len(self.orders) + 1
        self.orders.append({
            "id": order_id,
            "item": item,
            "quantity": quantity,
            "customer": customer,
            "timestamp": datetime.now()
        })
        
        logger.info(f"✅ Order #{order_id} completed successfully!")
        
        # Check if we need to restock
        if self.inventory[item] < 5:
            logger.warning(f"📦 Low stock alert: {item} down to {self.inventory[item]}")
        
        return True
    
    # 📊 Get daily summary
    def daily_summary(self):
        logger.info("📈 Generating daily summary...")
        logger.debug(f"🔍 Total orders processed: {len(self.orders)}")
        
        for item, stock in self.inventory.items():
            if stock < 5:
                logger.warning(f"⚠️ Restock needed: {item} ({stock} remaining)")
            else:
                logger.debug(f"✅ {item}: {stock} in stock")

# 🎮 Let's use it!
processor = OrderProcessor()

# Simulate some orders
processor.process_order("🍕 Pizza", 3, "Alice")
processor.process_order("🍔 Burger", 20, "Bob")  # This will fail
processor.process_order("🍕 Pizza", 8, "Charlie")  # This will trigger low stock

# Get summary
processor.daily_summary()

🎯 Try it yourself: Add a restock_item method that logs when items are restocked!

🎮 Example 2: Game Server Monitor

Let’s make monitoring fun:

import logging
import random
import time

# 🏆 Game server monitoring system
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    datefmt='%H:%M:%S'
)

class GameServer:
    def __init__(self, name):
        self.name = name
        self.players = []
        self.cpu_usage = 20
        self.memory_usage = 30
        self.logger = logging.getLogger(f"GameServer-{name}")
    
    # 🎮 Player joins
    def player_join(self, player_name):
        self.players.append(player_name)
        self.logger.info(f"🎮 {player_name} joined the server!")
        self.logger.debug(f"👥 Total players: {len(self.players)}")
        
        # Simulate resource usage increase
        self.cpu_usage += random.randint(5, 10)
        self.memory_usage += random.randint(3, 7)
        
        self._check_resources()
    
    # 👋 Player leaves
    def player_leave(self, player_name):
        if player_name in self.players:
            self.players.remove(player_name)
            self.logger.info(f"👋 {player_name} left the server")
            
            # Resources go down
            self.cpu_usage = max(20, self.cpu_usage - random.randint(3, 8))
            self.memory_usage = max(30, self.memory_usage - random.randint(2, 5))
    
    # 🔍 Check server resources
    def _check_resources(self):
        self.logger.debug(f"💻 CPU: {self.cpu_usage}% | RAM: {self.memory_usage}%")
        
        if self.cpu_usage > 80:
            self.logger.warning(f"🔥 High CPU usage: {self.cpu_usage}%!")
        
        if self.memory_usage > 75:
            self.logger.warning(f"💾 High memory usage: {self.memory_usage}%!")
        
        if len(self.players) > 10:
            self.logger.warning(f"👥 Server getting crowded: {len(self.players)} players")
    
    # 📊 Server status
    def status_report(self):
        self.logger.info(f"📊 === {self.name} Status Report ===")
        self.logger.info(f"👥 Players online: {len(self.players)}")
        self.logger.debug(f"👤 Player list: {', '.join(self.players) if self.players else 'None'}")
        self.logger.info(f"💻 CPU: {self.cpu_usage}% | RAM: {self.memory_usage}%")
        
        # Health check
        if self.cpu_usage < 60 and self.memory_usage < 60:
            self.logger.info("✅ Server health: Excellent")
        elif self.cpu_usage < 80 and self.memory_usage < 75:
            self.logger.info("⚡ Server health: Good")
        else:
            self.logger.warning("⚠️ Server health: Needs attention")

# 🎮 Simulate game server activity
server = GameServer("DragonRealm")

# Players joining
players = ["Alice🦄", "Bob🐉", "Charlie⚔️", "Diana🏹", "Eve🧙‍♀️"]
for player in players:
    server.player_join(player)
    time.sleep(0.5)  # Small delay for realistic logs

# Status check
server.status_report()

# Some players leave
server.player_leave("Bob🐉")
server.player_leave("Diana🏹")

# Final status
server.status_report()

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Custom Log Formatting

When you’re ready to level up, try custom formatters:

import logging

# 🎯 Create a custom formatter with emojis
class EmojiFormatter(logging.Formatter):
    emoji_map = {
        logging.DEBUG: "🔍",
        logging.INFO: "📊",
        logging.WARNING: "⚠️",
        logging.ERROR: "❌",
        logging.CRITICAL: "🚨"
    }
    
    def format(self, record):
        emoji = self.emoji_map.get(record.levelno, "📝")
        record.emoji = emoji
        return super().format(record)

# 🪄 Set up the magical formatter
handler = logging.StreamHandler()
formatter = EmojiFormatter('%(emoji)s %(levelname)-8s | %(message)s')
handler.setFormatter(formatter)

logger = logging.getLogger("MagicalLogger")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

# ✨ Test our magical logger
logger.debug("Finding the bug...")
logger.info("Process completed successfully")
logger.warning("Memory usage is getting high")

🏗️ Advanced Topic 2: Log Level Context Manager

For the brave developers:

import logging
from contextlib import contextmanager

# 🚀 Temporary log level changer
@contextmanager
def log_level(logger, level):
    """Temporarily change log level - perfect for debugging! 🎯"""
    old_level = logger.level
    logger.setLevel(level)
    logger.debug(f"🔄 Switching log level to {logging.getLevelName(level)}")
    try:
        yield logger
    finally:
        logger.setLevel(old_level)
        logger.debug(f"🔄 Restored log level to {logging.getLevelName(old_level)}")

# 💡 Usage example
logger = logging.getLogger("SmartLogger")
logger.setLevel(logging.INFO)

logger.info("📊 Normal operation mode")
logger.debug("🔍 This won't show (level is INFO)")

# Temporarily enable DEBUG for troubleshooting
with log_level(logger, logging.DEBUG):
    logger.debug("🔍 Now I can see debug messages!")
    logger.info("📊 Info still works too")

logger.debug("🔍 Back to being invisible")

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Print vs Logging

# ❌ Wrong way - using print for debugging
def calculate_discount(price, percentage):
    print(f"Calculating discount for ${price}")  # 😰 No control!
    discount = price * (percentage / 100)
    print(f"Discount amount: ${discount}")
    return price - discount

# ✅ Correct way - using proper logging
import logging
logger = logging.getLogger(__name__)

def calculate_discount(price, percentage):
    logger.debug(f"🧮 Calculating {percentage}% discount for ${price}")
    discount = price * (percentage / 100)
    logger.info(f"💰 Applied discount: ${discount:.2f}")
    return price - discount

🤯 Pitfall 2: Wrong Level Selection

# ❌ Dangerous - using wrong levels
logger.debug("❌ User password incorrect!")  # Too low level for security!
logger.warning("📊 Processing order #12345")  # Not a warning!
logger.info("🚨 SYSTEM CRASH IMMINENT")  # Should be CRITICAL!

# ✅ Safe - appropriate level usage
logger.warning("⚠️ Failed login attempt for user 'admin'")
logger.info("📦 Processing order #12345")
logger.critical("🚨 Database connection lost!")
logger.debug("🔍 Checking cache for user_id=42")

🛠️ Best Practices

🎯 Choose Wisely: DEBUG for development details, INFO for flow, WARNING for issues
📝 Be Descriptive: Include context in your messages
🛡️ Security First: Never log sensitive data (passwords, tokens)
🎨 Stay Consistent: Use the same format across your app
✨ Performance Aware: DEBUG logging can slow things down

🧪 Hands-On Exercise

🎯 Challenge: Build a Weather Station Monitor

Create a logging system for a weather station:

📋 Requirements:

✅ Log temperature readings (INFO level)
🌡️ Warn when temperature exceeds thresholds
💨 Debug wind speed calculations
🌧️ Track rainfall with appropriate levels
📊 Generate hourly summaries

🚀 Bonus Points:

Add custom formatter for weather emojis
Implement log rotation for daily files
Create alert system for extreme weather

💡 Solution

🔍 Click to see solution

import logging
import random
from datetime import datetime

# 🎯 Our weather station monitoring system!
class WeatherStation:
    def __init__(self, location):
        self.location = location
        self.logger = self._setup_logger()
        self.readings = []
        
    def _setup_logger(self):
        """Set up logger with custom formatting 🎨"""
        logger = logging.getLogger(f"WeatherStation-{self.location}")
        logger.setLevel(logging.DEBUG)
        
        # Console handler with custom format
        handler = logging.StreamHandler()
        formatter = logging.Formatter(
            '%(asctime)s | %(name)s | %(levelname)s | %(message)s',
            datefmt='%H:%M:%S'
        )
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        
        return logger
    
    def read_temperature(self):
        """Read temperature sensor 🌡️"""
        temp = random.uniform(15, 35)
        self.logger.info(f"🌡️ Temperature: {temp:.1f}°C")
        
        # Check thresholds
        if temp > 30:
            self.logger.warning(f"🔥 High temperature alert: {temp:.1f}°C")
        elif temp < 18:
            self.logger.warning(f"❄️ Low temperature alert: {temp:.1f}°C")
        
        return temp
    
    def read_wind_speed(self):
        """Read wind speed sensor 💨"""
        base_speed = random.uniform(5, 25)
        gust_factor = random.uniform(0.8, 1.5)
        
        self.logger.debug(f"🔍 Base wind speed: {base_speed:.1f} km/h")
        self.logger.debug(f"🔍 Gust factor: {gust_factor:.2f}")
        
        actual_speed = base_speed * gust_factor
        self.logger.info(f"💨 Wind speed: {actual_speed:.1f} km/h")
        
        if actual_speed > 30:
            self.logger.warning(f"🌪️ Strong wind warning: {actual_speed:.1f} km/h")
        
        return actual_speed
    
    def read_rainfall(self):
        """Read rainfall sensor 🌧️"""
        rainfall = random.uniform(0, 10)
        self.logger.info(f"🌧️ Rainfall: {rainfall:.1f} mm")
        
        if rainfall > 5:
            self.logger.warning(f"☔ Heavy rain alert: {rainfall:.1f} mm")
        
        return rainfall
    
    def collect_reading(self):
        """Collect all sensor readings 📊"""
        self.logger.debug("📡 Starting sensor collection...")
        
        reading = {
            "timestamp": datetime.now(),
            "temperature": self.read_temperature(),
            "wind_speed": self.read_wind_speed(),
            "rainfall": self.read_rainfall()
        }
        
        self.readings.append(reading)
        self.logger.debug("✅ Sensor collection complete")
        
        return reading
    
    def hourly_summary(self):
        """Generate hourly weather summary 📈"""
        self.logger.info("📊 === Hourly Weather Summary ===")
        
        if not self.readings:
            self.logger.warning("⚠️ No readings available for summary")
            return
        
        # Calculate averages
        avg_temp = sum(r["temperature"] for r in self.readings) / len(self.readings)
        avg_wind = sum(r["wind_speed"] for r in self.readings) / len(self.readings)
        total_rain = sum(r["rainfall"] for r in self.readings)
        
        self.logger.info(f"🌡️ Average temperature: {avg_temp:.1f}°C")
        self.logger.info(f"💨 Average wind speed: {avg_wind:.1f} km/h")
        self.logger.info(f"🌧️ Total rainfall: {total_rain:.1f} mm")
        
        # Weather assessment
        if avg_temp > 28 and total_rain < 1:
            self.logger.warning("☀️ Hot and dry conditions - fire risk!")
        elif avg_wind > 25 and total_rain > 5:
            self.logger.warning("⛈️ Stormy conditions detected!")
        else:
            self.logger.info("✅ Weather conditions: Normal")

# 🎮 Test our weather station!
station = WeatherStation("Tokyo")

# Simulate hourly readings
for i in range(5):
    station.logger.info(f"📡 Reading #{i+1}")
    station.collect_reading()
    
# Generate summary
station.hourly_summary()

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

✅ Use logging levels appropriately (DEBUG, INFO, WARNING) 💪
✅ Replace print statements with proper logging 🛡️
✅ Design logging strategies for real applications 🎯
✅ Debug issues with the right level of detail 🐛
✅ Monitor applications like a pro! 🚀

Remember: Good logging is like having a conversation with your future self - make it clear and helpful! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Python logging levels!

Here’s what to do next:

💻 Practice with the weather station exercise
🏗️ Add logging to your existing projects
📚 Explore ERROR and CRITICAL levels in our next tutorial
🌟 Share your logging best practices with your team!

Remember: Every debugging session becomes easier with good logging. Keep learning, keep logging, and most importantly, have fun! 🚀

Happy coding! 🎉🚀✨

Prerequisites

What you'll learn