django-lambda-tasks 0.6.7__tar.gz → 0.7.0__tar.gz

{django_lambda_tasks-0.6.7 → django_lambda_tasks-0.7.0}/.kiro/steering/product.md

@@ -143,6 +143,7 @@ class SQSLambdaTaskMessage(BaseModel):
 
 `handler(event, context)` in `handler.py`:
 - Processes each SQS record independently
+- Calls `django.db.close_old_connections()` before each record to close database connections that have become unusable between warm invocations (idle timeouts, RDS failovers, network interruptions)
 - Passes `record["messageId"]` as `message_id` to `execute_immediately()` — this becomes the `TaskRecord` primary key, enabling deduplication on redelivery
 - 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

{django_lambda_tasks-0.6.7 → django_lambda_tasks-0.7.0}/.kiro/steering/structure.md

@@ -43,7 +43,7 @@ django-lambda-tasks/
 - `decorators.py` — defines `LambdaTaskWrapper` and `@lambda_task` decorator factory; enforces kwargs-only at decoration time; validates timeouts (> 0, soft < hard) at decoration time; upper-bound timeout validation deferred to execution time based on queue type
 - `models.py` — `TaskRecord` (Django ORM), `SQSLambdaTaskMessage` (Pydantic, SQS schema + execution logic), `SQSLambdaTask` (Pydantic, holds message + routing; `_execute()` inspects queue config to publish to SQS, submit to Batch via `submit_batch_job`, execute eagerly, or submit to the local process pool; `execute_on_commit()` registers `_execute` with `transaction.on_commit`)
 - `local_executor.py` — `ProcessPoolExecutor`-based async local execution; `get_pool()` lazily creates a module-level pool; `submit_task()` fire-and-forget submission; `_execute_in_worker()` deserializes and runs the task in a child process; `_pool_initializer()` calls `django.setup()` per worker (and sets `SIGINT` to `SIG_IGN` so workers ignore Ctrl+C); `_install_shutdown_handlers()` installs main-thread `SIGINT`/`SIGTERM` handlers that release the pool before chaining to the previous handler
-- `handler.py` — Lambda entry point (`handler(event, context)`); cold-start init (memory limit → 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`. Also provides `main()` as the AWS Batch container entry point (`python -m lambda_tasks.handler`) — reads `LAMBDA_TASKS_MESSAGE` env var, constructs a synthetic SQS event, and delegates to `handler()`
+- `handler.py` — Lambda entry point (`handler(event, context)`); cold-start init (memory limit → 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; calls `db.close_old_connections()` before each SQS record to handle stale connections on warm starts; processes SQS records independently; returns `batchItemFailures`. Also provides `main()` as the AWS Batch container entry point (`python -m lambda_tasks.handler`) — reads `LAMBDA_TASKS_MESSAGE` env var, constructs a synthetic SQS event, and delegates to `handler()`
 - `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.6.7/README.md → django_lambda_tasks-0.7.0/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: django-lambda-tasks
+Version: 0.7.0
+Summary: Run async tasks in a lambda function
+Requires-Python: >=3.10
+Requires-Dist: awslambdaric
+Requires-Dist: boto3
+Requires-Dist: django
+Requires-Dist: pydantic
+Requires-Dist: redis
+Description-Content-Type: text/markdown
+
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -535,6 +547,8 @@ 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: 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.
 
+Before processing each SQS record, the handler calls `django.db.close_old_connections()` to close any database connections that have become unusable between invocations. Lambda containers are reused across invocations (warm starts), but database connections may be closed server-side due to idle timeouts, RDS failovers, or network interruptions. Without this, the first database query in a task would fail with `OperationalError: the connection is closed`.
+
 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_lambda_tasks-0.6.7/PKG-INFO → django_lambda_tasks-0.7.0/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: django-lambda-tasks
-Version: 0.6.7
-Summary: Run async tasks in a lambda function
-Requires-Python: >=3.10
-Requires-Dist: awslambdaric
-Requires-Dist: boto3
-Requires-Dist: django
-Requires-Dist: pydantic
-Requires-Dist: redis
-Description-Content-Type: text/markdown
-
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -547,6 +535,8 @@ 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: 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.
 
+Before processing each SQS record, the handler calls `django.db.close_old_connections()` to close any database connections that have become unusable between invocations. Lambda containers are reused across invocations (warm starts), but database connections may be closed server-side due to idle timeouts, RDS failovers, or network interruptions. Without this, the first database query in a task would fail with `OperationalError: the connection is closed`.
+
 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_lambda_tasks-0.6.7 → django_lambda_tasks-0.7.0}/lambda_tasks/handler.py

