Quick Start Guide

This guide will get you up and running with LogEverything in 5 minutes.

🏃‍♂️ Zero Configuration Start

LogEverything works immediately with zero configuration:

from logeverything import Logger

# Create a logger - auto-detects your environment
log = Logger("my_app")

# Start logging immediately
log.info("Application started")
log.warning("This is a warning")
log.error("Something went wrong")
log.debug("Debug information")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | my_app     | Application started
2026-05-01 05:38:53 | [⚠️ WARNING ] | my_app     | This is a warning
2026-05-01 05:38:53 | [ ❌ ERROR  ] | my_app     | Something went wrong
2026-05-01 05:38:53 | [ 🔍 DEBUG  ] | my_app     | Debug information
What happened?

  • LogEverything auto-detected your environment (script/web/notebook)

  • Applied optimal defaults for your context

  • Provided beautiful, readable output

⚡ Smart Decorators

Add automatic function logging with a single decorator:

from logeverything.decorators import log

@log
def calculate_total(items, tax_rate=0.1):
    """Calculate total with tax."""
    subtotal = sum(items)
    tax = subtotal * tax_rate
    return subtotal + tax

# Function execution is automatically logged
total = calculate_total([10.99, 5.99, 15.99], tax_rate=0.08)
print(f"Total: ${total:.2f}")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | decorator_temp | 🔵 CALL calculate_total(items=[10.99, 5.99, 15.99], tax_rate=0.08) [tmpeps_fd80.py:56]
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | decorator_temp | ✅ DONE calculate_total (4.19ms) ➜ 35.6076
Total: $35.61
What the decorator does:

  • Logs function entry with arguments

  • Logs execution time

  • Logs return value

  • Handles exceptions automatically

  • Automatically finds the best available logger

🎯 Targeted Logging with Specific Loggers

Use the using parameter to target specific loggers:

from logeverything import Logger
from logeverything.decorators import log

# Create specialized loggers
api_logger = Logger("API", level="INFO")
db_logger = Logger("Database", level="DEBUG")

@log(using="API")  # Use the API logger
def fetch_user_data(user_id):
    """Fetch user data from API."""
    return {"id": user_id, "name": f"User {user_id}"}

@log(using="Database")  # Use the Database logger
def save_user_data(user_data):
    """Save user data to database."""
    return f"Saved user {user_data['id']}"

# Each function uses its specified logger
user = fetch_user_data(123)
result = save_user_data(user)
print(f"Operation completed: {result}")

Output:

Operation completed: Saved user 123
Benefits of explicit logger selection:

  • Route different operations to appropriate loggers

  • Control log levels per component

  • Better organization and filtering

  • Clear separation of concerns

🚀 Async Applications

For async applications, use AsyncLogger for 6.8x better performance:

import asyncio
from logeverything.asyncio import AsyncLogger

async def fetch_user_data(user_id):
    """Simulate fetching user data."""
    log = AsyncLogger("user_service")

    user_log = log.bind(user_id=user_id)
    user_log.info("Fetching user data")
    await asyncio.sleep(0.1)  # Simulate async operation

    user_data = {"id": user_id, "name": f"User {user_id}"}
    user_log.info("User data retrieved")
    return user_data

# Process multiple users concurrently
users = await asyncio.gather(
    fetch_user_data(1),
    fetch_user_data(2),
    fetch_user_data(3)
)

print(f"Retrieved {len(users)} users")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=1] Fetching user data
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=2] Fetching user data
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=3] Fetching user data
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=1] User data retrieved
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=2] User data retrieved
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | user_service | [user_id=3] User data retrieved
Retrieved 3 users

🧠 Intelligent Type Casting

LogEverything automatically handles sync/async logger and function mismatches:

import asyncio
from logeverything import Logger  # Sync logger
from logeverything.decorators import log

# Create a sync logger
sync_logger = Logger("mixed_app")

