structlog-config 0.1.0__py3-none-any.whl

structlog_config/__init__.py

@@ -0,0 +1,184 @@
+import logging
+from typing import Protocol
+
+import orjson
+import structlog
+import structlog.dev
+from structlog.processors import ExceptionRenderer
+from structlog.tracebacks import ExceptionDictTransformer
+from structlog.typing import FilteringBoundLogger
+
+from structlog_config.formatters import (
+    PathPrettifier,
+    add_fastapi_context,
+    logger_name,
+    pretty_traceback_exception_formatter,
+    simplify_activemodel_objects,
+)
+
+from . import packages
+from .constants import NO_COLOR, PYTHON_LOG_PATH
+from .environments import is_production, is_pytest, is_staging
+from .stdlib_logging import (
+    get_environment_log_level_as_string,
+    redirect_stdlib_loggers,
+)
+from .warnings import redirect_showwarnings
+
+package_logger = logging.getLogger(__name__)
+
+
+def log_processors_for_mode(json_logger: bool) -> list[structlog.types.Processor]:
+    if json_logger:
+
+        def orjson_dumps_sorted(value, *args, **kwargs):
+            "sort_keys=True is not supported, so we do it manually"
+            # kwargs includes a default fallback json formatter
+            return orjson.dumps(
+                # starlette-context includes non-string keys (enums)
+                value,
+                option=orjson.OPT_SORT_KEYS | orjson.OPT_NON_STR_KEYS,
+                **kwargs,
+            )
+
+        return [
+            # add exc_info=True to a log and get a full stack trace attached to it
+            structlog.processors.format_exc_info,
+            # simple, short exception rendering in prod since sentry is in place
+            # https://www.structlog.org/en/stable/exceptions.html this is a customized version of dict_tracebacks
+            ExceptionRenderer(
+                ExceptionDictTransformer(
+                    show_locals=False,
+                    use_rich=False,
+                    # number of frames is completely arbitrary
+                    max_frames=5,
+                    # TODO `suppress`?
+                )
+            ),
+            # in prod, we want logs to be rendered as JSON payloads
+            structlog.processors.JSONRenderer(serializer=orjson_dumps_sorted),
+        ]
+
+    return [
+        structlog.dev.ConsoleRenderer(
+            colors=not NO_COLOR,
+            exception_formatter=pretty_traceback_exception_formatter
+            if packages.pretty_traceback
+            else structlog.dev.default_exception_formatter,
+        )
+    ]
+
+
+def get_default_processors(json_logger) -> list[structlog.types.Processor]:
+    """
+    Return the default list of processors for structlog configuration.
+    """
+    processors = [
+        # although this is stdlib, it's needed, although I'm not sure entirely why
+        structlog.stdlib.add_log_level,
+        structlog.contextvars.merge_contextvars,
+        logger_name,
+        add_fastapi_context if packages.starlette_context else None,
+        simplify_activemodel_objects
+        if packages.activemodel and packages.typeid
+        else None,
+        PathPrettifier(),
+        structlog.processors.TimeStamper(fmt="iso", utc=True),
+        # add `stack_info=True` to a log and get a `stack` attached to the log
+        structlog.processors.StackInfoRenderer(),
+        *log_processors_for_mode(json_logger),
+    ]
+
+    return [processor for processor in processors if processor is not None]
+
+
+def _logger_factory(json_logger: bool):
+    """
+    Allow dev users to redirect logs to a file using PYTHON_LOG_PATH
+
+    In production, optimized for speed (https://www.structlog.org/en/stable/performance.html)
+    """
+
+    if json_logger:
+        return structlog.BytesLoggerFactory()
+
+    if PYTHON_LOG_PATH:
+        python_log = open(PYTHON_LOG_PATH, "a", encoding="utf-8")
+        return structlog.PrintLoggerFactory(file=python_log)
+
+    # Default case
+    return structlog.PrintLoggerFactory()
+
+
+class LoggerWithContext(FilteringBoundLogger, Protocol):
+    """
+    A customized bound logger class that adds easy-to-remember methods for adding context.
+
+    We don't use a real subclass because `make_filtering_bound_logger` has some logic we don't
+    want to replicate.
+    """
+
+    def context(self, *args, **kwargs) -> None:
+        "context manager to temporarily set and clear logging context"
+        ...
+
+    def local(self, *args, **kwargs) -> None:
+        "set thread-local context"
+        ...
+
+    def clear(self) -> None:
+        "clear thread-local context"
+        ...
+
+
+# TODO this may be a bad idea, but I really don't like how the `bound` stuff looks and how to access it, way too ugly
+def add_simple_context_aliases(log) -> LoggerWithContext:
+    log.context = structlog.contextvars.bound_contextvars
+    log.local = structlog.contextvars.bind_contextvars
+    log.clear = structlog.contextvars.clear_contextvars
+
+    return log
+
+
+def configure_logger(
+    *, logger_factory=None, json_logger: bool | None = None
+) -> LoggerWithContext:
+    """
+    Create a struct logger with some special additions:
+
+    >>> with log.context(key=value):
+    >>>    log.info("some message")
+
+    >>> log.local(key=value)
+    >>> log.info("some message")
+    >>> log.clear()
+
+    Args:
+        logger_factory: Optional logger factory to override the default
+        json_logger: Optional flag to use JSON logging. If None, defaults to
+            production or staging environment sourced from PYTHON_ENV.
+    """
+    # Reset structlog configuration to make sure we're starting fresh
+    # This is important for tests where configure_logger might be called multiple times
+    structlog.reset_defaults()
+
+    if json_logger is None:
+        json_logger = is_production() or is_staging()
+
+    redirect_stdlib_loggers(json_logger)
+    redirect_showwarnings()
+
+    structlog.configure(
+        # Don't cache the loggers during tests, it makes it hard to capture them
+        cache_logger_on_first_use=not is_pytest(),
+        wrapper_class=structlog.make_filtering_bound_logger(
+            get_environment_log_level_as_string()
+        ),
+        logger_factory=logger_factory or _logger_factory(json_logger),
+        processors=get_default_processors(json_logger),
+    )
+
+    log = structlog.get_logger()
+    log = add_simple_context_aliases(log)
+
+    return log

