django-lambda-tasks 0.2.3__tar.gz → 0.2.5__tar.gz

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/.kiro/steering/product.md

@@ -135,10 +135,10 @@ class SQSLambdaTaskMessage(BaseModel):
 - Returns `{"batchItemFailures": [...]}` for partial-batch failure reporting
 - Only pre-execution failures (malformed message, import error, misconfiguration) are reported as `batchItemFailures` — task logic failures are caught and recorded as `FAILED` TaskRecords without raising
 - Recommended SQS queue settings: `maxReceiveCount=1` with a DLQ configured; automatic retries are not useful since task failures are not re-driven by design
-- Cold-start sequence runs inside the handler on the first invocation (not at module import time) to avoid Lambda init-duration timeouts: `resolve_environment()` → `resolve_secrets_into_env()` → conditional `django.setup()` → `_configure_logging()`
+- Cold-start sequence runs inside the handler on the first invocation (not at module import time) to avoid Lambda init-duration timeouts: a temporary `StreamHandler` is attached to the `lambda_tasks` logger, then `resolve_environment()` → `resolve_secrets_into_env()` (handler removed) → conditional `django.setup()`
 - A module-level `_cold_start_done` sentinel ensures the sequence runs only once; subsequent warm invocations skip it
 - Both loaders run unconditionally (outside the `DJANGO_SETTINGS_MODULE` check) — the environment secret may provide that var, and individual secrets may depend on environment-loaded vars
-- `_configure_logging()` sets the `lambda_tasks` logger hierarchy to `INFO` (or the level specified by `LAMBDA_TASKS_LOG_LEVEL` env var) so that `task_logger` output appears in CloudWatch
+- A temporary `StreamHandler` is attached to the `lambda_tasks` logger for the duration of the loaders so their log output is visible before Django's `LOGGING` dictConfig has run; it is removed immediately after so that Django's configuration is the sole authority on logging from that point on
 
 ## Environment Loader
 

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/.kiro/steering/structure.md

@@ -40,7 +40,7 @@ django-lambda-tasks/
 
 - `decorators.py` — defines `@lambda_task`; enforces kwargs-only at decoration time
 - `models.py` — `TaskRecord` (Django ORM), `SQSLambdaTaskMessage` (Pydantic, SQS schema + execution logic), `SQSLambdaTask` (Pydantic, holds message + routing; `_execute()` publishes to SQS or executes eagerly; `execute_on_commit()` registers `_execute` with `transaction.on_commit`)
-- `handler.py` — Lambda entry point; cold-start init (`resolve_environment()` → `resolve_secrets_into_env()` → conditional `django.setup()`) runs inside the handler on first invocation, guarded by `_cold_start_done` sentinel; processes SQS records independently; returns `batchItemFailures`
+- `handler.py` — Lambda entry point; cold-start init (temporary log handler → `resolve_environment()` → `resolve_secrets_into_env()` → handler removed → conditional `django.setup()`) runs inside the handler on first invocation, guarded by `_cold_start_done` sentinel; processes SQS records independently; returns `batchItemFailures`
 - `environment_loader.py` — loads env vars from a Secrets Manager secret at cold start; validates flat JSON format; idempotent via `_loaded` sentinel
 - `secret_loader.py` — resolves `LAMBDA_TASKS_SECRET_*` env vars from Secrets Manager before Django starts; validates format, detects conflicts, batches API calls; idempotent via `_loaded` sentinel
 - `logging.py` — `task_logger` singleton; `message_id` set/cleared around each task execution

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.2.3
+Version: 0.2.5
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: awslambdaric
@@ -320,7 +320,7 @@ def send_welcome_email(*, user_id: int, template: str) -> str:
 
 `task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. `SQSLambdaTaskMessage.execute_immediately()` sets the `message_id` before each task runs and clears it afterwards — you don't need to manage it yourself.
 
-The Lambda handler configures the `lambda_tasks` logger hierarchy to `INFO` at cold start so that `task_logger` lines appear in CloudWatch. You can override the level by setting the `LAMBDA_TASKS_LOG_LEVEL` environment variable on your Lambda function (e.g. `DEBUG`, `WARNING`).
+The Lambda handler configures the `lambda_tasks` logger hierarchy to `INFO` at cold start so that `task_logger` lines appear in CloudWatch. You can control the level by configuring the `lambda_tasks` logger in your Django `LOGGING` setting (e.g. set it to `DEBUG` or `WARNING`). If your `LOGGING` dictConfig sets a root logger with a handler (as most Django projects do), `lambda_tasks` will inherit from it via propagation.
 
 Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `message_id` prefix.
 
@@ -460,14 +460,13 @@ Point your Lambda function's handler at:
 lambda_tasks.handler.handler
 ```
 