@@ -21,6 +21,7 @@ import urllib.request
 import uuid
 
 import django
+from django import db
 from django.apps import apps
 
 from lambda_tasks.environment_loader import resolve_environment
@@ -132,6 +133,7 @@ def handler(event: dict, context: object) -> dict:
 
     for record in event["Records"]:
         try:
+            db.close_old_connections()
             SQSLambdaTaskMessage.model_validate_json(
                 record["body"]
             ).execute_immediately(message_id=record["messageId"])

{django_lambda_tasks-0.6.7 → django_lambda_tasks-0.7.0}/pyproject.toml

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

{django_lambda_tasks-0.6.7 → django_lambda_tasks-0.7.0}/tests/test_handler.py

@@ -26,6 +26,14 @@ from hypothesis import strategies as st
 
 from lambda_tasks.handler import handler
 
+
+@pytest.fixture(autouse=True)
+def _patch_close_old_connections():
+    """Prevent close_old_connections from triggering the DB access guard in unit tests."""
+    with patch("lambda_tasks.handler.db.close_old_connections"):
+        yield
+
+
 # ---------------------------------------------------------------------------
 # Signature test
 # ---------------------------------------------------------------------------
@@ -457,3 +465,71 @@ class TestColdStartLogging:
 
         assert lambda_tasks_logger.handlers == []
         assert lambda_tasks_logger.level == logging.NOTSET
+
+
+# ---------------------------------------------------------------------------
+# Stale connection handling
+# ---------------------------------------------------------------------------
+
+
+class TestHandlerClosesOldConnections:
+    def test_close_old_connections_called_before_each_record(self):
+        """close_old_connections() is called before processing each SQS record."""
+        call_order = []
+
+        def _track_close():
+            call_order.append("close")
+
+        def _make_message(body: str):
+            msg = MagicMock()
+
+            def _execute(**kwargs):
+                call_order.append("execute")
+
+            msg.execute_immediately.side_effect = _execute
+            return msg
+
+        records = [
+            _make_record("msg-1", _valid_body()),
+            _make_record("msg-2", _valid_body()),
+        ]
+
+        with (
+            patch(
+                "lambda_tasks.handler.db.close_old_connections",
+                side_effect=_track_close,
+            ),
+            _patch_model_validate(_make_message),
+        ):
+            handler(event={"Records": records}, context=None)
+
+        assert call_order == ["close", "execute", "close", "execute"]
+
+    def test_close_old_connections_called_even_when_record_fails(self):
+        """close_old_connections() is called before each record, including ones that fail."""
+        close_count = 0
+
+        def _track_close():
+            nonlocal close_count
+            close_count += 1
+
+        def _make_message(body: str):
+            msg = MagicMock()
+            msg.execute_immediately.side_effect = RuntimeError("boom")
+            return msg
+
+        records = [
+            _make_record("msg-1", _valid_body()),
+            _make_record("msg-2", _valid_body()),
+        ]
+
+        with (
+            patch(
+                "lambda_tasks.handler.db.close_old_connections",
+                side_effect=_track_close,
+            ),
+            _patch_model_validate(_make_message),
+        ):
+            handler(event={"Records": records}, context=None)
+
+        assert close_count == 2