utils/logger.py

"""

Centralized Logging System for Flare Platform

"""
import sys
import logging
import json
import os
import threading
import traceback
from datetime import datetime
from enum import Enum
from typing import Optional, Dict, Any, Union
from pathlib import Path

class LogLevel(Enum):
    DEBUG = "DEBUG"
    INFO = "INFO"
    WARNING = "WARNING"
    ERROR = "ERROR"
    CRITICAL = "CRITICAL"

class FlareLogger:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        if self._initialized:
            return
            
        self._initialized = True
        
        # Log level from environment
        self.log_level = LogLevel[os.getenv('LOG_LEVEL', 'INFO')]
        
        # Configure Python logging
        self.logger = logging.getLogger('flare')
        self.logger.setLevel(self.log_level.value)
        
        # Remove default handlers
        self.logger.handlers = []
        
        # Console handler with custom format
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setFormatter(self._get_formatter())
        self.logger.addHandler(console_handler)
        
        # File handler for production
        if os.getenv('LOG_TO_FILE', 'false').lower() == 'true':
            log_dir = Path('logs')
            log_dir.mkdir(exist_ok=True)
            file_handler = logging.FileHandler(
                log_dir / f"flare_{datetime.now().strftime('%Y%m%d')}.log"
            )
            file_handler.setFormatter(self._get_formatter())
            self.logger.addHandler(file_handler)
        
        # Future: Add ElasticSearch handler here
        # if os.getenv('ELASTICSEARCH_URL'):
        #     from elasticsearch_handler import ElasticsearchHandler
        #     es_handler = ElasticsearchHandler(
        #         hosts=[os.getenv('ELASTICSEARCH_URL')],
        #         index='flare-logs'
        #     )
        #     self.logger.addHandler(es_handler)
    
    def _get_formatter(self):
        return logging.Formatter(
            '[%(asctime)s.%(msecs)03d] [%(levelname)s] [%(name)s] %(message)s',
            datefmt='%H:%M:%S'
        )
    
    def log(self, level: LogLevel, message: str, **kwargs):
        """Central logging method with structured data"""
        # Add context data
        extra_data = {
            'timestamp': datetime.utcnow().isoformat(),
            'service': 'flare',
            'thread_id': threading.get_ident(),
            **kwargs
        }
        
        # Log with structured data
        log_message = message
        if kwargs:
            # Format kwargs for readability
            kwargs_str = json.dumps(kwargs, ensure_ascii=False, default=str)
            log_message = f"{message} | {kwargs_str}"
        
        getattr(self.logger, level.value.lower())(log_message, extra={'data': extra_data})
        
        # Always flush for real-time debugging
        sys.stdout.flush()
    
    def debug(self, message: str, **kwargs):
        """Log debug message"""
        self.log(LogLevel.DEBUG, message, **kwargs)
    
    def info(self, message: str, **kwargs):
        """Log info message"""
        self.log(LogLevel.INFO, message, **kwargs)
    
    def warning(self, message: str, **kwargs):
        """Log warning message"""
        self.log(LogLevel.WARNING, message, **kwargs)
    
    def error(self, message: str, **kwargs):
        """Log error message"""
        self.log(LogLevel.ERROR, message, **kwargs)
    
    def critical(self, message: str, **kwargs):
        """Log critical message"""
        self.log(LogLevel.CRITICAL, message, **kwargs)
    
    def set_level(self, level: str):
        """Dynamically change log level"""
        try:
            self.log_level = LogLevel[level.upper()]
            self.logger.setLevel(self.log_level.value)
            self.info(f"Log level changed to {level}")
        except KeyError:
            self.warning(f"Invalid log level: {level}")

# Global logger instance
logger = FlareLogger()

# Convenience functions
def log_debug(message: str, **kwargs):
    """Log debug message"""
    logger.debug(message, **kwargs)

def log_info(message: str, **kwargs):
    """Log info message"""
    logger.info(message, **kwargs)

def log_warning(message: str, **kwargs):
    """Log warning message"""
    logger.warning(message, **kwargs)

def log_error(message: str, exception: Optional[Exception] = None, **kwargs):
    """

    Log error message with optional exception

    

    Usage:

        log_error("Error occurred")

        log_error("Error occurred", e)  # Otomatik olarak str(e) ve traceback ekler

        log_error("Error occurred", error="custom error")

        log_error("Error occurred", e, extra_field="value")

    """
    import traceback
    
    # Eğer exception parametresi verilmişse, otomatik olarak error ve traceback ekle
    if exception is not None:
        # Eğer kwargs'da error yoksa, exception'dan al
        if 'error' not in kwargs:
            kwargs['error'] = str(exception)
        
        # Exception tipini ekle
        if 'error_type' not in kwargs:
            kwargs['error_type'] = type(exception).__name__
        
        # Eğer kwargs'da traceback yoksa ve bu bir Exception ise, traceback ekle
        if 'traceback' not in kwargs and isinstance(exception, Exception):
            kwargs['traceback'] = traceback.format_exc()
        
        # Özel exception tipleri için ekstra bilgi
        if hasattr(exception, '__dict__'):
            # Custom exception'ların attribute'larını ekle
            for attr, value in exception.__dict__.items():
                if not attr.startswith('_') and attr not in kwargs:
                    kwargs[f'exc_{attr}'] = value
        
        # HTTP status code varsa ekle
        if hasattr(exception, 'status_code') and 'status_code' not in kwargs:
            kwargs['status_code'] = exception.status_code
    
    # Orijinal logger'a gönder
    logger.error(message, **kwargs)

def log_critical(message: str, **kwargs):
    """Log critical message"""
    logger.critical(message, **kwargs)

# Backward compatibility
def log(message: str, level: str = "INFO", **kwargs):
    """Legacy log function for compatibility"""
    getattr(logger, level.lower())(message, **kwargs)

# Performance logging helpers
class LogTimer:
    """Context manager for timing operations"""
    def __init__(self, operation_name: str, **extra_kwargs):
        self.operation_name = operation_name
        self.extra_kwargs = extra_kwargs
        self.start_time = None
    
    def __enter__(self):
        self.start_time = datetime.now()
        log_debug(f"Starting {self.operation_name}", **self.extra_kwargs)
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        duration_ms = (datetime.now() - self.start_time).total_seconds() * 1000
        if exc_type:
            log_error(
                f"{self.operation_name} failed after {duration_ms:.2f}ms",
                error=str(exc_val),
                duration_ms=duration_ms,
                **self.extra_kwargs
            )
        else:
            log_info(
                f"{self.operation_name} completed in {duration_ms:.2f}ms",
                duration_ms=duration_ms,
                **self.extra_kwargs
            )