django-lambda-tasks 0.10.0__tar.gz → 0.11.0__tar.gz

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/.kiro/steering/product.md

@@ -127,7 +127,7 @@ class SQSLambdaTaskMessage(BaseModel):
 
 ## Execution
 
-`SQSLambdaTaskMessage.execute_immediately(*, message_id: str)` in `models.py`:
+`SQSLambdaTaskMessage.execute_immediately(*, message_id: str)` in `models.py` sets the `task_logger` `message_id` and enters `task_scope(...)` (Sentry transaction name + tags), then delegates the run to the private `_run(*, message_id)` method which:
 1. Checks for an existing `TaskRecord` with the same `pk` (`message_id`) 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), validated against queue max (900 for SQS, 3600 for Batch)
@@ -313,6 +313,24 @@ def my_task(*, user_id: int) -> None:
 
 `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.
 
+## Sentry
+
+The library does not call `sentry_sdk.init(...)` — the host application owns Sentry setup (typically `DjangoIntegration` + `AwsLambdaIntegration`). The problem those integrations leave is attribution: on Lambda, `AwsLambdaIntegration` names every event's transaction after the Lambda function, so all tasks share one transaction (and a single invocation-level transaction is shared across a batch of SQS records); on AWS Batch there is no request and no Lambda integration, so the transaction and URL are `"--"` and `traces_sample_rate` produces no trace for the task body. Either way you cannot tell which task ran or raised.
+
+`lambda_tasks.sentry.task_scope(*, task_name, message_id, n_retries)` fixes this. `execute_immediately` wraps the task body in it, which — when a Sentry client is active — opens an isolated `sentry_sdk.new_scope()` **and a per-task root span/transaction** named after the task. This gives one trace per task on both Lambda and Batch. It records, both on the span and as scope tags:
+
+- transaction/span **name** = the fully-qualified task name (e.g. `myapp.tasks.my_task`)
+- `lambda_task` = task name
+- `lambda_task.message_id` = the `TaskRecord` primary key
+- `lambda_task.n_retries` = the retry counter
+- `lambda_task.runtime` = the physical execution environment, read from the AWS environment: `AWS_LAMBDA_FUNCTION_NAME` on Lambda or `AWS_BATCH_JQ_NAME` (the Batch job queue name) on Batch; omitted when neither is present
+
+The scope covers the success, retry, and failure paths, so task-logic exceptions (which the executor records as `FAILED` and does not re-raise to the handler) still carry the task name when captured by Sentry. The scope tags are kept in addition to span metadata so error events are attributed even when the performance span is not sampled.
+
+**SDK version compatibility:** `task_scope` is future-proof across the sentry-sdk 2.x→3.0 boundary. On 2.x it uses `start_transaction` + `set_tag` (a root span must be a transaction to be sent); on 3.0 (stream mode, where transactions are removed and tags no longer propagate to spans) it uses `start_span` + `set_attribute`. The correct API is detected at runtime via `hasattr`, so no code change is needed when the host upgrades the SDK.
+
+`task_scope` is a no-op when `sentry_sdk` is not installed or no client is initialised, so Sentry is not a dependency of the library. `sentry-sdk` is a dev dependency only, for the test suite. No custom Sentry integration is needed — per-task tracing at the one execution entry point covers both Lambda and Batch.
+
 ## Built-in Tasks
 
 `lambda_tasks.tasks` provides maintenance tasks that ship with the library:

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/.kiro/steering/structure.md

@@ -16,6 +16,7 @@ django-lambda-tasks/
 │   ├── decorators.py           # LambdaTaskWrapper, @lambda_task
 │   ├── handler.py              # AWS Lambda entry point + AWS Batch container entry point (main)
 │   ├── logging.py              # task_logger — invocation-scoped LoggerAdapter
+│   ├── sentry.py               # task_scope — per-task Sentry transaction name + tags
 │   ├── models.py               # TaskRecord, SQSLambdaTaskMessage, SQSLambdaTask
 │   ├── settings.py             # LambdaTasksSettings, constants, queue type helpers
 │   ├── secret_loader.py        # Resolves LAMBDA_TASKS_SECRET_* env vars at cold start
@@ -41,12 +42,13 @@ django-lambda-tasks/
 ## Module Responsibilities
 
 - `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`)
+- `models.py` — `TaskRecord` (Django ORM), `SQSLambdaTaskMessage` (Pydantic, SQS schema + execution logic; `execute_immediately` owns the logging + Sentry context and delegates the run to a private `_run` method), `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; 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
+- `sentry.py` — `task_scope` context manager; opens an isolated `new_scope` and a per-task root span/transaction named after the task, so both errors and performance traces are attributed per task (one trace per task on Lambda and Batch, not one invocation-level transaction shared across an SQS batch). Records `lambda_task` / `lambda_task.message_id` / `lambda_task.n_retries` / `lambda_task.runtime` as span metadata and scope tags; `lambda_task.runtime` is the execution environment read from `AWS_LAMBDA_FUNCTION_NAME` (Lambda) or `AWS_BATCH_JQ_NAME` (Batch). Future-proof across the SDK 2.x→3.0 boundary: it uses `start_transaction`+`set_tag` on 2.x and `start_span`+`set_attribute` on 3.0 (stream mode), detected at runtime via `hasattr`. A no-op when `sentry_sdk` is absent or uninitialised, so the library has no hard dependency on Sentry (`sentry-sdk` is a dev dependency only). Wrapped around the task body in `SQSLambdaTaskMessage.execute_immediately`
 - `settings.py` — constants (`MAX_DELAY`, `MAX_TIMEOUT`, `MAX_BATCH_TIMEOUT`); `_is_sqs_queue()` and `_is_batch_queue()` helpers; `LambdaTasksSettings` instantiated fresh per use (reads live Django settings); `queue_max_timeout()` method returns 900 or 3600 based on queue type
 - `admin.py` — Django admin registration for `TaskRecord`
 - `apps.py` — Django `AppConfig`; `ready()` imports `checks` to register deployment checks and installs the local-executor shutdown signal handlers when `LOCAL_WORKERS > 0`

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/.kiro/steering/tech.md

