django-lambda-tasks 0.1.1__tar.gz → 0.1.2__tar.gz

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/.kiro/specs/deferred-task-enqueue/tasks.md

@@ -94,7 +94,7 @@ All new functions and methods use kwargs-only signatures (enforced by `*`).
   - Add `to_json(self, **kwargs: Any) -> dict`:
     - Pop `_delay` / `_queue` overrides (same resolution logic as `on_commit`)
     - Validate remaining kwargs via `self._kwargs_model.model_validate(kwargs)`
-    - Build `SQSLambdaTaskMessage(task_name=..., invocation_id=str(uuid.uuid4()), kwargs=...)`
+    - Build `SQSLambdaTaskMessage(task_name=..., kwargs=...)`
     - Return `SQSLambdaSQSLambdaTaskMessage(message=task_message, delay=delay, queue=queue).model_dump()`
   - Add `enqueue_from_json(self, *, data: dict) -> None`:
     - Validate via `SQSLambdaSQSLambdaTaskMessage.model_validate(data)`

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/.kiro/specs/eager-mode-example-app/design.md

@@ -85,10 +85,7 @@ if conf.EAGER:
 
   message = SQSLambdaTaskMessage(
     task_name=task_name,
-    invocation_id=str(uuid.uuid4()),
     kwargs=task_kwargs,
-    soft_timeout=soft_timeout,
-    hard_timeout=hard_timeout,
   )
   execute_task(message=message)
   return

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/.kiro/steering/product.md

@@ -64,7 +64,7 @@ def sync_user(*, user_id: int) -> None:
 
 ## retry_on
 
-Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task raises an instance of any of those types (or a subclass), the executor automatically re-enqueues the task via `execute_on_commit` with the same kwargs, a fresh `invocation_id`, and an incremented `_n_retries` counter.
+Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task raises an instance of any of those types (or a subclass), the executor automatically re-enqueues the task via `execute_on_commit` with the same kwargs, and an incremented `_n_retries` counter.
 
 - `TaskRecord.status` is set to `RETRYING` and the traceback is recorded
 - The retry is a new invocation — the current record is terminal at `RETRYING`
@@ -98,7 +98,7 @@ class SQSLambdaTaskMessage(BaseModel):
 ## Execution
 
 `SQSLambdaTaskMessage.execute_immediately()` in `models.py`:
-1. Checks for an existing `TaskRecord` with the same `invocation_id` via `get_or_create`
+1. Checks for an existing `TaskRecord` with the same `pk` via `get_or_create`
 2. If a record already exists (any status), logs and returns immediately — duplicate deliveries are silently skipped
 3. Resolves timeouts: decorator default → settings defaults (soft=270s, hard=300s)
 4. Runs task inside `transaction.atomic()` + `TimeoutContext`
@@ -141,7 +141,7 @@ Behaviour:
 
 ## TaskRecord Model
 
-Fields: `task_name`, `invocation_id` (unique UUID), `kwargs`, `status`, `start_time`, `end_time`, `result`, `traceback`
+Fields: `task_name`, `pk` (unique UUID), `kwargs`, `status`, `start_time`, `end_time`, `result`, `traceback`
 
 Statuses: `RUNNING`, `SUCCESS`, `FAILED`, `RETRYING`
 
@@ -167,7 +167,7 @@ Set `LAMBDA_TASKS_EAGER = True` to run tasks synchronously in-process (no SQS).
 
 ## Logging
 
-Import `task_logger` to emit log records that are automatically prefixed with the active `invocation_id`:
+Import `task_logger` to emit log records that are automatically prefixed with the active `message_id`:
 
 ```python
 from lambda_tasks.logging import task_logger
@@ -179,7 +179,7 @@ def my_task(*, user_id: int) -> None:
     # → "[abc-123] processing user 42"
 ```
 