-The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: `resolve_environment()` → `resolve_secrets_into_env()` → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
+The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: temporary log handler attached → `resolve_environment()` → `resolve_secrets_into_env()` → log handler removed → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
 
 Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and that all task modules are importable (i.e. your application code is on the Python path).
 
 | Environment Variable | Required | Description |
 |---|---|---|
 | `DJANGO_SETTINGS_MODULE` | Yes | Django settings module path (e.g. `myapp.settings.production`). |
-| `LAMBDA_TASKS_LOG_LEVEL` | No | Log level for the `lambda_tasks` logger hierarchy (default `INFO`). Set to `DEBUG`, `WARNING`, etc. as needed. |
 | `LAMBDA_TASKS_ENVIRONMENT_SECRETS_MANAGER_ARN` | No | Secrets Manager reference (`<arn>:<version-stage>:<version-id>`) to load as environment variables at cold start (runs first). |
 | `LAMBDA_TASKS_SECRET_*` | No | Secrets Manager references resolved into individual env vars at cold start (runs second, after environment loading). |
 

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/README.md

@@ -308,7 +308,7 @@ def send_welcome_email(*, user_id: int, template: str) -> str:
 
 `task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. `SQSLambdaTaskMessage.execute_immediately()` sets the `message_id` before each task runs and clears it afterwards — you don't need to manage it yourself.
 
-The Lambda handler configures the `lambda_tasks` logger hierarchy to `INFO` at cold start so that `task_logger` lines appear in CloudWatch. You can override the level by setting the `LAMBDA_TASKS_LOG_LEVEL` environment variable on your Lambda function (e.g. `DEBUG`, `WARNING`).
+The Lambda handler configures the `lambda_tasks` logger hierarchy to `INFO` at cold start so that `task_logger` lines appear in CloudWatch. You can control the level by configuring the `lambda_tasks` logger in your Django `LOGGING` setting (e.g. set it to `DEBUG` or `WARNING`). If your `LOGGING` dictConfig sets a root logger with a handler (as most Django projects do), `lambda_tasks` will inherit from it via propagation.
 
 Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `message_id` prefix.
 
@@ -448,14 +448,13 @@ Point your Lambda function's handler at:
 lambda_tasks.handler.handler
 ```
 
-The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: `resolve_environment()` → `resolve_secrets_into_env()` → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
+The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: temporary log handler attached → `resolve_environment()` → `resolve_secrets_into_env()` → log handler removed → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
 
 Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and that all task modules are importable (i.e. your application code is on the Python path).
 
 | Environment Variable | Required | Description |
 |---|---|---|
 | `DJANGO_SETTINGS_MODULE` | Yes | Django settings module path (e.g. `myapp.settings.production`). |
-| `LAMBDA_TASKS_LOG_LEVEL` | No | Log level for the `lambda_tasks` logger hierarchy (default `INFO`). Set to `DEBUG`, `WARNING`, etc. as needed. |
 | `LAMBDA_TASKS_ENVIRONMENT_SECRETS_MANAGER_ARN` | No | Secrets Manager reference (`<arn>:<version-stage>:<version-id>`) to load as environment variables at cold start (runs first). |
 | `LAMBDA_TASKS_SECRET_*` | No | Secrets Manager references resolved into individual env vars at cold start (runs second, after environment loading). |
 

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/lambda_tasks/admin.py

@@ -28,15 +28,15 @@ class TaskRecordAdmin(admin.ModelAdmin):
             super()
             .get_queryset(request)
             .annotate(
-                duration=ExpressionWrapper(
+                computed_duration=ExpressionWrapper(
                     F("end_time") - F("start_time"), output_field=DurationField()
                 )
             )
         )
 
-    @admin.display(description="Duration", ordering="duration")
+    @admin.display(description="Duration", ordering="computed_duration")
     def duration(self, obj: TaskRecord) -> str | None:
-        d = getattr(obj, "duration", None)
+        d = getattr(obj, "computed_duration", None)
         if d is None:
             return None
         total_seconds = d.total_seconds()

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/lambda_tasks/handler.py

@@ -32,45 +32,36 @@ def _perform_cold_start() -> None:
     Both loaders are idempotent and run unconditionally — the environment
     secret may provide DJANGO_SETTINGS_MODULE, and individual secrets may
     depend on environment-loaded vars.
