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

{django_lambda_tasks-0.1.0 → 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.0 → 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.0 → 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`
@@ -121,13 +121,13 @@ class SQSLambdaTaskMessage(BaseModel):
 
 `resolve_secrets_into_env()` in `secret_loader.py` runs once at Lambda cold start, before `django.setup()`.
 
-Any env var prefixed `AWS_SECRETS_MANAGER_` is treated as a Secrets Manager reference. The unprefixed name is the target env var.
+Any env var prefixed `LAMBDA_TASKS_SECRET_` is treated as a Secrets Manager reference. The unprefixed name is the target env var.
 
 Required format: `<arn>:<json-key>:<version-stage>:<version-id>` (10 colon-separated segments, all fields non-empty).
 
 Behaviour:
 - All references are validated before any AWS call — malformed references raise `ValueError` immediately
-- Setting both `AWS_SECRETS_MANAGER_FOO` and `FOO` is a configuration error and raises `ValueError`
+- Setting both `LAMBDA_TASKS_SECRET_FOO` and `FOO` is a configuration error and raises `ValueError`
 - Calls are batched by `(ARN, version-stage, version-id)` — one `GetSecretValue` per unique combination
 - Fetched secrets are cached in-process; warm invocations pay no extra cost
 
@@ -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.0 → django_lambda_tasks-0.1.2}/.kiro/steering/structure.md

@@ -17,7 +17,7 @@ django-lambda-tasks/
 │   ├── logging.py              # task_logger — invocation-scoped LoggerAdapter
 │   ├── models.py               # TaskRecord, SQSLambdaTaskMessage, SQSLambdaTask
 │   ├── settings.py             # LambdaTasksSettings (lazy Django settings reader)
-│   ├── secret_loader.py        # Resolves AWS_SECRETS_MANAGER_* env vars at cold start
+│   ├── secret_loader.py        # Resolves LAMBDA_TASKS_SECRET_* env vars at cold start
 │   ├── timeouts.py             # TimeoutContext implementation
 │   └── migrations/             # Django migrations for TaskRecord
 ├── tests/                      # pytest test suite
@@ -39,8 +39,8 @@ 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; calls `resolve_secrets_into_env()` then `django.setup()` at cold start; processes SQS records independently; returns `batchItemFailures`
-- `secret_loader.py` — resolves `AWS_SECRETS_MANAGER_*` 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
+- `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; `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.0/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:
 
@@ -393,15 +399,15 @@ Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and tha
 
 The Lambda handler supports loading secret values from AWS Secrets Manager into the environment before Django starts. This lets your Django settings file read from `os.environ` as normal while keeping secrets out of plaintext environment variables.
 
-Set any env var with the prefix `AWS_SECRETS_MANAGER_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
+Set any env var with the prefix `LAMBDA_TASKS_SECRET_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
 ```
 
 At cold start, before `django.setup()` is called, the handler calls `resolve_secrets_into_env()` which:
 
-1. Scans all env vars for the `AWS_SECRETS_MANAGER_` prefix
+1. Scans all env vars for the `LAMBDA_TASKS_SECRET_` prefix
 2. Validates every reference — malformed references raise immediately so the container fails to start rather than misconfiguring Django silently
 3. Groups references by `(ARN, version-stage, version-id)` and makes one `GetSecretValue` call per unique combination
 4. Extracts the named JSON key from the secret and writes it into `os.environ`
@@ -425,8 +431,8 @@ arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWS
 Multiple env vars can reference different keys from the same secret — only one `GetSecretValue` call is made for that `(ARN, version-stage, version-id)` combination:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
-AWS_SECRETS_MANAGER_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
 ```
 
 #### Validation errors
@@ -435,7 +441,7 @@ The following all raise `ValueError` at cold start, preventing the Lambda contai
 
 - Wrong number of colon-separated segments (must be exactly 10)
 - Empty `json-key`, `version-stage`, or `version-id`
-- Both `AWS_SECRETS_MANAGER_FOO` and `FOO` are set — use one or the other
+- Both `LAMBDA_TASKS_SECRET_FOO` and `FOO` are set — use one or the other
 - The named JSON key does not exist in the fetched secret
 - The secret value is not valid JSON
 

django_lambda_tasks-0.1.0/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.0
-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:
 
@@ -403,15 +389,15 @@ Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and tha
 
 The Lambda handler supports loading secret values from AWS Secrets Manager into the environment before Django starts. This lets your Django settings file read from `os.environ` as normal while keeping secrets out of plaintext environment variables.
 
-Set any env var with the prefix `AWS_SECRETS_MANAGER_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
+Set any env var with the prefix `LAMBDA_TASKS_SECRET_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
 ```
 
 At cold start, before `django.setup()` is called, the handler calls `resolve_secrets_into_env()` which:
 
-1. Scans all env vars for the `AWS_SECRETS_MANAGER_` prefix
+1. Scans all env vars for the `LAMBDA_TASKS_SECRET_` prefix
 2. Validates every reference — malformed references raise immediately so the container fails to start rather than misconfiguring Django silently
 3. Groups references by `(ARN, version-stage, version-id)` and makes one `GetSecretValue` call per unique combination
 4. Extracts the named JSON key from the secret and writes it into `os.environ`
@@ -435,8 +421,8 @@ arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWS
 Multiple env vars can reference different keys from the same secret — only one `GetSecretValue` call is made for that `(ARN, version-stage, version-id)` combination:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
-AWS_SECRETS_MANAGER_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
 ```
 
 #### Validation errors
@@ -445,7 +431,7 @@ The following all raise `ValueError` at cold start, preventing the Lambda contai
 
 - Wrong number of colon-separated segments (must be exactly 10)
 - Empty `json-key`, `version-stage`, or `version-id`
-- Both `AWS_SECRETS_MANAGER_FOO` and `FOO` are set — use one or the other
+- Both `LAMBDA_TASKS_SECRET_FOO` and `FOO` are set — use one or the other
 - The named JSON key does not exist in the fetched secret
 - The secret value is not valid JSON
 

{django_lambda_tasks-0.1.0 → 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.0 → 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.0 → django_lambda_tasks-0.1.2}/lambda_tasks/handler.py

@@ -10,16 +10,15 @@ import logging
 import os
 
 import django
-from django.apps import apps as django_apps
+from django.apps import apps
 
-from lambda_tasks.models import SQSLambdaTaskMessage
 from lambda_tasks.secret_loader import resolve_secrets_into_env
 
 # Cold-start Django setup — runs once per Lambda container.
 # Secrets are resolved first so Django settings can reference the populated
-# env vars.  resolve_secrets_into_env() is idempotent and caches fetched
+# env vars. resolve_secrets_into_env() is idempotent and caches fetched
 # secrets in-process, so subsequent invocations pay no extra cost.
-if os.environ.get("DJANGO_SETTINGS_MODULE") and not django_apps.ready:
+if os.environ.get("DJANGO_SETTINGS_MODULE") and not apps.ready:
     resolve_secrets_into_env()
     django.setup()
 
@@ -32,13 +31,16 @@ def handler(*, event: dict, context: object) -> dict:
 
     Returns a partial-batch failure report so AWS only re-drives failed records.
     """
+    # Local import due to AppRegistryNotReady
+    from lambda_tasks.models import SQSLambdaTaskMessage
+
     batch_item_failures: list[dict] = []
 
     for record in event["Records"]:
         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.0 → 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.0 → 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.0 → 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.0 → django_lambda_tasks-0.1.2}/lambda_tasks/secret_loader.py

@@ -1,14 +1,14 @@
 """
 Resolves environment variables that reference AWS Secrets Manager ARNs.
 
-Any env var prefixed with ``AWS_SECRETS_MANAGER_`` is treated as a pointer
+Any env var prefixed with ``LAMBDA_TASKS_SECRET_`` is treated as a pointer
 to a secret value.  The unprefixed name is the target env var to populate.
 
 Required value format
 ---------------------
 Every reference must follow the full dynamic reference syntax::
 
-    AWS_SECRETS_MANAGER_DJANGO_ADMIN_URL=arn:aws:secretsmanager:eu-west-1:123:secret:my-secret:DJANGO_ADMIN_URL:AWSCURRENT:v1
+    LAMBDA_TASKS_SECRET_DJANGO_ADMIN_URL=arn:aws:secretsmanager:eu-west-1:123:secret:my-secret:DJANGO_ADMIN_URL:AWSCURRENT:v1
 
 That is: ``<arn>:<json-key>:<version-stage>:<version-id>``
 
@@ -16,7 +16,7 @@ All four suffix segments must be present and non-empty.
 A malformed reference raises ``ValueError`` immediately so the Lambda
 container fails at cold start rather than silently misconfiguring Django.
 
-It is a configuration error to set both ``AWS_SECRETS_MANAGER_FOO`` and
+It is a configuration error to set both ``LAMBDA_TASKS_SECRET_FOO`` and
 ``FOO`` — use one or the other.  Having both raises ``ValueError`` at cold
 start so the misconfiguration is caught immediately.
 
@@ -35,7 +35,7 @@ import boto3
 
 logger = logging.getLogger(__name__)
 
-_PREFIX = "AWS_SECRETS_MANAGER_"
+_PREFIX = "LAMBDA_TASKS_SECRET_"
 
 # Module-level cache: (arn, version_stage, version_id) → raw secret string.
 # Populated on first call; reused for the lifetime of the Lambda container.
@@ -128,14 +128,14 @@ def _fetch_secret(*, client: object, ref: _SecretReference) -> dict[str, str]:
 
 
 def resolve_secrets_into_env() -> None:
-    """Scan env vars for ``AWS_SECRETS_MANAGER_*`` references and resolve them.
+    """Scan env vars for ``LAMBDA_TASKS_SECRET_*`` references and resolve them.
 
     For each matching env var the resolved value is written back into
     ``os.environ`` under the unprefixed name.
 
     Raises ``ValueError`` at cold start if:
     - A reference is malformed (wrong segment count, any empty field)
-    - The target env var is already set — use ``AWS_SECRETS_MANAGER_FOO`` or
+    - The target env var is already set — use ``LAMBDA_TASKS_SECRET_FOO`` or
       ``FOO``, not both
 
     This function is idempotent — calling it multiple times is safe and cheap
@@ -157,7 +157,7 @@ def resolve_secrets_into_env() -> None:
     if conflicts:
         raise ValueError(
             "The following environment variables are set both directly and via "
-            f"AWS_SECRETS_MANAGER_*: {', '.join(sorted(conflicts))}. "
+            f"LAMBDA_TASKS_SECRET_*: {', '.join(sorted(conflicts))}. "
             "Use one or the other, not both."
         )
 

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

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

{django_lambda_tasks-0.1.0 → 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.0 → 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"