simple-module-background-tasks 0.0.40__tar.gz → 0.0.42__tar.gz

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_background_tasks
-Version: 0.0.40
+Version: 0.0.42
 Summary: Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -23,10 +23,10 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: celery[redis]<6,>=5.4
 Requires-Dist: redis<7,>=5
-Requires-Dist: simple-module-core==0.0.40
-Requires-Dist: simple-module-db==0.0.40
-Requires-Dist: simple-module-hosting==0.0.40
-Requires-Dist: simple-module-settings==0.0.40
+Requires-Dist: simple-module-core==0.0.42
+Requires-Dist: simple-module-db==0.0.42
+Requires-Dist: simple-module-hosting==0.0.42
+Requires-Dist: simple-module-settings==0.0.42
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/__init__.py

@@ -3,11 +3,14 @@
 from typing import TYPE_CHECKING, Any
 
 from background_tasks.after_commit import enqueue_after_commit
+from background_tasks.constants import SM_TRACKING_HEADER
 from background_tasks.log_context import (
     bind_task_context,
     get_log_context,
     install_log_filter,
 )
+from background_tasks.task_resource import with_task_resource
+from background_tasks.tracking import TrackingMode
 
 if TYPE_CHECKING:
     from background_tasks.task_heartbeat import heartbeat
@@ -30,10 +33,13 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
+    "SM_TRACKING_HEADER",
+    "TrackingMode",
     "bind_task_context",
     "enqueue_after_commit",
     "get_log_context",
     "heartbeat",
     "install_log_filter",
     "settings_for",
+    "with_task_resource",
 ]

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/_signal_support.py

@@ -13,13 +13,16 @@ from collections.abc import Callable
 from datetime import UTC, datetime
 from typing import Any
 
+from celery import current_app
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from background_tasks.constants import INTERNAL_TASK_SWEEP_OUTBOX, TaskStatus
 from background_tasks.models import TaskExecution
 from background_tasks.sync_db import sync_session
+from background_tasks.task_resource import message_resource
+from background_tasks.tenant_context import message_owner
+from background_tasks.tracking import records_signal, tracking_mode
 
 logger = logging.getLogger(__name__)
 
@@ -112,13 +115,6 @@ def render_traceback(einfo: Any, exception: BaseException | None) -> str | None:
     return None
 
 
