jerry-thomas 0.3.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

datapipeline/pipeline/context.py

@@ -1,18 +1,24 @@
 from __future__ import annotations
 
+import logging
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
-from typing import Iterator, Mapping, Any
+from typing import Iterator, Mapping, Any, Callable, Optional
+from datetime import datetime
 
 from datapipeline.runtime import Runtime
+from datapipeline.pipeline.observability import ObserverRegistry
 from datapipeline.services.artifacts import (
+    ArtifactNotRegisteredError,
     ArtifactManager,
     ArtifactSpec,
     ArtifactValue,
-    PARTITIONED_IDS_SPEC,
+    VECTOR_SCHEMA_SPEC,
 )
+from datapipeline.utils.window import resolve_window_bounds
 
+logger = logging.getLogger(__name__)
 
 _current_context: ContextVar[PipelineContext | None] = ContextVar(
     "datapipeline_pipeline_context", default=None
@@ -24,6 +30,8 @@ class PipelineContext:
     """Lightweight runtime context shared across pipeline stages."""
 
     runtime: Runtime
+    transform_observer: Callable[..., None] | None = None
+    observer_registry: Optional[ObserverRegistry] = None
     _cache: dict[str, Any] = field(default_factory=dict)
 
     @property
@@ -42,13 +50,64 @@ class PipelineContext:
     def require_artifact(self, spec: ArtifactSpec[ArtifactValue]) -> ArtifactValue:
         return self.artifacts.load(spec)
 
-    def load_expected_ids(self) -> list[str]:
-        ids = self._cache.get("expected_ids")
-        if ids is None:
-            ids = list(self.artifacts.load(PARTITIONED_IDS_SPEC))
-            self._cache["expected_ids"] = ids
+    def load_expected_ids(self, *, payload: str = "features") -> list[str]:
+        key = f"expected_ids:{payload}"
+        cached = self._cache.get(key)
+        if cached is not None:
+            return list(cached)
+        entries = self.load_schema(payload=payload)
+        if not entries:
+            if payload == "targets":
+                logger.debug("Target schema entries missing; proceeding without target baseline.")
+                self._cache[key] = []
+                return []
+            raise RuntimeError("Vector schema artifact missing; run `jerry build` to materialize schema.json.")
+        ids = [entry["id"] for entry in entries if isinstance(entry.get("id"), str)]
+        self._cache[key] = ids
         return list(ids)
 
+    def load_schema(self, *, payload: str = "features") -> list[dict[str, Any]]:
+        key = f"schema:{payload}"
+        cached = self._cache.get(key)
+        if cached is None:
+            try:
+                doc = self.artifacts.load(VECTOR_SCHEMA_SPEC)
+            except ArtifactNotRegisteredError:
+                cached = []
+            else:
+                section = doc.get("targets" if payload == "targets" else "features")
+                if isinstance(section, list):
+                    cached = [entry for entry in section if isinstance(entry, dict)]
+                else:
+                    cached = []
+            self._cache[key] = cached
+        return [dict(entry) for entry in cached] if cached else []
+
+    @property
+    def schema_required(self) -> bool:
+        return bool(getattr(self.runtime, "schema_required", True))
+
+    def window_bounds(self, *, rectangular_required: bool = False) -> tuple[datetime | None, datetime | None]:
+        key = "window_bounds:required" if rectangular_required else "window_bounds:optional"
+        cached = self._cache.get(key)
+        if cached is not None:
+            return cached
+        bounds = resolve_window_bounds(self.runtime, rectangular_required)
+        if rectangular_required:
+            self.runtime.window_bounds = bounds
+        self._cache[key] = bounds
+        return bounds
+
+    @property
+    def start_time(self) -> datetime | None:
+        start, _ = self.window_bounds()
+        return start
+
+    @property
+    def end_time(self) -> datetime | None:
+        _, end = self.window_bounds()
+        return end
+
     @contextmanager
     def activate(self) -> Iterator[PipelineContext]:
         token = _current_context.set(self)

datapipeline/pipeline/observability.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Callable, Mapping, Optional, Protocol, runtime_checkable
+
+
+@dataclass(frozen=True)
+class TransformEvent:
+    type: str
+    payload: Mapping[str, object]
+
+
+# Observer receives a structured event.
+Observer = Callable[[TransformEvent], None]
+# Factory builds an observer for a given logger (may return None if not active at current level).
+ObserverFactory = Callable[[logging.Logger], Optional[Observer]]
+
+
+@runtime_checkable
+class SupportsObserver(Protocol):
+    def set_observer(self, observer: Optional[Observer]) -> None:
+        ...
+
+
+class ObserverRegistry:
+    def __init__(self, factories: Optional[Mapping[str, ObserverFactory]] = None) -> None:
+        self._factories: dict[str, ObserverFactory] = dict(factories or {})
+
+    def register(self, name: str, factory: ObserverFactory) -> None:
+        self._factories[name] = factory
+
+    def get(self, name: str, logger: logging.Logger) -> Optional[Observer]:
+        factory = self._factories.get(name)
+        if not factory:
+            return None
+        return factory(logger)
+
+
+def _scaler_observer_factory(logger: logging.Logger) -> Optional[Observer]:
+    if not logger.isEnabledFor(logging.DEBUG):
+        return None
+
+    warned: set[str] = set()
+
+    def _observer(event: TransformEvent) -> None:
+        if event.type != "scaler_none":
+            return
+        fid = event.payload.get("feature_id")
+        if logger.isEnabledFor(logging.DEBUG):
+            if isinstance(fid, str) and fid not in warned:
+                warned.add(fid)
+                logger.warning(
+                    "Scaler encountered None value during scaling for feature=%s "
+                    "(further occurrences suppressed; consider fill/lint upstream).",
+                    fid,
+                )
+
+    return _observer
+
+
+def default_observer_registry() -> ObserverRegistry:
+    registry = ObserverRegistry()
+    registry.register("scale", _scaler_observer_factory)
+    return registry

datapipeline/pipeline/pipelines.py

@@ -1,7 +1,10 @@
 import heapq
 from collections.abc import Iterator, Sequence
 from typing import Any
+from itertools import tee
 
+from datapipeline.domain.sample import Sample
+from datapipeline.domain.vector import Vector
 from datapipeline.pipeline.utils.keygen import group_key_for
 from datapipeline.pipeline.utils.memory_sort import batch_sort
 from datapipeline.config.dataset.feature import FeatureRecordConfig
@@ -13,6 +16,9 @@ from datapipeline.pipeline.stages import (
     regularize_feature_stream,
     apply_feature_transforms,
     vector_assemble_stage,
+    sample_assemble_stage,
+    align_stream,
+    window_keys,
 )
 from datapipeline.pipeline.context import PipelineContext
 
@@ -72,20 +78,66 @@ def build_vector_pipeline(
     context: PipelineContext,
     configs: Sequence[FeatureRecordConfig],
     group_by_cadence: str,
-    stage: int | None = None,
+    target_configs: Sequence[FeatureRecordConfig] | None = None,
+    *,
+    rectangular: bool = True,
 ) -> Iterator[Any]:
-    """Build the vector assembly pipeline.
-    Stages:
-      - 0..5: delegates to feature pipeline for the first configured feature
-      - 6: assembled vectors
-    """
-    if stage is not None and stage <= 5:
-        first = next(iter(configs))
-        return build_feature_pipeline(context, first, stage=stage)
-
-    streams = [build_feature_pipeline(context, cfg, stage=None) for cfg in configs]
+    """Build the vector assembly pipeline for features and optionally attach targets."""
+    feature_cfgs = list(configs)
+    target_cfgs = list(target_configs or [])
+    if not feature_cfgs and not target_cfgs:
+        return iter(())
+
+    if rectangular:
+        start, end = context.window_bounds(rectangular_required=True)
+        keys = window_keys(start, end, group_by_cadence)
+    else:
+        keys = None
+
+    feature_vectors = _assemble_vectors(
+        context,
+        feature_cfgs,
+        group_by_cadence,
+    )
+    if keys is not None:
+        # share keys across feature/target alignment
+        if target_cfgs:
+            keys_feature, keys_target = tee(keys, 2)
+        else:
+            keys_feature = keys
+            keys_target = None
+        feature_vectors = align_stream(feature_vectors, keys=keys_feature)
+    else:
+        keys_target = None
+
+    if not target_cfgs:
+        return sample_assemble_stage(feature_vectors)
+
+    target_vectors = _assemble_vectors(
+        context,
+        target_cfgs,
+        group_by_cadence,
+    )
+    if keys is not None:
+        target_vectors = align_stream(target_vectors, keys=keys_target)
+    return sample_assemble_stage(feature_vectors, target_vectors)
+
+
+def _assemble_vectors(
+    context: PipelineContext,
+    configs: Sequence[FeatureRecordConfig],
+    group_by_cadence: str,
+) -> Iterator[tuple[tuple, Vector]]:
+    if not configs:
+        return iter(())
+    streams = [
+        build_feature_pipeline(
+            context,
+            cfg,
+        )
+        for cfg in configs
+    ]
     merged = heapq.merge(
         *streams, key=lambda fr: group_key_for(fr, group_by_cadence)
     )
-    vectors = vector_assemble_stage(merged, group_by_cadence)
-    return vectors
+    return vector_assemble_stage(merged, group_by_cadence)

datapipeline/pipeline/split.py

@@ -1,12 +1,12 @@
 import hashlib
-from collections.abc import Iterator, Mapping, MutableMapping, Sequence
+from collections.abc import Iterator, Mapping, Sequence
 from datetime import datetime
-from typing import Any, Literal, Tuple
+from typing import Any, Literal
 
+from datapipeline.domain.sample import Sample
 from datapipeline.domain.vector import Vector
 from datapipeline.config.split import (
     SplitConfig,
-    HashSplitConfig,
     TimeSplitConfig,
 )
 
@@ -121,24 +121,25 @@ class VectorSplitApplicator:
                 self._keep is None or self._keep_placeholder)
         )
 
