High-Performance Python Logging

# Structured Logging with key-value data
from tamga import Tamga
import time
import uuid

logger = Tamga()

# Log with structured data using any log level
logger.info("User action",
    user_id="usr_123",
    action="login",
    ip_address="192.168.1.1",
    success=True,
    duration_ms=234
)

# Request logging example
def log_request(request, response):
    request_id = str(uuid.uuid4())

    logger.debug("HTTP Request",
        request_id=request_id,
        method=request.method,
        path=request.path,
        status=response.status_code,
        duration_ms=response.elapsed_ms,
        user_agent=request.headers.get('User-Agent'),
        ip=request.remote_addr
    )

# Performance monitoring with different levels
start_time = time.time()
# ... your code ...
duration = time.time() - start_time

logger.success("Operation completed",
    operation="data_processing",
    records_processed=10000,
    duration_seconds=round(duration, 2),
    success_rate=0.997
)

# Error logging with context
logger.error("Database connection failed",
    host="localhost",
    port=5432,
    database="myapp",
    error_code="CONNECTION_TIMEOUT"
)

# Metric logging with key-value pairs
logger.metric("API Response",
    endpoint="/api/users",
    method="GET",
    status_code=200,
    response_time_ms=125,
    cache_hit=True
)

# High-Performance Configuration
from tamga import Tamga

# Optimize for maximum throughput
logger = Tamga(
    file_output=True,
    console_output=False,    # Disable console for much faster performance
    buffer_size=1000,       # Large buffer for batch operations
)

# Process large dataset efficiently
for i, record in enumerate(large_dataset):
    logger.info("Processing record", record_id=record.id, batch=i//1000)

    # Periodic flush to prevent memory buildup
    if i % 10000 == 0:
        logger.flush()
        logger.success("Batch processed", records_count=i, batch_size=10000)

# Thread-safe logging from multiple threads
import threading

def worker(worker_id):
    for i in range(1000):
        logger.debug("Processing item", worker_id=worker_id, item_number=i, thread_safe=True)

# Safe concurrent logging
threads = [
    threading.Thread(target=worker, args=(i,))
    for i in range(10)
]

for t in threads:
    t.start()
for t in threads:
    t.join()

logger.flush()  # Ensure all logs are written

# MongoDB Integration (Async)
from tamga import Tamga
import os

logger = Tamga(
    # MongoDB with async support
    mongo_output=True,
    mongo_uri=os.getenv("MONGO_URI"),
    mongo_database_name="logs_db",
    mongo_collection_name="application_logs",

    # Also log to files
    file_output=True,
    json_output=True,

    # Performance settings
    buffer_size=100,
)

# MongoDB operations are non-blocking with key-value logging
logger.info("User logged in", user_id="usr_123", session_id="sess_abc", ip="192.168.1.1")
logger.error("Payment processing failed", payment_id="pay_456", amount=99.99, error_code="CARD_DECLINED")

# Logs are automatically stored with:
# - level, message, date, time, timezone
# - timestamp (Unix timestamp)
# - Indexed for fast queries

# The MongoDB integration uses motor (async driver)
# Perfect for high-throughput applications

# Multi-Service Notifications via Apprise
from tamga import Tamga
import os

logger = Tamga(
    # Configure notification services (80+ supported)
    notify_services=[
        # Discord
        "discord://webhook_id/webhook_token",

        # Slack
        "slack://tokenA/tokenB/tokenC/#channel",

        # Email via SMTP
        "mailto://user:pass@smtp.gmail.com:587/?to=alerts@company.com",

        # SMS via Twilio
        "twilio://SID:Token@+1234567890/+0987654321",

        # Telegram
        "tgram://bot_token/chat_id",

        # Microsoft Teams, PushOver, Matrix, and many more...
    ],

    # Which log levels trigger notifications
    notify_levels=["CRITICAL", "ERROR", "NOTIFY"],

    # Notification title template
    notify_title="🚨 {appname} Alert: {level}",

    # Format: text, markdown, or html
    notify_format="markdown",
)

# These trigger notifications (async) with key-value data
logger.critical("Database server is down!",
    server="db-prod-01",
    uptime_hours=0,
    error_count=15
)
logger.error("Failed to process payment",
    user_id="user_123",
    amount=99.99,
    payment_method="card",
    error_code="DECLINED"
)
logger.notify("New premium subscription",
    plan="enterprise",
    amount=299,
    currency="USD",
    user_type="new"
)

# Advanced usage with key-value pairs
logger.notify(
    "Large order placed",
    title="💰 Sales Alert",  # Custom title
    order_value=10000,
    customer_tier="premium",
    items_count=25
)

# Send to specific services (overrides defaults)
logger.notify(
    "Urgent: Production server down",
    services=["discord://emergency/webhook", "twilio://..."],
    severity="high",
    affected_users=1250
)

# These DON'T trigger notifications (not in notifyLevels)
logger.warning("Cache miss rate increasing", hit_rate=0.75, threshold=0.85)
logger.info("Regular operation message", requests_processed=1000)

# Production-Ready Configuration
from tamga import Tamga
import os

logger = Tamga(
    # Console only in development
    console_output=os.getenv("ENV") != "production",

    # File outputs with rotation
    file_output=True,
    file_path="logs/app.log",
    max_file_size_mb=50,          # Rotate at 50MB
    enable_backup=True,      # Keep backups

    # JSON for log aggregation
    json_output=True,
    file_path="logs/app.json",
    max_json_size_mb=50,

    # Database logging
    sql_output=True,
    sql_path="logs/app.db",
    max_sql_size_mb=100,         # 100MB for SQL

    # Performance tuning
    buffer_size=200 if os.getenv("ENV") == "production" else 10,

    # Centralized logging
    mongo_output=bool(os.getenv("MONGO_URI")),
    mongo_uri=os.getenv("MONGO_URI"),

    # Multi-service notifications
    notify_services=[
        os.getenv("DISCORD_WEBHOOK"),
        os.getenv("SLACK_WEBHOOK"),
        f"mailto://{os.getenv('SMTP_USER')}:{os.getenv('SMTP_PASS')}@smtp.gmail.com:587/?to=alerts@company.com",
    ] if os.getenv("NOTIFICATIONS_ENABLED") else [],
    notify_levels=["CRITICAL", "NOTIFY"],
    notify_title="{appname} Alert: {level}",
    notify_format="markdown",
)

# Application lifecycle
try:
    logger.info("Application starting")
    logger.info("Environment loaded",
        env=os.getenv("ENV"),
        version=os.getenv("APP_VERSION"),
        workers=os.cpu_count()
    )

    # Your application code
    logger.success("All services initialized")

    # Important business event - sends notification
    logger.notify("Service deployed to production")

except Exception as e:
    logger.critical(f"Fatal startup error: {str(e)}")
    logger.flush()  # Ensure critical error is written
    raise

finally:
    logger.info("Shutting down gracefully")
    logger.flush()  # Final flush before exit