import logging
from smartlogger.core.formatter import ColorFormatter
from smartlogger.core.handler import ColorHandler
# Create a custom logger with SmartLogger
logger = logging.getLogger('my_custom_app')
logger.setLevel(logging.DEBUG)
# Use SmartLogger's handler and formatter
handler = ColorHandler()
formatter = ColorFormatter(
 '%(asctime)s | %(name)s | %(levelname)s | %(message)s'
)
handler.setFormatter(formatter)
logger.addHandler(handler)
# Your beautiful custom logs!
logger.info("🎨 Custom formatting with colors!")

# ⚠️ Remember: Import order is critical!
import logging
import smartlogger.auto # ← Must be imported before any logging configuration!
# Now configure your existing enterprise logging setup
LOGGING_CONFIG = {
 'version': 1,
 'disable_existing_loggers': False,
 'formatters': {
 'standard': {
 'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
 },
 },
 'handlers': {
 'default': {
 'level': 'INFO',
 'formatter': 'standard',
 'class': 'logging.StreamHandler',
 },
 },
 'loggers': {
 '': {
 'handlers': ['default'],
 'level': 'INFO',
 'propagate': False
 }
 }
}
logging.config.dictConfig(LOGGING_CONFIG)
# SmartLogger automatically enhances ALL your existing loggers!
logger = logging.getLogger('enterprise.module')
logger.info("🏢 Enterprise logging is now colorful!")

import logging
import smartlogger.auto # ← Immediately after logging import!
from flask import Flask
app = Flask(__name__)
logger = logging.getLogger('webapp')
@app.route('/users/<user_id>')
def get_user(user_id):
 logger.info(f"🔍 Fetching user data for ID: {user_id}")
 
 try:
 user = database.get_user(user_id)
 logger.info(f"✅ User found: {user.email}")
 return user.to_json()
 except UserNotFound:
 logger.warning(f"⚠️ User {user_id} not found in database")
 return {"error": "User not found"}, 404
 except DatabaseError as e:
 logger.error(f"❌ Database error: {e}")
 return {"error": "Internal server error"}, 500

import logging
import smartlogger.auto # ← Import right after logging!
logger = logging.getLogger('ml_pipeline')
def train_model(dataset_path):
 logger.info(f"🚀 Starting model training with dataset: {dataset_path}")
 
 try:
 data = load_dataset(dataset_path)
 logger.info(f"📊 Dataset loaded: {len(data)} samples")
 
 if len(data) < 1000:
 logger.warning(f"⚠️ Small dataset detected ({len(data)} samples)")
 
 model = train_neural_network(data)
 accuracy = evaluate_model(model)
 
 if accuracy > 0.95:
 logger.info(f"🎯 Excellent model performance: {accuracy:.2%}")
 elif accuracy > 0.80:
 logger.warning(f"📈 Good model performance: {accuracy:.2%}")
 else:
 logger.error(f"📉 Poor model performance: {accuracy:.2%}")
 
 except Exception as e:
 logger.critical(f"🚨 Model training failed: {e}")
 raise

import logging
import smartlogger.auto # ← Critical: Import immediately after logging!
import pandas as pd
logger = logging.getLogger('data_processor')
def process_customer_data(file_path):
 logger.info(f"📁 Processing customer data from: {file_path}")
 
 try:
 df = pd.read_csv(file_path)
 logger.debug(f"🔍 Raw data shape: {df.shape}")
 
 # Data validation
 missing_data = df.isnull().sum().sum()
 if missing_data > 0:
 logger.warning(f"⚠️ Found {missing_data} missing values")
 
 # Process data
 cleaned_df = clean_data(df)
 logger.info(f"✅ Data cleaning completed: {cleaned_df.shape}")
 
 # Save results
 cleaned_df.to_csv('processed_data.csv')
 logger.info("💾 Processed data saved successfully")
 
 except FileNotFoundError:
 logger.error(f"❌ Data file not found: {file_path}")
 except pd.errors.EmptyDataError:
 logger.critical(f"🚨 Data file is empty: {file_path}")

# 1. 🕵️ Environment Detection
def detect_color_support():
 """Detects if the current environment supports ANSI colors"""
 # Checks terminal type, environment variables, IDE support
 return is_terminal_supports_color()
# 2. 🎨 Smart Color Application
def apply_colors(log_record):
 """Applies appropriate colors based on log level"""
 if not supports_colors:
 return original_format(log_record)
 
 color = get_color_for_level(log_record.levelname)
 return f"{color}{log_record.levelname}{RESET}"
# 3. 🔄 Safe Monkey-Patching
def patch_logging():
 """Safely patches logging without breaking existing code"""
 original_formatter = logging.Formatter
 logging.Formatter = EnhancedColorFormatter
 # Maintains 100% backward compatibility!

# Compare installation times:
pip install some-logging-lib # Downloads 20+ dependencies 😴
pip install pysmartlogger # Just SmartLogger! ⚡

Quick Start for Contributors

🎯 Areas We Need Help With

📋 Development Guidelines

# ✅ CORRECT ORDER
import logging
import smartlogger.auto # ← Must be here!
logging.basicConfig() # ← Configuration after SmartLogger
# ❌ WRONG ORDER 
import logging
logging.basicConfig() # ← Configuration before SmartLogger
import smartlogger.auto # ← Too late! Colors won't work

from smartlogger.config.colors import Colors
# Customize colors
Colors.INFO = Colors.CYAN # Make INFO messages cyan
Colors.DEBUG = Colors.MAGENTA # Make DEBUG messages magenta