-    def __call__(self, stream: Iterator[Tuple[Any, Vector]]) -> Iterator[Tuple[Any, Vector]]:
+    def __call__(self, stream: Iterator[Sample]) -> Iterator[Sample]:
         return self.apply(stream)
 
-    def apply(self, stream: Iterator[Tuple[Any, Vector]]) -> Iterator[Tuple[Any, Vector]]:
-        for group_key, vector in stream:
+    def apply(self, stream: Iterator[Sample]) -> Iterator[Sample]:
+        for sample in stream:
+            group_key, vector = sample.key, sample.features
             label = self._labeler.label(group_key, vector)
             if self._output == "filter":
                 if not self._filter_enabled:
-                    yield group_key, vector
+                    yield sample
                     continue
                 if label == self._keep:
-                    yield group_key, vector
+                    yield sample
                 else:
                     continue
             else:
                 data = clone(vector.values)
                 data[self._field] = label
-                yield group_key, Vector(values=data)
+                yield sample.with_features(Vector(values=data))
 
 
 def build_labeler(cfg: SplitConfig) -> BaseLabeler:
@@ -153,7 +154,7 @@ def build_applicator(cfg: SplitConfig, keep: str | None = None) -> VectorSplitAp
     return VectorSplitApplicator(labeler=labeler, output="filter", keep=selected)
 
 
