log2fast-fastapi 0.1.0__py3-none-any.whl

log2fast_fastapi/__init__.py

@@ -0,0 +1,27 @@
+from .__version__ import __version__
+from .base import FastLogger, get_logger
+from .middleware import RequestLoggingMiddleware, get_request_id
+from .settings import (
+    LogEnvironment,
+    LogFileSettings,
+    LogFormat,
+    LogLevel,
+    LogSettings,
+    RotationStrategy,
+    settings,
+)
+
+__all__ = [
+    "__version__",
+    "FastLogger",
+    "get_logger",
+    "LogSettings",
+    "LogLevel",
+    "LogFormat",
+    "LogEnvironment",
+    "LogFileSettings",
+    "RotationStrategy",
+    "settings",
+    "RequestLoggingMiddleware",
+    "get_request_id",
+]

log2fast_fastapi/__version__.py

@@ -0,0 +1,5 @@
+"""Version information for log2fast-fastapi."""
+
+__version__ = "0.1.0"
+__author__ = "Angel Daniel Sanchez Castillo"
+__license__ = "MIT"

log2fast_fastapi/base.py

@@ -0,0 +1,342 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Any
+
+from .formatters import (
+    ColoredFormatter,
+    JSONFormatter,
+    SimpleFormatter,
+    StructuredFormatter,
+)
+from .settings import LogFormat, LogSettings, RotationStrategy, settings
+
+
+class FastLogger:
+    """
+    Professional logger wrapper for FastAPI applications.
+
+    Provides environment-aware logging with support for:
+    - Multiple output formats (JSON, colored, structured, simple)
+    - File rotation
+    - Module-based loggers
+    - Context injection (request_id, user_id, etc.)
+    """
+
+    _instances: dict[str, logging.Logger] = {}
+    _configured: bool = False
+
+    def __init__(
+        self,
+        name: str,
+        config: LogSettings | None = None,
+    ):
+        """
+        Initialize a FastLogger instance.
+
+        Args:
+            name: Logger name (typically module name)
+            config: Optional custom configuration (uses global settings if not provided)
+        """
+        self.name = name
+        self.config = config or settings
+        self.logger = self._get_or_create_logger(name)
+
+    @classmethod
+    def _get_or_create_logger(cls, name: str) -> logging.Logger:
+        """Get or create a logger instance."""
+        if name not in cls._instances:
+            logger = logging.getLogger(name)
+
+            # Configure logger if not already configured
+            if not cls._configured:
+                cls._configure_root_logger()
+
+            cls._instances[name] = logger
+
+        return cls._instances[name]
+
+    @classmethod
+    def _configure_root_logger(cls) -> None:
+        """Configure the root logger with handlers and formatters."""
+        if cls._configured:
+            return
+
+        root_logger = logging.getLogger()
+        root_logger.setLevel(settings.get_effective_level())
+
+        # Remove existing handlers
+        root_logger.handlers.clear()
+
+        # Add console handler if enabled
+        if settings.console_enabled:
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(settings.get_effective_level())
+            console_handler.setFormatter(
+                cls._get_formatter(settings.get_effective_format())
+            )
+            root_logger.addHandler(console_handler)
+
+        # Add file handler if enabled
+        if settings.file_settings.enabled:
+            file_handler = cls._create_file_handler()
+            if file_handler:
+                file_handler.setLevel(settings.get_effective_level())
+                # Always use JSON format for file output in production
+                if settings.get_effective_format() == LogFormat.JSON.value:
+                    file_handler.setFormatter(cls._get_formatter(LogFormat.JSON.value))
+                else:
+                    file_handler.setFormatter(
+                        cls._get_formatter(LogFormat.STRUCTURED.value)
+                    )
+                root_logger.addHandler(file_handler)
+
+        cls._configured = True
+
+    @classmethod
+    def _get_formatter(cls, format_type: str) -> logging.Formatter:
+        """Get the appropriate formatter based on format type."""
+        formatters = {
+            LogFormat.JSON.value: JSONFormatter(),
+            LogFormat.COLORED.value: ColoredFormatter(
+                fmt="[%(asctime)s] %(levelname)s | %(name)s | %(message)s"
+            ),
+            LogFormat.STRUCTURED.value: StructuredFormatter(),
+            LogFormat.SIMPLE.value: SimpleFormatter(),
+        }
+        return formatters.get(format_type, SimpleFormatter())
+
+    @classmethod
+    def _create_file_handler(
+        cls, logger_name: str | None = None
+    ) -> RotatingFileHandler | TimedRotatingFileHandler | None:
+        """
+        Create a rotating file handler (time-based or size-based).
+
+        Args:
+            logger_name: Optional logger name for per-module files
+        """
+        try:
+            # Create logs directory if it doesn't exist
+            log_dir = settings.file_settings.directory
+            if not os.path.isabs(log_dir):
+                # Make it relative to current working directory (where the app runs)
+                log_dir = os.path.join(os.getcwd(), log_dir)
+
+            os.makedirs(log_dir, exist_ok=True)
+
+            # Generate filename
+            filename_vars = {
+                "module": settings.module_name or "app",
+                "environment": settings.log_environment.value,
+                "logger": logger_name or "app",
+            }
+
+            # Use logger name if per_module_files is enabled
+            if settings.file_settings.per_module_files and logger_name:
+                # Sanitize logger name for filename (replace dots with underscores)
+                safe_logger_name = logger_name.replace(".", "_")
+                filename_vars["logger"] = safe_logger_name
+                # Override pattern to include logger name
+                filename = f"{safe_logger_name}_{settings.log_environment.value}.log"
+            else:
+                filename = settings.file_settings.filename_pattern.format(
+                    **filename_vars
+                )
+
+            filepath = os.path.join(log_dir, filename)
+
+            # Create handler based on rotation strategy
+            if settings.file_settings.rotation_strategy == RotationStrategy.TIME:
+                # Time-based rotation (default: daily at midnight, keep 31 days)
+                handler = TimedRotatingFileHandler(
+                    filepath,
+                    when=settings.file_settings.when,
+                    interval=settings.file_settings.interval,
+                    backupCount=settings.file_settings.backup_count,
+                    encoding="utf-8",
+                )
+            else:
+                # Size-based rotation
+                handler = RotatingFileHandler(
+                    filepath,
+                    maxBytes=settings.file_settings.max_bytes,
+                    backupCount=settings.file_settings.backup_count,
+                    encoding="utf-8",
+                )
+
+            return handler
+
+        except Exception as e:
+            print(f"⚠️  Failed to create file handler: {e}")
+            return None
+
+    @classmethod
+    def reconfigure(cls, new_settings: LogSettings) -> None:
+        """
+        Reconfigure all loggers with new settings.
+
+        Args:
+            new_settings: New logging configuration
+        """
+        global settings
+        settings = new_settings
+        cls._configured = False
+        cls._configure_root_logger()
+
+    def _log_with_context(
+        self,
+        level: int,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Internal method to log with context.
+
+        Args:
+            level: Log level
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments where this log should appear (e.g., ['development', 'debug'])
+                     If None, logs in all environments
+            **kwargs: Additional arguments for logger
+        """
+        # Check if we should log in current environment
+        if only_in is not None:
+            current_env = self.config.log_environment.value
+            if current_env not in only_in:
+                # Skip logging in this environment
+                return
+
+        extra = kwargs.get("extra", {})
+
+        if extra_data:
+            extra["extra_data"] = extra_data
+
+        kwargs["extra"] = extra
+        self.logger.log(level, message, **kwargs)
+
+    # Public logging methods
+    def debug(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log a debug message.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in (e.g., ['development', 'debug'])
+        """
+        self._log_with_context(logging.DEBUG, message, extra_data, only_in, **kwargs)
+
+    def info(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log an info message.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in (e.g., ['development', 'production'])
+        """
+        self._log_with_context(logging.INFO, message, extra_data, only_in, **kwargs)
+
+    def warning(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log a warning message.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in
+        """
+        self._log_with_context(logging.WARNING, message, extra_data, only_in, **kwargs)
+
+    def error(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log an error message.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in
+        """
+        self._log_with_context(logging.ERROR, message, extra_data, only_in, **kwargs)
+
+    def critical(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log a critical message.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in
+        """
+        self._log_with_context(logging.CRITICAL, message, extra_data, only_in, **kwargs)
+
+    def exception(
+        self,
+        message: str,
+        extra_data: dict[str, Any] | None = None,
+        only_in: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Log an exception with traceback.
+
+        Args:
+            message: Log message
+            extra_data: Extra context data
+            only_in: List of environments to log in
+        """
+        kwargs["exc_info"] = True
+        self._log_with_context(logging.ERROR, message, extra_data, only_in, **kwargs)
+
+
+def get_logger(name: str, config: LogSettings | None = None) -> FastLogger:
+    """
+    Factory function to get a module-specific logger.
+
+    Args:
+        name: Logger name (typically __name__ of the calling module)
+        config: Optional custom configuration
+
+    Returns:
+        FastLogger instance
+
+    Example:
+        >>> from log2fast_fastapi import get_logger
+        >>> logger = get_logger(__name__)
+        >>> logger.info("Application started")
+    """
+    return FastLogger(name, config)

log2fast_fastapi/formatters.py

@@ -0,0 +1,148 @@
+import json
+import logging
+from datetime import datetime
+from typing import Any
+
+
+class ColoredFormatter(logging.Formatter):
+    """Colored formatter for console output in development."""
+
+    # ANSI color codes
+    COLORS = {
+        "DEBUG": "\033[36m",  # Cyan
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Magenta
+    }
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record with colors.
+
+        IMPORTANT: We create a shallow copy of the record to avoid modifying
+        the original, which would cause color codes to leak into file logs.
+        """
+        # Create a shallow copy to avoid modifying the original record
+        record_copy = logging.makeLogRecord(record.__dict__)
+
+        # Add color to level name
+        levelname = record_copy.levelname
+        if levelname in self.COLORS:
+            record_copy.levelname = (
+                f"{self.COLORS[levelname]}{self.BOLD}{levelname}{self.RESET}"
+            )
+
+        # Add color to module name
+        record_copy.name = f"\033[94m{record_copy.name}{self.RESET}"  # Blue
+
+        # Format timestamp
+        record_copy.asctime = self.formatTime(record_copy, "%Y-%m-%d %H:%M:%S")
+
+        # Format the message using the copy
+        formatted = super().format(record_copy)
+
+        return formatted
+
+
+class JSONFormatter(logging.Formatter):
+    """JSON formatter for structured logging in production."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON."""
+        log_data: dict[str, Any] = {
+            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+        }
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = self.formatException(record.exc_info)
+
+        # Add extra fields from record
+        if hasattr(record, "request_id"):
+            log_data["request_id"] = record.request_id
+
+        if hasattr(record, "user_id"):
+            log_data["user_id"] = record.user_id
+
+        if hasattr(record, "extra_data"):
+            log_data["extra"] = record.extra_data
+
+        # Add any custom attributes
+        for key, value in record.__dict__.items():
+            if key not in [
+                "name",
+                "msg",
+                "args",
+                "created",
+                "filename",
+                "funcName",
+                "levelname",
+                "levelno",
+                "lineno",
+                "module",
+                "msecs",
+                "message",
+                "pathname",
+                "process",
+                "processName",
+                "relativeCreated",
+                "thread",
+                "threadName",
+                "exc_info",
+                "exc_text",
+                "stack_info",
+                "request_id",
+                "user_id",
+                "extra_data",
+            ]:
+                if not key.startswith("_"):
+                    log_data[key] = value
+
+        return json.dumps(log_data, ensure_ascii=False)
+
+
+class StructuredFormatter(logging.Formatter):
+    """Structured formatter for human-readable logs with context."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record with structured information."""
+        # Base format
+        base = f"[{self.formatTime(record, '%Y-%m-%d %H:%M:%S')}] {record.levelname:8s} | {record.name:20s} | {record.getMessage()}"
+
+        # Add context if available
+        context_parts = []
+
+        if hasattr(record, "request_id"):
+            context_parts.append(f"request_id={record.request_id}")
+
+        if hasattr(record, "user_id"):
+            context_parts.append(f"user_id={record.user_id}")
+
+        if hasattr(record, "extra_data") and record.extra_data:
+            for key, value in record.extra_data.items():
+                context_parts.append(f"{key}={value}")
+
+        if context_parts:
+            base += f" [{', '.join(context_parts)}]"
+
+        # Add exception if present
+        if record.exc_info:
+            base += f"\n{self.formatException(record.exc_info)}"
+
+        return base
+
+
+class SimpleFormatter(logging.Formatter):
+    """Simple formatter for testing and minimal output."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record simply."""
+        return f"[{record.levelname}] {record.name}: {record.getMessage()}"

log2fast_fastapi/middleware.py

@@ -0,0 +1,106 @@
+import time
+import uuid
+from collections.abc import Callable
+from contextvars import ContextVar
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from .base import get_logger
+
+# Context variable to store request ID across async calls
+request_id_var: ContextVar[str] = ContextVar("request_id", default="")
+
+logger = get_logger(__name__)
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for logging HTTP requests and responses in FastAPI.
+
+    Features:
+    - Automatic request ID generation
+    - Request/response timing
+    - Configurable body logging
+    - Context injection for request ID
+    """
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[[Request], Response]
+    ) -> Response:
+        """Process the request and log information."""
+        # Generate unique request ID
+        request_id = str(uuid.uuid4())
+        request_id_var.set(request_id)
+
+        # Start timing
+        start_time = time.time()
+
+        # Log request
+        logger.info(
+            f"Request started: {request.method} {request.url.path}",
+            extra_data={
+                "method": request.method,
+                "path": request.url.path,
+                "query_params": str(request.query_params),
+                "client_host": request.client.host if request.client else None,
+            },
+            extra={"request_id": request_id},
+        )
+
+        # Process request
+        try:
+            response = await call_next(request)
+
+            # Calculate duration
+            duration = time.time() - start_time
+
+            # Log response
+            logger.info(
+                f"Request completed: {request.method} {request.url.path} - {response.status_code}",
+                extra_data={
+                    "method": request.method,
+                    "path": request.url.path,
+                    "status_code": response.status_code,
+                    "duration_ms": round(duration * 1000, 2),
+                },
+                extra={"request_id": request_id},
+            )
+
+            # Add request ID to response headers
+            response.headers["X-Request-ID"] = request_id
+
+            return response
+
+        except Exception as e:
+            # Calculate duration
+            duration = time.time() - start_time
+
+            # Log error
+            logger.exception(
+                f"Request failed: {request.method} {request.url.path}",
+                extra_data={
+                    "method": request.method,
+                    "path": request.url.path,
+                    "error": str(e),
+                    "duration_ms": round(duration * 1000, 2),
+                },
+                extra={"request_id": request_id},
+            )
+
+            # Re-raise the exception
+            raise
+
+
+def get_request_id() -> str:
+    """
+    Get the current request ID from context.
+
+    Returns:
+        Current request ID or empty string if not in request context
+
+    Example:
+        >>> from log2fast_fastapi.middleware import get_request_id
+        >>> request_id = get_request_id()
+    """
+    return request_id_var.get()

log2fast_fastapi/settings.py

@@ -0,0 +1,187 @@
+import os
+from enum import Enum
+
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Look for .env in the current working directory (where the app is running)
+# This allows the package to work correctly when installed via pip
+DOTENV_PATH = os.path.join(os.getcwd(), ".env")
+
+
+class LogLevel(str, Enum):
+    """Log levels supported by the logger."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class LogEnvironment(str, Enum):
+    """Supported logging environments."""
+
+    DEVELOPMENT = "development"
+    PRODUCTION = "production"
+    TESTING = "testing"
+    DEBUG = "debug"
+
+
+class LogFormat(str, Enum):
+    """Supported log formats."""
+
+    JSON = "json"
+    COLORED = "colored"
+    STRUCTURED = "structured"
+    SIMPLE = "simple"
+
+
+class RotationStrategy(str, Enum):
+    """Log file rotation strategies."""
+
+    TIME = "time"  # Rotate by time (daily, hourly, etc.)
+    SIZE = "size"  # Rotate by file size
+
+
+class LogFileSettings(BaseModel):
+    """Configuration for file logging."""
+
+    enabled: bool = Field(default=True, description="Enable file logging")
+    directory: str = Field(default="logs", description="Directory for log files")
+
+    # Rotation strategy
+    rotation_strategy: RotationStrategy = Field(
+        default=RotationStrategy.TIME,
+        description="Rotation strategy: 'time' (daily) or 'size' (by file size)",
+    )
+
+    # Time-based rotation settings (when rotation_strategy='time')
+    when: str = Field(
+        default="midnight",
+        description="When to rotate: 'midnight', 'H' (hourly), 'D' (daily), 'W0'-'W6' (weekday)",
+    )
+    interval: int = Field(
+        default=1,
+        description="Interval for rotation (e.g., 1 for daily, 2 for every 2 days)",
+    )
+    backup_count: int = Field(
+        default=31, description="Number of backup files to keep (default 31 days)"
+    )
+
+    # Size-based rotation settings (when rotation_strategy='size')
+    max_bytes: int = Field(
+        default=10 * 1024 * 1024,
+        description="Max size per log file in bytes (10MB default, only for size-based rotation)",
+    )
+
+    # Common settings
+    filename_pattern: str = Field(
+        default="{module}_{environment}.log",
+        description="Pattern for log filenames. Available: {module}, {environment}, {logger}",
+    )
+    per_module_files: bool = Field(
+        default=False,
+        description="Create separate log files per module (uses logger name in filename)",
+    )
+
+
+class LogSettings(BaseSettings):
+    """Main logging configuration."""
+
+    # Environment configuration
+    log_environment: LogEnvironment = Field(
+        default=LogEnvironment.DEVELOPMENT,
+        description="Current logging environment",
+    )
+
+    # Log level configuration (None = auto-configure based on environment)
+    log_level: LogLevel | None = Field(
+        default=None,
+        description="Minimum log level to capture (None = auto from environment)",
+    )
+
+    # Format configuration (None = auto-configure based on environment)
+    log_format: LogFormat | None = Field(
+        default=None, description="Log output format (None = auto from environment)"
+    )
+
+    # Console logging
+    console_enabled: bool = Field(default=True, description="Enable console logging")
+
+    # File logging
+    file_settings: LogFileSettings = Field(
+        default_factory=LogFileSettings, description="File logging configuration"
+    )
+
+    # Request logging (for FastAPI middleware)
+    log_requests: bool = Field(
+        default=True, description="Enable request/response logging"
+    )
+    log_request_body: bool = Field(
+        default=False, description="Include request body in logs (be careful with PII)"
+    )
+    log_response_body: bool = Field(
+        default=False,
+        description="Include response body in logs (be careful with PII)",
+    )
+
+    # Module-specific settings
+    module_name: str | None = Field(
+        default=None, description="Default module name for loggers"
+    )
+
+    model_config = SettingsConfigDict(
+        env_file=DOTENV_PATH,
+        env_file_encoding="utf-8",
+        env_prefix="LOG_",
+        env_nested_delimiter="__",  # Enable reading nested vars like LOG_FILE_SETTINGS__DIRECTORY
+        extra="ignore",
+    )
+
+    def get_effective_level(self) -> str:
+        """Get the effective log level based on environment."""
+        # If explicitly set, use that value
+        if self.log_level is not None:
+            return self.log_level.value
+
+        # Auto-configure based on environment
+        environment_defaults = {
+            LogEnvironment.DEBUG: LogLevel.DEBUG,
+            LogEnvironment.DEVELOPMENT: LogLevel.INFO,
+            LogEnvironment.TESTING: LogLevel.INFO,
+            LogEnvironment.PRODUCTION: LogLevel.WARNING,
+        }
+
+        return environment_defaults.get(self.log_environment, LogLevel.INFO).value
+
+    def get_effective_format(self) -> str:
+        """Get the effective log format based on environment."""
+        # If explicitly set, use that value
+        if self.log_format is not None:
+            return self.log_format.value
+
+        # Auto-configure based on environment
+        environment_defaults = {
+            LogEnvironment.DEBUG: LogFormat.COLORED,
+            LogEnvironment.DEVELOPMENT: LogFormat.COLORED,
+            LogEnvironment.TESTING: LogFormat.SIMPLE,
+            LogEnvironment.PRODUCTION: LogFormat.JSON,
+        }
+
+        return environment_defaults.get(self.log_environment, LogFormat.COLORED).value
+
+
+try:
+    settings = LogSettings()
+except Exception as e:
+    import traceback
+
+    print("🚨 Error loading log configuration:")
+    print(e)
+    traceback.print_exc()
+    # Fallback to defaults (auto-configure based on environment)
+    settings = LogSettings(
+        log_environment=LogEnvironment.DEVELOPMENT,
+    )
+    print("⚠️  Using fallback log configuration (DEVELOPMENT mode)")

log2fast_fastapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.4
+Name: log2fast-fastapi
+Version: 0.1.0
+Summary: Advanced logging module for FastAPI - Designed for Solautyc Team internal use
+Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Angel Daniel Sanchez Castillo
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/AngelDanielSanchezCastillo/log2fast-fastapi
+Project-URL: Documentation, https://github.com/AngelDanielSanchezCastillo/log2fast-fastapi/tree/main/docs
+Project-URL: Repository, https://github.com/AngelDanielSanchezCastillo/log2fast-fastapi
+Project-URL: Issues, https://github.com/AngelDanielSanchezCastillo/log2fast-fastapi/issues
+Keywords: fastapi,logging,rotation,colored-logs,structured-logging,middleware
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# log2fast-fastapi
+
+🚀 Advanced logging module for FastAPI with file rotation, colored output, and environment-based auto-configuration
+
+> [!WARNING]
+> **Internal Use Notice**
+> 
+> This package is designed and maintained by the **Solautyc Team** for internal use. While it is publicly available, it may not work as expected in all environments or use cases outside of our specific infrastructure. We do not provide support or guarantees for external usage, and we are not responsible for any issues that may arise from using this package in other contexts.
+> 
+> Use at your own risk. Contributions and feedback are welcome, but compatibility with external environments is not guaranteed.
+
+## Features
+
+- 🎨 **Multiple Output Formats**: JSON (production), Colored (development), Structured (debugging), Simple (testing)
+- 🌍 **Environment-Based Configuration**: Automatic setup for dev, test, prod, and debug
+- 📦 **Module-Based Loggers**: Each module gets its own logger instance
+- 🔄 **File Rotation**: Automatic log file rotation with configurable size
+- 🔄 **Environment-Specific Logging**: Control which logs appear in which environments (prevent sensitive data leaks)
+- 🚀 **FastAPI Integration**: Middleware for automatic request/response logging with unique request IDs
+- 📊 **Structured Logging**: Add context data to any log message
+- 📊 **Context Injection**: Support for request_id, user_id, and custom context data
+- 🎯 **Zero Configuration**: Works out of the box with sensible defaults
+
+## 📚 Documentation
+
+- **[Usage Guide](docs/usage.md)** - Comprehensive usage guide with examples
+- **[File Management](docs/file_management.md)** - Complete guide on log rotation and storage (English)
+- **[Gestión de Archivos](docs/file_management_es.md)** - Guía completa de rotación y almacenamiento (Español)
+- **[Logger Best Practices](docs/logger_best_practices.md)** - Best practices for creating and naming loggers
+
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install log2fast-fastapi
+```
+
+### From Source
+
+```bash
+# Clone the repository
+git clone https://github.com/AngelDanielSanchezCastillo/log2fast-fastapi.git
+cd log2fast-fastapi
+
+# Install in development mode
+pip install -e .
+
+# Or install with dev dependencies
+pip install -e ".[dev]"
+```
+
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from log2fast_fastapi import get_logger
+
+logger = get_logger(__name__)
+
+logger.info("Application started")
+logger.warning("This is a warning")
+logger.error("An error occurred")
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from log2fast_fastapi import RequestLoggingMiddleware, get_logger
+
+app = FastAPI()
+app.add_middleware(RequestLoggingMiddleware)
+
+logger = get_logger(__name__)
+
+@app.get("/")
+async def root():
+    logger.info("Root endpoint accessed")
+    return {"message": "Hello World"}
+```
+
+### Logging with Context
+
+```python
+from log2fast_fastapi import get_logger
+
+logger = get_logger(__name__)
+
+logger.info(
+    "User logged in",
+    extra_data={
+        "user_id": "12345",
+        "ip_address": "192.168.1.1"
+    }
+)
+```
+
+### Environment-Specific Logging (Prevent Sensitive Data Leaks!)
+
+```python
+# Logs ONLY in development/debug (NOT in production)
+logger.debug(
+    "Sensitive debug info",
+    extra_data={"password_hash": "...", "token": "..."},
+    only_in=["development", "debug"]
+)
+
+# Logs ONLY in production
+logger.info(
+    "Performance metrics",
+    extra_data={"response_time": 120},
+    only_in=["production"]
+)
+```
+
+## Configuration
+
+**Simple: Just set the environment in `.env`**
+
+```bash
+# That's it! Format and level auto-configure
+LOG_ENVIRONMENT=production
+```
+
+Auto-configuration by environment:
+
+| Environment | Auto Level | Auto Format |
+|------------|-----------|-------------|
+| `development` | INFO | colored |
+| `production` | WARNING | json |
+| `testing` | INFO | simple |
+| `debug` | DEBUG | colored |
+
+**Optional: Override defaults**
+
+
+```bash
+# Optional: Override auto-configuration
+LOG_LEVEL=DEBUG
+LOG_FORMAT=json
+LOG_FILE_SETTINGS__ENABLED=true
+```
+
+## Environment Presets
+
+### Development
+- Format: Colored console output
+- Level: INFO
+- Perfect for local development
+
+### Production
+- Format: JSON (structured)
+- Level: WARNING
+- Optimized for log aggregation tools
+
+### Testing
+- Format: Simple
+- Level: INFO
+- Minimal output for tests
+
+### Debug
+- Format: Colored
+- Level: DEBUG
+- Maximum verbosity
+
+## Documentation
+
+See [docs/usage.md](docs/usage.md) for complete documentation including:
+- Advanced configuration
+- Custom formatters
+- Best practices
+- Integration examples
+
+## Example
+
+Run the example application:
+
+```bash
+python log2fast_fastapi/example.py
+```
+
+Then visit:
+- http://localhost:8000/ - Root endpoint
+- http://localhost:8000/users/123 - User endpoint
+- http://localhost:8000/docs - API documentation
+
+## Testing
+
+Run the test suite:
+
+```bash
+python log2fast_fastapi/tests/test_logging.py
+```
+
+## Module Structure
+
+```
+log2fast-fastapi/
+├── pyproject.toml       # Package configuration
+├── MANIFEST.in          # Additional files to include
+├── README.md            # This file
+├── LICENSE              # License file
+├── src/
+│   └── log2fast_fastapi/
+│       ├── __init__.py          # Main exports
+│       ├── __version__.py       # Version information
+│       ├── base.py              # Core FastLogger class
+│       ├── settings.py          # Configuration with Pydantic
+│       ├── formatters.py        # Custom log formatters
+│       └── middleware.py        # FastAPI middleware
+├── docs/
+│   ├── usage.md                 # Complete documentation
+│   ├── file_management.md       # File rotation guide (EN)
+│   ├── file_management_es.md    # File rotation guide (ES)
+│   ├── logger_best_practices.md # Best practices
+│   └── publishing.md            # PyPI publishing guide
+├── examples/
+│   ├── example.py               # Basic example
+│   ├── demo_features.py         # Feature demonstrations
+│   └── demo_rotation.py         # Rotation examples
+└── tests/
+    ├── test_logging.py          # Test suite
+    └── test_new_features.py     # Feature tests
+```
+
+## License
+
+Same as parent project.

log2fast_fastapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+log2fast_fastapi/__init__.py,sha256=MrLI4vM6FL8srk59V17kel__hiTWq-WIJ-MlS26RObM,553
+log2fast_fastapi/__version__.py,sha256=kCz8xqPR71dMahmGZzxB8Rtha610gFPxiN-puxGgNSg,136
+log2fast_fastapi/base.py,sha256=jd0dM3umwY-oGo161p-ianwZlspVBoien19bN8pIPVE,11113
+log2fast_fastapi/formatters.py,sha256=OHjPiZp1aYF21_FK12ffdSkpZYBJVF8qAwybtAIVBcQ,4758
+log2fast_fastapi/middleware.py,sha256=WslD7pQMWvsHYxRI1yLWZD6kffh1bTtmzJ7rZlInFKA,3162
+log2fast_fastapi/settings.py,sha256=tRGoOKigjy1J_kmFjsSiyovjlXe3-ubZL8HUViRNkDs,5962
+log2fast_fastapi-0.1.0.dist-info/licenses/LICENSE,sha256=CkISX1hNEwxxrPTOXet3IYMEH28Bn7SoUyKniRjg68I,1086
+log2fast_fastapi-0.1.0.dist-info/METADATA,sha256=h2RXhjg5kl7C2PRkMeXprVVwJCotkn9QrjV_PguQRkA,9163
+log2fast_fastapi-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+log2fast_fastapi-0.1.0.dist-info/top_level.txt,sha256=f7HIwpDpuUBk-2bhKzlkZ-WWqOS_eR_LO8fZ-XH3mqg,17
+log2fast_fastapi-0.1.0.dist-info/RECORD,,

log2fast_fastapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

log2fast_fastapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Angel Daniel Sanchez Castillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

log2fast_fastapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+log2fast_fastapi