@@ -23,6 +23,7 @@ inclusion: always
 |---|---|---|
 | `pytest` | `>= 9.0.2` | Test runner |
 | `hypothesis` | present | Property-based testing (`.hypothesis/` directory exists) |
+| `sentry-sdk` | present | Testing the `task_scope` Sentry integration; not a runtime dependency |
 
 ## Package Manager
 

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: django-lambda-tasks
-Version: 0.10.0
+Version: 0.11.0
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.11
 Requires-Dist: awslambdaric
@@ -444,6 +444,32 @@ fields @timestamp, @message
 | sort @timestamp asc
 ```
 
+### Sentry
+
+If your application uses Sentry, tasks are automatically attributed to their task name. Without this, Sentry's `AwsLambdaIntegration` names every event's transaction after the Lambda function (so all tasks share one transaction), and on AWS Batch there is no transaction at all (it shows as `"--"`) — so you cannot tell which task raised an error.
+
+You do **not** need to add a custom integration or change your `sentry_sdk.init(...)`. Keep your existing setup:
+
+```python
+sentry_sdk.init(
+    dsn=SENTRY_DSN,
+    integrations=[DjangoIntegration(), AwsLambdaIntegration()],
+    # ...
+)
+```
+
+When a task runs, `execute_immediately()` opens an isolated Sentry scope **and a per-task trace** (a root span/transaction named after the task). With `traces_sample_rate` set, you get one trace per task on both Lambda and Batch — rather than a single invocation-level transaction shared across a batch of SQS records. It sets, on both the span and the scope:
+
+- the **transaction/span name** to the fully-qualified task name (e.g. `myapp.tasks.send_welcome_email`), overriding the Lambda function name on Lambda and replacing `"--"` on Batch
+- `lambda_task` (task name), `lambda_task.message_id`, and `lambda_task.n_retries`
+- `lambda_task.runtime` — the physical execution environment, derived from the AWS environment: the Lambda function name (`AWS_LAMBDA_FUNCTION_NAME`) on Lambda, or the Batch job queue name (`AWS_BATCH_JQ_NAME`) on Batch. Omitted when neither is set (e.g. local/eager execution).
+
+This covers task failures too: the executor records failures as `FAILED` `TaskRecord`s rather than re-raising, so the trace wraps the task body to ensure Sentry error events still carry the task name.
+
+The integration is future-proof across the sentry-sdk 2.x→3.0 boundary: it uses `start_transaction`/`set_tag` on 2.x and `start_span`/`set_attribute` on 3.0 (stream mode), chosen automatically at runtime — no change needed when you upgrade the SDK.
+
+`sentry_sdk` is not a dependency of this library — if it is not installed or not initialised, the enrichment is a silent no-op.
+
 ---
 
 ## Automatic retries

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/README.md

@@ -432,6 +432,32 @@ fields @timestamp, @message
 | sort @timestamp asc
 ```
 