@log(using="mixed_app")  # Sync logger with async function - automatically handled!
async def async_process(data):
    """Async function using sync logger - works seamlessly."""
    await asyncio.sleep(0.1)
    return f"processed_{data}"

@log(using="mixed_app")  # Same logger works with sync functions too
def sync_validate(result):
    """Sync function using the same logger."""
    return len(result) > 5

# Both functions work with the same logger regardless of sync/async nature
result = await async_process("data")
is_valid = sync_validate(result)
print(f"Result: {result}, Valid: {is_valid}")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | mixed_app_async_shared | 🔵 CALL async_process(data='data') [base_events.py:1936]
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | mixed_app_async_shared | ✅ DONE async_process (100.62ms) ➜ 'processed_data'
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | mixed_app              | 🔵 CALL _async_main.<locals>.sync_validate(result='processed_data') [base_events.py:1936]
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | mixed_app              | ✅ DONE _async_main.<locals>.sync_validate (4.88ms) ➜ True
Result: processed_data, Valid: True
What happened?

  • LogEverything detected the sync logger with async function mismatch

  • Automatically created an async-compatible logger with same configuration

  • Both sync and async functions work seamlessly with intelligent casting

  • Zero configuration required - works transparently

🎨 Visual Enhancement

Enable beautiful visual formatting:

from logeverything import Logger

# Enable visual mode for beautiful output
log = Logger("visual_demo")
log.configure(
    visual_mode=True,
    use_symbols=True,
    use_colors=True
)

log.info("✨ Visual mode enabled")
log.warning("⚠️  This is a warning")
log.error("❌ Something went wrong")
log.debug("🔍 Debug information")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | visual_demo | ✨ Visual mode enabled
2026-05-01 05:38:53 | [⚠️ WARNING ] | visual_demo | ⚠️  This is a warning
2026-05-01 05:38:53 | [ ❌ ERROR  ] | visual_demo | ❌ Something went wrong
2026-05-01 05:38:53 | [ 🔍 DEBUG  ] | visual_demo | 🔍 Debug information

📊 Context Managers

Use context managers for hierarchical logging:

from logeverything import Logger

log = Logger("data_processor")
log.configure(visual_mode=True, use_symbols=True)

# Context manager for hierarchical logging
with log.context("Data Processing Pipeline"):
    log.info("🚀 Starting pipeline")

    with log.context("Data Loading"):
        log.info("📁 Loading CSV files")
        log.info("✅ Loaded 1,000 records")

    with log.context("Data Validation"):
        log.info("🔍 Validating data integrity")
        log.warning("⚠️  Found 5 invalid records")
        log.info("🧹 Cleaned invalid data")

    with log.context("Data Processing"):
        log.info("⚙️  Applying transformations")
        log.info("📊 Generating statistics")
        log.info("✅ Processing completed")

log.info("🎉 Pipeline finished successfully")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor | ┌─► Data Processing Pipeline
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    🚀 Starting pipeline
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    ┌─► Data Loading
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       📁 Loading CSV files
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       ✅ Loaded 1,000 records
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    └─◄ Data Loading complete
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    ┌─► Data Validation
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       🔍 Validating data integrity
2026-05-01 05:38:53 | [⚠️ WARNING ] | data_processor |       ⚠️  Found 5 invalid records
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       🧹 Cleaned invalid data
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    └─◄ Data Validation complete
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    ┌─► Data Processing
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       ⚙️  Applying transformations
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       📊 Generating statistics
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |       ✅ Processing completed
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor |    └─◄ Data Processing complete
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor | └─◄ Data Processing Pipeline complete
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | data_processor | 🎉 Pipeline finished successfully

🔧 Configuration Profiles

Use pre-configured profiles for different environments:

from logeverything import Logger

# Development profile - detailed logging
dev_log = Logger("dev_app")
dev_log.configure(profile="development")
dev_log.info("Development mode logging")

