dirigent-core 0.28.0__tar.gz → 0.29.0__tar.gz

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirigent-core
-Version: 0.28.0
+Version: 0.29.0
 Summary: Dirigent engine core: schema, configuration, and plugin host.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
@@ -12,9 +12,9 @@ Requires-Dist: argon2-cffi>=25.1.0
 Requires-Dist: asyncpg>=0.31.0
 Requires-Dist: cronsim>=2.7
 Requires-Dist: cryptography>=46.0.5
-Requires-Dist: dirigent-client==0.28.0
-Requires-Dist: dirigent-common==0.28.0
-Requires-Dist: dirigent-plugin==0.28.0
+Requires-Dist: dirigent-client==0.29.0
+Requires-Dist: dirigent-common==0.29.0
+Requires-Dist: dirigent-plugin==0.29.0
 Requires-Dist: jsonschema>=4.26.0
 Requires-Dist: opentelemetry-api>=1.44.0
 Requires-Dist: pydantic-settings>=2.15.0

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-core"
-version = "0.28.0"
+version = "0.29.0"
 description = "Dirigent engine core: schema, configuration, and plugin host."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,9 +17,9 @@ dependencies = [
     "asyncpg>=0.31.0",
     "cronsim>=2.7",
     "cryptography>=46.0.5",
-    "dirigent-client==0.28.0",
-    "dirigent-common==0.28.0",
-    "dirigent-plugin==0.28.0",
+    "dirigent-client==0.29.0",
+    "dirigent-common==0.29.0",
+    "dirigent-plugin==0.29.0",
     "jsonschema>=4.26.0",
     "opentelemetry-api>=1.44.0",
     "pydantic-settings>=2.15.0",

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-core"
-version = "0.28.0"
+version = "0.29.0"
 description = "Dirigent engine core: schema, configuration, and plugin host."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,9 +17,9 @@ dependencies = [
     "asyncpg>=0.31.0",
     "cronsim>=2.7",
     "cryptography>=46.0.5",
-    "dirigent-client==0.28.0",
-    "dirigent-common==0.28.0",
-    "dirigent-plugin==0.28.0",
+    "dirigent-client==0.29.0",
+    "dirigent-common==0.29.0",
+    "dirigent-plugin==0.29.0",
     "jsonschema>=4.26.0",
     "opentelemetry-api>=1.44.0",
     "pydantic-settings>=2.15.0",

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/alerting.py

@@ -38,6 +38,7 @@ from dirigent_common import (
     scrub,
     secrets_of,
 )
+from dirigent_common.depth import shown
 from dirigent_core.database import is_deadlock, session_scope
 from dirigent_core.engine.definition import load_definition
 from dirigent_core.engine.services import EngineServices
@@ -146,7 +147,7 @@ def build_context(
             "error": run.error,
             "error_code": run.error_code,
             "error_params": dict(run.error_params or {}),
-            "params": dict(run.params),
+            "params": shown(dict(run.params)),
             "trigger": run.triggered_by_label or run.triggered_by_kind.value,
             "started_at": run.started_at.isoformat() if run.started_at else None,
             "finished_at": run.finished_at.isoformat() if run.finished_at else None,

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/engine/definition.py

@@ -1,6 +1,8 @@
 """The pipeline definition model: one immutable document per version, shared by everything."""
 
+import asyncio
 import re
+import threading
 from datetime import datetime, timedelta
 from enum import StrEnum
 from typing import Annotated, Any, Final, Literal, Self, cast
@@ -23,6 +25,7 @@ from dirigent_common import (
     bounded_evaluation,
     compile_template,
 )
+from dirigent_common.depth import MAX_STORED_DEPTH, nests_past
 from dirigent_common.durations import Duration, format_duration
 from dirigent_core.engine.references import has_reference, references_in
 from dirigent_core.errors import DomainError
@@ -33,6 +36,7 @@ from dirigent_core.messages import (
     PARAMETER_INVALID,
     PARAMETER_SCHEMA_INVALID,
     PARAMETER_UNCHECKED,
+    PARAMETERS_TOO_DEEP,
     REPLY_BAD_HEADER,
     REPLY_BAD_STATUS,
     REPLY_BODY_TWICE,
@@ -659,7 +663,20 @@ class PipelineDefinition(BaseModel):
                 pending.difference_update(ready)
         return ordered
 
-    def validate_params(self, params: JsonMap, format_checker: FormatChecker) -> JsonMap:
+    async def check_params(self, params: JsonMap, format_checker: FormatChecker) -> JsonMap:
+        """Validate parameters as :meth:`validate_params` does, on a thread rather than the event loop.
+
+        The check stops at ``PARAMETERS_CHECKED_WITHIN`` or as soon as the caller is cancelled.
+        """
+        stopped = threading.Event()
+        try:
+            return await asyncio.to_thread(self.validate_params, params, format_checker, stopped)
+        finally:
+            stopped.set()
+
+    def validate_params(
+        self, params: JsonMap, format_checker: FormatChecker, stopped: threading.Event | None = None
+    ) -> JsonMap:
         """Validate supplied parameters against the pipeline's own schema, filling defaults.
 
         ``format_checker`` is the instance's assembled checker, so a ``format`` a parameter
@@ -669,14 +686,16 @@ class PipelineDefinition(BaseModel):
         existed can hold a schema that is not one, and jsonschema then raises something no
         caller of this method catches.
 
-        The check runs where it is called, the event loop included, and stops at
-        ``PARAMETERS_CHECKED_WITHIN``.
+        The check runs where it is called and stops at ``PARAMETERS_CHECKED_WITHIN``, or once
+        ``stopped`` is set. A caller on the event loop uses :meth:`check_params` instead.
         """
         resolved = _with_defaults(self.params, params)
+        if nests_past(cast("JsonValue", resolved)):
+            raise ParameterError(PARAMETERS_TOO_DEEP, limit=MAX_STORED_DEPTH)
         try:
             Draft202012Validator.check_schema(self.params)
             validator = ValueValidator(self.params, format_checker=format_checker, registry=LOCAL_REFERENCES)
-            with bounded_evaluation(PARAMETERS_CHECKED_WITHIN):
+            with bounded_evaluation(PARAMETERS_CHECKED_WITHIN, stopped):
                 validator.validate(resolved)
         except SchemaValidationError as error:
             location = "/".join(str(part) for part in error.absolute_path) or "(root)"

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/engine/executor.py

@@ -30,6 +30,7 @@ from dirigent_common import (
     raised_detail,
     scrub,
 )
+from dirigent_common.depth import MAX_STORED_DEPTH, nests_past
 from dirigent_core import telemetry, wakeups
 from dirigent_core.artifacts import canonical_json, persist_output
 from dirigent_core.database import session_scope, with_deadlock_retry
@@ -79,6 +80,7 @@ from dirigent_core.messages import (
     GONE_PROBES,
     ITEM_UNPAIRED,
     LEASE_RECOVERIES,
+    OUTPUT_TOO_DEEP,
     REMOTE_JOB_FAILED,
     REMOTE_JOB_GONE,
     REMOTE_JOB_SAID,
@@ -468,7 +470,7 @@ class Engine:
                 stop = asyncio.Event()
                 flusher = asyncio.create_task(self._flush_while_running(logger, stop))
                 try:
-                    result = await self._counted(await self._call_block(unit, context), meter)
+                    result = await self._counted(_bounded(await self._call_block(unit, context)), meter)
                 finally:
                     stop.set()
                     with contextlib.suppress(asyncio.CancelledError):
@@ -490,6 +492,9 @@ class Engine:
                     storage=context.uncounted_storage,
                     seconds=time.monotonic() - started,
                 )
+            except Exception as error:
+                telemetry.record_failure(span, error, logger.secrets)
+                raise
             finally:
                 await meter.settle()
 
@@ -547,7 +552,7 @@ class Engine:
         try:
             async with asyncio.timeout(unit.step.timeout.total_seconds() if unit.step.timeout else None):
                 if sensor is not None:
-                    with self._timed(unit.block_id, "poke"):
+                    with self._timed(unit.block_id, "poke", context):
                         return _read_poke(await sensor.poke(config, context))
                 if operator is None:  # pragma: no cover - the host resolved it above
                     return Errored(failure=Failure.rejected(BLOCK_NOT_INSTALLED, block=repr(unit.block_id)))
@@ -576,12 +581,12 @@ class Engine:
         if unit.fetched_output is not None:
             return Produced(output=unit.fetched_output)
         if not unit.is_probe or unit.remote_handle is None:
-            with self._timed(unit.block_id, "execute"):
+            with self._timed(unit.block_id, "execute", context):
                 produced = await operator.execute(config, context)
             if isinstance(produced, RemoteHandle):
                 return Submitted(handle=produced)
             return Produced(output=produced.model_dump(mode="json"))
-        with self._timed(unit.block_id, "probe"):
+        with self._timed(unit.block_id, "probe", context):
             probe = await operator.probe(unit.remote_handle, config, context)
         advanced = None if probe.meta is None else unit.remote_handle.model_copy(update={"meta": probe.meta})
         handle = advanced or unit.remote_handle
@@ -594,7 +599,7 @@ class Engine:
                     handle=advanced,
                 )
             case ProbeStatus.SUCCEEDED:
-                with self._timed(unit.block_id, "fetch"):
+                with self._timed(unit.block_id, "fetch", context):
                     retrieved = await operator.fetch(handle, config, context)
                 return Produced(output=retrieved.model_dump(mode="json"), fetched=True)
             case ProbeStatus.FAILED:
@@ -608,10 +613,13 @@ class Engine:
                 return Vanished(message=probe.message or REMOTE_JOB_GONE.render())
 
     @contextlib.contextmanager
-    def _timed(self, block_id: str, call: str) -> Generator[None]:
-        """Wrap one block call in its own span and record how long it took."""
+    def _timed(self, block_id: str, call: str, context: EngineStepContext) -> Generator[None]:
+        """Wrap one block call in its own span and record how long it took.
+
+        A failure lands on the span with every secret the call opened scrubbed from it.
+        """
         started = time.monotonic()
-        with telemetry.block_span(block_id, call):
+        with telemetry.block_span(block_id, call, context.opened_secrets):
             try:
                 yield
             finally:
@@ -1289,3 +1297,10 @@ async def _pair_refusal(session: AsyncSession, run_id: UUID, parent: str, item_i
         return None
     key = pair[1].item_key if pair is not None else str(item_index)
     return Issue.of(ITEM_UNPAIRED, index=item_index, key=repr(key), step=repr(parent))
+
+
+def _bounded(result: CallResult) -> CallResult:
+    """Fail a call whose output nests deeper than a run stores."""
+    if isinstance(result, Produced) and nests_past(cast("JsonValue", result.output)):
+        return Errored(failure=Failure.rejected(OUTPUT_TOO_DEEP, limit=MAX_STORED_DEPTH))
+    return result

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/engine/runs.py

@@ -21,7 +21,8 @@ from dirigent_client.enums import (
     RunStatus,
     TriggerKind,
 )
-from dirigent_common import JsonMap, Message
+from dirigent_common import JsonMap, Message, raised_detail
+from dirigent_common.depth import MAX_STORED_DEPTH, nests_past
 from dirigent_core import telemetry, wakeups
 from dirigent_core.artifacts import persist_output
 from dirigent_core.database import session_scope
@@ -41,6 +42,7 @@ from dirigent_core.engine.definition import (
     schemas_named,
 )
 from dirigent_core.engine.expansion import is_gate, new_attempt, write_items
+from dirigent_core.engine.failure import Failure
 from dirigent_core.engine.references import ReferenceScope, resolve
 from dirigent_core.engine.services import EngineServices
 from dirigent_core.engine.state import advance, lock_pipeline, lock_run
@@ -60,6 +62,7 @@ from dirigent_core.messages import (
     FAN_OUT_TOO_WIDE,
     GATE_NOT_RETRYABLE,
     GIVEN_NO_ENTRY,
+    INPUT_TOO_DEEP,
     NO_ATTEMPT_TO_RETRY,
     NOT_ENTERED,
     NOT_PAUSABLE,
@@ -280,7 +283,7 @@ async def create_run(
     moment = now or utcnow()
     definition = load_definition(version.document)
     _check_entry(definition, entry)
-    resolved_params = definition.validate_params(params or {}, services.format_checker)
+    resolved_params = await definition.check_params(params or {}, services.format_checker)
     _refuse_disabled_blocks(definition, services)
     pinned_schemas = await _pin_schemas(session, services, version)
     who = attribution or Attribution()
@@ -444,8 +447,17 @@ async def _write_source(
         session.add(attempt)
         return
     attempt.kind = AttemptKind.RECEIVED
-    attempt.status = AttemptStatus.SUCCEEDED
     attempt.input = {"via": entry.via}
+    if nests_past(cast("JsonValue", entry.output)):
+        refused = Failure.rejected(INPUT_TOO_DEEP, step=repr(name), limit=MAX_STORED_DEPTH)
+        attempt.status = AttemptStatus.FAILED
+        attempt.error = refused.message
+        attempt.error_code = refused.code
+        attempt.error_params = refused.params or None
+        attempt.error_class = refused.error_class.value
+        session.add(attempt)
+        return
+    attempt.status = AttemptStatus.SUCCEEDED
     session.add(attempt)
     await session.flush()
     reference = await persist_output(
@@ -707,7 +719,11 @@ async def cancel_remote(
         config = block.config_model.model_validate((attempt.input or {}).get("config", {}))
         accepted = await block.cancel(RemoteHandle.model_validate(attempt.remote_handle), config, context)
     except Exception as error:  # best effort by contract: a refusal must not block the cancel
-        _logger.warning("remote cancellation failed", attempt_id=str(attempt.id), error=str(error))
+        _logger.warning(
+            "remote cancellation failed",
+            attempt_id=str(attempt.id),
+            error=raised_detail(error, redact=context.opened_secrets),
+        )
         return
     _logger.info("remote cancellation requested", attempt_id=str(attempt.id), accepted=accepted)
 

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/messages.py

@@ -208,6 +208,10 @@ PARAMETER_UNCHECKED = PARAMETER.define(
     "the parameters were not checked against the pipeline's parameter schema within {timeout}",
 )
 
+PARAMETERS_TOO_DEEP = PARAMETER.define(
+    "too_deep", "the parameters nest deeper than the {limit} levels of lists and objects a run stores"
+)
+
 DOCUMENT = Catalogue("document")
 
 NOT_YAML = DOCUMENT.define("not_yaml", "the document is not valid YAML or JSON: {detail}")
@@ -873,6 +877,14 @@ SERVER_SETTLED = RUN.define("server_settled", "step {step} is a {kind}, which th
 
 NOT_ENTERED = RUN.define("not_entered", "the input arrived at {entered}, so {step} was not entered")
 
+INPUT_TOO_DEEP = RUN.define(
+    "input_too_deep", "the input at {step} nests deeper than the {limit} levels of lists and objects a run stores"
+)
+
+OUTPUT_TOO_DEEP = RUN.define(
+    "output_too_deep", "the step's output nests deeper than the {limit} levels of lists and objects a run stores"
+)
+
 REPLY_REFUSED = RUN.define("reply_refused", "reply {step} could not be rendered: {detail}")
 
 REPLY_STATUS = RUN.define(

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/pipelines.py

@@ -9,6 +9,7 @@ from typing import Final, NamedTuple
 from uuid import UUID
 
 import sqlalchemy as sa
+from pydantic import ValidationError
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import InstrumentedAttribute
@@ -22,6 +23,7 @@ from dirigent_client.schemas import (
     PipelinePlan,
     PlanAction,
     SourceChanges,
+    StepShape,
     ValidationIssue,
 )
 from dirigent_common import JsonMap
@@ -523,6 +525,39 @@ async def last_runs(session: AsyncSession, pipeline_ids: Sequence[UUID]) -> dict
     }
 
 
+async def listing_shapes(session: AsyncSession, pipeline_ids: Sequence[UUID]) -> dict[UUID, list[StepShape]]:
+    """Read the steps of each of a page of pipelines' current versions, as a miniature draws them.
+
+    One statement for the whole page: each pipeline's current version, joined on the version
+    number the pipeline row holds. A stored document this build can no longer read draws no shape.
+    """
+    if not pipeline_ids:
+        return {}
+    current = (
+        sa.select(PipelineVersion)
+        .join(Pipeline, Pipeline.id == PipelineVersion.pipeline_id)
+        .where(Pipeline.id.in_(pipeline_ids), PipelineVersion.version == Pipeline.current_version)
+    )
+    shapes: dict[UUID, list[StepShape]] = {}
+    for version in (await session.execute(current)).scalars():
+        try:
+            definition = load_definition(version.ordered_document)
+        except ValidationError:
+            continue
+        shapes[version.pipeline_id] = [
+            StepShape(
+                code=code,
+                name=step.name,
+                kind=step.kind,
+                block=step.block_id,
+                depends_on=list(step.depends_on),
+                fan_out=step.is_fan_out,
+            )
+            for code, step in definition.steps.items()
+        ]
+    return shapes
+
+
 class FailedStep(NamedTuple):
     """A run's first failed attempt, as a listing names it: which step, and what it said."""
 

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/reporting.py

@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from dirigent_client.enums import AttemptStatus, LogLevel, RunItemStatus
 from dirigent_common import JsonMap, render
+from dirigent_common.depth import shown
 from dirigent_core import alerting, telemetry
 from dirigent_core.artifacts import MARKDOWN_CONTENT_TYPE, canonical_json, persist_document
 from dirigent_core.engine.definition import PipelineDefinition
@@ -210,7 +211,7 @@ async def run_facts(
         # The refusal the step ended on, taken whole: its sentence, its code and its params
         # come off one attempt, so a reader re-rendering it is not mixing two failures.
         failed = next((one for one in of_step if one.status is AttemptStatus.FAILED and one.error), None)
-        output = dict(last.output) if last is not None and last.output is not None else None
+        output = shown(dict(last.output)) if last is not None and last.output is not None else None
         uri, size = stored.get(last.id, (None, None)) if last is not None else (None, None)
         steps.append(
             StepFacts(

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/sources/endpoint.py

@@ -16,6 +16,7 @@ from pydantic import BaseModel, ConfigDict, Field, JsonValue
 from dirigent_client.enums import BodyKind
 from dirigent_client.schemas import EndpointInput
 from dirigent_common import Issue, JsonMap, Size
+from dirigent_common.depth import nests_past
 from dirigent_common.requests import form_values, gather_values, media_type
 from dirigent_core.messages import (
     BODY_WITHOUT_TYPE,
@@ -290,7 +291,7 @@ def _read_body(raw: bytes, family: BodyKind, charset: str) -> JsonValue | Refusa
             return Refusal.of(ENDPOINT_BODY_NOT_JSON, status=400, detail=str(error))
         except RecursionError:
             return Refusal.of(ENDPOINT_BODY_TOO_DEEP, status=400, limit=MAX_BODY_DEPTH)
-        if _nests_past(value, MAX_BODY_DEPTH):
+        if nests_past(value, MAX_BODY_DEPTH):
             return Refusal.of(ENDPOINT_BODY_TOO_DEEP, status=400, limit=MAX_BODY_DEPTH)
         return value
     codec = CHARSETS.get(charset.strip().lower()) if family is BodyKind.TEXT else "ascii"
@@ -303,21 +304,6 @@ def _read_body(raw: bytes, family: BodyKind, charset: str) -> JsonValue | Refusa
     return form_values(text) if family is BodyKind.FORM else text
 
 
-def _nests_past(value: JsonValue, limit: int) -> bool:
-    """Say whether a parsed body holds a list or object more than ``limit`` levels down."""
-    level = [value]
-    for _ in range(limit):
-        level = [
-            child
-            for held in level
-            if isinstance(held, dict | list)
-            for child in (held.values() if isinstance(held, dict) else held)
-        ]
-        if not level:
-            return False
-    return any(isinstance(held, dict | list) for held in level)
-
-
 def _holds_a_lone_surrogate(value: JsonValue) -> bool:
     """Say whether a parsed body holds half a surrogate pair, which JSON parses and nothing can store."""
     try:

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/telemetry.py

@@ -7,7 +7,7 @@ says where to send data.
 
 import os
 import socket
-from collections.abc import Callable, Generator, Iterable, Mapping
+from collections.abc import Callable, Collection, Generator, Iterable, Mapping
 from contextlib import contextmanager
 from typing import Any, Final
 
@@ -17,6 +17,7 @@ from opentelemetry.metrics import CallbackOptions, Observation
 from opentelemetry.trace import Span, SpanKind, Status, StatusCode
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
+from dirigent_common import raised_detail, scrub
 from dirigent_core.config import Settings
 from dirigent_core.logging import get_logger
 
@@ -316,7 +317,9 @@ def attempt_span(*, run_id: str, step: str, block: str, attempt: int, parent: Co
     """Open the span covering one step attempt, from claim to settled outcome.
 
     ``parent`` is the run's own trace context, read back from the run row, which is what
-    puts an attempt run on a worker into the trace of whatever asked for the run.
+    puts an attempt run on a worker into the trace of whatever asked for the run. An
+    exception leaving the span is not recorded on it: the attempt records its failure
+    through :func:`record_failure`, scrubbed.
     """
     with _tracer.start_as_current_span(
         f"step {step}",
@@ -328,28 +331,46 @@ def attempt_span(*, run_id: str, step: str, block: str, attempt: int, parent: Co
             "dirigent.block": block,
             "dirigent.attempt": attempt,
         },
+        record_exception=False,
+        set_status_on_exception=False,
     ) as span:
         yield span
 
 
 @contextmanager
-def block_span(block: str, call: str) -> Generator[Span]:
-    """Open the span covering one block call: execute, probe, fetch, or cancel."""
+def block_span(block: str, call: str, secrets: Collection[str] = ()) -> Generator[Span]:
+    """Open the span covering one block call: execute, probe, fetch, or cancel.
+
+    An exception the call raises is recorded with every one of ``secrets`` scrubbed from it,
+    and raised on unchanged. ``secrets`` is read when the call fails, so a live set the call
+    adds to covers what it opened.
+    """
     with _tracer.start_as_current_span(
         f"{block}.{call}",
         kind=SpanKind.CLIENT,
         attributes={"dirigent.block": block, "dirigent.block.call": call},
+        record_exception=False,
+        set_status_on_exception=False,
     ) as span:
-        yield span
+        try:
+            yield span
+        except Exception as error:
+            record_failure(span, error, secrets)
+            raise
 
 
-def record_failure(span: Span, error: BaseException | str) -> None:
-    """Mark a span as failed, with the message an operator would want in the trace."""
-    if isinstance(error, BaseException):
-        span.record_exception(error)
-        span.set_status(Status(StatusCode.ERROR, str(error)))
+def record_failure(span: Span, error: Exception | str, secrets: Collection[str] = ()) -> None:
+    """Mark a span as failed, with the message an operator would want in the trace.
+
+    Every one of ``secrets`` is scrubbed from what is recorded. An exception is recorded by its
+    class and its scrubbed text, never its traceback.
+    """
+    if isinstance(error, Exception):
+        said = raised_detail(error, redact=secrets)
+        span.add_event("exception", {"exception.type": type(error).__qualname__, "exception.message": said})
+        span.set_status(Status(StatusCode.ERROR, f"{type(error).__name__}: {said}"))
     else:
-        span.set_status(Status(StatusCode.ERROR, error))
+        span.set_status(Status(StatusCode.ERROR, scrub(error, secrets)))
 
 
 def current_traceparent() -> str | None:

{dirigent_core-0.28.0 → dirigent_core-0.29.0}/src/dirigent_core/triggers/backfill.py

@@ -97,7 +97,7 @@ async def backfill(
     resolved = dict(schedule.params) if params is None else dict(params)
     if dry_run:
         return [Filled(window=window) for window in windows]
-    load_definition(version.document).validate_params(resolved, services.format_checker)
+    await load_definition(version.document).check_params(resolved, services.format_checker)
     filled: list[Filled] = []
     for window in windows:
         run = await create_run(