+### Sentry
+
+If your application uses Sentry, tasks are automatically attributed to their task name. Without this, Sentry's `AwsLambdaIntegration` names every event's transaction after the Lambda function (so all tasks share one transaction), and on AWS Batch there is no transaction at all (it shows as `"--"`) — so you cannot tell which task raised an error.
+
+You do **not** need to add a custom integration or change your `sentry_sdk.init(...)`. Keep your existing setup:
+
+```python
+sentry_sdk.init(
+    dsn=SENTRY_DSN,
+    integrations=[DjangoIntegration(), AwsLambdaIntegration()],
+    # ...
+)
+```
+
+When a task runs, `execute_immediately()` opens an isolated Sentry scope **and a per-task trace** (a root span/transaction named after the task). With `traces_sample_rate` set, you get one trace per task on both Lambda and Batch — rather than a single invocation-level transaction shared across a batch of SQS records. It sets, on both the span and the scope:
+
+- the **transaction/span name** to the fully-qualified task name (e.g. `myapp.tasks.send_welcome_email`), overriding the Lambda function name on Lambda and replacing `"--"` on Batch
+- `lambda_task` (task name), `lambda_task.message_id`, and `lambda_task.n_retries`
+- `lambda_task.runtime` — the physical execution environment, derived from the AWS environment: the Lambda function name (`AWS_LAMBDA_FUNCTION_NAME`) on Lambda, or the Batch job queue name (`AWS_BATCH_JQ_NAME`) on Batch. Omitted when neither is set (e.g. local/eager execution).
+
+This covers task failures too: the executor records failures as `FAILED` `TaskRecord`s rather than re-raising, so the trace wraps the task body to ensure Sentry error events still carry the task name.
+
+The integration is future-proof across the sentry-sdk 2.x→3.0 boundary: it uses `start_transaction`/`set_tag` on 2.x and `start_span`/`set_attribute` on 3.0 (stream mode), chosen automatically at runtime — no change needed when you upgrade the SDK.
+
+`sentry_sdk` is not a dependency of this library — if it is not installed or not initialised, the enrichment is a silent no-op.
+
 ---
 
 ## Automatic retries

django_lambda_tasks-0.11.0/example/example_app/tasks.py

@@ -0,0 +1,31 @@
+from time import sleep
+
+from lambda_tasks.decorators import lambda_task
+from lambda_tasks.logging import task_logger
+
+
+@lambda_task()
+def greet(*, name: str) -> str:
+    """A successful task — produces one per-task Sentry transaction named
+    ``example_app.tasks.greet``."""
+    task_logger.info(f"Running greet with: {name=}")
+
+    for ii in range(3):
+        task_logger.info(f"Sleeping: {ii=}")
+        sleep(1)
+
+    try:
+        raise RuntimeError("testing")
+    except Exception:
+        task_logger.error("Raising", exc_info=True)
+
+    return f"Hello, {name}!"
+
+
+@lambda_task()
+def boom(*, name: str) -> str:
+    """A failing task — the executor records it as a FAILED TaskRecord and the
+    error is reported to Sentry attributed to ``example_app.tasks.boom`` (not
+    the Lambda function name), inside its own per-task trace."""
+    task_logger.info(f"Running boom with: {name=}")
+    raise RuntimeError(f"boom for {name}")

django_lambda_tasks-0.11.0/example/example_app/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+from example_app.views import trigger, trigger_error
+
+urlpatterns = [
+    path("trigger/", trigger),
+    path("trigger-error/", trigger_error),
+]

django_lambda_tasks-0.11.0/example/example_app/views.py

@@ -0,0 +1,17 @@
+from django.http import HttpRequest, HttpResponse
+from example_app.tasks import boom, greet
+
+
+def trigger(request: HttpRequest) -> HttpResponse:
+    """Enqueue the successful task — produces a per-task Sentry transaction."""
+    name = request.GET.get("name", "world")
+    greet.execute_on_commit(name=name)
+    return HttpResponse(f"greet task triggered for: {name}")
+
+
+def trigger_error(request: HttpRequest) -> HttpResponse:
+    """Enqueue the failing task — produces a Sentry error attributed to the
+    task name, inside its own per-task trace."""
+    name = request.GET.get("name", "world")
+    boom.execute_on_commit(name=name)
+    return HttpResponse(f"boom task triggered for: {name}")