-`task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. The executor sets the `invocation_id` before each task runs and clears it in a `finally` block. Using your own `logging.getLogger(__name__)` is fine — those records just won't carry the prefix.
+`task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. The executor sets the `message_id` before each task runs and clears it in a `finally` block. Using your own `logging.getLogger(__name__)` is fine — those records just won't carry the prefix.
 
 ## Conventions
 

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/.kiro/steering/structure.md

@@ -40,7 +40,7 @@ django-lambda-tasks/
 - `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; calls `resolve_secrets_into_env()` then `django.setup()` at cold start; processes SQS records independently; returns `batchItemFailures`
 - `secret_loader.py` — resolves `LAMBDA_TASKS_SECRET_*` env vars from Secrets Manager before Django starts; validates format, detects conflicts, batches API calls, caches results in-process
-- `logging.py` — `task_logger` singleton; `invocation_id` set/cleared around each task execution
+- `logging.py` — `task_logger` singleton; `message_id` set/cleared around each task execution
 - `settings.py` — `LambdaTasksSettings` instantiated fresh per use (reads live Django settings)
 - `admin.py` — Django admin registration for `TaskRecord`
 

django_lambda_tasks-0.1.1/README.md → django_lambda_tasks-0.1.2/PKG-INFO

@@ -1,3 +1,13 @@
+Metadata-Version: 2.4
+Name: django-lambda-tasks
+Version: 0.1.2
+Summary: Run async tasks in a lambda function
+Requires-Python: >=3.10
+Requires-Dist: boto3
+Requires-Dist: django
+Requires-Dist: pydantic
+Description-Content-Type: text/markdown
+
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler that AWS invokes with SQS message batches. Task results, status, and metadata are persisted in the Django database.
@@ -180,7 +190,6 @@ payload = send_welcome_email.serialize(user_id=42, template="welcome")
 # {
 #   "message": {
 #     "task_name": "myapp.tasks.send_welcome_email",
-#     "invocation_id": "<uuid4>",
 #     "kwargs": {"user_id": 42, "template": "welcome"}
 #   },
 #   "delay": 0,
@@ -199,8 +208,6 @@ task = SQSLambdaTask.model_validate(payload)
 task.execute_on_commit()
 ```
 
-> **Note:** `serialize()` generates a fresh `invocation_id` on every call. Capture the result once if you need a stable reference to a specific invocation.
-
 ---
 
 ## Timeouts
@@ -265,7 +272,7 @@ TaskRecord.objects.all()
 TaskRecord.objects.filter(status=TaskRecord.TaskStatus.FAILED)
 
 # Look up a specific invocation
-TaskRecord.objects.get(invocation_id="<uuid>")
+TaskRecord.objects.get(pk="<uuid>")
 ```
 
 ### `TaskRecord` fields
@@ -273,7 +280,6 @@ TaskRecord.objects.get(invocation_id="<uuid>")
 | Field | Type | Description |
 |---|---|---|
 | `task_name` | `str` | Fully-qualified function name (e.g. `myapp.tasks.send_welcome_email`). |
-| `invocation_id` | `UUID` | Unique ID generated at enqueue time. |
 | `kwargs` | `dict` | Serialized task arguments. |
 | `status` | `str` | One of `RUNNING`, `SUCCESS`, `FAILED`. |
 | `start_time` | `datetime \| None` | When the worker began executing the task. |
@@ -285,7 +291,7 @@ TaskRecord.objects.get(invocation_id="<uuid>")
 
 ## Logging
 
-Import `task_logger` to emit log records that are automatically prefixed with the active `invocation_id`. This makes it straightforward to filter all logs for a specific task invocation in CloudWatch Logs Insights.
+Import `task_logger` to emit log records that are automatically prefixed with the active `message_id`. This makes it straightforward to filter all logs for a specific task invocation in CloudWatch Logs Insights.
 
 ```python
 from lambda_tasks.logging import task_logger
