@aws/durable-execution-sdk-js-otel 1.1.0 → 1.2.1

package/dist-cjs/invocation-plugin.js

@@ -1,9 +1,21 @@
 'use strict';
 
+var pluginRegistration = require('./plugin-registration.js');
 var api = require('@opentelemetry/api');
 var core = require('@opentelemetry/core');
 var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
-var globalIdGenerator = require('./global-id-generator.js');
+
+/** Match ordinary OTel spans: a wall-clock origin plus monotonic elapsed time. */
+function captureInvocationClock() {
+    return {
+        epochMillis: Date.now(),
+        monotonicMillis: core.otperformance.now(),
+    };
+}
+function readInvocationClock(clock) {
+    // HrTime explicitly denotes absolute time; numeric TimeInput can be relative.
+    return core.millisToHrTime(clock.epochMillis + (core.otperformance.now() - clock.monotonicMillis));
+}
 
 const DEFAULT_INSTRUMENTATION_NAME = "aws-durable-execution-sdk-js";
 /**
@@ -14,18 +26,27 @@ const DEFAULT_INSTRUMENTATION_NAME = "aws-durable-execution-sdk-js";
  * durable execution.
  */
 class InvocationOtelPlugin {
+    static [pluginRegistration.PLUGIN_REGISTRATION] = {
+        exclusiveGroup: "durable-opentelemetry-view",
+    };
     tracerProvider;
     tracer;
     idGenerator;
     contextExtractor;
     instrumentationName;
+    flushTimeoutMillis;
     usesGlobalProvider;
     globalIdGeneratorInstalled;
     durableSampler;
     tracingEnabled = false;
+    // Operation and attempt spans ended after a flush starts need a final batch.
+    operationSpansNeedFlush = false;
+    externalCompletions = new pluginRegistration.ExternalCompletions();
+    endedOperationSpans = new WeakSet();
     workflowSpanName;
     enrichLogger;
     // Per-invocation state
+    invocationClock;
     spanMap = new Map();
     spanStack = [];
     invocationSpan;
@@ -41,6 +62,9 @@ class InvocationOtelPlugin {
     // Workflow span can be backdated to it; the now() fallback is taken here (not
     // at onInvocationEnd, where it would land after the span's own end time).
     executionStartTimestamp;
+    // Only a backend timestamp can define a retry-stable, zero-duration anchor.
+    syntheticRootAnchorTimestamp;
+    syntheticRootMaterialized = false;
     executionArn = "";
     executionTraceId = "";
     executionTraceFlags = 0;
@@ -48,18 +72,19 @@ class InvocationOtelPlugin {
     constructor(config) {
         const instrumentationName = config?.instrumentationName ?? DEFAULT_INSTRUMENTATION_NAME;
         this.instrumentationName = instrumentationName;
-        this.idGenerator = new globalIdGenerator.DeterministicIdGenerator();
-        this.contextExtractor = config?.contextExtractor ?? globalIdGenerator.xRayContextExtractor;
+        this.flushTimeoutMillis = pluginRegistration.resolveFlushTimeoutMillis(config?.flushTimeoutMillis);
+        this.idGenerator = new pluginRegistration.DeterministicIdGenerator();
+        this.contextExtractor = config?.contextExtractor ?? pluginRegistration.xRayContextExtractor;
         this.workflowSpanName = config?.workflowSpanName ?? "Workflow";
         this.enrichLogger = config?.enrichLogger ?? true;
-        const { tracerProvider, usesGlobalProvider } = globalIdGenerator.createTracerProvider(config, this.idGenerator);
+        const { tracerProvider, usesGlobalProvider } = pluginRegistration.createTracerProvider(config, this.idGenerator);
         this.tracerProvider = tracerProvider;
         this.usesGlobalProvider = usesGlobalProvider;
         this.tracer = this.tracerProvider.getTracer(instrumentationName);
-        this.durableSampler = globalIdGenerator.tryInstallDurableSampler(this.tracer);
+        this.durableSampler = pluginRegistration.tryInstallDurableSampler(this.tracer);
         this.globalIdGeneratorInstalled = !this.usesGlobalProvider;
         if (this.usesGlobalProvider) {
-            const installedIdGenerator = globalIdGenerator.tryInstallGlobalIdGenerator(this.tracer);
+            const installedIdGenerator = pluginRegistration.tryInstallGlobalIdGenerator(this.tracer);
             if (installedIdGenerator) {
                 this.idGenerator = installedIdGenerator;
                 this.globalIdGeneratorInstalled = true;
@@ -72,6 +97,10 @@ class InvocationOtelPlugin {
         if (!this.tracingEnabled) {
             return;
         }
+        // Match the epoch/elapsed-time model of an ordinary OTel span, but share
+        // this anchor across all live spans in the invocation. Never use the
+        // process timeOrigin: it can differ from the current wall-clock epoch.
+        this.invocationClock = captureInvocationClock();
         // 1. Store the execution ARN
         this.executionArn = info.executionArn;
         // 2. Invoke the context extractor
@@ -83,8 +112,8 @@ class InvocationOtelPlugin {
         // parent, else a synthetic execution root. A live ambient span is not used
         // as the ancestor (its trace is not stable across reinvocations); the
         // Invocation span may still parent onto a same-trace ambient span below.
-        const canonical = globalIdGenerator.canonicalTraceId(extractedContext, info.executionArn, info.executionStartTimestamp);
-        const execTraceContext = globalIdGenerator.resolveExecutionTraceContext(extractedContext, canonical, info.executionArn, () => globalIdGenerator.rootSamplingDecision(this.tracer, canonical, this.workflowSpanName, {
+        const canonical = pluginRegistration.canonicalTraceId(extractedContext, info.executionArn, info.executionStartTimestamp);
+        const execTraceContext = pluginRegistration.resolveExecutionTraceContext(extractedContext, canonical, info.executionArn, () => pluginRegistration.rootSamplingDecision(this.tracer, canonical, this.workflowSpanName, {
             "durable.execution.arn": info.executionArn,
         }));
         this.executionTraceId = canonical;
@@ -104,12 +133,16 @@ class InvocationOtelPlugin {
         // single real span is created and ended once, at the terminal invocation
         // (see onInvocationEnd). It carries the execution sampled bit so a
         // parent-based sampler stays consistent with the eventual root.
-        const workflowSpanId = globalIdGenerator.deriveWorkflowSpanId(info.executionArn);
+        const workflowSpanId = pluginRegistration.deriveWorkflowSpanId(info.executionArn);
         this.executionAncestor = execTraceContext.executionAncestor;
+        // Snapshot the Date: another hook must not be able to alter a later copy
+        // of this invocation's anchor by mutating the input object.
+        this.syntheticRootAnchorTimestamp = info.executionStartTimestamp
+            ? new Date(info.executionStartTimestamp.getTime())
+            : undefined;
         this.executionStartTimestamp =
-            info.executionStartTimestamp ??
-                this.executionStartTimestamp ??
-                new Date();
+            this.syntheticRootAnchorTimestamp ??
+                new Date(this.invocationClock.epochMillis);
         this.workflowSpan = api.trace.wrapSpanContext({
             traceId: this.executionTraceId,
             spanId: workflowSpanId,
@@ -132,8 +165,24 @@ class InvocationOtelPlugin {
                 "durable.execution.arn": info.executionArn,
                 "durable.invocation.first": info.isFirstInvocation,
             },
-            startTime: core.hrTime(),
+            startTime: this.liveTimestamp(),
         }, invocationParentContext);
+        this.externalCompletions.observe(info.updatedOperations, info.operations);
+        // Each sampled invocation can recover an earlier undelivered anchor. An
+        // opaque tracer retains terminal-only creation: without the sampler wrapper,
+        // an early anchor would independently query its hidden sampler again.
+        if (this.durableSampler && this.syntheticRootAnchorTimestamp) {
+            this.createSyntheticRoot()?.end(this.syntheticRootAnchorTimestamp);
+        }
+    }
+    providePropagationMetadata(input) {
+        if (!this.tracingEnabled ||
+            !this.invocationSpan ||
+            !this.workflowSpan ||
+            !pluginRegistration.isDurableSamplerInstalled(this.tracer, this.durableSampler)) {
+            return undefined;
+        }
+        return pluginRegistration.createPropagationMetadata(input, this.executionArn, this.executionTraceId, this.executionTraceFlags);
     }
     wrapInvocation(_info, fn) {
         if (!this.tracingEnabled || !this.invocationSpan) {
@@ -146,21 +195,15 @@ class InvocationOtelPlugin {
             this.resetInvocationState();
             return;
         }
-        const endTime = core.hrTime();
-        // 1. End all spans in the stack in reverse order
-        while (this.spanStack.length > 0) {
-            const span = this.spanStack.pop();
-            span.end(endTime);
-        }
-        // 1b. End any still-recording span left in spanMap (attempt spans, which are
-        // not on the stack; operation spans were unwound above). Safeguard against a
-        // leak on a non-terminal invocation (issue #831). isRecording() skips spans
-        // already ended by the stack unwind.
-        for (const span of this.spanMap.values()) {
-            if (span.isRecording()) {
-                span.end(endTime);
-            }
+        // Prefer normal lifecycle hooks, which preserve live parent scopes. Before
+        // returning, export any fresh completion the workflow did not reach. A
+        // later resume may label it replay even though it has never been exported.
+        for (const operation of this.externalCompletions.pending.values()) {
+            this.finishOperation({ ...operation, isReplay: false });
         }
+        const endTime = this.liveTimestamp();
+        // 1. Close the spans that exist at the initial invocation unwind.
+        this.endOpenSpans(endTime);
         // 2. End the invocation span if it exists
         if (this.invocationSpan) {
             this.invocationSpan.setAttribute("durable.invocation.status", info.status);
@@ -193,7 +236,10 @@ class InvocationOtelPlugin {
         if (this.executionSamplingDecision === sdkTraceNode.SamplingDecision.RECORD_AND_SAMPLED &&
             this.executionAncestor &&
             (info.status === "SUCCEEDED" || info.status === "FAILED")) {
-            const workflowSpanId = globalIdGenerator.deriveWorkflowSpanId(this.executionArn);
+            // Keep terminal-only fallback for providers without an early anchor.
+            // An anchor already materialized in this invocation is not emitted twice.
+            const syntheticRootSpan = this.createSyntheticRoot();
+            const workflowSpanId = pluginRegistration.deriveWorkflowSpanId(this.executionArn);
             const executionAncestorContext = api.trace.setSpanContext(api.ROOT_CONTEXT, this.executionAncestor);
             const workflowSpan = this.idGenerator.withIds({ spanId: workflowSpanId }, () => this.startSpan(this.workflowSpanName, {
                 kind: api.SpanKind.INTERNAL,
@@ -213,20 +259,69 @@ class InvocationOtelPlugin {
                 workflowSpan.setStatus({ code: api.SpanStatusCode.OK });
             }
             workflowSpan.end(endTime);
-        }
-        // Non-terminal (PENDING/RETRYING): no real Workflow span is created, so
-        // nothing to end — the identity was only ever a non-recording context.
-        // 4. Force flush the tracer provider
-        if ("forceFlush" in this.tracerProvider) {
+            syntheticRootSpan?.end(this.syntheticRootAnchorTimestamp ?? endTime);
+        }
+        // PENDING/RETRYING never materializes Workflow. A sampled invocation may
+        // already have ended its stable synthetic anchor before customer code ran.
+        // End owns the drain/flush loop; change hooks only enqueue notifications.
+        // Only segments actually ended above need a linked continuation. A span
+        // created during an awaited flush can still complete normally.
+        const flushDeadline = performance.now() + this.flushTimeoutMillis;
+        const flush = async () => {
             try {
-                await this.tracerProvider.forceFlush();
+                await pluginRegistration.flushTracerProvider(this.tracerProvider, this.usesGlobalProvider, Math.max(0, flushDeadline - performance.now()));
             }
             catch {
-                // Gracefully handle flush errors
+                // Gracefully handle flush errors.
             }
-        }
-        // 5. Clear all per-invocation state
+        };
+        do {
+            for (const operation of this.externalCompletions.pending.values()) {
+                this.finishOperation({ ...operation, isReplay: false });
+            }
+            this.operationSpansNeedFlush = false;
+            await flush();
+        } while (this.externalCompletions.pending.size > 0 &&
+            performance.now() < flushDeadline);
+        // Retain one bounded snapshot of terminal notifications already received,
+        // including while a provider wait timed out.
+        for (const operation of [...this.externalCompletions.pending.values()]) {
+            this.finishOperation({ ...operation, isReplay: false });
+        }
+        // A still-running operation may have started while flush yielded. End its
+        // owned recording span before dropping the maps.
+        this.endOpenSpans(this.liveTimestamp());
+        // Close hooks before the final batch: late lifecycle callbacks cannot create
+        // more spans while this last wait uses only the original budget remaining.
+        const flushFinalOperations = this.operationSpansNeedFlush;
         this.resetInvocationState();
+        if (flushFinalOperations && performance.now() < flushDeadline) {
+            await flush();
+        }
+    }
+    /** Creates at most one SDK-owned root per invocation; the caller ends it. */
+    createSyntheticRoot() {
+        if (this.syntheticRootMaterialized ||
+            this.executionSamplingDecision !== sdkTraceNode.SamplingDecision.RECORD_AND_SAMPLED ||
+            !this.executionAncestor ||
+            this.executionAncestor.isRemote) {
+            return undefined;
+        }
+        const span = this.idGenerator.withIds({
+            traceId: this.executionTraceId,
+            spanId: this.executionAncestor.spanId,
+        }, () => this.startSpan("DurableExecutionRoot", {
+            kind: api.SpanKind.INTERNAL,
+            attributes: {
+                "durable.execution.synthetic_root": true,
+                "durable.execution.arn": this.executionArn,
+            },
+            startTime: this.syntheticRootAnchorTimestamp ??
+                this.executionStartTimestamp ??
+                new Date(),
+        }, api.ROOT_CONTEXT));
+        this.syntheticRootMaterialized = true;
+        return span;
     }
     ensureGlobalIdGeneratorInstalled() {
         if (!this.usesGlobalProvider || this.globalIdGeneratorInstalled) {
@@ -237,8 +332,8 @@ class InvocationOtelPlugin {
         // again at invocation start, after preload initialization has completed.
         this.tracerProvider = api.trace.getTracerProvider();
         this.tracer = this.tracerProvider.getTracer(this.instrumentationName);
-        this.durableSampler = globalIdGenerator.tryInstallDurableSampler(this.tracer);
-        const installedIdGenerator = globalIdGenerator.tryInstallGlobalIdGenerator(this.tracer);
+        this.durableSampler = pluginRegistration.tryInstallDurableSampler(this.tracer);
+        const installedIdGenerator = pluginRegistration.tryInstallGlobalIdGenerator(this.tracer);
         if (installedIdGenerator) {
             this.idGenerator = installedIdGenerator;
             this.globalIdGeneratorInstalled = true;
@@ -247,19 +342,47 @@ class InvocationOtelPlugin {
         console.warn("[InvocationOtelPlugin] Expected a compatible OpenTelemetry SDK tracer at invocation start; telemetry is disabled for this invocation. Ensure the OpenTelemetry SDK is configured before invocation start.");
         return false;
     }
+    liveTimestamp() {
+        return readInvocationClock(this.invocationClock);
+    }
     resetInvocationState() {
+        this.externalCompletions.clear();
+        this.operationSpansNeedFlush = false;
+        this.endedOperationSpans = new WeakSet();
+        this.invocationClock = undefined;
         this.spanMap.clear();
         this.spanStack = [];
         this.invocationSpan = undefined;
         this.workflowSpan = undefined;
         this.executionAncestor = undefined;
         this.executionStartTimestamp = undefined;
+        this.syntheticRootAnchorTimestamp = undefined;
+        this.syntheticRootMaterialized = false;
         this.executionArn = "";
         this.executionTraceId = "";
         this.executionTraceFlags = 0;
         this.executionSamplingDecision = sdkTraceNode.SamplingDecision.NOT_RECORD;
         this.tracingEnabled = false;
     }
+    endOperationSpan(span, endTime) {
+        span.end(endTime);
+        this.operationSpansNeedFlush = true;
+    }
+    endOpenSpans(endTime) {
+        while (this.spanStack.length > 0) {
+            const span = this.spanStack.pop();
+            this.endOperationSpan(span, endTime);
+            this.endedOperationSpans.add(span);
+        }
+        // Attempts are held only in the map. Recording state avoids ending spans
+        // twice here; it is not used to infer whether a sampled-out span has ended.
+        for (const span of this.spanMap.values()) {
+            if (span.isRecording()) {
+                this.endOperationSpan(span, endTime);
+                this.endedOperationSpans.add(span);
+            }
+        }
+    }
     startSpan(name, options, parentContext) {
         const fn = () => this.tracer.startSpan(name, options, parentContext);
         return this.durableSampler
@@ -274,14 +397,16 @@ class InvocationOtelPlugin {
     invocationParentContext(executionAncestor, canonical) {
         const activeContext = api.context.active();
         const ambient = api.trace.getSpanContext(activeContext);
-        // Adopt the ambient span as the Invocation parent only when it is on the
-        // execution trace AND carries the same sampled bit as the execution
-        // ancestor. Matching the trace ID alone is not enough: if the ambient span's
+        // Adopt the ambient span only in propagated-parent mode, when it is on
+        // the execution trace AND carries the same sampled bit as the execution
+        // ancestor. Synthetic fallback keeps Workflow and Invocation on the same
+        // SDK-owned root. Matching the trace ID alone is not enough: if the ambient span's
         // sampled bit differs, the Invocation span would inherit the ambient
         // decision and could export after an explicit Sampled=0, or drop after the
         // root sampler chose sampled. On a mismatch, fall back to the execution
         // ancestor, which carries the authoritative decision.
-        if (ambient &&
+        if (executionAncestor.isRemote &&
+            ambient &&
             api.isSpanContextValid(ambient) &&
             ambient.traceId === canonical &&
             (ambient.traceFlags & api.TraceFlags.SAMPLED) ===
@@ -307,7 +432,7 @@ class InvocationOtelPlugin {
         }
         const initialContext = {
             traceId: this.executionTraceId,
-            spanId: globalIdGenerator.deriveSpanIdFromOperationId(operationId, this.executionArn),
+            spanId: pluginRegistration.deriveSpanIdFromOperationId(operationId, this.executionArn),
             traceFlags: this.executionTraceFlags,
             isRemote: false,
         };
@@ -326,13 +451,12 @@ class InvocationOtelPlugin {
         if (info.isReplay && this.spanMap.has(info.id)) {
             return;
         }
-        // Operation, continuation, and attempt spans use explicit monotonic
-        // timestamps rather than durable start/end timestamps. Durable timestamps
-        // can predate this invocation, while letting each span use the tracer's
-        // default timestamp can give it an independent wall-clock anchor. A shared
-        // monotonic clock keeps children inside their parent timing envelopes.
-        // Only the parentless Workflow span keeps a backdated start.
-        const deterministicSpanId = globalIdGenerator.deriveSpanIdFromOperationId(info.id, this.executionArn);
+        // All live spans use the invocation's wall-anchored monotonic clock, so
+        // wall-clock adjustments cannot collapse or inflate their durations.
+        // Invocation cleanup shares one end time for open spans. Durable timestamps
+        // can predate this invocation and are used only for the backdated Workflow
+        // and synthetic execution root starts.
+        const deterministicSpanId = pluginRegistration.deriveSpanIdFromOperationId(info.id, this.executionArn);
         const spanName = info.name ?? info.type;
         // Resolve parent span: use parentId from map, or fall back to invocation span
         let parentSpan;
@@ -371,7 +495,7 @@ class InvocationOtelPlugin {
             }, () => this.startSpan(spanName, {
                 attributes,
                 links: this.workflowLinks(),
-                startTime: core.hrTime(),
+                startTime: this.liveTimestamp(),
             }, parentContext));
         }
         else if (info.type === "CONTEXT" || info.type === "STEP") {
@@ -380,17 +504,10 @@ class InvocationOtelPlugin {
             // to the reproducible Workflow span, and links back to the initial logical
             // operation span (deterministic on the execution trace) so the segments
             // stay correlated across invocations.
-            //
-            // WaitForCondition is modeled differently by the OTel conformance
-            // contract: the resumed operation span keeps only its Workflow link, while
-            // the non-terminal first polling attempt links back to the first operation
-            // span once it is known to have completed successfully.
             span = this.startSpan(spanName, {
                 attributes,
-                links: info.subType === "WaitForCondition"
-                    ? this.workflowLinks()
-                    : this.replayLinks(info.id),
-                startTime: core.hrTime(),
+                links: this.replayLinks(info.id),
+                startTime: this.liveTimestamp(),
             }, parentContext);
         }
         // Push to map and stack
@@ -410,20 +527,33 @@ class InvocationOtelPlugin {
         return api.context.with(api.trace.setSpan(api.context.active(), span), fn);
     }
     async onOperationEnd(info) {
+        this.finishOperation(info);
+    }
+    // Child completion and parent finalization share one synchronous turn. A
+    // provider flush must not reset invocation state between these two actions.
+    finishOperation(info) {
         if (!this.tracingEnabled) {
             return;
         }
-        // Skip span creation for WAIT, INVOKE, CHAINED_INVOKE, and CALLBACK operations on replay
-        if (info.isReplay &&
-            (info.type === "WAIT" ||
-                info.type === "INVOKE" ||
-                info.type === "CHAINED_INVOKE" ||
-                info.type === "CALLBACK")) {
+        // Checkpoint updates may complete an unawaited operation from an earlier
+        // invocation. Drain it before removing its live parent from spanMap.
+        if (info.type === "CONTEXT" && !info.isReplay) {
+            for (const child of this.externalCompletions.pending.values()) {
+                if (child.parentId === info.id) {
+                    this.finishOperation({ ...child, isReplay: false });
+                }
+            }
+        }
+        // Updates and traversal can report the same completion in either order.
+        // The set is reset each invocation so failed-invocation redelivery remains
+        // eligible, while normal replay never exports a completion a second time.
+        if (this.externalCompletions.shouldSkip(info)) {
             return;
         }
-        if (this.spanMap.has(info.id)) {
-            // Operation was started in this invocation
-            const span = this.spanMap.get(info.id);
+        const currentSpan = this.spanMap.get(info.id);
+        if (currentSpan && !this.endedOperationSpans.has(currentSpan)) {
+            // Operation was started in this invocation and its segment is still open
+            const span = currentSpan;
             // Finalize the operation status from the core-supplied terminal status.
             // Container CONTEXT ops receive a terminal status from the core too:
             // run-in-child-context-handler passes SUCCEEDED/FAILED on both the
@@ -438,25 +568,12 @@ class InvocationOtelPlugin {
                 info.attempt != null) {
                 span.setAttribute("durable.attempt.number", info.attempt);
             }
-            // Record error if present; otherwise stamp explicit OK ONLY on a
-            // SUCCEEDED terminal status (matches Python OTel plugin #604). Only
-            // reached for operations that terminate this invocation — suspended ops
-            // early-return above and keep their STARTED status UNSET. Terminal
-            // FAILURE statuses (TIMED_OUT/STOPPED/FAILED/CANCELLED) can arrive with
-            // NO error object (callback-timeout, chained-invoke fast paths); those
-            // must NOT be labelled OK, so they are left UNSET.
+            pluginRegistration.setOperationSpanStatus(span, info);
             if (info.error) {
-                span.setStatus({
-                    code: api.SpanStatusCode.ERROR,
-                    message: info.error.message,
-                });
-                span.recordException(info.error);
-            }
-            else if (info.status === "SUCCEEDED") {
-                span.setStatus({ code: api.SpanStatusCode.OK });
+                span.recordException(info.error, this.liveTimestamp());
             }
             // End the span
-            span.end(core.hrTime());
+            this.endOperationSpan(span, this.liveTimestamp());
             // Remove from map
             this.spanMap.delete(info.id);
             // Remove from stack (find by reference)
@@ -465,7 +582,11 @@ class InvocationOtelPlugin {
                 this.spanStack.splice(stackIndex, 1);
             }
         }
-        else if (!info.isReplay) {
+        else if (!info.isReplay ||
+            this.externalCompletions.pending.has(info.id)) {
+            // A fresh checkpoint completion can be replay-marked: updated IDs were
+            // captured before this invocation received the update. Export it while
+            // its child parent is still active, without changing the SDK's info.
             // Operation was started in a prior invocation — create Continuation_Span
             const spanName = info.name ?? info.type;
             // Resolve parent span: use parentId from map (e.g. the CONTEXT span for
@@ -507,27 +628,16 @@ class InvocationOtelPlugin {
                 // deterministic on the execution trace, so the segments of one logical
                 // operation stay correlated across invocations.
                 links: this.replayLinks(info.id),
-                startTime: core.hrTime(),
+                startTime: this.liveTimestamp(),
             }, parentContext);
-            // Record error if present; otherwise stamp explicit OK ONLY on a
-            // SUCCEEDED terminal status (matches Python OTel plugin #604). This is
-            // the terminal completion path for an operation started in a prior
-            // invocation. Terminal FAILURE statuses can arrive with NO error object
-            // (callback-timeout, chained-invoke 'already failed' cross-invocation
-            // fast paths); those must NOT be labelled OK, so they are left UNSET.
+            pluginRegistration.setOperationSpanStatus(continuationSpan, info);
             if (info.error) {
-                continuationSpan.setStatus({
-                    code: api.SpanStatusCode.ERROR,
-                    message: info.error.message,
-                });
-                continuationSpan.recordException(info.error);
-            }
-            else if (info.status === "SUCCEEDED") {
-                continuationSpan.setStatus({ code: api.SpanStatusCode.OK });
+                continuationSpan.recordException(info.error, this.liveTimestamp());
             }
             // Immediately end
-            continuationSpan.end(core.hrTime());
+            this.endOperationSpan(continuationSpan, this.liveTimestamp());
         }
+        this.externalCompletions.markExported(info);
     }
     async onOperationAttemptStart(info) {
         if (!this.tracingEnabled) {
@@ -557,7 +667,7 @@ class InvocationOtelPlugin {
         }
         const attemptSpan = this.startSpan(spanName, {
             attributes,
-            startTime: core.hrTime(),
+            startTime: this.liveTimestamp(),
         }, parentContext);
         this.spanMap.set(this.attemptSpanKey(info.id, info.attempt), attemptSpan);
     }
@@ -578,7 +688,7 @@ class InvocationOtelPlugin {
         const key = this.attemptSpanKey(info.id, info.attempt);
         const attemptSpan = this.spanMap.get(key);
         if (attemptSpan) {
-            attemptSpan.addLinks(this.attemptLinks(info));
+            attemptSpan.addLinks(this.workflowLinks());
             attemptSpan.setAttribute("durable.attempt.outcome", info.outcome);
             if (info.outcome === "FAILED") {
                 attemptSpan.setStatus({
@@ -586,19 +696,21 @@ class InvocationOtelPlugin {
                     message: info.error?.message ?? "Attempt failed",
                 });
                 if (info.error) {
-                    attemptSpan.recordException(info.error);
+                    attemptSpan.recordException(info.error, this.liveTimestamp());
                 }
             }
             else {
                 // Non-failed attempt: stamp explicit OK (matches Python OTel #604).
                 attemptSpan.setStatus({ code: api.SpanStatusCode.OK });
             }
-            attemptSpan.end(core.hrTime());
+            this.endOperationSpan(attemptSpan, this.liveTimestamp());
             this.spanMap.delete(key);
         }
     }
-    async onOperationChange(_info) {
-        // No-op for this plugin
+    async onOperationChange(info) {
+        if (this.tracingEnabled) {
+            this.externalCompletions.observe(info.updatedOperations, info.operations);
+        }
     }
     enrichLogContext() {
         if (!this.tracingEnabled || !this.enrichLogger) {
@@ -646,14 +758,6 @@ class InvocationOtelPlugin {
         links.push(...this.workflowLinks());
         return links;
     }
-    attemptLinks(info) {
-        if (info.subType === "WaitForCondition" &&
-            info.attempt === 1 &&
-            info.outcome === "SUCCEEDED") {
-            return this.replayLinks(info.id);
-        }
-        return this.workflowLinks();
-    }
     attemptSpanKey(operationId, attempt) {
         return `attempt:${operationId}:${attempt}`;
     }