temporal-flowrensic-python-sdk 0.6.63__py3-none-any.whl

temporal_flowrensic/_telemetry.py

@@ -0,0 +1,559 @@
+"""The worker telemetry: the hello with its answer, the beats, the forwarding
+of the engine's and the worker's metrics, the histories of the runs the
+activity interceptor saw, and the handover at shutdown. It runs as tasks on
+the worker's event loop, and every call it makes is async."""
+
+from __future__ import annotations
+
+import asyncio
+import urllib.request
+import warnings
+from collections import OrderedDict
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Any, Awaitable, Callable, Optional, Sequence, Union
+
+from connectrpc.code import Code
+from connectrpc.errors import ConnectError
+
+from temporal_flowrensic._gen.flowrensic.v1.activity_metrics_pb2 import ActivityAttempt
+from temporal_flowrensic._gen.flowrensic.v1.ephemeral_run_pb2 import (
+    EphemeralRunHandoverRequest,
+    EphemeralRunHandshakeRequest,
+    EphemeralRunHandshakeResponse,
+    IngestEngineHistoryRequest,
+    IngestEphemeralRunMetricsRequest,
+    IngestWorkerMetricsRequest,
+    WorkerBeatRequest,
+)
+from temporal_flowrensic._gen.flowrensic.v1.services_connect import IngestServiceClient
+from temporal_flowrensic._names import interceptor_list
+from temporal_flowrensic._sink import (
+    DEFAULT_TIMEOUT_MS,
+    AttemptSink,
+    RecordSink,
+    SinkCounts,
+    create_attempt_sink,
+    default_worker_id,
+    client_headers,
+)
+
+__all__ = [
+    "FlowrensicWarning",
+    "ForwardAnyway",
+    "Fail",
+    "GiveUpQuietly",
+    "KeepTrying",
+    "NoAnswerStrategy",
+    "Retry",
+    "Telemetry",
+    "start_telemetry",
+]
+
+
+class FlowrensicWarning(UserWarning):
+    """A warning about what Flowrensic answered, such as an interval out of range."""
+
+
+@dataclass(frozen=True)
+class KeepTrying:
+    """Start the worker at once and ask again in the background, delay seconds
+    between two asks, and once answered do what the answer says."""
+
+    delay: float = 5.0
+
+
+@dataclass(frozen=True)
+class Fail:
+    """Raise at once."""
+
+
+@dataclass(frozen=True)
+class Retry:
+    """Ask again, attempts times in all with delay seconds between two asks, and then raise as Fail does."""
+
+    attempts: int
+    delay: float
+
+
+@dataclass(frozen=True)
+class GiveUpQuietly:
+    """Start the worker with nothing forwarded on a timer."""
+
+
+@dataclass(frozen=True)
+class ForwardAnyway:
+    """Start as if told to forward when there is a metrics address and an ephemeral run id, at the default interval."""
+
+
+NoAnswerStrategy = Union[KeepTrying, Fail, Retry, GiveUpQuietly, ForwardAnyway]
+"""What the worker does when the hello gets no answer."""
+
+_DEFAULT_INTERVAL = 5
+_MIN_INTERVAL = 1
+_MAX_INTERVAL = 60
+_SEEN_CAP = 10_000
+
+# How many histories a worker reads and sends at once.
+_HISTORIES_AT_ONCE = 16
+
+DEFAULT_SHUTDOWN_TIMEOUT_MS = 20_000
+"""Milliseconds the shutdown may send histories when start_telemetry is given no shutdown_timeout_ms."""
+
+# The codes Flowrensic refuses a hello with on purpose, such as an env it does
+# not know or a wrong key. Any other error is no answer.
+_REFUSALS = {
+    Code.INVALID_ARGUMENT,
+    Code.NOT_FOUND,
+    Code.ALREADY_EXISTS,
+    Code.PERMISSION_DENIED,
+    Code.FAILED_PRECONDITION,
+    Code.OUT_OF_RANGE,
+    Code.UNAUTHENTICATED,
+}
+
+# The events that end a run, so nothing is added to its history after them.
+_CLOSING = {
+    "workflow_execution_completed_event_attributes",
+    "workflow_execution_failed_event_attributes",
+    "workflow_execution_timed_out_event_attributes",
+    "workflow_execution_canceled_event_attributes",
+    "workflow_execution_terminated_event_attributes",
+    "workflow_execution_continued_as_new_event_attributes",
+}
+
+
+def _no_answer(error: BaseException) -> bool:
+    """Whether the call got no answer a worker can act on. Only a refusal on purpose is an answer."""
+    return not isinstance(error, ConnectError) or error.code not in _REFUSALS
+
+
+def _checked_interval(seconds: int) -> int:
+    """The interval of an answer, or the default when it is out of range, with a warning."""
+    if _MIN_INTERVAL <= seconds <= _MAX_INTERVAL:
+        return seconds
+    warnings.warn(
+        f"Flowrensic sent a scrape interval of {seconds} seconds, out of {_MIN_INTERVAL} to {_MAX_INTERVAL}; "
+        f"the worker keeps {_DEFAULT_INTERVAL} seconds",
+        FlowrensicWarning,
+        stacklevel=2,
+    )
+    return _DEFAULT_INTERVAL
+
+
+async def _ignoring_failure(job: Callable[[], Awaitable[Any]]) -> None:
+    try:
+        await job()
+    except asyncio.CancelledError:
+        raise
+    except Exception:  # noqa: BLE001
+        return
+
+
+def _scrape(address: str, timeout_ms: int) -> str:
+    with urllib.request.urlopen(f"http://{address}/metrics", timeout=timeout_ms / 1000) as res:  # noqa: S310
+        if res.status != 200:
+            raise RuntimeError(f"metrics endpoint returned {res.status}")
+        return res.read().decode("utf-8")
+
+
+_HISTOGRAM_SERIES = ("_bucket", "_sum", "_count")
+
+
+def _only_named(page: str, names: frozenset[str]) -> str:
+    """The lines of the engine's page the server reads: a series line whose name
+    is named, and a HELP or TYPE line whose name, or that name with a histogram
+    suffix, is named. No names, from a server that gives none, keeps the whole
+    page."""
+    if not names:
+        return page
+    kept: list[str] = []
+    for line in page.split("\n"):
+        text = line.strip()
+        if text.startswith("#"):
+            words = text.split(None, 3)
+            if (
+                len(words) >= 3
+                and words[1] in ("HELP", "TYPE")
+                and (words[2] in names or any(words[2] + s in names for s in _HISTOGRAM_SERIES))
+            ):
+                kept.append(line)
+            continue
+        end = next((i for i, c in enumerate(text) if c.isspace() or c == "{"), len(text))
+        if text and text[:end] in names:
+            kept.append(line)
+    return "\n".join(kept) + "\n" if kept else ""
+
+
+class _SeenSink(RecordSink[ActivityAttempt]):
+    """The sink the activity interceptor reports to: it notes the run of each
+    attempt, so its history is sent, and passes the attempt on."""
+
+    def __init__(self, telemetry: Telemetry, inner: AttemptSink) -> None:  # noqa: D107
+        # Not a buffer of its own: every call goes to inner.
+        self._telemetry = telemetry
+        self._inner = inner
+
+    def record(self, one: ActivityAttempt) -> None:
+        try:
+            self._telemetry._saw(one)
+        except Exception:  # noqa: BLE001
+            pass
+        self._inner.record(one)
+
+    def counts(self) -> SinkCounts:
+        return self._inner.counts()
+
+    def flush_sync(self) -> None:
+        self._inner.flush_sync()
+
+    async def flush(self) -> None:
+        await self._inner.flush()
+
+    def close_sync(self) -> None:
+        self._inner.close_sync()
+
+    async def close(self) -> None:
+        await self._inner.close()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._inner, name)
+
+
+class Telemetry:
+    """A worker's telemetry, from start_telemetry."""
+
+    def __init__(self) -> None:  # noqa: D107
+        self.answered = False
+        """Whether Flowrensic answered the hello, at start or later in the background."""
+        self.forwarding = False
+        """Whether the answer told this worker to forward the engine's metrics."""
+        self.interval_seconds = 0
+        """The interval the worker sends on, in seconds."""
+        self.sending_histories = True
+        """Whether the worker sends the histories of the runs it saw."""
+        self.engine_metric_names: frozenset[str] = frozenset()
+        """The series of the engine's page the server reads. Empty sends the whole page."""
+        self.when_answered: asyncio.Future[bool]
+        """Done with True once Flowrensic answers, and with False when it refuses
+        in the background, the strategy ran with no answer, or shutdown came first."""
+        self.sink: AttemptSink
+        """The sink to give the activity interceptor."""
+        self._seen: OrderedDict[str, str] = OrderedDict()
+        # The length of the history last sent for each run seen.
+        self._sent: dict[str, int] = {}
+        self._shutdown: Callable[[], Awaitable[None]]
+
+    def _saw(self, attempt: ActivityAttempt) -> None:
+        if self.sending_histories and attempt.run_key and attempt.workflow_execution_id:
+            self._seen[attempt.run_key] = attempt.workflow_execution_id
+            self._seen.move_to_end(attempt.run_key)
+            while len(self._seen) > _SEEN_CAP:
+                gone, _ = self._seen.popitem(last=False)
+                self._sent.pop(gone, None)
+
+    async def shutdown(self) -> None:
+        """The last beat and scrape, the histories of the runs this worker saw,
+        the attempts still waiting, and the handover. Returns once they landed."""
+        await self._shutdown()
+
+
+async def start_telemetry(
+    *,
+    server_base_url: str,
+    current_env: str,
+    namespace: str,
+    temporal_address: str = "",
+    temporal_client: Any = None,
+    env_access_key: str = "",
+    current_ephemeral_run: str = "",
+    metrics_address: str = "",
+    worker_metrics_address: str = "",
+    worker_id: str = "",
+    worker_name: str = "",
+    version: str = "",
+    workflow_interceptors: Optional[Sequence[Any]] = None,
+    no_answer: Optional[NoAnswerStrategy] = None,
+    timeout_ms: int = DEFAULT_TIMEOUT_MS,
+    shutdown_timeout_ms: int = DEFAULT_SHUTDOWN_TIMEOUT_MS,
+) -> Telemetry:
+    """Says hello to Flowrensic with the env and the ephemeral run, and does
+    what the answer says. When the hello gets no answer it does what no_answer
+    says, KeepTrying when left out. The answer says whether this worker
+    forwards the engine's metrics and how often it sends. On that interval it
+    sends a beat, the engine's metrics when told to, the worker's own metrics
+    when it has their address, and the history of every run the activity
+    interceptor reported through telemetry.sink, read from Temporal.
+
+    temporal_client is the worker's own temporalio Client, used to read the
+    histories; it is needed for an engine behind TLS or an API key. Left out, a
+    plain client to temporal_address is opened the first time a history is
+    read. A worker told that Flowrensic pulls the histories itself never opens
+    one. worker_name is the name of the worker, which the sink sends with each
+    attempt. workflow_interceptors are the workflow interceptors the worker loads,
+    sent by name; left out, no list is sent. timeout_ms is in
+    milliseconds, the other times in seconds. shutdown_timeout_ms is how long
+    the shutdown may send histories, in milliseconds, counted from when it
+    starts: the beat and the last scrape go first, past it no more histories
+    are started, and then the sink is closed and the handover sent."""
+    if not server_base_url:
+        raise ValueError("flowrensic: server_base_url is required")
+    strategy: NoAnswerStrategy = no_answer if no_answer is not None else KeepTrying()
+    worker_id = worker_id or default_worker_id()
+    interceptors = interceptor_list(workflow_interceptors)
+    timeout_ms = max(1, timeout_ms)
+    shutdown_timeout_ms = max(1, shutdown_timeout_ms)
+    headers = client_headers(current_env, env_access_key, current_ephemeral_run)
+    ingest = IngestServiceClient(server_base_url.rstrip("/"), send_compression=None)
+    t = Telemetry()
+
+    def listed(message: Any) -> Any:
+        if interceptors is not None:
+            message.workflow_interceptors.CopyFrom(interceptors)
+        return message
+
+    async def ask() -> EphemeralRunHandshakeResponse:
+        return await ingest.ephemeral_run_handshake(
+            listed(
+                EphemeralRunHandshakeRequest(
+                    metrics_address=metrics_address,
+                    worker_id=worker_id,
+                    version=version,
+                )
+            ),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
+
+    def take(answer: EphemeralRunHandshakeResponse) -> None:
+        t.answered = True
+        t.forwarding = answer.forward
+        t.interval_seconds = _checked_interval(answer.interval_seconds)
+        t.sending_histories = not answer.skip_histories
+        t.engine_metric_names = frozenset(answer.engine_metric_names)
+
+    attempts = max(1, strategy.attempts) if isinstance(strategy, Retry) else 1
+    unanswered = False
+    for attempt in range(1, attempts + 1):
+        try:
+            take(await ask())
+            break
+        except Exception as error:  # noqa: BLE001
+            if isinstance(strategy, Retry) and attempt < attempts and _no_answer(error):
+                await asyncio.sleep(strategy.delay)
+                continue
+            if not _no_answer(error) or isinstance(strategy, (Fail, Retry)):
+                await ingest.close()
+                raise
+            if isinstance(strategy, KeepTrying):
+                unanswered = True
+            elif isinstance(strategy, GiveUpQuietly):
+                t.forwarding = False
+                t.interval_seconds = 0
+            else:
+                t.forwarding = bool(metrics_address) and bool(current_ephemeral_run)
+                t.interval_seconds = _DEFAULT_INTERVAL
+            break
+
+    t.sink = _SeenSink(
+        t, create_attempt_sink(
+            server_base_url,
+            worker_id=worker_id,
+            worker_name=worker_name,
+            current_env=current_env,
+            env_access_key=env_access_key,
+            current_ephemeral_run=current_ephemeral_run,
+            timeout_ms=timeout_ms,
+        )
+    )
+
+    temporal: list[Any] = [temporal_client]
+
+    async def connect() -> Any:
+        if temporal[0] is None:
+            from temporalio.client import Client
+
+            temporal[0] = await Client.connect(temporal_address, namespace=namespace)
+        return temporal[0]
+
+    async def scrape() -> None:
+        text = await asyncio.get_running_loop().run_in_executor(None, _scrape, metrics_address, timeout_ms)
+        await ingest.ingest_ephemeral_run_metrics(
+            IngestEphemeralRunMetricsRequest(worker_id=worker_id, exposition=_only_named(text, t.engine_metric_names)),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
+
+    async def scrape_worker() -> None:
+        text = await asyncio.get_running_loop().run_in_executor(None, _scrape, worker_metrics_address, timeout_ms)
+        await ingest.ingest_worker_metrics(
+            IngestWorkerMetricsRequest(worker_id=worker_id, exposition=text),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
+
+    async def forward_history(run_id: str, workflow_id: str) -> None:
+        from temporalio.api.common.v1 import WorkflowExecution
+        from temporalio.api.history.v1 import History
+        from temporalio.api.workflowservice.v1 import (
+            DescribeWorkflowExecutionRequest,
+            GetWorkflowExecutionHistoryRequest,
+        )
+
+        client = await connect()
+        # Sent again only when the engine holds more events than were sent last.
+        described = await client.workflow_service.describe_workflow_execution(
+            DescribeWorkflowExecutionRequest(
+                namespace=namespace,
+                execution=WorkflowExecution(workflow_id=workflow_id, run_id=run_id),
+            ),
+            timeout=timedelta(milliseconds=timeout_ms),
+        )
+        length = described.workflow_execution_info.history_length
+        if length > 0 and length == t._sent.get(run_id, 0):
+            return
+        events: list[Any] = []
+        token = b""
+        while True:
+            page = await client.workflow_service.get_workflow_execution_history(
+                GetWorkflowExecutionHistoryRequest(
+                    namespace=namespace,
+                    execution=WorkflowExecution(workflow_id=workflow_id, run_id=run_id),
+                    next_page_token=token,
+                ),
+                timeout=timedelta(milliseconds=timeout_ms),
+            )
+            events.extend(page.history.events)
+            if not page.next_page_token:
+                break
+            token = page.next_page_token
+        await ingest.ingest_engine_history(
+            IngestEngineHistoryRequest(
+                run_id=run_id,
+                namespace=namespace,
+                workflow_id=workflow_id,
+                task_attempt=described.pending_workflow_task.attempt,
+                history=History(events=events).SerializeToString(),
+            ),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
+        t._sent[run_id] = len(events)
+        if events and events[-1].WhichOneof("attributes") in _CLOSING:
+            t._seen.pop(run_id, None)
+            t._sent.pop(run_id, None)
+
+    async def collect(deadline: Optional[float] = None) -> None:
+        # deadline is a time of the loop; past it no more histories are started.
+        async def beat() -> None:
+            await ingest.worker_beat(
+                listed(
+                    WorkerBeatRequest(worker_id=worker_id, version=version)
+                ),
+                headers=headers,
+                timeout_ms=timeout_ms,
+            )
+
+        await _ignoring_failure(beat)
+        if t.forwarding:
+            await _ignoring_failure(scrape)
+        if worker_metrics_address:
+            await _ignoring_failure(scrape_worker)
+        if not t.sending_histories:
+            return
+        runs = list(t._seen.items())
+        queue = iter(runs)
+
+        async def send_more() -> None:
+            for run_id, workflow_id in queue:
+                if deadline is not None and loop.time() >= deadline:
+                    return
+                await _ignoring_failure(lambda r=run_id, w=workflow_id: forward_history(r, w))
+
+        await asyncio.gather(*(send_more() for _ in range(min(_HISTORIES_AT_ONCE, len(runs)))))
+
+    loop = asyncio.get_running_loop()
+    state: dict[str, Any] = {"working": None, "ticker": None}
+
+    def tick() -> None:
+        # A tick that comes while the one before it still works is skipped.
+        working = state["working"]
+        if working is not None and not working.done():
+            return
+        state["working"] = loop.create_task(collect())
+
+    async def ticking() -> None:
+        while True:
+            await asyncio.sleep(t.interval_seconds)
+            tick()
+
+    def start_ticking() -> None:
+        if t.interval_seconds > 0 and state["ticker"] is None:
+            state["ticker"] = loop.create_task(ticking())
+
+    start_ticking()
+
+    stop_asking = asyncio.Event()
+
+    async def keep_asking() -> bool:
+        delay = strategy.delay if isinstance(strategy, KeepTrying) else 0.0
+        while True:
+            try:
+                await asyncio.wait_for(stop_asking.wait(), timeout=delay)
+                return False
+            except asyncio.TimeoutError:
+                pass
+            try:
+                answer = await ask()
+            except Exception as error:  # noqa: BLE001
+                if stop_asking.is_set() or not _no_answer(error):
+                    return False
+                continue
+            if stop_asking.is_set():
+                return False
+            take(answer)
+            if not t.sending_histories:
+                t._seen.clear()
+                t._sent.clear()
+            start_ticking()
+            tick()
+            return True
+
+    if unanswered:
+        t.when_answered = loop.create_task(keep_asking())
+    else:
+        done: asyncio.Future[bool] = loop.create_future()
+        done.set_result(t.answered)
+        t.when_answered = done
+
+    async def shutdown() -> None:
+        deadline = loop.time() + shutdown_timeout_ms / 1000
+        stop_asking.set()
+        await asyncio.shield(t.when_answered)
+        ticker = state["ticker"]
+        if ticker is not None:
+            ticker.cancel()
+        working = state["working"]
+        if working is not None and not working.done():
+            working.cancel()
+            try:
+                await working
+            except BaseException:  # noqa: BLE001
+                pass
+        # keep trying with no answer has no Flowrensic to hand over to.
+        hand_over = t.answered or not unanswered
+        if hand_over:
+            await collect(deadline)
+        await t.sink.close()
+        if hand_over:
+            await _ignoring_failure(
+                lambda: ingest.ephemeral_run_handover(
+                    EphemeralRunHandoverRequest(worker_id=worker_id, version=version),
+                    headers=headers,
+                    timeout_ms=timeout_ms,
+                )
+            )
+        await _ignoring_failure(ingest.close)
+
+    t._shutdown = shutdown
+    return t

temporal_flowrensic/activity.py

@@ -0,0 +1,136 @@
+"""The Flowrensic activity interceptor for a Temporal Python worker, beside
+temporalio.activity."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import timedelta
+from typing import Any, Optional
+
+from google.protobuf.timestamp_pb2 import Timestamp
+from temporalio import activity as _activity
+from temporalio.exceptions import ApplicationError, CancelledError
+from temporalio.worker import (
+    ActivityInboundInterceptor,
+    ActivityOutboundInterceptor,
+    ExecuteActivityInput,
+    Interceptor as _TemporalInterceptor,
+)
+
+from temporal_flowrensic._gen.flowrensic.v1.activity_metrics_pb2 import (
+    OUTCOME_CANCELED,
+    OUTCOME_COMPLETED,
+    OUTCOME_FAILED,
+    ActivityAttempt,
+)
+from temporal_flowrensic._sink import RecordSink
+
+__all__ = ["Interceptor"]
+
+
+def _classify(err: BaseException) -> tuple[int, str]:
+    """The outcome and error type of a failed attempt."""
+    try:
+        if isinstance(err, (CancelledError, asyncio.CancelledError)):
+            return OUTCOME_CANCELED, "CancelledFailure"
+        if isinstance(err, ApplicationError):
+            return OUTCOME_FAILED, err.type or "ApplicationFailure"
+        return OUTCOME_FAILED, type(err).__name__
+    except Exception:  # noqa: BLE001
+        return OUTCOME_FAILED, "Unknown"
+
+
+def _ms(value: Optional[timedelta]) -> int:
+    return 0 if value is None else round(value.total_seconds() * 1000)
+
+
+def _timestamp(seconds: float) -> Timestamp:
+    out = Timestamp()
+    out.FromNanoseconds(int(seconds * 1_000_000_000))
+    return out
+
+
+class Interceptor(_TemporalInterceptor):
+    """The Flowrensic interceptor, to put in Worker(interceptors=[...]). It
+    records one ActivityAttempt per activity attempt into sink, and never
+    changes what the activity returns or raises. It adds nothing to workflows.
+
+    The namespace of each attempt is the one Temporal gives in the activity
+    info. current_env is the env the worker runs in, current_ephemeral_run which run of
+    that env this is, and version the version this worker serves. Flowrensic
+    refuses an attempt that names an env and no ephemeral run."""
+
+    def __init__(
+        self,
+        sink: RecordSink[ActivityAttempt],
+        *,
+        current_env: str = "",
+        current_ephemeral_run: str = "",
+        version: str = "",
+    ) -> None:
+        self._sink = sink
+        self._env = current_env
+        self._ephemeral_run = current_ephemeral_run
+        self._version = version
+
+    def intercept_activity(self, next: ActivityInboundInterceptor) -> ActivityInboundInterceptor:
+        return _ActivityInbound(next, self)
+
+    def _emit(self, started: float, outcome: int, error_type: str) -> None:
+        """Records one attempt. An error inside it is swallowed."""
+        sink = self._sink
+        try:
+            ended = time.time()
+            info = _activity.info()
+            policy = info.retry_policy
+            scheduled = info.scheduled_time
+            attempt = ActivityAttempt(
+                namespace=getattr(info, "namespace", "") or info.workflow_namespace,
+                env=self._env,
+                ephemeral_run=self._ephemeral_run,
+                version=self._version,
+                workflow_type=info.workflow_type or "",
+                workflow_execution_id=info.workflow_id or "",
+                run_key=info.workflow_run_id or "",
+                activity_type=info.activity_type,
+                activity_id=info.activity_id,
+                attempt=info.attempt,
+                task_queue=info.task_queue,
+                outcome=outcome,
+                error_type=error_type,
+                started_at=_timestamp(started),
+                ended_at=_timestamp(ended),
+                duration_ms=round((ended - started) * 1000),
+                start_to_close_timeout_ms=_ms(info.start_to_close_timeout),
+                maximum_attempts=(policy.maximum_attempts if policy is not None else 0) or 0,
+                heartbeat_timeout_ms=_ms(info.heartbeat_timeout),
+            )
+            if scheduled is not None:
+                attempt.scheduled_at.FromDatetime(scheduled)
+            sink.record(attempt)
+        except Exception:  # noqa: BLE001
+            return
+
+
+class _ActivityInbound(ActivityInboundInterceptor):
+    def __init__(self, next: ActivityInboundInterceptor, owner: Interceptor) -> None:
+        super().__init__(next)
+        self._owner = owner
+
+    def init(self, outbound: ActivityOutboundInterceptor) -> None:
+        super().init(_ActivityOutbound(outbound))
+
+    async def execute_activity(self, input: ExecuteActivityInput) -> Any:
+        started = time.time()
+        try:
+            result = await super().execute_activity(input)
+        except BaseException as err:
+            self._owner._emit(started, *_classify(err))
+            raise
+        self._owner._emit(started, OUTCOME_COMPLETED, "")
+        return result
+
+
+class _ActivityOutbound(ActivityOutboundInterceptor):
+    pass