-def apply_split_stage(runtime, stream: Iterator[Tuple[Any, Vector]]) -> Iterator[Tuple[Any, Vector]]:
+def apply_split_stage(runtime, stream: Iterator[Sample]) -> Iterator[Sample]:
     """Apply project-configured split at the end of the vector pipeline.
 
     Reads `runtime.split` (set during bootstrap from project.globals.split) and,

datapipeline/pipeline/stages.py

@@ -1,20 +1,25 @@
 from collections import defaultdict
-from itertools import groupby
-from typing import Any, Iterable, Iterator, Tuple, Mapping
+from itertools import chain, groupby
+from typing import Any, Iterable, Iterator, Mapping
+from datetime import datetime
+
 from datapipeline.pipeline.context import PipelineContext
-from datapipeline.services.artifacts import PARTITIONED_IDS_SPEC
 from datapipeline.services.constants import POSTPROCESS_TRANSFORMS, SCALER_STATISTICS
 
 from datapipeline.domain.feature import FeatureRecord, FeatureRecordSequence
 from datapipeline.domain.vector import Vector, vectorize_record_group
+from datapipeline.domain.sample import Sample
 from datapipeline.pipeline.utils.memory_sort import batch_sort
+
 from datapipeline.pipeline.utils.transform_utils import apply_transforms
 from datapipeline.plugins import FEATURE_TRANSFORMS_EP, VECTOR_TRANSFORMS_EP, RECORD_TRANSFORMS_EP, STREAM_TRANFORMS_EP, DEBUG_TRANSFORMS_EP
 
 from datapipeline.domain.record import TemporalRecord
 from datapipeline.pipeline.utils.keygen import FeatureIdGenerator, group_key_for
 from datapipeline.sources.models.source import Source
-from datapipeline.pipeline.split import apply_split_stage as split_stage
+from datapipeline.transforms.vector import VectorEnsureSchemaTransform
+from datapipeline.config.dataset.normalize import floor_time_to_bucket
+from datapipeline.utils.time import parse_timecode
 
 
 def open_source_stream(context: PipelineContext, stream_alias: str) -> Source:
@@ -39,7 +44,8 @@ def apply_record_operations(
 ) -> Iterator[TemporalRecord]:
     """Apply record transforms defined in contract policies in order."""
     steps = context.runtime.registries.record_operations.get(stream_id)
-    records = apply_transforms(record_stream, RECORD_TRANSFORMS_EP, steps, context)
+    records = apply_transforms(
+        record_stream, RECORD_TRANSFORMS_EP, steps, context)
     return records
 
 
@@ -65,7 +71,7 @@ def regularize_feature_stream(
     batch_size: int,
 ) -> Iterator[FeatureRecord]:
     """Apply feature transforms defined in contract policies in order."""
-    # Sort by (id, time) to satisfy stream transforms (ensure_ticks/fill)
+    # Sort by (id, time) to satisfy stream transforms (ensure_cadence/fill)
     sorted = batch_sort(
         feature_stream,
         batch_size=batch_size,
@@ -121,11 +127,8 @@ def apply_feature_transforms(
 def vector_assemble_stage(
     merged: Iterator[FeatureRecord | FeatureRecordSequence],
     group_by_cadence: str,
-) -> Iterator[Tuple[Any, Vector]]:
-    """Group the merged feature stream by group_key.
-    Coalesce each partitioned feature_id into record buckets.
-    Yield (group_key, Vector) pairs ready for downstream consumption."""
-
+) -> Iterator[tuple[tuple, Vector]]:
+    """Group merged feature stream by key and emit raw vectors."""
     for group_key, group in groupby(
         merged, key=lambda fr: group_key_for(fr, group_by_cadence)
     ):
@@ -136,23 +139,131 @@ def vector_assemble_stage(
             else:
                 records = [fr.record]
             feature_map[fr.id].extend(records)
-        yield group_key, vectorize_record_group(feature_map)
+        vector = vectorize_record_group(feature_map)
+        yield group_key, vector
+
+
+def window_keys(start: datetime | None, end: datetime | None, cadence: str | None) -> Iterator[tuple] | None:
+    if start is None or end is None or cadence is None:
+        return None
+    try:
+        current = floor_time_to_bucket(start, cadence)
+        stop = floor_time_to_bucket(end, cadence)
+        step = parse_timecode(cadence)
+    except Exception:
+        return None
+    if stop < current:
+        return None
+
+    def _iter():
+        t = current
+        while t <= stop:
+            yield (t,)
+            t = t + step
+
+    return _iter()
+
+
+def align_stream(
+    stream: Iterator[tuple[tuple, Vector]] | None,
+    keys: Iterator[tuple] | None,
+) -> Iterator[tuple[tuple, Vector]]:
+    if keys is None:
+        return iter(stream or ())
+    it = iter(stream or ())
+    current = next(it, None)
+    for key in keys:
+        while current and current[0] < key:
+            current = next(it, None)
+        if current and current[0] == key:
+            yield current
+            current = next(it, None)
+        else:
+            yield (key, Vector(values={}))
+
+
+def sample_assemble_stage(
+    feature_vectors: Iterator[tuple[tuple, Vector]],
+    target_vectors: Iterator[tuple[tuple, Vector]] | None = None,
+) -> Iterator[Sample]:
+    """Combine feature/target vectors into Sample objects."""
+    feature_iter = iter(feature_vectors)
+    target_iter = iter(target_vectors or ())
+
+    def _advance(it):
+        try:
+            return next(it)
+        except StopIteration:
+            return None
+
+    current_feature = _advance(feature_iter)
+    current_target = _advance(target_iter)
+
+    while current_feature:
+        feature_key, feature_vector = current_feature
+        targets = None
+
+        while current_target and current_target[0] < feature_key:
+            current_target = _advance(target_iter)
+
+        if current_target and current_target[0] == feature_key:
+            targets = current_target[1]
+            current_target = _advance(target_iter)
+
+        yield Sample(key=feature_key, features=feature_vector, targets=targets)
+        current_feature = _advance(feature_iter)
 
 
 def post_process(
     context: PipelineContext,
-    stream: Iterator[Tuple[Any, Vector]],
-) -> Iterator[Tuple[Any, Vector]]:
+    stream: Iterator[Sample],
+) -> Iterator[Sample]:
     """Apply project-scoped postprocess transforms (from registry).
 
     Explicit prereq artifact flow:
     - Read a precomputed expected feature-id list (full ids) from the build
       folder. If missing, instruct the user to generate it via CLI.
     """
+    stream = _apply_vector_schema(context, stream)
     runtime = context.runtime
     transforms = runtime.registries.postprocesses.get(POSTPROCESS_TRANSFORMS)
-
     if not transforms:
         return stream
-
     return apply_transforms(stream, VECTOR_TRANSFORMS_EP, transforms, context)
+
+
+def _apply_vector_schema(
+    context: PipelineContext,
+    stream: Iterator[Sample],
+) -> Iterator[Sample]:
+    with context.activate():
+        feature_entries = context.load_schema(payload="features")
+        target_entries = context.load_schema(payload="targets")
+
+        if not feature_entries:
+            if context.schema_required:
+                raise RuntimeError("Schema missing for payload 'features'. Run `jerry build` to materialize schema.json.")
+            feature_stream = stream
+        else:
+            feature_schema = VectorEnsureSchemaTransform(on_missing="fill", on_extra="drop")
+            feature_schema.bind_context(context)
+            feature_stream = feature_schema(stream)
+
+        def _apply_targets(upstream: Iterator[Sample]) -> Iterator[Sample]:
+            if target_entries:
+                target_schema = VectorEnsureSchemaTransform(payload="targets", on_missing="fill", on_extra="drop")
+                target_schema.bind_context(context)
+                return target_schema(upstream)
+            if not context.schema_required:
+                return upstream
+            # schema required but missing: only raise if targets are present in stream
+            iterator = iter(upstream)
+            try:
+                first = next(iterator)
+            except StopIteration:
+                return iter(())
+            if first.targets is None:
+                return chain([first], iterator)
+            raise RuntimeError("Schema missing for payload 'targets'. Run `jerry build` to materialize schema.json.")
+
+        return _apply_targets(feature_stream)

datapipeline/pipeline/utils/keygen.py

@@ -1,7 +1,8 @@
 from typing import Union, List, Any
 from datetime import datetime
 
-from datapipeline.config.dataset.normalize import floor_time_to_resolution
+from datapipeline.config.dataset.normalize import floor_time_to_bucket
+from datapipeline.transforms.vector_utils import PARTITION_SEP
 
 
 class FeatureIdGenerator:
@@ -9,18 +10,30 @@ class FeatureIdGenerator:
     Generates unique feature keys by appending suffixes from expand_by fields.
     """
 