structlog_config/constants.py

@@ -0,0 +1,9 @@
+import os
+
+from decouple import config
+
+PYTHON_LOG_PATH = config("PYTHON_LOG_PATH", default=None)
+PYTHONASYNCIODEBUG = config("PYTHONASYNCIODEBUG", default=False, cast=bool)
+
+NO_COLOR = "NO_COLOR" in os.environ
+"support NO_COLOR standard https://no-color.org"

structlog_config/env_config.py

@@ -0,0 +1,48 @@
+"""
+Configure custom logger behavior based on environment variables.
+"""
+
+import os
+import re
+
+# Regex to match LOG_LEVEL_* and LOG_PATH_* environment variables
+LOG_LEVEL_PATTERN = re.compile(r"^LOG_LEVEL_(.+)$")
+LOG_PATH_PATTERN = re.compile(r"^LOG_PATH_(.+)$")
+
+
+def get_custom_logger_configs() -> dict[str, dict[str, str]]:
+    """
+    Parse environment variables to extract custom logger configurations.
+
+    Examples:
+        LOG_LEVEL_HTTPX=DEBUG
+        LOG_PATH_HTTPX=/var/log/httpx.log
+
+        LOG_LEVEL_MY_CUSTOM_LOGGER=INFO
+        LOG_PATH_MY_CUSTOM_LOGGER=/var/log/custom.log
+
+    Returns:
+        Dictionary mapping logger names to their configuration.
+        Example: {"httpx": {"level": "DEBUG", "path": "/var/log/httpx.log"}}
+    """
+    custom_configs = {}
+
+    # Process environment variables in reverse alphabetical order
+    # This ensures that HTTP_X will be processed after HTTPX if both exist,
+    # making the last one (alphabetically) win
+    for env_var in sorted(os.environ.keys(), reverse=True):
+        # Check for level configuration
+        if level_match := LOG_LEVEL_PATTERN.match(env_var):
+            logger_name = level_match.group(1).lower().replace("_", ".")
+            if logger_name not in custom_configs:
+                custom_configs[logger_name] = {}
+            custom_configs[logger_name]["level"] = os.environ[env_var]
+
+        # Check for path configuration
+        elif path_match := LOG_PATH_PATTERN.match(env_var):
+            logger_name = path_match.group(1).lower().replace("_", ".")
+            if logger_name not in custom_configs:
+                custom_configs[logger_name] = {}
+            custom_configs[logger_name]["path"] = os.environ[env_var]
+
+    return custom_configs