django_lambda_tasks-0.11.0/example/example_project/sentry.py

@@ -0,0 +1,50 @@
+"""Optional Sentry initialisation for the example app.
+
+Demonstrates how a host application wires Sentry so that
+``django-lambda-tasks`` can attribute per-task traces and errors. This mirrors
+a typical production ``sentry_sdk.init(...)`` (Django + AWS Lambda integrations
+and tracing), but is driven entirely by environment variables so the example
+runs with or without Sentry configured.
+
+``init_sentry()`` is called from ``settings.py`` at import time. Because the
+local process-pool workers call ``django.setup()`` (which imports settings) in
+each child process, this runs in the web process *and* in every task worker —
+which is exactly what is needed for the per-task trace to be captured where the
+task actually executes.
+"""
+
+import logging
+import os
+
+
+def init_sentry() -> None:
+    """Initialise Sentry if ``SENTRY_DSN`` is set; otherwise do nothing.
+
+    Idempotent enough for the example's purposes: ``sentry_sdk.init`` is safe to
+    call once per process, and this is only invoked from settings import.
+    """
+    dsn = os.environ.get("SENTRY_DSN")
+    if not dsn:
+        return
+
+    import sentry_sdk
+    from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
+    from sentry_sdk.integrations.django import DjangoIntegration
+    from sentry_sdk.integrations.logging import LoggingIntegration
+
+    sentry_sdk.init(
+        dsn=dsn,
+        integrations=[
+            DjangoIntegration(),
+            AwsLambdaIntegration(),
+            # On sentry-sdk 2.x the logging integration defaulted to
+            # event_level=ERROR, so logger.error(...) calls (e.g. task_logger)
+            # became Sentry events automatically. On 3.0 the default is None, so
+            # error logs no longer surface as events. Set it explicitly so
+            # task_logger.error output appears in Sentry on both SDK versions.
+            LoggingIntegration(event_level=logging.ERROR),
+        ],
+        # Sample every transaction so the per-task trace is always sent while
+        # you are testing. Lower this in a real deployment.
+        traces_sample_rate=float(os.environ.get("SENTRY_TRACES_SAMPLE_RATE", "1.0")),
+    )

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/example/example_project/settings.py

@@ -88,3 +88,10 @@ LOGGING = {
         "level": "INFO",
     },
 }
+
+# Optional Sentry integration — set SENTRY_DSN to enable. Initialised here (at
+# settings import) so it also runs inside each local process-pool worker, which
+# imports settings via django.setup(). See example_project/sentry.py.
+from example_project.sentry import init_sentry  # noqa: E402
+
+init_sentry()

{django_lambda_tasks-0.10.0 → django_lambda_tasks-0.11.0}/lambda_tasks/models.py

@@ -21,6 +21,7 @@ from redis.exceptions import LockError
 
 from lambda_tasks.local_executor import submit_task
 from lambda_tasks.logging import task_logger