-# Beat ticks that fire every few seconds and are a no-op almost every time;
-# recording each run buried real work (QA, GH #459). Only a run that went wrong
-# is worth a row.
-_UNRECORDED_WHEN_QUIET = frozenset({INTERNAL_TASK_SWEEP_OUTBOX})
-_QUIET_STATUSES = frozenset({None, TaskStatus.PENDING, TaskStatus.RUNNING, TaskStatus.SUCCESS})
-
-
 def apply_signal(
     handler: str,
     *,
@@ -127,6 +123,9 @@ def apply_signal(
     after: Callable[[TaskExecution], None] | None = None,
     tenant_id: str | None = None,
     owner_user_id: str | None = None,
+    task: Any = None,
+    request: Any = None,
+    headers: dict | None = None,
 ) -> TaskExecution | None:
     """Open a sync session, upsert by celery_task_id, log on failure.
 
@@ -136,12 +135,30 @@ def apply_signal(
     ``tenant_id`` and ``owner_user_id`` (the message's) are written only when
     known, so a signal whose message carries neither never blanks a row already
     stamped.
+
+    The task's tracking mode (:mod:`.tracking`) decides first whether this
+    signal is recorded at all. When it is, the row also takes args, kwargs,
+    queue, owner and resource from the message when ``defaults`` lack them, so
+    a worker can create the row itself when the publisher never did.
     """
-    if (
-        defaults.get("task_name") in _UNRECORDED_WHEN_QUIET
-        and defaults.get("status") in _QUIET_STATUSES
-    ):
+    name = defaults.get("task_name", "")
+    mode = tracking_mode(task=task, request=request, headers=headers, name=name)
+    app = getattr(task, "app", None) or current_app
+    if not records_signal(mode, handler, defaults.get("status"), app=app):
         return None
+    request = request if request is not None else getattr(task, "request", None)
+    if request is not None:
+        metadata = {}
+        if getattr(request, "args", None) is not None:
+            metadata["args"] = list(request.args)
+        if getattr(request, "kwargs", None) is not None:
+            metadata["kwargs"] = dict(request.kwargs)
+        delivery = getattr(request, "delivery_info", None) or {}
+        if delivery.get("routing_key"):
+            metadata["queue"] = delivery["routing_key"]
+        defaults = {**metadata, **defaults}
+        owner_user_id = owner_user_id or message_owner(request=request)
+    defaults = {**message_resource(headers=headers, request=request), **defaults}
     if tenant_id:
         defaults = {**defaults, "tenant_id": tenant_id}
     if owner_user_id:

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/celery_app.py

@@ -174,6 +174,8 @@ def build_celery(settings: BackgroundTasksSettings) -> Celery:
             beat_schedule[name] = entry
 
     celery.conf.update(
+        sm_execution_tracking=settings.execution_tracking,
+        sm_track_publish=settings.track_publish,
         broker_url=settings.broker_url,
         result_backend=settings.result_backend,
         task_default_queue=settings.task_default_queue,

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/constants.py

@@ -199,3 +199,9 @@ DEFAULT_LOG_RETENTION_DAYS = 7
 LOG_PER_PAGE = 50
 # Level names the admin filter offers, lowest first.
 LOG_LEVEL_NAMES = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
+
+# Message metadata shared by publishers and workers.
+SM_TRACKING_HEADER = "sm_tracking"
+SM_RESOURCE_TYPE_HEADER = "sm_resource_type"
+SM_RESOURCE_ID_HEADER = "sm_resource_id"
+RESOURCE_REF_MAX_LENGTH = 255

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/endpoints/api_status.py

@@ -1,8 +1,8 @@
-"""Owner-scoped task status (#536).
+"""Owner- and resource-scoped task status (#536, #709).
 
 Mounted apart from the admin router because it carries no ``PERM_VIEW`` gate:
-the person who started a job may follow it without being a task operator. It
-is marked ``Authenticated()`` (SM031); the ownership check lives in the
+owners and resource viewers may follow a job without being task operators. It
+is marked ``Authenticated()`` (SM031); the visibility check lives in the
 handler, and every refusal is a 404 so the route does not reveal which task
 ids exist.
 """
@@ -13,9 +13,12 @@ import re
 
 from fastapi import APIRouter, Depends, HTTPException, Request
 from simple_module_core.permissions import grants
+from simple_module_core.resources import ACTION_VIEW
 from simple_module_db import RequestSession, current_tenant_id
 from simple_module_db.deps import get_db
+from simple_module_db.resource_policy import load_authorized
 from simple_module_hosting.permissions import ensure_resolved_permissions
+from simple_module_hosting.resource_deps import resource_principal
 from simple_module_hosting.token_guard import Authenticated
 from sqlalchemy import select
 from sqlmodel import col
@@ -30,15 +33,28 @@ _TYPE_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_.]{0,254}")
 _NOT_FOUND = "Task not found"
 
 
-async def _visible(request: Request, row: TaskExecution, user_id: str) -> bool:
+async def _visible(request: Request, row: TaskExecution, user_id: str, db: RequestSession) -> bool:
     if grants(await ensure_resolved_permissions(request), PERM_VIEW):
         return True
-    if not row.owner_user_id or row.owner_user_id != user_id:
-        return False
-    if not bool(getattr(request.app.state.sm.settings, "multi_tenant", False)):
+    if bool(getattr(request.app.state.sm.settings, "multi_tenant", False)):
+        tenant_id = current_tenant_id.get()
+        if tenant_id is None or row.tenant_id != tenant_id:
+            return False
+    if row.owner_user_id and row.owner_user_id == user_id:
         return True
-    tenant_id = current_tenant_id.get()
-    return tenant_id is not None and row.tenant_id == tenant_id
+    if not row.resource_type or not row.resource_id:
+        return False
+    resource = request.app.state.sm.resource_types.get(row.resource_type)
+    if resource is None:
+        return False
+    try:
+        stmt = resource.select_by_id(row.resource_id)
+    except ValueError:
+        return False
+    obj, allowed = await load_authorized(
+        db, resource.policy, await resource_principal(request), ACTION_VIEW, stmt
+    )
+    return obj is not None and allowed
 
 
 @router.get(
@@ -62,7 +78,7 @@ async def get_task_status(
             .limit(1)
         )
     ).scalar_one_or_none()
-    if row is None or not await _visible(request, row, str(user.id)):
+    if row is None or not await _visible(request, row, str(user.id), db):
         raise HTTPException(status_code=404, detail=_NOT_FOUND)
     error = row.exception_type
     if error and not _TYPE_NAME.fullmatch(error):

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/models.py

@@ -9,7 +9,7 @@ from typing import Any, ClassVar
 from simple_module_db.base import create_module_base
 from simple_module_db.mixins import AuditMixin
 from simple_module_db.types import AwareDateTime
-from sqlalchemy import JSON, Column, Index, String
+from sqlalchemy import JSON, CheckConstraint, Column, Index, String
 from sqlmodel import Field
 
 from background_tasks.constants import (
@@ -22,6 +22,7 @@ from background_tasks.constants import (
     OWNER_ID_MAX_LENGTH,
     PROGRESS_MESSAGE_MAX_LENGTH,
     PROGRESS_PHASE_MAX_LENGTH,
+    RESOURCE_REF_MAX_LENGTH,
     TABLE_LOG_RECORD,
     TABLE_OUTBOX,
     TABLE_TASK_EXECUTION,
@@ -86,6 +87,11 @@ class TaskExecution(Base, AuditMixin, table=True):  # ty: ignore[unsupported-bas
     # publishes. It scopes who may read the task's status (#536).
     owner_user_id: str | None = Field(default=None, index=True, max_length=OWNER_ID_MAX_LENGTH)
 
+    # Optional resource this task is about (#709); lets viewers of that resource
+    # read the task's status. Both set or both null (check constraint below).
+    resource_type: str | None = Field(default=None, max_length=RESOURCE_REF_MAX_LENGTH)
+    resource_id: str | None = Field(default=None, max_length=RESOURCE_REF_MAX_LENGTH)
+
     # Progress the task body reports through ``heartbeat(progress=...)``.
     progress_current: int | None = None
     progress_total: int | None = None
@@ -118,6 +124,10 @@ class TaskExecution(Base, AuditMixin, table=True):  # ty: ignore[unsupported-bas
     heartbeat_at: datetime | None = None
 
     __table_args__ = (
+        CheckConstraint(
+            "(resource_type IS NULL) = (resource_id IS NULL)",
+            name="task_resource_pair",
+        ),
         Index(
             "ix_background_tasks_task_execution_status_queued",
             "status",

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/outbox_dispatch.py

@@ -41,7 +41,7 @@ from collections.abc import Sequence
 from datetime import datetime, timedelta
 from typing import Any
 
-from simple_module_core.durable_events import DurableContext, deserialize_event
+from simple_module_core.durable_events import IN_DELIVERY, DurableContext, deserialize_event
 from simple_module_core.events import EventBus
 from simple_module_db import is_valid_tenant_id
 from simple_module_db.callbacks import discard_on_commit_callbacks, run_on_commit_callbacks
@@ -166,7 +166,11 @@ async def deliver_one(
                     async with deadline:
                         with handler_guard(session):
                             ctx = DurableContext(db=session, attempt=row.attempts)
-                            await sub.handler(event, ctx)
+                            token = IN_DELIVERY.set(True)
+                            try:
+                                await sub.handler(event, ctx)
+                            finally:
+                                IN_DELIVERY.reset(token)
                 except TimeoutError as exc:
                     if not deadline.expired():
                         raise  # the handler's own timeout, not ours

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/outbox_transport.py

@@ -132,6 +132,8 @@ class OutboxTransport(_OutboxWriter):
         # Eager in-process deliveries still running (kept so they aren't
         # garbage-collected mid-flight, and so ``drain`` can await them).
         self._tasks: set[asyncio.Task[Any]] = set()
+        # Chained eager publishes must not share a StaticPool transaction (#655).
+        self._dispatch_lock = asyncio.Lock()
 
     def policy(self) -> OutboxPolicy:
         s = self._services.settings
@@ -155,8 +157,9 @@ class OutboxTransport(_OutboxWriter):
         id_strs = [str(i) for i in id_list]
         after_commit(db, [lambda: self._send(id_strs)])
 
-    def _dispatch(self, ids: list[uuid.UUID]) -> Any:
-        return dispatch(self._db_state.session_factory, self._bus, self.policy(), ids=ids)
+    async def _dispatch(self, ids: list[uuid.UUID]) -> Any:
+        async with self._dispatch_lock:
+            return await dispatch(self._db_state.session_factory, self._bus, self.policy(), ids=ids)
 
     def _dispatch_soon(self, ids: list[uuid.UUID]) -> None:
         """Eager delivery from a session's ``after_commit`` event.

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/retry_service.py

@@ -20,13 +20,15 @@ from sqlmodel import col
 
 from background_tasks._signal_support import now_utc
 from background_tasks.after_commit import after_commit
-from background_tasks.constants import RETRY_ALL_BATCH, TaskStatus
+from background_tasks.constants import RETRY_ALL_BATCH, SM_TRACKING_HEADER, TaskStatus
 from background_tasks.contracts.events import TaskRetried
 from background_tasks.contracts.schemas import RetryFailedResult
 from background_tasks.filters import Conditions, bulk_retry_conditions
 from background_tasks.models import TaskExecution
 from background_tasks.sync_db import sync_session
+from background_tasks.task_resource import resource_headers
 from background_tasks.tenant_context import publish_as_owner
+from background_tasks.tracking import TrackingMode
 
 if TYPE_CHECKING:
     from celery import Celery
@@ -196,6 +198,13 @@ class RetryCoordinator:
             "task_id": task_id,
         }
 
+        # The retry already reserved a ``pending`` row; a reduced tracking
+        # mode would never move it on, so an operator's retry is tracked fully.
+        headers: dict[str, str] = {SM_TRACKING_HEADER: TrackingMode.FULL.value}
+        if row.resource_type and row.resource_id:
+            headers.update(resource_headers(row.resource_type, row.resource_id))
+        options["headers"] = headers
+
         def publish() -> str:
             try:
                 return _send()
@@ -233,6 +242,8 @@ class RetryCoordinator:
             queue=row.queue,
             tenant_id=row.tenant_id,
             owner_user_id=row.owner_user_id,
+            resource_type=row.resource_type,
+            resource_id=row.resource_id,
             args=list(row.args or []),
             kwargs=dict(row.kwargs or {}),
             retried_from_id=row.id,

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/settings.py

@@ -53,6 +53,7 @@ from background_tasks.settings_env_checks import (
     forbid_localhost_broker_in_production,
     warn_on_legacy_redis_vars,
 )
+from background_tasks.tracking import TrackingMode
 
 __all__ = ["DEFAULT_RETENTION_DAYS", "ENV_PREFIX", "BackgroundTasksSettings"]
 
@@ -62,6 +63,33 @@ logger = logging.getLogger(__name__)
 class BackgroundTasksSettings(CelerySettingsFields):
     """Configuration for the Celery + Redis task runner."""
 
+    execution_tracking: TrackingMode = Field(
+        default=TrackingMode.FULL, json_schema_extra=_CELERY_RESTART
+    )
+    track_publish: bool = Field(default=True, json_schema_extra=_CELERY_RESTART)
+
+    @classmethod
+    def settings_customise_sources(
+        cls, settings_cls, init_settings, env_settings, dotenv_settings, file_secret_settings
+    ):
+        # Tracking controls are DB-backed; preserve env wiring for older fields.
+        def db_only(source):
+            def read():
+                return {
+                    k: v
+                    for k, v in source().items()
+                    if k not in {"execution_tracking", "track_publish"}
+                }
+
+            return read
+
+        return (
+            init_settings,
+            db_only(env_settings),
+            db_only(dotenv_settings),
+            db_only(file_secret_settings),
+        )
+
     # ── Durable event outbox (GH #459) ──────────────────────
     outbox_mode: Literal["celery", "inprocess"] = Field(
         default="celery", json_schema_extra=_CELERY_RESTART

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/signals.py

@@ -42,7 +42,6 @@ from background_tasks.log_context import signal_task_finished, signal_task_start
 from background_tasks.models import TaskExecution
 from background_tasks.task_heartbeat import forget_heartbeat
 from background_tasks.tenant_context import (
-    message_owner,
     message_tenant,
     published_owner,
     published_tenant,
@@ -86,6 +85,7 @@ def on_task_publish(
     }
     apply_signal(
         "on_task_publish",
+        headers=headers,
         celery_task_id=task_id,
         defaults=defaults,
         tenant_id=published_tenant(headers),
@@ -106,6 +106,7 @@ def on_task_prerun(
     **_k: Any,
 ) -> None:
     """Flip the row to ``running``, start the heartbeat, bind log context."""
+    restore_tenant(task_id=task_id, task=task or sender)
     args_n, kwargs_n = coerce_args_kwargs(args, kwargs)
     now = now_utc()
     name = task_name_of(sender, task)
@@ -120,11 +121,10 @@ def on_task_prerun(
             "started_at": now,
             "heartbeat_at": now,
         },
-        tenant_id=message_tenant(task=task),
-        owner_user_id=message_owner(task=task),
+        task=task or sender,
+        tenant_id=message_tenant(task=task or sender),
     )
     signal_task_started(task_id=task_id, task_name=name)
-    restore_tenant(task_id=task_id, task=task)
 
 
 @signals.task_postrun.connect
@@ -140,15 +140,18 @@ def on_task_postrun(
     ``task_retry`` which fire *before* postrun; postrun only refreshes the
     heartbeat so the sweep doesn't immediately flip a just-finished row.
     """
-    apply_signal(
-        "on_task_postrun",
-        celery_task_id=task_id,
-        defaults={"task_name": task_name_of(sender, task), "heartbeat_at": now_utc()},
-        tenant_id=message_tenant(task=task),
-    )
-    release_tenant(task_id=task_id)
-    forget_heartbeat(task_id)
-    signal_task_finished(task_id=task_id)
+    try:
+        apply_signal(
+            "on_task_postrun",
+            celery_task_id=task_id,
+            defaults={"task_name": task_name_of(sender, task), "heartbeat_at": now_utc()},
+            task=task or sender,
+            tenant_id=message_tenant(task=task or sender),
+        )
+    finally:
+        release_tenant(task_id=task_id)
+        forget_heartbeat(task_id)
+        signal_task_finished(task_id=task_id)
 
 
 @signals.task_success.connect
@@ -164,6 +167,7 @@ def on_task_success(sender: Any = None, result: Any = None, **_k: Any) -> None:
             "traceback": None,
             "exception_type": None,
         },
+        task=sender,
         tenant_id=message_tenant(task=sender),
     )
 
@@ -189,6 +193,7 @@ def on_task_failure(
             "exception_type": exception_type,
             "finished_at": now_utc(),
         },
+        task=sender,
         tenant_id=message_tenant(task=sender),
     )
 
@@ -225,6 +230,8 @@ def on_task_retry(
             "heartbeat_at": now_utc(),
         },
         after=_stamp_reason,
+        task=sender,
+        request=request,
         tenant_id=message_tenant(request=request),
     )
 
@@ -239,6 +246,8 @@ def on_task_revoked(sender: Any = None, request: Any = None, **_k: Any) -> None:
             "status": TaskStatus.REVOKED,
             "finished_at": now_utc(),
         },
+        task=sender,
+        request=request,
         tenant_id=message_tenant(request=request),
     )
 

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/sync_db.py

@@ -28,6 +28,7 @@ from simple_module_db.query_filter import EngineTenancy, bind_engine_policy
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
 from sqlalchemy.orm import Session, sessionmaker
+from sqlmodel import SQLModel
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +44,20 @@ _tenant_strict: bool = False
 _default_tenant: str | None = None
 
 
+class WorkerTenancy(SQLModel, frozen=True):
+    """Snapshot of the host tenancy configured for this worker (#685)."""
+
+    multi_tenant: bool
+    default_tenant: str | None
+
+
+def worker_tenancy() -> WorkerTenancy | None:
+    """Return configured tenancy, or ``None`` when no database URL is pinned."""
+    if _url_override is None:
+        return None
+    return WorkerTenancy(multi_tenant=_tenant_strict, default_tenant=_default_tenant)
+
+
 class WorkerSession(Session):
     """This engine's own session class, so the entity listeners attached to it
     never double up with a ``DatabaseState``'s (each state has its own

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/task_heartbeat.py

@@ -35,6 +35,7 @@ from background_tasks.constants import (
 )
 from background_tasks.models import TaskExecution
 from background_tasks.sync_db import sync_session
+from background_tasks.tracking import TrackingMode, tracking_mode
 
 logger = logging.getLogger(__name__)
 
@@ -99,7 +100,7 @@ def heartbeat(
     reporting on.
     """
     task_id = _current_task_id()
-    if task_id is None:
+    if task_id is None or tracking_mode(task=current_task) != TrackingMode.FULL:
         return False
     try:
         reported = _progress_values(progress, message, phase)

simple_module_background_tasks-0.0.42/background_tasks/task_resource.py

@@ -0,0 +1,55 @@
+"""Explicit resource references on task messages (#709)."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from background_tasks.constants import (
+    RESOURCE_REF_MAX_LENGTH,
+    SM_RESOURCE_ID_HEADER,
+    SM_RESOURCE_TYPE_HEADER,
+)
+from background_tasks.tenant_context import header_of_request
+
+if TYPE_CHECKING:
+    from celery.canvas import Signature
+
+_TYPE_NAME = re.compile(r"[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+")
+
+
+def resource_headers(resource_type: str, resource_id: str) -> dict[str, str]:
+    """Validate before publishing; never silently truncate an identity."""
+    if (
+        not isinstance(resource_type, str)
+        or len(resource_type) > RESOURCE_REF_MAX_LENGTH
+        or not _TYPE_NAME.fullmatch(resource_type)
+        or not isinstance(resource_id, str)
+        or not resource_id.strip()
+        or len(resource_id) > RESOURCE_REF_MAX_LENGTH
+        or any(ord(c) < 32 or ord(c) == 127 for c in resource_id)
+    ):
+        raise ValueError("Invalid task resource reference")
+    return {SM_RESOURCE_TYPE_HEADER: resource_type, SM_RESOURCE_ID_HEADER: resource_id}
+
+
+def with_task_resource(signature: Signature, *, resource_type: str, resource_id: str) -> Signature:
+    """Clone a signature, preserving its other options and headers."""
+    headers = resource_headers(resource_type, resource_id)
+    return signature.clone().set(headers={**(signature.options.get("headers") or {}), **headers})
+
+
+def message_resource(*, headers: dict | None = None, request: Any = None) -> dict[str, str]:
+    """Accept a validated pair only; malformed external messages grant no access."""
+    kind = (headers or {}).get(SM_RESOURCE_TYPE_HEADER)
+    key = (headers or {}).get(SM_RESOURCE_ID_HEADER)
+    if headers is None:
+        kind = header_of_request(request, SM_RESOURCE_TYPE_HEADER)
+        key = header_of_request(request, SM_RESOURCE_ID_HEADER)
+    if not isinstance(kind, str) or not isinstance(key, str):
+        return {}
+    try:
+        resource_headers(kind, key)
+    except ValueError:
+        return {}
+    return {"resource_type": kind, "resource_id": key}

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/tasks.py

@@ -38,6 +38,7 @@ from background_tasks.log_purge import purge_log_records
 from background_tasks.models import OutboxMessage, TaskExecution
 from background_tasks.settings import BackgroundTasksSettings
 from background_tasks.sync_db import sync_session
+from background_tasks.tracking import TrackingMode
 from background_tasks.worker_settings import load_runner_settings
 
 logger = logging.getLogger(__name__)
@@ -174,7 +175,7 @@ def dispatch_outbox(ids: list[str]) -> dict[str, int]:
     return run_dispatch(list(ids))
 
 
-@shared_task(name=INTERNAL_TASK_SWEEP_OUTBOX)
+@shared_task(name=INTERNAL_TASK_SWEEP_OUTBOX, sm_tracking=TrackingMode.FAILURES)
 def sweep_outbox() -> dict[str, int]:
     """Deliver every due outbox row and reclaim expired leases (beat, every 30 s)."""
     from background_tasks.outbox_worker import run_dispatch

{simple_module_background_tasks-0.0.40 → simple_module_background_tasks-0.0.42}/background_tasks/tenant_context.py

@@ -119,7 +119,8 @@ def _tenant_of(task: Any) -> str | None:
     return _tenant_of_request(getattr(task, "request", None))
 
 
-def _header_of_request(request: Any, name: str) -> Any:
+def header_of_request(request: Any, name: str) -> Any:
+    """A message header off a running task's request (``Request`` or publish-side object)."""
     value = getattr(request, name, None)
     # A worker ``Request`` (revoked signal) keeps headers in a dict instead.
     for attr in ("headers", "request_dict"):
@@ -133,14 +134,14 @@ def message_owner(*, task: Any = None, request: Any = None) -> str | None:
     request = request if request is not None else getattr(task, "request", None)
     if request is None:
         return None
-    value = _header_of_request(request, OWNER_HEADER)
+    value = header_of_request(request, OWNER_HEADER)
     return str(value)[:OWNER_ID_MAX_LENGTH] if value else None
 
 
 def _tenant_of_request(request: Any) -> str | None:
     if request is None:
         return None
-    value = _header_of_request(request, TENANT_HEADER)
+    value = header_of_request(request, TENANT_HEADER)
     if not value:
         return None
     if not is_valid_tenant_id(value):
@@ -199,6 +200,7 @@ __all__ = [
     "OWNER_HEADER",
     "TENANT_HEADER",
     "default_tenant",
+    "header_of_request",
     "message_owner",
     "message_tenant",
     "publish_as_owner",