import asyncio
from pathlib import Path
from ko_log import LoggerFactory, QueueManager
from ko_log.models import (
    LoggingSystemConfig, LoggerConfig, QueueConfig,
    HandlerConfig, HandlerType, RendererConfig, RendererType,
    PlainStreamRendererConfig, AsyncStreamHandlerConfig,
)

async def main():
    # 1. Configure queue manager
    queue_config = QueueConfig(
        max_queue_size=10_000,
        backpressure_policy="block",
        drain_timeout=5.0,
    )
    queue_manager = QueueManager(config=queue_config)
    await queue_manager.start()

    # 2. Configure logging system
    system_config = LoggingSystemConfig(
        loggers=[
            LoggerConfig(
                name="app",
                level="INFO",
                handlers=[
                    HandlerConfig(
                        type=HandlerType.STREAM,
                        renderer=RendererConfig(
                            type=RendererType.STREAM_PLAIN,
                            params=PlainStreamRendererConfig(
                                fmt="[%(asctime)s] [%(level)-8s] [%(name)s]: %(event)s",
                                datefmt="%Y-%m-%d %H:%M:%S",
                            ),
                        ),
                        params=AsyncStreamHandlerConfig(use_stderr=False),
                    ),
                ],
            ),
        ],
    )

    # 3. Create logger factory
    factory = LoggerFactory(
        config=system_config,
        queue_manager=queue_manager,
        log_path=Path("./factory.log"),
    )

    # 4. Get logger and use it
    logger = factory.get_logger("app")
    
    # Synchronous logging
    logger.info("Application started", version="1.0.0")
    
    # Asynchronous logging
    await logger.ainfo("Processing request", user_id=123)
    
    # Context binding
    bound_logger = logger.bind(service="auth", env="prod")
    bound_logger.warning("Rate limit exceeded", ip="192.168.1.1")
    
    # Lifecycle tracking
    async with logger.ainfo_life("Database migration"):
        await asyncio.sleep(0.5)  # Simulated work
    
    # 5. Cleanup
    await queue_manager.shutdown()

if __name__ == "__main__":
    asyncio.run(main())

import json
from ko_log import LoggerFactory, QueueManager

# Read JSON config file
with open("config.json") as f:
    config = json.load(f)

# Setup queueing manager
queue_manager = QueueManager.from_json({"max_queue_size": 10000})
await queue_manager.start()

# Create factory then logger from config
factory = LoggerFactory.from_json(
    config=config,
    queue_manager=queue_manager,
    log_path="./factory.log",
)
logger = factory.get_logger("root")

from ko_log.types import EventDict, Processor

# Configure the processor
def add_request_id(config: CustomConfig) -> Processor:
    request_id = config.params.request_id
    
    # Define the processor
    def processor(event_dict: EventDict) -> EventDict:
        event_dict.setdefault("request_id", request_id)
        return event_dict
    
    return processor

logger = factory.get_logger("app")

# Bind immutable context
api_logger = logger.bind(service="api", version="v1")
api_logger.info("Request received", endpoint="/users")

# Chain bindings
request_logger = api_logger.bind(request_id="abc123")
request_logger.info("Processing", user_id=456)

# Sync
with logger.info_life("Database query", table="users") as log:
    # Logs "Begin: Database query"
    do_work()
    log.info("Did work")
    # Logs "End (0.15): Database query"

# Async
async with logger.ainfo_life("API call", endpoint="/data") as log:
    await fetch_data()
    await log.ainfo("Data fetched")

try:
    risky_operation()
except ValueError:
    logger.error("Operation failed", operation="risky")
    # Automatically captures sys.exc_info() if `dict_tracebacks` processor is enabled

from ko_log.models import LoggerConfig, HandlerConfig
from pydantic import ValidationError

try:
    config = LoggerConfig(
        name="test",
        level="INVALID",  # ❌ Validation error
    )
except ValidationError as e:
    print(e)

try:
    logger = factory.get_logger("non_existent")
except AlConfigurationError as e:
    print(e.msg)  # "Logger `non_existent` not found"
    print(e.code)  # "CONFIGURATION::LoggerFactory::VALIDATION::ERROR"

try:
    handler = AsyncFileHandler(
        renderer=renderer,
        processors=[],
        filename="/read-only/path/app.log",
        mode="wb",
        encoding="utf-8",
        override_existing=True,
    )
    handler._write_sync("Test message")
except AlHandlerError as e:
    print(e.msg)  # "Failed to open the file at path `/temp/read-only.log`"
    print(e.code)  # "HANDLER::AsyncFileHandler::IO::ERROR"
    # Log to fallback handler, send alert, etc.

try:
    factory.get_logger_from_json({
        "name": "app",
        "processors": [{"type": "unknown_processor"}]
    })
except AlLoggerCreationError as e:
    print(e.msg)  # "Failed to create logger `root`"
    print(e.__cause__)  # AlProcessorError: Unknown processor type: unknown_processor

try:
    queue_manager.push_sync(record)
except AlQueueManagerError as e:
    print(e.msg)  # "Failed to synchronously emit log message of logger `root` to handlers `[<$AsyncNullHandler>]`"
    print(e.code)  # "DISPATCH::QueueManager::ROUTING::ERROR"

exception.msg          # Human-readable message
exception.msg_code     # Message + error code
exception.code         # Machine-readable error code
exception.user_msg     # Optional user-facing message
exception.recoverable  # Boolean: can retry?
exception.__cause__    # Underlying exception (if any)

try:
    processor(event_dict)
except AlProcessorError as e:
    print(repr(e))  # Shows JSON context
    # "PROCESSOR::ProcessorName::FORMATTING::ERROR:
    # {
    #   "event_dict": {...},
    #   "processor_type": "filter_by_level",
    #   "timestamp": "2024-01-01T12:00:00Z"
    # }"

import pytest
from collections.abc import Generator
from ko_log import Sink, QueueManager, LoggerFactory

@pytest.fixture
def logger_with_sink(
    queue_manager: QueueManager, factory: LoggerFactory
) -> Generator[tuple[LoggerFactory, Sink], None]:

    # Get a logger and attach the `Sink` into it's handler
    logger = factory.get_logger("test")
    sink = Sink()
    queue_manager.add_sink(logger_name="test", sink=sink)

    yield logger, sink
    
    # Necessary if it is intended to use the handler's I/O
    queue_manager.remove_sink(logger_name="test")

def test_logging(logger_with_sink: tuple[LoggerFactory, Sink]):
    logger, sink = logger_with_sink
    logger.info("Test message")
    
    # `Sink` captures all outputs
    assert len(sink.events) == 1
    assert "Test message" in sink.events[0]