+    COMPONENT_PREFIX = "@"
+    COMPONENT_JOINER = "_"
+    VALUE_DELIMITER = ":"
+
     def __init__(self, partition_by: Union[str, List[str], None]):
         self.partition_by = partition_by
 
+    def _format_component(self, field: str, value: Any) -> str:
+        value_str = "" if value is None else str(value)
+        return f"{self.COMPONENT_PREFIX}{field}{self.VALUE_DELIMITER}{value_str}"
+
     def generate(self, base_id: str, record: Any) -> str:
         if not self.partition_by:
             return base_id
         if isinstance(self.partition_by, str):
-            suffix = getattr(record, self.partition_by)
+            value = getattr(record, self.partition_by)
+            suffix = self._format_component(self.partition_by, value)
         else:
-            suffix = "__".join(str(getattr(record, f))
-                               for f in self.partition_by)
-        return f"{base_id}__{suffix}"
+            parts = [
+                self._format_component(field, getattr(record, field))
+                for field in self.partition_by
+            ]
+            suffix = self.COMPONENT_JOINER.join(parts)
+        return f"{base_id}{PARTITION_SEP}{suffix}"
 
 
 def _anchor_time(item: Any) -> datetime | None:
@@ -36,7 +49,7 @@ def _anchor_time(item: Any) -> datetime | None:
     return getattr(recs[0], "time", None) if recs else None
 
 