structlog_config/environments.py

@@ -0,0 +1,31 @@
+import os
+import typing as t
+
+from decouple import config
+
+
+def python_environment() -> str:
+    return t.cast(str, config("PYTHON_ENV", default="development", cast=str)).lower()
+
+
+def is_testing():
+    return python_environment() == "test"
+
+
+def is_production():
+    return python_environment() == "production"
+
+
+def is_staging():
+    return python_environment() == "staging"
+
+
+def is_development():
+    return python_environment() == "development"
+
+
+def is_pytest():
+    """
+    PYTEST_CURRENT_TEST is set by pytest to indicate the current test being run
+    """
+    return "PYTEST_CURRENT_TEST" in os.environ

structlog_config/fastapi_access_logger.py

@@ -0,0 +1,115 @@
+from time import perf_counter
+from urllib.parse import quote
+
+import structlog
+from fastapi import FastAPI
+from starlette.middleware.base import RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Match, Mount
+from starlette.types import Scope
+
+log = structlog.get_logger("access_log")
+
+
+def get_route_name(app: FastAPI, scope: Scope, prefix: str = "") -> str:
+    """Generate a descriptive route name for timing metrics"""
+    if prefix:
+        prefix += "."
+
+    route = next(
+        (r for r in app.router.routes if r.matches(scope)[0] == Match.FULL), None
+    )
+
+    if hasattr(route, "endpoint") and hasattr(route, "name"):
+        return f"{prefix}{route.endpoint.__module__}.{route.name}"  # type: ignore
+    elif isinstance(route, Mount):
+        return f"{type(route.app).__name__}<{route.name!r}>"
+    else:
+        return scope["path"]
+
+
+def get_path_with_query_string(scope: Scope) -> str:
+    """Get the URL with the substitution of query parameters.
+
+    Args:
+        scope (Scope): Current context.
+
+    Returns:
+        str: URL with query parameters
+    """
+    if "path" not in scope:
+        return "-"
+    path_with_query_string = quote(scope["path"])
+    if raw_query_string := scope["query_string"]:
+        query_string = raw_query_string.decode("ascii")
+        path_with_query_string = f"{path_with_query_string}?{query_string}"
+    return path_with_query_string
+
+
+def get_client_addr(scope: Scope) -> str:
+    """Get the client's address.
+
+    Args:
+        scope (Scope): Current context.
+
+    Returns:
+        str: Client's address in the IP:PORT format.
+    """
+    client = scope.get("client")
+    if not client:
+        return ""
+    ip, port = client
+    return f"{ip}:{port}"
+
+
+# TODO we should look at the static asset logic and pull the prefix path from tha
+def is_static_assets_request(scope: Scope) -> bool:
+    """Check if the request is for static assets. Pretty naive check.
+
+    Args:
+        scope (Scope): Current context.
+
+    Returns:
+        bool: True if the request is for static assets, False otherwise.
+    """
+    return scope["path"].endswith(".css") or scope["path"].endswith(".js")
+
+
+def add_middleware(
+    app: FastAPI,
+) -> None:
+    """Use this method to add this middleware to your fastapi application."""
+
+    @app.middleware("http")
+    async def access_log_middleware(
+        request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        scope = request.scope
+        route_name = get_route_name(app, request.scope)
+
+        # TODO what other request types are there? why do we need this guard?
+        if scope["type"] != "http":
+            return await call_next(request)
+
+        start = perf_counter()
+        response = await call_next(request)
+
+        assert start
+        elapsed = perf_counter() - start
+
+        # debug log all asset requests otherwise the logs because unreadable
+        log_method = log.debug if is_static_assets_request(scope) else log.info
+
+        log_method(
+            f"{response.status_code} {scope['method']} {get_path_with_query_string(scope)}",
+            time=round(elapsed * 1000),
+            status=response.status_code,
+            method=scope["method"],
+            path=scope["path"],
+            query=scope["query_string"].decode(),
+            client_ip=get_client_addr(scope),
+            route=route_name,
+        )
+
+        return response

structlog_config/formatters.py

@@ -0,0 +1,166 @@
+import logging
+from pathlib import Path
+from typing import Any, MutableMapping, TextIO
+
+from structlog.typing import EventDict, ExcInfo
+
+from structlog_config.constants import NO_COLOR
+
+
+def simplify_activemodel_objects(
+    logger: logging.Logger,
+    method_name: str,
+    event_dict: MutableMapping[str, Any],
+) -> MutableMapping[str, Any]:
+    """
+    Make the following transformations to the logs:
+
+    - Convert keys ('object') whose value inherit from activemodel's BaseModel to object_id=str(object.id)
+    - Convert TypeIDs to their string representation object=str(object)
+
+    What's tricky about this method, and other structlog processors, is they are run *after* a response
+    is returned to the user. So, they don't error out in tests and it doesn't impact users. They do show up in Sentry.
+    """
+    from activemodel import BaseModel
+    from sqlalchemy.orm.base import object_state
+    from typeid import TypeID
+
+    for key, value in list(event_dict.items()):
+        if isinstance(value, BaseModel):
+
+            def get_field_no_refresh(instance, field_name):
+                """
+                This was a hard-won little bit of code: in fastapi, this action happens *after* the
+                db session dependency has finished, which means the session is closed.
+
+                If a DB operation within the session causes the model to be marked as stale, then this will trigger
+                a `sqlalchemy.orm.exc.DetachedInstanceError` error. This logic pulls the cached value from the object
+                which is better for performance *and* avoids the error.
+                """
+                return str(object_state(instance).dict.get(field_name))
+
+            # TODO this will break as soon as a model doesn't have `id` as pk
+            event_dict[f"{key}_id"] = get_field_no_refresh(value, "id")
+            del event_dict[key]
+
+        elif isinstance(value, TypeID):
+            event_dict[key] = str(value)
+
+    return event_dict
+
+
+def logger_name(logger: Any, method_name: Any, event_dict: EventDict) -> EventDict:
+    """
+    structlog does not have named loggers, so we roll our own
+
+    >>> structlog.get_logger(logger_name="my_logger_name")
+    """
+
+    if logger_name := event_dict.pop("logger_name", None):
+        # `logger` is a special key that structlog treats as the logger name
+        # look at `structlog.stdlib.add_logger_name` for more information
+        event_dict.setdefault("logger", logger_name)
+
+    return event_dict
+
+
+def pretty_traceback_exception_formatter(sio: TextIO, exc_info: ExcInfo) -> None:
+    """
+    By default, rich and then better-exceptions is used to render exceptions when a ConsoleRenderer is used.
+
+    I prefer pretty-traceback, so I've added a custom processor to use it.
+
+    https://github.com/hynek/structlog/blob/66e22d261bf493ad2084009ec97c51832fdbb0b9/src/structlog/dev.py#L412
+    """
+
+    # only available in dev
+    from pretty_traceback.formatting import exc_to_traceback_str
+
+    _, exc_value, traceback = exc_info
+    formatted_exception = exc_to_traceback_str(exc_value, traceback, color=not NO_COLOR)
+    sio.write("\n" + formatted_exception)
+
+
+# lifted from:
+# https://github.com/underyx/structlog-pretty/blob/a6a4abbb1f6e4a879f9f5a95ba067577cea65a08/structlog_pretty/processors.py#L226C1-L252C26
+class PathPrettifier:
+    """A processor for printing paths.
+
+    Changes all pathlib.Path objects.
+
+    1. Remove PosixPath(...) wrapper by calling str() on the path.
+    2. If path is relative to current working directory,
+       print it relative to working directory.
+
+    Note that working directory is determined when configuring structlog.
+    """
+
+    def __init__(self, base_dir: Path | None = None):
+        self.base_dir = base_dir or Path.cwd()
+
+    def __call__(self, _, __, event_dict):
+        for key, path in event_dict.items():
+            if not isinstance(path, Path):
+                continue
+            path = event_dict[key]
+            try:
+                path = path.relative_to(self.base_dir)
+            except ValueError:
+                pass  # path is not relative to cwd
+            event_dict[key] = str(path)
+
+        return event_dict
+
+
+# https://github.com/amenezes/structlog_ext_utils/blob/9b4fbd301c891dd55faf4ce3b102c08a5a0f970a/structlog_ext_utils/processors.py#L59
+class RenameField:
+    """
+    A structlog processor that renames fields in the event dictionary.
+
+    This processor allows for renaming keys in the event dictionary during log processing.
+
+    Parameters
+    ----------
+    fields : dict
+        A dictionary mapping original field names (keys) to new field names (values).
+        For example, {'old_name': 'new_name'} will rename 'old_name' to 'new_name'.
+
+    Returns
+    -------
+    callable
+        A callable that transforms an event dictionary by renaming specified fields.
+
+    Examples
+    --------
+    >>> from structlog.processors import TimeStamper
+    >>> processors = [
+    ...     RenameField({"timestamp": "new_field"}),
+    ... ]
+    >>> # This will rename "timestamp" field to "New_field" in log events
+    """
+
+    def __init__(self, fields: dict) -> None:
+        self.fields = fields
+
+    def __call__(self, _, __, event_dict):
+        for from_key, to_key in self.fields.items():
+            if event_dict.get(from_key):
+                event_dict[to_key] = event_dict.pop(from_key)
+        return event_dict
+
+
+def add_fastapi_context(
+    logger: logging.Logger,
+    method_name: str,
+    event_dict: MutableMapping[str, Any],
+) -> MutableMapping[str, Any]:
+    """
+    Take all state added to starlette-context and add to the logs
+
+    https://github.com/tomwojcik/starlette-context/blob/master/example/setup_logging.py
+    """
+    from starlette_context import context
+
+    if context.exists():
+        event_dict.update(context.data)
+    return event_dict

structlog_config/packages.py

@@ -0,0 +1,33 @@
+"""
+Determine if certain packages are installed to conditionally enable processors
+"""
+
+try:
+    import orjson
+except ImportError:
+    orjson = None
+
+try:
+    import sqlalchemy
+except ImportError:
+    sqlalchemy = None
+
+try:
+    import activemodel
+except ImportError:
+    activemodel = None
+
+try:
+    import typeid
+except ImportError:
+    typeid = None
+
+try:
+    import pretty_traceback
+except ImportError:
+    pretty_traceback = None
+
+try:
+    import starlette_context
+except ImportError:
+    starlette_context = None

structlog_config/stdlib_logging.py

@@ -0,0 +1,172 @@
+import logging
+import sys
+from pathlib import Path
+
+import structlog
+from decouple import config
+
+from structlog_config.env_config import get_custom_logger_configs
+
+from .constants import PYTHONASYNCIODEBUG
+from .environments import is_production, is_staging
+
+
+def get_environment_log_level_as_string() -> str:
+    return config("LOG_LEVEL", default="INFO", cast=str).upper()
+
+
+def reset_stdlib_logger(
+    logger_name: str,
+    default_structlog_handler: logging.Handler,
+    level_override: str | None = None,
+):
+    std_logger = logging.getLogger(logger_name)
+    std_logger.propagate = False
+    std_logger.handlers = []
+    std_logger.addHandler(default_structlog_handler)
+
+    if level_override:
+        std_logger.setLevel(level_override)
+
+
+def redirect_stdlib_loggers(json_logger: bool):
+    """
+    Redirect all standard logging module loggers to use the structlog configuration.
+
+    Inspired by: https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e
+    """
+    from structlog.stdlib import ProcessorFormatter
+
+    level = get_environment_log_level_as_string()
+
+    # TODO I don't understand why we can't use a processor stack as-is here. Need to investigate further.
+
+    # Use ProcessorFormatter to format log records using structlog processors
+    from .__init__ import get_default_processors
+
+    processors = get_default_processors(json_logger=json_logger)
+
+    formatter = ProcessorFormatter(
+        processors=[
+            # required to strip extra keys that the structlog stdlib bindings add in
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            processors[-1]
+            if not is_production() and not is_staging()
+            # don't use ORJSON here, as the stdlib formatter chain expects a str not a bytes
+            else structlog.processors.JSONRenderer(sort_keys=True),
+        ],
+        # processors unique to stdlib logging
+        foreign_pre_chain=[
+            # logger names are not supported when not using structlog.stdlib.LoggerFactory
+            # https://github.com/hynek/structlog/issues/254
+            structlog.stdlib.add_logger_name,
+            # omit the renderer so we can implement our own
+            *processors[:-1],
+        ],
+    )
+
+    def handler_for_path(path: str) -> logging.FileHandler:
+        path_obj = Path(path)
+        # Create parent directories if they don't exist
+        path_obj.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(path)
+        file_handler.setFormatter(formatter)
+        return file_handler
+
+    # Create a handler for the root logger
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(level)
+    handler.setFormatter(formatter)
+
+    # Configure the root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    root_logger.handlers = [handler]  # Replace existing handlers with our handler
+
+    # Disable propagation to avoid duplicate logs
+    root_logger.propagate = True
+
+    # TODO there is a JSON-like format that can be used to configure loggers instead :/
+    std_logging_configuration = {
+        "httpcore": {},
+        "httpx": {
+            "levels": {
+                "INFO": "WARNING",
+            }
+        },
+        "azure.core.pipeline.policies.http_logging_policy": {
+            "levels": {
+                "INFO": "WARNING",
+            }
+        },
+    }
+
+    # Merged from silence_loud_loggers - only silence asyncio if not explicitly debugging it
+    if not PYTHONASYNCIODEBUG:
+        std_logging_configuration["asyncio"] = {"level": "WARNING"}
+
+    """
+    These loggers either:
+
+    1. Are way too chatty by default
+    2. Setup before our logging is initialized
+
+    This configuration allows us to easily override configuration of various loggers as we add additional complexity
+    to the application. The levels map allows us to define specific level mutations based on the current level configuration
+    for a set of standard loggers.
+    """
+
+    environment_logger_config = get_custom_logger_configs()
+
+    # now, let's handle some loggers that are probably already initialized with a handler
+    for logger_name, logger_config in std_logging_configuration.items():
+        level_override = None
+
+        # Check if we have a direct level setting
+        if "level" in logger_config:
+            level_override = logger_config["level"]
+        # Otherwise, check if we have a level mapping for the current log level
+        elif "levels" in logger_config and level in logger_config["levels"]:
+            level_override = logger_config["levels"][level]
+
+        handler_for_logger = handler
+
+        # Override with environment-specific config if available
+        if logger_name in environment_logger_config:
+            env_config = environment_logger_config[logger_name]
+
+            # if we have a custom path, use that instead
+            if "path" in env_config:
+                handler_for_logger = handler_for_path(env_config["path"])
+
+            if "level" in env_config:
+                level_override = env_config["level"]
+
+        reset_stdlib_logger(
+            logger_name,
+            handler_for_logger,
+            level_override,
+        )
+
+    # Handle any additional loggers defined in environment variables
+    for logger_name, logger_config in environment_logger_config.items():
+        # skip if already configured!
+        if logger_name in std_logging_configuration:
+            continue
+
+        handler_for_logger = handler
+
+        if "path" in logger_config:
+            # if we have a custom path, use that instead
+            handler_for_logger = handler_for_path(logger_config["path"])
+
+        reset_stdlib_logger(
+            logger_name,
+            handler_for_logger,
+            logger_config.get("level"),
+        )
+
+    # TODO do i need to setup exception overrides as well?
+    # https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e#file-custom_logging-py-L114-L128
+    # if sys.excepthook != sys.__excepthook__:
+    #     logging.getLogger(__name__).warning("sys.excepthook has been overridden.")

structlog_config/warnings.py

@@ -0,0 +1,51 @@
+"""
+Warning setup functionality to redirect Python warnings to structlog.
+"""
+
+import warnings
+from typing import Any, TextIO
+
+import structlog
+
+_original_warnings_showwarning: Any = None
+
+
+def _showwarning(
+    message: Warning | str,
+    category: type[Warning],
+    filename: str,
+    lineno: int,
+    file: TextIO | None = None,
+    line: str | None = None,
+) -> Any:
+    """
+    Redirects warnings to structlog so they appear in task logs etc.
+
+    Implementation of showwarnings which redirects to logging, which will first
+    check to see if the file parameter is None. If a file is specified, it will
+    delegate to the original warnings implementation of showwarning. Otherwise,
+    it will call warnings.formatwarning and will log the resulting string to a
+    warnings logger named "py.warnings" with level logging.WARNING.
+    """
+    if file is not None:
+        if _original_warnings_showwarning is not None:
+            _original_warnings_showwarning(
+                message, category, filename, lineno, file, line
+            )
+    else:
+        log = structlog.get_logger(logger_name="py.warnings")
+        log.warning(
+            str(message), category=category.__name__, filename=filename, lineno=lineno
+        )
+
+
+def redirect_showwarnings():
+    """
+    Redirect Python warnings to use structlog for logging.
+    """
+    global _original_warnings_showwarning
+
+    if _original_warnings_showwarning is None:
+        _original_warnings_showwarning = warnings.showwarning
+        # Capture warnings and show them via structlog
+        warnings.showwarning = _showwarning

structlog_config-0.1.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: structlog-config
+Version: 0.1.0
+Summary: A comprehensive structlog configuration with sensible defaults for development and production environments, featuring context management, exception formatting, and path prettification.
+Project-URL: Repository, https://github.com/iloveitaly/structlog-config
+Author-email: Michael Bianco <mike@mikebian.co>
+Keywords: json-logging,logging,structlog,structured-logging
+Requires-Python: >=3.10
+Requires-Dist: orjson>=3.10.15
+Requires-Dist: python-decouple-typed>=3.11.0
+Requires-Dist: structlog>=25.2.0
+Description-Content-Type: text/markdown
+
+# Structlog Configuration
+
+Logging is really important:
+
+* High performance JSON logging in production
+* All loggers, even plugin or system loggers, should route through the same formatter
+* Structured logging everywhere
+* Ability to easily set thread-local log context
+
+## Stdib Log Management
+
+Note that `{LOGGER_NAME}` is the name of the system logger assigned via `logging.getLogger(__name__)`:
+
+* `OPENAI_LOG_LEVEL`
+* `OPENAI_LOG_PATH`. Ignored in production.
+
+## FastAPI Access Logger
+
+Structured, simple access log with request timing to replace the default fastapi access log. Why?
+
+1. It's less verbose
+2. Uses structured logging params instead of string interpolation
+3. debug level logs any static assets
+
+Here's how to use it:
+
+1. [Disable fastapi's default logging.](https://github.com/iloveitaly/python-starter-template/blob/f54cb47d8d104987f2e4a668f9045a62e0d6818a/main.py#L55-L56)
+2. [Add the middleware to your FastAPI app.](https://github.com/iloveitaly/python-starter-template/blob/f54cb47d8d104987f2e4a668f9045a62e0d6818a/app/routes/middleware/__init__.py#L63-L65)
+
+Adapted from:
+
+- https://github.com/iloveitaly/fastapi-logger/blob/main/fastapi_structlog/middleware/access_log.py#L70
+- https://github.com/fastapiutils/fastapi-utils/blob/master/fastapi_utils/timing.py
+- https://pypi.org/project/fastapi-structlog/
+- https://pypi.org/project/asgi-correlation-id/
+- https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e
+- https://github.com/sharu1204/fastapi-structlog/blob/master/app/main.py
+
+## Related Projects
+
+* https://github.com/underyx/structlog-pretty
+* https://pypi.org/project/httpx-structlog/
+
+## References
+
+- https://github.com/replicate/cog/blob/2e57549e18e044982bd100e286a1929f50880383/python/cog/logging.py#L20
+- https://github.com/apache/airflow/blob/4280b83977cd5a53c2b24143f3c9a6a63e298acc/task_sdk/src/airflow/sdk/log.py#L187
+- https://github.com/kiwicom/structlog-sentry
+- https://github.com/jeremyh/datacube-explorer/blob/b289b0cde0973a38a9d50233fe0fff00e8eb2c8e/cubedash/logs.py#L40C21-L40C42

structlog_config-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+structlog_config/__init__.py,sha256=OA1J4X3oWWPyqu1vojagsCrHmWDahqyFP_tAJJMYpTk,6162
+structlog_config/constants.py,sha256=uwfeIMlu6yzl67dOS_JP427CO-9nyHX1kRyjp-Obb1M,260
+structlog_config/env_config.py,sha256=CEjovBIJWxHtbzeqU2VAZ0SwYl8VKL_ECSgIfBU2Pbs,1738
+structlog_config/environments.py,sha256=JpZYVVDGxEf1EaKdPdn6Jo-4wJK6SqF0ueFl7e2TBvI,612
+structlog_config/fastapi_access_logger.py,sha256=DjO0Gn4zRNxXNBeOiibgwlovyg2dHbUFB2UMUzAE4Iw,3462
+structlog_config/formatters.py,sha256=cprGEjvRFphJixbb0nVCpPn9sfw_Wv4d2vPtKDpM05A,5846
+structlog_config/packages.py,sha256=asxrzLR-iRYAbkoSYutyTdIRcruTjHgkzfe2pjm2VFM,519
+structlog_config/stdlib_logging.py,sha256=hQfX-NpEezqbPyvfw-F95i5-i3-zoaAvaWzSLEjsggM,6097
+structlog_config/warnings.py,sha256=c74VRLxhx7jW96vkYfYwrKkGOaqQLLIfKQuaeB7i4n0,1594
+structlog_config-0.1.0.dist-info/METADATA,sha256=uvFkIiX-qnlT0it-Zp1rJ0vb_VAMUsEP_HXIdwlMruM,2654
+structlog_config-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+structlog_config-0.1.0.dist-info/RECORD,,

structlog_config-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any