@@ -298,9 +304,9 @@ def send_welcome_email(*, user_id: int, template: str) -> str:
     return "sent"
 ```
 
-`task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. `SQSLambdaTaskMessage.execute_immediately()` sets the `invocation_id` before each task runs and clears it afterwards — you don't need to manage it yourself.
+`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.
 
-Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `invocation_id` prefix.
+Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `message_id` prefix.
 
 To filter by invocation in CloudWatch Logs Insights:
 

django_lambda_tasks-0.1.1/PKG-INFO → django_lambda_tasks-0.1.2/README.md

@@ -1,13 +1,3 @@
-Metadata-Version: 2.4
-Name: django-lambda-tasks
-Version: 0.1.1
-Summary: Run async tasks in a lambda function
-Requires-Python: >=3.10
-Requires-Dist: boto3
-Requires-Dist: django
-Requires-Dist: pydantic
-Description-Content-Type: text/markdown
-
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler that AWS invokes with SQS message batches. Task results, status, and metadata are persisted in the Django database.
@@ -190,7 +180,6 @@ payload = send_welcome_email.serialize(user_id=42, template="welcome")
 # {
 #   "message": {
 #     "task_name": "myapp.tasks.send_welcome_email",
-#     "invocation_id": "<uuid4>",
 #     "kwargs": {"user_id": 42, "template": "welcome"}
 #   },
 #   "delay": 0,
@@ -209,8 +198,6 @@ task = SQSLambdaTask.model_validate(payload)
 task.execute_on_commit()
 ```
 
-> **Note:** `serialize()` generates a fresh `invocation_id` on every call. Capture the result once if you need a stable reference to a specific invocation.
-
 ---
 
 ## Timeouts
@@ -275,7 +262,7 @@ TaskRecord.objects.all()
 TaskRecord.objects.filter(status=TaskRecord.TaskStatus.FAILED)
 
 # Look up a specific invocation
-TaskRecord.objects.get(invocation_id="<uuid>")
+TaskRecord.objects.get(pk="<uuid>")
 ```
 
 ### `TaskRecord` fields
@@ -283,7 +270,6 @@ TaskRecord.objects.get(invocation_id="<uuid>")
 | Field | Type | Description |
 |---|---|---|
 | `task_name` | `str` | Fully-qualified function name (e.g. `myapp.tasks.send_welcome_email`). |
-| `invocation_id` | `UUID` | Unique ID generated at enqueue time. |
 | `kwargs` | `dict` | Serialized task arguments. |
 | `status` | `str` | One of `RUNNING`, `SUCCESS`, `FAILED`. |
 | `start_time` | `datetime \| None` | When the worker began executing the task. |
@@ -295,7 +281,7 @@ TaskRecord.objects.get(invocation_id="<uuid>")
 
 ## Logging
 
-Import `task_logger` to emit log records that are automatically prefixed with the active `invocation_id`. This makes it straightforward to filter all logs for a specific task invocation in CloudWatch Logs Insights.
+Import `task_logger` to emit log records that are automatically prefixed with the active `message_id`. This makes it straightforward to filter all logs for a specific task invocation in CloudWatch Logs Insights.
 
 ```python
 from lambda_tasks.logging import task_logger
@@ -308,9 +294,9 @@ def send_welcome_email(*, user_id: int, template: str) -> str:
     return "sent"
 ```
 
-`task_logger` is a `LoggerAdapter` wrapping the `lambda_tasks.task` logger. `SQSLambdaTaskMessage.execute_immediately()` sets the `invocation_id` before each task runs and clears it afterwards — you don't need to manage it yourself.
+`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.
 
-Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `invocation_id` prefix.
+Using your own `logging.getLogger(__name__)` is fine too; those records just won't carry the `message_id` prefix.
 
 To filter by invocation in CloudWatch Logs Insights:
 

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/admin.py

@@ -10,6 +10,7 @@ from lambda_tasks.models import TaskRecord
 @admin.register(TaskRecord)
 class TaskRecordAdmin(admin.ModelAdmin):
     list_display = (
+        "pk",
         "task_name",
         "status",
         "start_time",
@@ -20,7 +21,7 @@ class TaskRecordAdmin(admin.ModelAdmin):
     )
     list_filter = ("status", "task_name")
     date_hierarchy = "start_time"