-def group_key_for(item: Any, resolution: str) -> tuple:
+def group_key_for(item: Any, cadence: str) -> tuple:
     """Compute 1-tuple bucket key from a FeatureRecord or FeatureRecordSequence."""
     t = _anchor_time(item)
-    return (floor_time_to_resolution(t, resolution),)
+    return (floor_time_to_bucket(t, cadence),)

datapipeline/pipeline/utils/memory_sort.py

@@ -1,17 +1,12 @@
 from typing import Iterable, Iterator, Callable, TypeVar
 import heapq
-
-
-def apply_pipeline(stream, stages):
-    for stage in stages:
-        stream = stage(stream)
-    return stream
+from itertools import count
 
 
 T = TypeVar("T")
 
 
-def read_batches(iterable: Iterable[T], batch_size: int, key: Callable[[T], any]) -> Iterator[list[T]]:
+def read_batches(iterable: Iterable[T], batch_size: int, key: Callable[[T], object]) -> Iterator[list[T]]:
     batch = []
     for item in iterable:
         batch.append(item)
@@ -22,6 +17,23 @@ def read_batches(iterable: Iterable[T], batch_size: int, key: Callable[[T], any]
         yield sorted(batch, key=key)
 
 
-def batch_sort(iterable: Iterable[T], batch_size: int, key: Callable[[T], any]) -> Iterator[T]:
-    sorted_batches = read_batches(iterable, batch_size, key)
-    return heapq.merge(*sorted_batches, key=key)
+def batch_sort(iterable: Iterable[T], batch_size: int, key: Callable[[T], object]) -> Iterator[T]:
+    """Sort an iterable by chunking then merging to reduce peak memory usage."""
+    batches = read_batches(iterable, batch_size, key)
+
+    heap: list[tuple[object, int, T, Iterator[T]]] = []
+    seq = count()
+
+    for batch in batches:
+        it = iter(batch)
+        first = next(it, None)
+        if first is None:
+            continue
+        heapq.heappush(heap, (key(first), next(seq), first, it))
+
+    while heap:
+        _, _, item, it = heapq.heappop(heap)
+        yield item
+        nxt = next(it, None)
+        if nxt is not None:
+            heapq.heappush(heap, (key(nxt), next(seq), nxt, it))

datapipeline/pipeline/utils/transform_utils.py

@@ -1,9 +1,11 @@
+import logging
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from typing import Any, Optional, Tuple
 from inspect import isclass, signature, Parameter
 from contextlib import nullcontext
 
 from datapipeline.pipeline.context import PipelineContext
+from datapipeline.pipeline.observability import ObserverRegistry, SupportsObserver, TransformEvent
 
 from datapipeline.utils.load import load_ep
 
@@ -79,9 +81,16 @@ def apply_transforms(
     group: str,
     transforms: Optional[Sequence[Mapping[str, Any]]],
     context: Optional[PipelineContext] = None,
+    observer: Callable[[TransformEvent], None] | None = None,
+    observer_registry: ObserverRegistry | None = None,
 ) -> Iterator[Any]:
     """Instantiate and apply configured transforms in order."""
 
+    observer = observer or (getattr(context, "transform_observer", None)
+                            if context is not None else None)
+    registry = observer_registry or (getattr(context, "observer_registry", None)
+                                     if context is not None else None)
+
     context_cm = context.activate() if context else nullcontext()
     with context_cm:
         for transform in transforms or ():
@@ -90,7 +99,20 @@ def apply_transforms(
             if isclass(ep):
                 inst = _instantiate_entry_point(ep, params, context)
                 _bind_context(inst, context)
+                eff_observer = observer
+                if eff_observer is None and registry:
+                    eff_observer = registry.get(
+                        name, logging.getLogger(f"{group}.{name}")
+                    )
+                _attach_observer(inst, eff_observer)
                 stream = inst(stream)
             else:
                 stream = _call_with_params(ep, stream, params, context)
     return stream
+
+
+def _attach_observer(transform: Any, observer: Callable[..., None] | None) -> None:
+    if observer is None:
+        return
+    if isinstance(transform, SupportsObserver):
+        transform.set_observer(observer)