structlog-config 0.1.0__tar.gz → 0.2.0__tar.gz

{structlog_config-0.1.0 → structlog_config-0.2.0}/.copier-answers.yml

@@ -1,2 +1,2 @@
 # this exact file name is required in this exact location if updates are to work
-{"_commit": "v0.2.1-31-gb45b358", "_src_path": "https://github.com/iloveitaly/python-package-template", "project_name": "structlog_config", "full_name": "Michael Bianco", "email": "mike@mikebian.co", "github_username": "iloveitaly"}
+{"_commit": "v0.2.1-31-gb45b358", "_src_path": "https://github.com/iloveitaly/python-package-template", "project_name": "structlog-config", "full_name": "Michael Bianco", "email": "mike@mikebian.co", "github_username": "iloveitaly"}

{structlog_config-0.1.0 → structlog_config-0.2.0}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.2.0](https://github.com/iloveitaly/structlog-config/compare/v0.1.0...v0.2.0) (2025-08-05)
+
+
+### Features
+
+* add custom TRACE log level and logger extension ([73e0551](https://github.com/iloveitaly/structlog-config/commit/73e05513c24e8ffe986105753a9a8d4ae5f5f496))
+* call setup_trace in configure_logger to enable tracing ([85ee622](https://github.com/iloveitaly/structlog-config/commit/85ee622ad5647c7a97032f79cb12cee9ab6bcac1))
+* global level override always set on std loggers, override static overrides if lower ([a7b66ea](https://github.com/iloveitaly/structlog-config/commit/a7b66ea626829b36a46ad4f73a4f1eb5bd12ca86))
+* patch structlog to support custom trace log level ([35c1dca](https://github.com/iloveitaly/structlog-config/commit/35c1dca852b1d746d3538d5082d7f5a25bedc056))
+
+
+### Bug Fixes
+
+* ensure TRACE log level is properly registered and utilized in logger ([87dc788](https://github.com/iloveitaly/structlog-config/commit/87dc788c661bff5daa7d6ed5416cdc0a98322278))
+* include .js.map in static asset request detection ([ff9bb4a](https://github.com/iloveitaly/structlog-config/commit/ff9bb4a6c9cd8bde1e9989399eeb2b4efc7d334a))
+
+
+### Documentation
+
+* clarify description of PYTHONASYNCIODEBUG constant ([2e2e0e9](https://github.com/iloveitaly/structlog-config/commit/2e2e0e9c07bfe80a0ba3e3d8b7278b76619cefa4))
+* ipython logging adjustment ([1990a7c](https://github.com/iloveitaly/structlog-config/commit/1990a7cc130c4e30256a19caf8079a1697d137b8))
+* update README with detailed logging setup instructions ([746fb8f](https://github.com/iloveitaly/structlog-config/commit/746fb8f64b542c74041141d787b62ff084b10805))
+
 ## 0.1.0 (2025-04-14)
 
 

{structlog_config-0.1.0 → structlog_config-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structlog-config
-Version: 0.1.0
+Version: 0.2.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>
@@ -11,21 +11,46 @@ Requires-Dist: python-decouple-typed>=3.11.0
 Requires-Dist: structlog>=25.2.0
 Description-Content-Type: text/markdown
 
-# Structlog Configuration
+# Opinionated Defaults for Structlog
 
-Logging is really important:
+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_logging
+
+configure_logging()
+```
 
 ## Stdib Log Management
 
-Note that `{LOGGER_NAME}` is the name of the system logger assigned via `logging.getLogger(__name__)`:
+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.
 
-* `OPENAI_LOG_LEVEL`
-* `OPENAI_LOG_PATH`. Ignored in production.
+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
 
@@ -40,14 +65,15 @@ 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:
+## iPython
 
-- 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
+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
 
@@ -56,7 +82,21 @@ Adapted from:
 
 ## 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.2.0/README.md

@@ -0,0 +1,89 @@
+# 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_logging
+
+configure_logging()
+```
+
+## Stdib 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.1.0 → structlog_config-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "structlog-config"
-version = "0.1.0"
+version = "0.2.0"
 description = "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"]
 readme = "README.md"

{structlog_config-0.1.0 → structlog_config-0.2.0}/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-0.2.0/structlog_config/constants.py

@@ -0,0 +1,16 @@
+import logging
+import os
+
+from decouple import config
+
+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-0.1.0 → structlog_config-0.2.0}/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-0.1.0 → structlog_config-0.2.0}/structlog_config/fastapi_access_logger.py

@@ -73,7 +73,12 @@ 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")
+    )
 
 
 def add_middleware(

structlog_config-0.2.0/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-0.1.0 → structlog_config-0.2.0}/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 :/
     std_logging_configuration = {
-        "httpcore": {},
+        # "httpcore": {},
         "httpx": {
             "levels": {
                 "INFO": "WARNING",
@@ -100,11 +110,6 @@ def redirect_stdlib_loggers(json_logger: bool):
             }
         },
     }
-
-    # 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 +121,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 +188,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?