-    search_fields = ("invocation_id", "kwargs")
+    search_fields = ("pk", "kwargs")
 
     def get_queryset(self, request: HttpRequest) -> QuerySet:
         return (

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/decorators.py

@@ -153,7 +153,6 @@ class LambdaTaskWrapper:
 
         message = SQSLambdaTaskMessage(
             task_name=f"{self._func.__module__}.{self._func.__qualname__}",
-            invocation_id=str(uuid.uuid4()),
             kwargs=dict(kwargs),
             n_retries=n_retries,
         )
@@ -170,7 +169,7 @@ class LambdaTaskWrapper:
         Accepts task kwargs plus reserved override kwargs:
             _delay: int
 
-        Returns a dict matching SQSLambdaTaskMessage schema with a stable invocation_id.
+        Returns a dict matching SQSLambdaTaskMessage schema
 
         Raises:
             pydantic.ValidationError: if kwargs fail the task's declared type annotations.

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/handler.py

@@ -40,7 +40,7 @@ def handler(*, event: dict, context: object) -> dict:
         try:
             SQSLambdaTaskMessage.model_validate_json(
                 record["body"]
-            ).execute_immediately()
+            ).execute_immediately(message_id=record["messageId"])
         except Exception:
             logger.error(
                 "Failed to process SQS record %s",

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/logging.py

@@ -1,6 +1,6 @@
 """
 Provides task_logger — a LoggerAdapter that automatically includes the
-current invocation_id on every log record while a task is executing.
+current message_id on every log record while a task is executing.
 
 Usage in task functions::
 
@@ -9,7 +9,7 @@ Usage in task functions::
     @lambda_task(...)
     def my_task(*, user_id: int) -> None:
         task_logger.info("processing user %s", user_id)
-        # → "processing user 42" tagged with the active invocation_id
+        # → "processing user 42" tagged with the active message_id
 """
 
 import logging
@@ -18,16 +18,16 @@ from typing import Any
 
 
 class _TaskLogger(logging.LoggerAdapter):
-    """LoggerAdapter that prepends [invocation_id] to every message."""
+    """LoggerAdapter that prepends [message_id] to every message."""
 
     def __init__(self) -> None:
         super().__init__(logging.getLogger("lambda_tasks.task"), extra={})
-        self.invocation_id: str | None = None
+        self.message_id: str | None = None
 
     def process(
         self, msg: Any, kwargs: MutableMapping[str, Any]
     ) -> tuple[Any, MutableMapping[str, Any]]:
-        prefix = f"[{self.invocation_id}] " if self.invocation_id else ""
+        prefix = f"[{self.message_id}] " if self.message_id else ""
         return f"{prefix}{msg}", kwargs
 
 

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 6.0.3 on 2026-03-26 11:44
+# Generated by Django 6.0.3 on 2026-03-26 14:06
 
 from django.db import migrations, models
 
@@ -15,15 +15,9 @@ class Migration(migrations.Migration):
             fields=[
                 (
                     "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
+                    models.UUIDField(editable=False, primary_key=True, serialize=False),
                 ),
                 ("task_name", models.CharField(editable=False, max_length=255)),
-                ("invocation_id", models.UUIDField(editable=False, unique=True)),
                 ("kwargs", models.JSONField(editable=False)),
                 ("n_retries", models.PositiveSmallIntegerField(editable=False)),
                 (
@@ -50,9 +44,6 @@ class Migration(migrations.Migration):
                     models.Index(
                         fields=["task_name"], name="lambda_task_task_na_f00cb7_idx"
                     ),
-                    models.Index(
-                        fields=["invocation_id"], name="lambda_task_invocat_3d5a22_idx"
-                    ),
                     models.Index(
                         fields=["status"], name="lambda_task_status_6901ee_idx"
                     ),

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/lambda_tasks/models.py

@@ -2,6 +2,7 @@
 
 import random
 import traceback
+import uuid
 
 import boto3
 from django.core.exceptions import ImproperlyConfigured
@@ -33,8 +34,8 @@ class TaskStatus(models.TextChoices):
 class TaskRecord(models.Model):
     TaskStatus = TaskStatus
 
+    id = models.UUIDField(primary_key=True, editable=False)
     task_name = models.CharField(max_length=255, editable=False)
-    invocation_id = models.UUIDField(unique=True, editable=False)
     kwargs = models.JSONField(editable=False)
     n_retries = models.PositiveSmallIntegerField(editable=False)
     status = models.CharField(
@@ -55,7 +56,6 @@ class TaskRecord(models.Model):
         ordering = ["-start_time"]
         indexes = [
             models.Index(fields=["task_name"]),
-            models.Index(fields=["invocation_id"]),
             models.Index(fields=["status"]),
             models.Index(fields=["-start_time"]),
         ]
@@ -71,18 +71,17 @@ class SQSLambdaTaskMessage(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     task_name: str
-    invocation_id: str
     kwargs: dict
     n_retries: int = Field(default=0, ge=0)
 
-    def execute_immediately(self) -> None:
+    def execute_immediately(self, *, message_id: str) -> None:
         """Execute a background task described.
 
         Creates a TaskRecord, resolves timeouts, validates configuration,
         runs the task inside an atomic block with timeout enforcement, and
         persists the outcome.
         """
-        task_logger.invocation_id = self.invocation_id
+        task_logger.message_id = message_id
 
         try:
             task_logger.info(f"Received {self.task_name}")
@@ -104,7 +103,7 @@ class SQSLambdaTaskMessage(BaseModel):
 
             record, created = (
                 TaskRecord.objects.get_or_create(  # ty: ignore[unresolved-attribute]
-                    invocation_id=self.invocation_id,
+                    pk=message_id,
                     defaults={
                         "task_name": self.task_name,
                         "kwargs": self.kwargs,
@@ -200,7 +199,7 @@ class SQSLambdaTaskMessage(BaseModel):
                 )
 
         finally:
-            task_logger.invocation_id = None
+            task_logger.message_id = None
 
 
 class SQSLambdaTask(BaseModel):
@@ -224,7 +223,7 @@ class SQSLambdaTask(BaseModel):
         conf = LambdaTasksSettings()
 
         if conf.EAGER:
-            self.message.execute_immediately()
+            self.message.execute_immediately(message_id=str(uuid.uuid4()))
         else:
             try:
                 queue_url = conf.QUEUES[self.queue]

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/pyproject.toml

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

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/tests/test_admin.py

@@ -10,6 +10,7 @@ def test_task_record_registered_in_admin():
 
 def test_task_record_admin_list_display():
     assert admin.site._registry[TaskRecord].list_display == (
+        "pk",
         "task_name",
         "status",
         "start_time",

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/tests/test_deferred_enqueue.py

@@ -58,13 +58,6 @@ def test_to_json_task_name_matches_module_qualname():
     assert result["message"]["task_name"] == expected
 
 
-def test_to_json_invocation_id_is_valid_uuid4():
-    """result['message']['invocation_id'] is a valid UUID4 string."""
-    result = _wrapper.serialize(x=1)
-    parsed = uuid.UUID(result["message"]["invocation_id"])
-    assert parsed.version == 4
-
-
 def test_to_json_raises_validation_error_for_wrong_type_kwargs():
     """to_json(x='not_an_int') raises ValidationError when x is annotated as int."""
     with pytest.raises(ValidationError):
@@ -95,7 +88,6 @@ _valid_deferred_dict_st = st.fixed_dictionaries(
         "message": st.fixed_dictionaries(
             {
                 "task_name": st.just("tests.test_deferred_enqueue._task"),
-                "invocation_id": st.uuids().map(str),
                 "kwargs": st.fixed_dictionaries({"x": st.integers()}),
             }
         ),
@@ -120,7 +112,6 @@ def test_p1_to_json_structural_invariant(x: int) -> None:
     result = _wrapper.serialize(x=x)
     SQSLambdaTask.model_validate(result)
     assert result["message"]["task_name"] == f"{_task.__module__}.{_task.__qualname__}"
-    assert uuid.UUID(result["message"]["invocation_id"]).version == 4
     assert result["message"]["kwargs"] == {"x": x}
     assert result["delay"] == 0
     assert result["queue"] == "default"

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/tests/test_handler.py

@@ -37,7 +37,6 @@ def _valid_body(task_name: str = "my_module.my_task", **kwargs) -> str:
     return json.dumps(
         {
             "task_name": task_name,
-            "invocation_id": str(uuid.uuid4()),
             "kwargs": kwargs,
         }
     )
@@ -78,8 +77,7 @@ class TestHandlerAllSucceed:
 class TestHandlerPartialFailure:
     def test_one_record_fails_only_that_id_in_failures(self):
         """One record fails → only that messageId in batchItemFailures."""
-        fail_body = _valid_body()
-        ok_body = _valid_body()
+        ok_body, fail_body = (f"{_valid_body()}-{i}" for i in range(2))
         records = [
             _make_record("msg-ok", ok_body),
             _make_record("msg-fail", fail_body),
@@ -146,9 +144,7 @@ class TestHandlerIndependentProcessing:
     def test_failure_does_not_prevent_subsequent_records(self):
         """A failure in one record does not prevent processing of subsequent records."""
         processed = []
-        fail_body = _valid_body()
-        before_body = _valid_body()
-        after_body = _valid_body()
+        before_body, fail_body, after_body = (f"{_valid_body()}-{i}" for i in range(3))
 
         records = [
             _make_record("msg-before", before_body),
@@ -169,7 +165,7 @@ class TestHandlerIndependentProcessing:
                 msg.execute_immediately.side_effect = RuntimeError("boom")
             else:
 
-                def _execute(mid=msg_id):
+                def _execute(mid=msg_id, **kwargs):
                     processed.append(mid)
 
                 msg.execute_immediately.side_effect = _execute
@@ -212,7 +208,7 @@ class TestHandlerIndependentProcessing:
 @settings(max_examples=100)
 def test_property_11_batch_records_processed_independently(flags):
     """Property 11: Every record is attempted; batchItemFailures contains exactly the failed IDs."""
-    bodies = [_valid_body() for _ in range(len(flags))]
+    bodies = [f"{_valid_body()}-{i}" for i in range(len(flags))]
     records = [_make_record(f"msg-{i}", bodies[i]) for i in range(len(flags))]
     expected_failures = {f"msg-{i}" for i, ok in enumerate(flags) if not ok}
     attempted_bodies = []
@@ -280,7 +276,6 @@ def test_property_4_django_setup_before_execute_task(monkeypatch):
     body = json.dumps(
         {
             "task_name": "some.task",
-            "invocation_id": str(uuid.uuid4()),
             "kwargs": {},
         }
     )

{django_lambda_tasks-0.1.1 → django_lambda_tasks-0.1.2}/tests/test_logging.py

@@ -2,10 +2,10 @@
 Tests for lambda_tasks.logging (task_logger).
 
 Covers:
-- task_logger prefixes messages with [invocation_id] when set
-- task_logger emits undecorated messages when invocation_id is None
-- invocation_id is cleared after execute_task completes (success and failure)
-- log messages emitted during task execution carry the invocation_id prefix
+- task_logger prefixes messages with [message_id] when set
+- task_logger emits undecorated messages when message_id is None
+- message_id is cleared after execute_task completes (success and failure)
+- log messages emitted during task execution carry the message_id prefix
 """
 
 import logging
@@ -43,7 +43,6 @@ def _task_name(wrapper) -> str:
 def _make_message(task_name: str, kwargs: dict) -> SQSLambdaTaskMessage:
     return SQSLambdaTaskMessage(
         task_name=task_name,
-        invocation_id=str(uuid.uuid4()),
         kwargs=kwargs,
     )
 
@@ -55,70 +54,72 @@ def _make_message(task_name: str, kwargs: dict) -> SQSLambdaTaskMessage:
 
 class TestTaskLoggerProcess:
     def setup_method(self):
-        task_logger.invocation_id = None
+        task_logger.message_id = None
 
     def teardown_method(self):
-        task_logger.invocation_id = None
+        task_logger.message_id = None
 
-    def test_prefixes_message_when_invocation_id_set(self):
-        task_logger.invocation_id = "abc-123"
+    def test_prefixes_message_when_message_id_set(self):
+        task_logger.message_id = "abc-123"
         msg, _ = task_logger.process("hello", {})
         assert msg == "[abc-123] hello"
 
-    def test_no_prefix_when_invocation_id_is_none(self):
-        task_logger.invocation_id = None
+    def test_no_prefix_when_message_id_is_none(self):
+        task_logger.message_id = None
         msg, _ = task_logger.process("hello", {})
         assert msg == "hello"
 
     def test_kwargs_passed_through_unchanged(self):
-        task_logger.invocation_id = "x"
+        task_logger.message_id = "x"
         extra = {"exc_info": True}
         _, returned_kwargs = task_logger.process("msg", extra)
         assert returned_kwargs is extra
 
 
 # ---------------------------------------------------------------------------
-# Tests: invocation_id lifecycle in execute_task
+# Tests: message_id lifecycle in execute_task
 # ---------------------------------------------------------------------------
 
 
 @pytest.mark.django_db(transaction=True)
 class TestTaskLoggerLifecycle:
-    def test_invocation_id_cleared_after_success(self):
+    def test_message_id_cleared_after_success(self):
         msg = _make_message(_task_name(_logging_task_success), {"value": 1})
         with patch("lambda_tasks.models.TimeoutContext"):
-            msg.execute_immediately()
-        assert task_logger.invocation_id is None
+            msg.execute_immediately(message_id=str(uuid.uuid4()))
+        assert task_logger.message_id is None
 
-    def test_invocation_id_cleared_after_failure(self):
+    def test_message_id_cleared_after_failure(self):
 
         msg = _make_message(_task_name(_logging_task_failure), {"value": 2})
         with patch("lambda_tasks.models.TimeoutContext"):
-            msg.execute_immediately()
-        assert task_logger.invocation_id is None
+            msg.execute_immediately(message_id=str(uuid.uuid4()))
+        assert task_logger.message_id is None
 
-    def test_log_records_during_task_carry_invocation_id(self, caplog):
+    def test_log_records_during_task_carry_message_id(self, caplog):
 
         msg = _make_message(_task_name(_logging_task_success), {"value": 7})
+        message_id = str(uuid.uuid4())
         with patch("lambda_tasks.models.TimeoutContext"):
             with caplog.at_level(logging.INFO, logger="lambda_tasks.task"):
-                msg.execute_immediately()
+                msg.execute_immediately(message_id=message_id)
 
         task_messages = [
             r.message for r in caplog.records if "inside task" in r.message
         ]
         assert len(task_messages) == 1
-        assert f"[{msg.invocation_id}]" in task_messages[0]
+        assert f"[{message_id}]" in task_messages[0]
 
-    def test_log_records_on_failure_carry_invocation_id(self, caplog):
+    def test_log_records_on_failure_carry_message_id(self, caplog):
 
         msg = _make_message(_task_name(_logging_task_failure), {"value": 3})
+        message_id = str(uuid.uuid4())
         with patch("lambda_tasks.models.TimeoutContext"):
             with caplog.at_level(logging.INFO, logger="lambda_tasks.task"):
-                msg.execute_immediately()
+                msg.execute_immediately(message_id=message_id)
 
         task_messages = [
             r.message for r in caplog.records if "about to fail" in r.message
         ]
         assert len(task_messages) == 1
-        assert f"[{msg.invocation_id}]" in task_messages[0]
+        assert f"[{message_id}]" in task_messages[0]