structlog-config 0.1.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

structlog_config/__init__.py

@@ -1,9 +1,10 @@
-import logging
-from typing import Protocol
+from contextlib import _GeneratorContextManager
+from typing import Generator, Protocol
 
 import orjson
 import structlog
 import structlog.dev
+from decouple import config
 from structlog.processors import ExceptionRenderer
 from structlog.tracebacks import ExceptionDictTransformer
 from structlog.typing import FilteringBoundLogger
@@ -16,17 +17,19 @@ from structlog_config.formatters import (
     simplify_activemodel_objects,
 )
 
-from . import packages
-from .constants import NO_COLOR, PYTHON_LOG_PATH
+from . import (
+    packages,
+    trace,  # noqa: F401
+)
+from .constants import NO_COLOR, package_logger
 from .environments import is_production, is_pytest, is_staging
+from .levels import get_environment_log_level_as_string
 from .stdlib_logging import (
-    get_environment_log_level_as_string,
     redirect_stdlib_loggers,
 )
+from .trace import setup_trace
 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:
@@ -99,11 +102,19 @@ def _logger_factory(json_logger: bool):
     In production, optimized for speed (https://www.structlog.org/en/stable/performance.html)
     """
 
+    # avoid a constant for this ENV so we can mutate within tests
+    python_log_path = config("PYTHON_LOG_PATH", default=None)
+
     if json_logger:
+        # TODO I guess we could support this, but the assumption is stdout is going to be used in prod environments
+        if python_log_path:
+            package_logger.warning(
+                "PYTHON_LOG_PATH is not supported with a JSON logger, forcing stdout"
+            )
         return structlog.BytesLoggerFactory()
 
-    if PYTHON_LOG_PATH:
-        python_log = open(PYTHON_LOG_PATH, "a", encoding="utf-8")
+    if python_log_path:
+        python_log = open(python_log_path, "a", encoding="utf-8")
         return structlog.PrintLoggerFactory(file=python_log)
 
     # Default case
@@ -118,7 +129,7 @@ class LoggerWithContext(FilteringBoundLogger, Protocol):
     want to replicate.
     """
 
-    def context(self, *args, **kwargs) -> None:
+    def context(self, *args, **kwargs) -> _GeneratorContextManager[None, None, None]:
         "context manager to temporarily set and clear logging context"
         ...
 
@@ -158,6 +169,8 @@ def configure_logger(
         json_logger: Optional flag to use JSON logging. If None, defaults to
             production or staging environment sourced from PYTHON_ENV.
     """
+    setup_trace()
+
     # 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()

structlog_config/constants.py

@@ -1,9 +1,16 @@
+import logging
 import os
 
 from decouple import config
 
-PYTHON_LOG_PATH = config("PYTHON_LOG_PATH", default=None)
 PYTHONASYNCIODEBUG = config("PYTHONASYNCIODEBUG", default=False, cast=bool)
+"this is a builtin env var, we check for it to ensure we don't silence this log level"
 
 NO_COLOR = "NO_COLOR" in os.environ
 "support NO_COLOR standard https://no-color.org"
+
+package_logger = logging.getLogger(__name__)
+"strange name to not be confused with all of the log-related names floating around"
+
+TRACE_LOG_LEVEL = 5
+"Custom log level for trace logging, lower than DEBUG"

structlog_config/env_config.py

@@ -10,7 +10,7 @@ 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]]:
+def get_custom_logger_config() -> dict[str, dict[str, str]]:
     """
     Parse environment variables to extract custom logger configurations.
 

structlog_config/fastapi_access_logger.py

@@ -3,13 +3,16 @@ from urllib.parse import quote
 
 import structlog
 from fastapi import FastAPI
+from python_ipware import IpWare
 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
+from starlette.websockets import WebSocket
 
 log = structlog.get_logger("access_log")
+ipw = IpWare()
 
 
 def get_route_name(app: FastAPI, scope: Scope, prefix: str = "") -> str:
@@ -63,6 +66,42 @@ def get_client_addr(scope: Scope) -> str:
     return f"{ip}:{port}"
 
 
+def client_ip_from_request(request: Request | WebSocket) -> str | None:
+    """
+    Get the client IP address from the request.
+
+    Headers are not case-sensitive.
+
+    Uses ipware library to properly extract client IP from various proxy headers.
+    Fallback to direct client connection if no proxy headers found.
+    """
+    headers = request.headers
+
+    # TODO this seems really inefficient, we should just rewrite the ipware into this repo :/
+    # Convert Starlette headers to format expected by ipware (HTTP_ prefixed)
+    # ipware expects headers in WSGI/Django-style meta format where HTTP headers
+    # are prefixed with "HTTP_" and dashes become underscores.
+    # See: https://github.com/un33k/python-ipware/blob/main/python_ipware/python_ipware.py#L33-L40
+    meta_dict = {}
+    for name, value in headers.items():
+        # Convert header name to HTTP_ prefixed format
+        meta_key = f"HTTP_{name.upper().replace('-', '_')}"
+        meta_dict[meta_key] = value
+
+    # Use ipware to extract IP from headers
+    ip, trusted_route = ipw.get_client_ip(meta=meta_dict)
+    if ip:
+        log.debug(
+            "extracted client IP from headers", ip=ip, trusted_route=trusted_route
+        )
+        return str(ip)
+
+    # Fallback to direct client connection
+    host = request.client.host if request.client else None
+
+    return host
+
+
 # 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.
@@ -73,13 +112,32 @@ def is_static_assets_request(scope: Scope) -> bool:
     Returns:
         bool: True if the request is for static assets, False otherwise.
     """
-    return scope["path"].endswith(".css") or scope["path"].endswith(".js")
+    return (
+        scope["path"].endswith(".css")
+        or scope["path"].endswith(".js")
+        # .map files are attempted when devtools are enabled
+        or scope["path"].endswith(".js.map")
+        or scope["path"].endswith(".ico")
+        or scope["path"].endswith(".png")
+        or scope["path"].endswith(".jpg")
+        or scope["path"].endswith(".jpeg")
+        or scope["path"].endswith(".gif")
+    )
 
 
 def add_middleware(
     app: FastAPI,
 ) -> None:
-    """Use this method to add this middleware to your fastapi application."""
+    """
+    Add better access logging to fastapi:
+
+    >>> from structlog_config import fastapi_access_logger
+    >>> fastapi_access_logger.add_middleware(app)
+
+    You'll also want to disable the default uvicorn logs:
+
+    >>> uvicorn.run(..., log_config=None, access_log=False)
+    """
 
     @app.middleware("http")
     async def access_log_middleware(
@@ -108,7 +166,7 @@ def add_middleware(
             method=scope["method"],
             path=scope["path"],
             query=scope["query_string"].decode(),
-            client_ip=get_client_addr(scope),
+            client_ip=client_ip_from_request(request),
             route=route_name,
         )
 

structlog_config/formatters.py

@@ -77,6 +77,7 @@ def pretty_traceback_exception_formatter(sio: TextIO, exc_info: ExcInfo) -> None
     from pretty_traceback.formatting import exc_to_traceback_str
 
     _, exc_value, traceback = exc_info
+    # TODO support local_stack_only env var support
     formatted_exception = exc_to_traceback_str(exc_value, traceback, color=not NO_COLOR)
     sio.write("\n" + formatted_exception)
 

structlog_config/levels.py

@@ -0,0 +1,35 @@
+import logging
+
+from decouple import config
+
+
+def get_environment_log_level_as_string() -> str:
+    level = config("LOG_LEVEL", default="INFO", cast=str).upper()
+
+    if not level.strip():
+        level = "INFO"
+
+    return level
+
+
+def compare_log_levels(left: str, right: str) -> int:
+    """
+    Compare log levels using logging.getLevelNamesMapping for accurate int values.
+
+    Example:
+    >>> compare_log_levels("DEBUG", "INFO")
+    -1  # DEBUG is less than INFO
+
+    Asks the question "Is INFO higher than DEBUG?"
+    """
+    level_map = logging.getLevelNamesMapping()
+    left_level = level_map.get(left, left)
+    right_level = level_map.get(right, right)
+
+    # TODO should more gracefully fail here, but let's see what happens
+    if not isinstance(left_level, int) or not isinstance(right_level, int):
+        raise ValueError(
+            f"Invalid log level comparison: {left} ({type(left_level)}) vs {right} ({type(right_level)})"
+        )
+
+    return left_level - right_level

structlog_config/stdlib_logging.py

@@ -1,3 +1,7 @@
+"""
+Redirect all stdlib loggers to use the structlog configuration.
+"""
+
 import logging
 import sys
 from pathlib import Path
@@ -5,52 +9,51 @@ 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 .env_config import get_custom_logger_config
 from .environments import is_production, is_staging
-
-
-def get_environment_log_level_as_string() -> str:
-    return config("LOG_LEVEL", default="INFO", cast=str).upper()
+from .levels import (
+    compare_log_levels,
+    get_environment_log_level_as_string,
+)
 
 
 def reset_stdlib_logger(
-    logger_name: str,
-    default_structlog_handler: logging.Handler,
-    level_override: str | None = None,
+    logger_name: str, default_structlog_handler: logging.Handler, level_override: str
 ):
     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)
+    std_logger.setLevel(level_override)
 
 
 def redirect_stdlib_loggers(json_logger: bool):
     """
     Redirect all standard logging module loggers to use the structlog configuration.
 
+    - json_loggers determines if logs are rendered as JSON or not
+    - The stdlib log stream is used to write logs to the output device (normally, stdout)
+
     Inspired by: https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e
     """
     from structlog.stdlib import ProcessorFormatter
 
-    level = get_environment_log_level_as_string()
+    global_log_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.
 
+    # TODO why are we importing this here?
     # Use ProcessorFormatter to format log records using structlog processors
     from .__init__ import get_default_processors
 
-    processors = get_default_processors(json_logger=json_logger)
+    default_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]
+            default_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),
@@ -61,7 +64,7 @@ def redirect_stdlib_loggers(json_logger: bool):
             # https://github.com/hynek/structlog/issues/254
             structlog.stdlib.add_logger_name,
             # omit the renderer so we can implement our own
-            *processors[:-1],
+            *default_processors[:-1],
         ],
     )
 
@@ -73,22 +76,29 @@ def redirect_stdlib_loggers(json_logger: bool):
         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)
+    python_log_path = config("PYTHON_LOG_PATH", default=None)
+
+    # if json_logger and python_log_path:
+
+    default_handler = (
+        logging.FileHandler(python_log_path)
+        if python_log_path
+        else logging.StreamHandler(sys.stdout)
+    )
+    default_handler.setLevel(global_log_level)
+    default_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
+    root_logger.setLevel(global_log_level)
+    root_logger.handlers = [default_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 :/
+    #      we should probably transition to using that format instead of this customized mapping
     std_logging_configuration = {
-        "httpcore": {},
         "httpx": {
             "levels": {
                 "INFO": "WARNING",
@@ -99,12 +109,13 @@ def redirect_stdlib_loggers(json_logger: bool):
                 "INFO": "WARNING",
             }
         },
+        # stripe INFO logs are pretty noisy by default
+        "stripe": {
+            "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:
 
@@ -116,45 +127,65 @@ def redirect_stdlib_loggers(json_logger: bool):
     for a set of standard loggers.
     """
 
-    environment_logger_config = get_custom_logger_configs()
+    # TODO do we need this? could be AI slop
+
+    if not PYTHONASYNCIODEBUG:
+        std_logging_configuration["asyncio"] = {"level": "WARNING"}
+
+    environment_logger_config = get_custom_logger_config()
 
     # 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 we have a level override, use that
         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
+            assert isinstance(level_override, str), (
+                f"Expected level override for {logger_name} to be a string, got {type(level_override)}"
+            )
+        # Check if we have a level mapping for the current log level
+        elif "levels" in logger_config and global_log_level in logger_config["levels"]:
+            level_override = logger_config["levels"][global_log_level]
+
+        # if a static override exists, only use it if it is lower than the global log level
+        if level_override and (
+            compare_log_levels(
+                level_override,
+                global_log_level,
+            )
+            < 0
+        ):
+            level_override = None
+
+        handler_for_logger = default_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
+            # right now this is the only handler override type we support
             if "path" in env_config:
                 handler_for_logger = handler_for_path(env_config["path"])
 
+            # if the level is set via dynamic config, always use that
             if "level" in env_config:
                 level_override = env_config["level"]
 
         reset_stdlib_logger(
             logger_name,
             handler_for_logger,
-            level_override,
+            level_override or global_log_level,
         )
 
     # Handle any additional loggers defined in environment variables
     for logger_name, logger_config in environment_logger_config.items():
-        # skip if already configured!
+        # skip if already configured via the above loop
         if logger_name in std_logging_configuration:
             continue
 
-        handler_for_logger = handler
+        handler_for_logger = default_handler
 
         if "path" in logger_config:
             # if we have a custom path, use that instead
@@ -163,7 +194,7 @@ def redirect_stdlib_loggers(json_logger: bool):
         reset_stdlib_logger(
             logger_name,
             handler_for_logger,
-            logger_config.get("level"),
+            logger_config.get("level", global_log_level),
         )
 
     # TODO do i need to setup exception overrides as well?

structlog_config/trace.py

@@ -0,0 +1,62 @@
+"""
+Adapted from:
+- https://github.com/willmcgugan/httpx/blob/973d1ed4e06577d928061092affe8f94def03331/httpx/_utils.py#L231
+- https://github.com/vladmandic/sdnext/blob/d5d857aa961edbc46c9e77e7698f2e60011e7439/installer.py#L154
+
+TODO this is not fully integrated into the codebase
+"""
+
+import logging
+import typing
+from functools import partial, partialmethod
+
+from structlog._log_levels import NAME_TO_LEVEL
+from structlog._native import LEVEL_TO_FILTERING_LOGGER, _make_filtering_bound_logger
+
+from structlog_config.constants import TRACE_LOG_LEVEL
+
+# Track if setup has already been called
+_setup_called = False
+
+
+# Stub for type checkers.
+class Logger(logging.Logger):
+    def trace(
+        self, message: str, *args: typing.Any, **kwargs: typing.Any
+    ) -> None: ...  # pragma: nocover
+
+
+# def trace(self, message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
+#     if self.isEnabledFor(TRACE_LOG_LEVEL):
+#         self._log(TRACE_LOG_LEVEL, message, args, **kwargs)
+
+
+def setup_trace() -> None:
+    """Setup TRACE logging level. Safe to call multiple times."""
+    global _setup_called
+
+    if _setup_called:
+        return
+
+    # TODO consider adding warning to check the state of the underlying patched code
+    # patch structlog maps to include the additional level
+    NAME_TO_LEVEL["trace"] = TRACE_LOG_LEVEL
+    LEVEL_TO_FILTERING_LOGGER[TRACE_LOG_LEVEL] = _make_filtering_bound_logger(
+        TRACE_LOG_LEVEL
+    )
+
+    logging.TRACE = TRACE_LOG_LEVEL
+    logging.addLevelName(TRACE_LOG_LEVEL, "TRACE")
+
+    if hasattr(logging.Logger, "trace"):
+        logging.warning("Logger.trace method already exists, not overriding it")
+    else:
+        logging.Logger.trace = partialmethod(logging.Logger.log, logging.TRACE)
+
+    # Check if trace function already exists in logging module
+    if hasattr(logging, "trace"):
+        logging.warning("logging.trace function already exists, overriding it")
+    else:
+        logging.trace = partial(logging.log, logging.TRACE)
+
+    _setup_called = True

structlog_config/warnings.py

@@ -9,6 +9,8 @@ import structlog
 
 _original_warnings_showwarning: Any = None
 
+warning_logger = structlog.get_logger(logger_name="py.warnings")
+
 
 def _showwarning(
     message: Warning | str,
@@ -20,23 +22,11 @@ def _showwarning(
 ) -> 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
-        )
+
+    warning_logger.warning(
+        str(message), category=category.__name__, filename=filename, lineno=lineno
+    )
 
 
 def redirect_showwarnings():

structlog_config-0.4.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.3
+Name: structlog-config
+Version: 0.4.0
+Summary: A comprehensive structlog configuration with sensible defaults for development and production environments, featuring context management, exception formatting, and path prettification.
+Keywords: logging,structlog,json-logging,structured-logging
+Author: Michael Bianco
+Author-email: Michael Bianco <mike@mikebian.co>
+Requires-Dist: orjson>=3.10.15
+Requires-Dist: python-decouple-typed>=3.11.0
+Requires-Dist: python-ipware>=3.0.0
+Requires-Dist: structlog>=25.2.0
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/iloveitaly/structlog-config
+Description-Content-Type: text/markdown
+
+# Opinionated Defaults for Structlog
+
+Logging is really important. Getting logging to work well in python feels like black magic: there's a ton of configuration
+across structlog, warnings, std loggers, fastapi + celery context, JSON logging in production, etc that requires lots of
+fiddling and testing to get working. I finally got this working for me in my [project template](https://github.com/iloveitaly/python-starter-template) and extracted this out into a nice package.
+
+Here are the main goals:
+
+* 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
+* Nice log formatters for stack traces, ORM ([ActiveModel/SQLModel](https://github.com/iloveitaly/activemodel)), etc
+* Ability to log level and output (i.e. file path) *by logger* for easy development debugging
+* If you are using fastapi, structured logging for access logs
+
+## Usage
+
+```python
+from structlog_config import configure_logger
+
+log = configure_logger()
+
+log.info("the log", key="value")
+```
+
+## TRACE Logging Level
+
+This package adds support for a custom `TRACE` logging level (level 5) that's even more verbose than `DEBUG`. This is useful for extremely detailed debugging scenarios.
+
+The `TRACE` level is automatically set up when you call `configure_logger()`. You can use it like any other logging level:
+
+```python
+import logging
+from structlog_config import configure_logger
+
+log = configure_logger()
+
+# Using structlog
+log.info("This is info")
+log.debug("This is debug") 
+log.trace("This is trace")  # Most verbose
+
+# Using stdlib logging
+logging.trace("Module-level trace message")
+logger = logging.getLogger(__name__)
+logger.trace("Instance trace message")
+```
+
+Set the log level to TRACE using the environment variable:
+
+```bash
+LOG_LEVEL=TRACE
+```
+
+## Stdlib Log Management
+
+By default, all stdlib loggers are:
+
+1. Given the same global logging level, with some default adjustments for noisy loggers (looking at you, `httpx`)
+2. Use a structlog formatter (you get structured logging, context, etc in any stdlib logger calls)
+3. The root processor is overwritten so any child loggers created after initialization will use the same formatter
+
+You can customize loggers by name (i.e. the name used in `logging.getLogger(__name__)`) using ENV variables.
+
+For example, if you wanted to [mimic `OPENAI_LOG` functionality](https://github.com/openai/openai-python/blob/de7c0e2d9375d042a42e3db6c17e5af9a5701a99/src/openai/_utils/_logs.py#L16):
+
+* `LOG_LEVEL_OPENAI=DEBUG`
+* `LOG_PATH_OPENAI=tmp/openai.log`
+* `LOG_LEVEL_HTTPX=DEBUG`
+* `LOG_PATH_HTTPX=tmp/openai.log`
+
+## 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)
+
+## iPython
+
+Often it's helpful to update logging level within an iPython session. You can do this and make sure all loggers pick up on it.
+
+```
+%env LOG_LEVEL=DEBUG
+from structlog_config import configure_logger
+configure_logger()
+```
+
+## Related Projects
+
+* https://github.com/underyx/structlog-pretty
+* https://pypi.org/project/httpx-structlog/
+
+## References
+
+General logging:
+
+- 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
+- https://stackoverflow.com/questions/76256249/logging-in-the-open-ai-python-library/78214464#78214464
+- https://github.com/openai/openai-python/blob/de7c0e2d9375d042a42e3db6c17e5af9a5701a99/src/openai/_utils/_logs.py#L16
+- https://www.python-httpx.org/logging/
+
+FastAPI access logger:
+
+- 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

structlog_config-0.4.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+structlog_config/__init__.py,sha256=DyY4x3_dY_hPNbS1aM7JRCGadTa1dYDIPzgrHu3AP68,6733
+structlog_config/constants.py,sha256=O1nPnB29yZdqqaI7aeTUrimA3LOtA5WpP6BGPLWJvj8,510
+structlog_config/env_config.py,sha256=_EJO0rgAKndRPSh4wuBaH3bui9F3nIpn8FaEkjAjZso,1737
+structlog_config/environments.py,sha256=JpZYVVDGxEf1EaKdPdn6Jo-4wJK6SqF0ueFl7e2TBvI,612
+structlog_config/fastapi_access_logger.py,sha256=REwchxGb5WHbiQi2zYtBPfkGHk-NvCKM2pVwJlwG5H8,5464
+structlog_config/formatters.py,sha256=ll0Y0QeRs1DMmD-ft1n1zA4Vn2STRSK-mOrczYB2OjE,5898
+structlog_config/levels.py,sha256=z1fTpvCCbAwcFK2k7rHWh_p-FqfFh4yIWCTZ1MNf_4U,993
+structlog_config/packages.py,sha256=asxrzLR-iRYAbkoSYutyTdIRcruTjHgkzfe2pjm2VFM,519
+structlog_config/stdlib_logging.py,sha256=Wnn59oRBIqn708CpR-akqVcG9ccSfCMLh56_7wxZRH0,7350
+structlog_config/trace.py,sha256=dBaSynxmw4Wg79wSHqYEMoByvv--v_oQw61dRdg4xUI,2016
+structlog_config/warnings.py,sha256=gKEcuHWqH0BaKitJtQkv-uJ0Z3uCH5nn6k8qpqjR-RM,998
+structlog_config-0.4.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+structlog_config-0.4.0.dist-info/METADATA,sha256=R2XtpZuBtPdum5qHcmmCoXbSFoQPm0iv4VQcAX0I7zI,5472
+structlog_config-0.4.0.dist-info/RECORD,,

structlog_config-0.4.0.dist-info/WHEEL

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

structlog_config-0.1.0.dist-info/METADATA

@@ -1,62 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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