+
+    A temporary StreamHandler is attached to the ``lambda_tasks`` logger for
+    the duration of the loaders so their log output is visible before Django's
+    LOGGING dictConfig has run. It is removed immediately after so that
+    Django's configuration is the sole authority on logging from that point on.
     """
     global _cold_start_done
 
     if _cold_start_done:
         return
 
-    resolve_environment()
-    resolve_secrets_into_env()
+    lambda_tasks_logger = logging.getLogger(__package__)
+    boot_handler = logging.StreamHandler()
+    boot_handler.setLevel(logging.DEBUG)
+    lambda_tasks_logger.addHandler(boot_handler)
+    lambda_tasks_logger.setLevel(logging.DEBUG)
+
+    try:
+        resolve_environment()
+        resolve_secrets_into_env()
+    finally:
+        lambda_tasks_logger.removeHandler(boot_handler)
+        lambda_tasks_logger.setLevel(logging.NOTSET)
 
     if os.environ.get("DJANGO_SETTINGS_MODULE") and not apps.ready:
         django.setup()
 
-    _configure_logging()
-
     _cold_start_done = True
 
 
-def _configure_logging() -> None:
-    """Ensure the lambda_tasks logger hierarchy emits at INFO so task log lines
-    appear in CloudWatch.
-
-    The AWS Lambda runtime pre-configures the root logger, but child loggers
-    default to WARNING unless explicitly configured. If Django's LOGGING
-    dictConfig has already set a level on the ``lambda_tasks`` logger (i.e. the
-    user explicitly configured it), we leave it alone. Otherwise we default to
-    INFO (or the value of the LAMBDA_TASKS_LOG_LEVEL env var).
-    """
-    lambda_tasks_logger = logging.getLogger("lambda_tasks")
-
-    # level == NOTSET means nobody (neither dictConfig nor user code) has
-    # explicitly configured this logger — safe to apply our default.
-    if lambda_tasks_logger.level != logging.NOTSET:
-        return
-
-    log_level_name = os.environ.get("LAMBDA_TASKS_LOG_LEVEL", "INFO").upper()
-    log_level = getattr(logging, log_level_name, logging.INFO)
-    lambda_tasks_logger.setLevel(log_level)
-
-
 def handler(event: dict, context: object) -> dict:
     """AWS Lambda entry point. Processes a batch of SQS records.
 

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/lambda_tasks/logging.py

@@ -21,7 +21,7 @@ class _TaskLogger(logging.LoggerAdapter):
     """LoggerAdapter that prepends [message_id] to every message."""
 
     def __init__(self) -> None:
-        super().__init__(logging.getLogger("lambda_tasks.task"), extra={})
+        super().__init__(logging.getLogger(f"{__package__}.task"), extra={})
         self.message_id: str | None = None
 
     def process(

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["lambda_tasks"]
 
 [project]
 name = "django-lambda-tasks"
-version = "0.2.3"
+version = "0.2.5"
 description = "Run async tasks in a lambda function"
 readme = "README.md"
 requires-python = ">=3.10"

{django_lambda_tasks-0.2.3 → django_lambda_tasks-0.2.5}/tests/test_handler.py

@@ -24,7 +24,7 @@ import pytest
 from hypothesis import given, settings
 from hypothesis import strategies as st
 
-from lambda_tasks.handler import _configure_logging, handler
+from lambda_tasks.handler import handler
 
 # ---------------------------------------------------------------------------
 # Signature test
@@ -371,45 +371,89 @@ def test_property_4_cold_start_runs_only_once(monkeypatch):
 
 
 # ---------------------------------------------------------------------------
-# _configure_logging tests
+# Cold-start logging tests
 # ---------------------------------------------------------------------------
 
 
-class TestConfigureLogging:
-    def test_sets_lambda_tasks_logger_to_info_by_default(self, monkeypatch):
-        """Without LAMBDA_TASKS_LOG_LEVEL env var, the lambda_tasks logger is set to INFO."""
-        monkeypatch.delenv("LAMBDA_TASKS_LOG_LEVEL", raising=False)
-        logging.getLogger("lambda_tasks").setLevel(logging.NOTSET)
-        _configure_logging()
-        assert logging.getLogger("lambda_tasks").level == logging.INFO
-
-    def test_task_logger_effective_level_is_info(self, monkeypatch):
-        """task_logger (lambda_tasks.task) inherits INFO from the parent."""
-        monkeypatch.delenv("LAMBDA_TASKS_LOG_LEVEL", raising=False)
-        logging.getLogger("lambda_tasks").setLevel(logging.NOTSET)
-        _configure_logging()
-        assert (
-            logging.getLogger("lambda_tasks.task").getEffectiveLevel() == logging.INFO
+class TestColdStartLogging:
+    def test_loader_logs_are_emitted_during_cold_start(self, monkeypatch, capfd):
+        """Loader log output is visible during cold start before Django setup."""
+        import lambda_tasks.handler as handler_module
+
+        monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
+
+        logged_messages: list[str] = []
+
+        def spy_resolve_environment():
+            logging.getLogger("lambda_tasks.environment_loader").info(
+                "env loader message"
+            )
+
+        def spy_resolve_secrets():
+            logging.getLogger("lambda_tasks.secret_loader").info(
+                "secret loader message"
+            )
+
+        monkeypatch.setattr(
+            "lambda_tasks.handler.resolve_environment", spy_resolve_environment
         )
+        monkeypatch.setattr(
+            "lambda_tasks.handler.resolve_secrets_into_env", spy_resolve_secrets
+        )
+
+        lambda_tasks_logger = logging.getLogger("lambda_tasks")
+        lambda_tasks_logger.handlers.clear()
+        lambda_tasks_logger.setLevel(logging.NOTSET)
+
+        handler_module._cold_start_done = False
+        handler_module.handler(event={"Records": []}, context=None)
+
+        captured = capfd.readouterr()
+        assert "env loader message" in captured.err
+        assert "secret loader message" in captured.err
+
+    def test_boot_handler_removed_after_loaders(self, monkeypatch):
+        """The temporary handler is removed after the loaders run, leaving
+        the logger clean for Django's LOGGING dictConfig."""
+        import lambda_tasks.handler as handler_module
+
+        monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
+        monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
+        monkeypatch.setattr(
+            "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
+        )
+
+        lambda_tasks_logger = logging.getLogger("lambda_tasks")
+        lambda_tasks_logger.handlers.clear()
+        lambda_tasks_logger.setLevel(logging.NOTSET)
+
+        handler_module._cold_start_done = False
+        handler_module.handler(event={"Records": []}, context=None)
+
+        assert lambda_tasks_logger.handlers == []
+        assert lambda_tasks_logger.level == logging.NOTSET
+
+    def test_boot_handler_removed_even_on_loader_error(self, monkeypatch):
+        """The temporary handler is cleaned up even if a loader raises."""
+        import lambda_tasks.handler as handler_module
+
+        monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
+        monkeypatch.setattr(
+            "lambda_tasks.handler.resolve_environment",
+            lambda: (_ for _ in ()).throw(ValueError("bad ref")),
+        )
+        monkeypatch.setattr(
+            "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
+        )
+
+        lambda_tasks_logger = logging.getLogger("lambda_tasks")
+        lambda_tasks_logger.handlers.clear()
+        lambda_tasks_logger.setLevel(logging.NOTSET)
+
+        handler_module._cold_start_done = False
+
+        with pytest.raises(ValueError, match="bad ref"):
+            handler_module.handler(event={"Records": []}, context=None)
 
-    def test_respects_lambda_tasks_log_level_env_var(self, monkeypatch):
-        """LAMBDA_TASKS_LOG_LEVEL env var controls the logger level."""
-        monkeypatch.setenv("LAMBDA_TASKS_LOG_LEVEL", "DEBUG")
-        logging.getLogger("lambda_tasks").setLevel(logging.NOTSET)
-        _configure_logging()
-        assert logging.getLogger("lambda_tasks").level == logging.DEBUG
-
-    def test_invalid_log_level_falls_back_to_info(self, monkeypatch):
-        """An invalid LAMBDA_TASKS_LOG_LEVEL value falls back to INFO."""
-        monkeypatch.setenv("LAMBDA_TASKS_LOG_LEVEL", "NONSENSE")
-        logging.getLogger("lambda_tasks").setLevel(logging.NOTSET)
-        _configure_logging()
-        assert logging.getLogger("lambda_tasks").level == logging.INFO
-
-    def test_does_not_override_explicit_django_logging_config(self, monkeypatch):
-        """If Django's LOGGING dictConfig already set a level, _configure_logging leaves it alone."""
-        monkeypatch.delenv("LAMBDA_TASKS_LOG_LEVEL", raising=False)
-        # Simulate Django dictConfig having set the logger to WARNING
-        logging.getLogger("lambda_tasks").setLevel(logging.WARNING)
-        _configure_logging()
-        assert logging.getLogger("lambda_tasks").level == logging.WARNING
+        assert lambda_tasks_logger.handlers == []
+        assert lambda_tasks_logger.level == logging.NOTSET