# Production profile - optimized performance
prod_log = Logger("prod_app")
prod_log.configure(profile="production")
prod_log.info("Production mode logging")

Output:

05:38:53            | [  ℹ️ INFO  ] | dev_app    | Development mode logging

📦 Structured Logging

Add structured data to your logs:

from logeverything import Logger

log = Logger("ecommerce")

# Structured logging with bound context
user_log = log.bind(
    user_id=12345,
    username="john_doe",
    ip_address="192.168.1.100",
    session_id="abc123"
)
user_log.info("User login successful")

# Additional context binding
session_log = log.bind(user_id=12345, session_id="abc123")
product_log = session_log.bind(product_id=789, category="electronics")
product_log.info("Product viewed")

cart_log = session_log.bind(product_id=789, quantity=2)
cart_log.info("Item added to cart")

Output:

2026-05-01 05:38:53 | [  ℹ️ INFO  ] | ecommerce  | [user_id=12345 | username=john_doe | ip_address=192.168.1.100 | session_id=abc123] User login successful
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | ecommerce  | [user_id=12345 | session_id=abc123 | product_id=789 | category=electronics] Product viewed
2026-05-01 05:38:53 | [  ℹ️ INFO  ] | ecommerce  | [user_id=12345 | session_id=abc123 | product_id=789 | quantity=2] Item added to cart

🛡️ Error Handling

Automatic exception logging:

from logeverything import Logger
from logeverything.decorators import log

logger = Logger("error_demo")

@log
def divide_numbers(a, b):
    """Divide two numbers with automatic error logging."""
    return a / b

# This will automatically log the exception
try:
    result = divide_numbers(10, 0)
except ZeroDivisionError:
    logger.info("Exception was automatically logged by decorator")

Output:

2026-05-01 05:38:54 | [  ℹ️ INFO  ] | error_demo | 🔵 CALL divide_numbers(a=10, b=0) [tmptzvji5xl.py:58]
2026-05-01 05:38:54 | [ ❌ ERROR  ] | error_demo | ❌ FAIL divide_numbers (4.24ms): ZeroDivisionError: division by zero
2026-05-01 05:38:54 | [  ℹ️ INFO  ] | error_demo | Exception was automatically logged by decorator

🌐 Web Applications

Perfect for web frameworks:

# FastAPI Example
from fastapi import FastAPI
from logeverything import Logger

app = FastAPI()
log = Logger("api")

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    request_log = log.bind(endpoint="/users", user_id=user_id)
    request_log.info("API request received")

    # Simulate database lookup
    with request_log.context("Database Lookup"):
        request_log.debug("Querying user database")
        # Simulated user data
        user_data = {"user_id": user_id, "name": "John Doe", "email": "john@example.com"}
        request_log.info("User found successfully")

    request_log.bind(user_count=1).info("Returning user data")
    return user_data

# Demonstrate the logging by calling the function
import asyncio
result = asyncio.run(get_user(123))
print(f"API returned: {result}")

Output:

Traceback (most recent call last):
  File "/tmp/tmpx63cpy28.py", line 47, in <module>
    from fastapi import FastAPI
ModuleNotFoundError: No module named 'fastapi'

⚙️ Next Steps

Now that you’ve seen the basics, explore more advanced features:

  1. 📚 User Guide: Dive deeper into logger classes, decorators, and async logging

  2. 🎨 Visual Formatting: Learn about themes, colors, and custom formatting

  3. ⚡ Performance: Optimize for high-throughput applications

  4. 🌐 Web Integration: Integrate with FastAPI, Django, and Flask

  5. 🔧 Configuration: Master profiles, handlers, and custom setups

Common Patterns:

# Simple application logging
from logeverything import Logger
log = Logger("my_app")

# Async application logging
from logeverything.asyncio import AsyncLogger
log = AsyncLogger("my_async_app")

# Function decoration
from logeverything.decorators import log
@log
def my_function(): pass

# Context management
with log.context("Operation"):
    # code here

📖 Learn More