+from lambda_tasks.sentry import capture_task_exception, task_scope
 from lambda_tasks.settings import (
     MAX_DELAY,
     BatchQueueConfig,
@@ -112,151 +113,170 @@ class SQSLambdaTaskMessage(BaseModel):
         Creates a TaskRecord, resolves timeouts, validates configuration,
         runs the task inside an atomic block with timeout enforcement, and
         persists the outcome.
+
+        Logging and Sentry context are scoped to the task for the duration of
+        the run so that exceptions are attributed to the task name rather than
+        to the Lambda function name or, on AWS Batch, to nothing at all.
         """
         task_logger.message_id = message_id
 
         try:
-            task_logger.info(f"Received {self.task_name}")
+            with task_scope(
+                task_name=self.task_name,
+                message_id=message_id,
+                n_retries=self.n_retries,
+            ):
+                self._run(message_id=message_id)
+        finally:
+            task_logger.message_id = None
 
-            # Local import to avoid circular dependency
-            from lambda_tasks.decorators import LambdaTaskWrapper
+    def _run(self, *, message_id: str) -> None:
+        """Resolve, run, and persist the outcome of the task.
 
-            wrapper = import_string(self.task_name)
+        Separated from :meth:`execute_immediately` so that the latter owns only
+        the logging and Sentry context management; this method holds the
+        execution logic and its early returns.
+        """
+        task_logger.info(f"Received {self.task_name}")
 
-            if not isinstance(wrapper, LambdaTaskWrapper):
-                raise TypeError(
-                    f"import_string('{self.task_name}') returned {type(wrapper)!r}, "
-                    f"expected LambdaTaskWrapper."
-                )
+        # Local import to avoid circular dependency
+        from lambda_tasks.decorators import LambdaTaskWrapper
 
-            # Resolve before creating the TaskRecord — ConfigurationError here means
-            # misconfigured settings, not a task failure, so no record should be written.
-            soft_timeout, hard_timeout = wrapper.resolved_timeouts
-
-            record, created = (
-                TaskRecord.objects.get_or_create(  # ty: ignore[unresolved-attribute]
-                    pk=message_id,
-                    defaults={
-                        "task_name": self.task_name,
-                        "kwargs": self.model_dump(mode="json")["kwargs"],
-                        "n_retries": self.n_retries,
-                        "status": TaskStatus.RUNNING,
-                        "start_time": now(),
-                    },
-                )
+        wrapper = import_string(self.task_name)
+
+        if not isinstance(wrapper, LambdaTaskWrapper):
+            raise TypeError(
+                f"import_string('{self.task_name}') returned {type(wrapper)!r}, "
+                f"expected LambdaTaskWrapper."
             )
 
-            if not created:
-                task_logger.warning(
-                    f"Skipping duplicate delivery (existing record status={record.status})"
-                )
-                return
+        # Resolve before creating the TaskRecord — ConfigurationError here means
+        # misconfigured settings, not a task failure, so no record should be written.
+        soft_timeout, hard_timeout = wrapper.resolved_timeouts
+
+        record, created = (
+            TaskRecord.objects.get_or_create(  # ty: ignore[unresolved-attribute]
+                pk=message_id,
+                defaults={
+                    "task_name": self.task_name,
+                    "kwargs": self.model_dump(mode="json")["kwargs"],
+                    "n_retries": self.n_retries,
+                    "status": TaskStatus.RUNNING,
+                    "start_time": now(),
+                },
+            )
+        )
 
-            ignored_exception: BaseException | None = None
-            ignored_traceback: str | None = None
-            result = None
+        if not created:
+            task_logger.warning(
+                f"Skipping duplicate delivery (existing record status={record.status})"
+            )
+            return
 
-            if wrapper.singleton:
-                cache = caches[LambdaTasksSettings().SINGLETON_CACHE]
-                lock_ctx = cache.lock(
-                    f"lambda_tasks.singleton_lock.{self.task_name}",
-                    blocking_timeout=0,
-                    timeout=hard_timeout,
-                )
-                if wrapper.retry_singleton:
-                    effective_retry_on = (LockError, *wrapper.retry_on)
-                else:
-                    effective_retry_on = wrapper.retry_on
+        ignored_exception: BaseException | None = None
+        ignored_traceback: str | None = None
+        result = None
+
+        if wrapper.singleton:
+            cache = caches[LambdaTasksSettings().SINGLETON_CACHE]
+            lock_ctx = cache.lock(
+                f"lambda_tasks.singleton_lock.{self.task_name}",
+                blocking_timeout=0,
+                timeout=hard_timeout,
+            )
+            if wrapper.retry_singleton:
+                effective_retry_on = (LockError, *wrapper.retry_on)
             else:
-                lock_ctx = contextlib.nullcontext()
                 effective_retry_on = wrapper.retry_on
+        else:
+            lock_ctx = contextlib.nullcontext()
+            effective_retry_on = wrapper.retry_on
 
-            try:
-                with lock_ctx:
-                    with transaction.atomic():
-                        with TimeoutContext(
-                            soft_timeout=soft_timeout, hard_timeout=hard_timeout
-                        ):
-                            result = wrapper(**self.kwargs)
-            except Exception as error:
-                if (
-                    wrapper.singleton
-                    and not wrapper.retry_singleton
-                    and isinstance(error, LockError)
-                ):
-                    ignored_exception = error
-                    ignored_traceback = traceback.format_exc()
-                elif effective_retry_on and isinstance(error, effective_retry_on):
-                    conf = LambdaTasksSettings()
-                    if self.n_retries >= conf.MAX_RETRIES:
-                        record.status = TaskStatus.FAILED
-                        record.traceback = traceback.format_exc()
-                        record.end_time = now()
-                        record.save(update_fields=["status", "traceback", "end_time"])
-
-                        task_logger.warning(
-                            f"Failed due to MaxRetriesExceededError in {record.duration}"
-                        )
-
-                        raise MaxRetriesExceededError(
-                            task_name=self.task_name, n_retries=self.n_retries
-                        )
-                    else:
-                        record.status = TaskStatus.RETRIED
-                        record.traceback = traceback.format_exc()
-                        record.end_time = now()
-                        record.save(update_fields=["status", "traceback", "end_time"])
-
-                        task_logger.warning(
-                            f"Retrying (due to {type(error).__name__}) after {record.duration}"
-                        )
-
-                        delay = min(
-                            wrapper.retry_delay + round(random.uniform(1, 5)), MAX_DELAY
-                        )
-
-                        retry_task = SQSLambdaTask(
-                            message=SQSLambdaTaskMessage(
-                                task_name=self.task_name,
-                                kwargs=self.kwargs,
-                                n_retries=self.n_retries + 1,
-                            ),
-                            delay=delay,
-                            queue=wrapper.queue,
-                        )
-                        retry_task.execute_on_commit()
-
-                        return
-                else:
-                    task_logger.error(error, exc_info=True)
-
+        try:
+            with lock_ctx:
+                with transaction.atomic():
+                    with TimeoutContext(
+                        soft_timeout=soft_timeout, hard_timeout=hard_timeout
+                    ):
+                        result = wrapper(**self.kwargs)
+        except Exception as error:
+            if (
+                wrapper.singleton
+                and not wrapper.retry_singleton
+                and isinstance(error, LockError)
+            ):
+                ignored_exception = error
+                ignored_traceback = traceback.format_exc()
+            elif effective_retry_on and isinstance(error, effective_retry_on):
+                conf = LambdaTasksSettings()
+                if self.n_retries >= conf.MAX_RETRIES:
+                    capture_task_exception()
                     record.status = TaskStatus.FAILED
                     record.traceback = traceback.format_exc()
                     record.end_time = now()
                     record.save(update_fields=["status", "traceback", "end_time"])
 
-                    task_logger.warning(f"Failed in {record.duration}")
-                    return
+                    task_logger.warning(
+                        f"Failed due to MaxRetriesExceededError in {record.duration}"
+                    )
 
-            if ignored_exception is None:
-                record.status = TaskStatus.SUCCEEDED
-                record.result = result
-                record.end_time = now()
-                record.save(update_fields=["status", "result", "end_time"])
+                    raise MaxRetriesExceededError(
+                        task_name=self.task_name, n_retries=self.n_retries
+                    )
+                else:
+                    record.status = TaskStatus.RETRIED
+                    record.traceback = traceback.format_exc()
+                    record.end_time = now()
+                    record.save(update_fields=["status", "traceback", "end_time"])
 
-                task_logger.info(f"Succeeded in {record.duration}")
+                    task_logger.warning(
+                        f"Retrying (due to {type(error).__name__}) after {record.duration}"
+                    )
+
+                    delay = min(
+                        wrapper.retry_delay + round(random.uniform(1, 5)), MAX_DELAY
+                    )
+
+                    retry_task = SQSLambdaTask(
+                        message=SQSLambdaTaskMessage(
+                            task_name=self.task_name,
+                            kwargs=self.kwargs,
+                            n_retries=self.n_retries + 1,
+                        ),
+                        delay=delay,
+                        queue=wrapper.queue,
+                    )
+                    retry_task.execute_on_commit()
+
+                    return
             else:
-                record.status = TaskStatus.SUCCEEDED
-                record.traceback = ignored_traceback
+                task_logger.error(error, exc_info=True)
+
+                capture_task_exception()
+                record.status = TaskStatus.FAILED
+                record.traceback = traceback.format_exc()
                 record.end_time = now()
                 record.save(update_fields=["status", "traceback", "end_time"])
 
-                task_logger.info(
-                    f"Succeeded (ignored {type(ignored_exception).__name__}) in {record.duration}"
-                )
+                task_logger.warning(f"Failed in {record.duration}")
+                return
 
-        finally:
-            task_logger.message_id = None
+        if ignored_exception is None:
+            record.status = TaskStatus.SUCCEEDED
+            record.result = result
+            record.end_time = now()
+            record.save(update_fields=["status", "result", "end_time"])
+
+            task_logger.info(f"Succeeded in {record.duration}")
+        else:
+            record.status = TaskStatus.SUCCEEDED
+            record.traceback = ignored_traceback
+            record.end_time = now()
+            record.save(update_fields=["status", "traceback", "end_time"])
+
+            task_logger.info(
+                f"Succeeded (ignored {type(ignored_exception).__name__}) in {record.duration}"
+            )
 
 
 class SQSLambdaTask(BaseModel):