@temelj/workflow 0.0.0-alpha.3 → 0.0.0-alpha.4

package/dist/otel/spans.mjs

@@ -0,0 +1,218 @@
+import { optionalDurationBetweenMilliseconds } from "../temporal.mjs";
+import { WORKFLOW_ATTRIBUTES, WORKFLOW_MESSAGING_ATTRIBUTES, WORKFLOW_SPAN_NAMES } from "../telemetry.mjs";
+import { contextFromTraceContext, errorRecordToException, spanLinkFromTraceContext, streamStatusFromEventKind, toException } from "./support.mjs";
+import { SpanStatusCode } from "@opentelemetry/api";
+//#region src/otel/spans.ts
+/** Records the spans for durable events, messages, hooks, schedules, workers, and streams. */
+var SpanRecorder = class {
+	#tracer;
+	#metrics;
+	#attributes;
+	constructor(tracer, metrics, attributes) {
+		this.#tracer = tracer;
+		this.#metrics = metrics;
+		this.#attributes = attributes;
+	}
+	recordDurableEventLatency(event, history) {
+		if (event.event.kind !== "message_wait_completed") return;
+		const completed = event.event;
+		const started = history.startedMessageWaitForCompleted(completed);
+		if (started === void 0) return;
+		const latency = optionalDurationBetweenMilliseconds(started.timestamp, completed.messageTimestamp);
+		if (latency === void 0) return;
+		const source = started.source ?? "message";
+		const attributes = this.#attributes({ [WORKFLOW_ATTRIBUTES.messageSource]: source });
+		this.#metrics.messageWaitLatency.record(latency, attributes);
+		if (source === "hook" || source === "webhook") this.#metrics.hookResumeLatency.record(latency, this.#attributes({ [WORKFLOW_ATTRIBUTES.hookKind]: source }));
+		this.recordMessageWaitSpan(completed, started, history);
+	}
+	recordDurableSleepSpan(event, history) {
+		if (event.event.kind !== "sleep_completed") return;
+		const completed = event.event;
+		const started = history.startedSleepForCompleted(completed);
+		if (started === void 0) return;
+		const requestedDuration = started.duration?.total({ unit: "millisecond" });
+		const actualDuration = optionalDurationBetweenMilliseconds(started.timestamp, completed.timestamp);
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.sleep, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.stepId]: completed.stepId,
+			[WORKFLOW_ATTRIBUTES.stepName]: completed.stepName,
+			[WORKFLOW_ATTRIBUTES.stepKind]: "sleep",
+			[WORKFLOW_ATTRIBUTES.sleepUntil]: started.until.toString(),
+			[WORKFLOW_ATTRIBUTES.sleepDurationMs]: requestedDuration,
+			[WORKFLOW_ATTRIBUTES.sleepActualMs]: actualDuration
+		}) });
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordChildWorkflowOperationSpan(event, history) {
+		if (event.event.kind !== "child_workflow_completed" && event.event.kind !== "child_workflow_failed") return;
+		const terminal = event.event;
+		const started = history.startedChildWorkflowForTerminal(terminal);
+		const duration = started === void 0 ? void 0 : optionalDurationBetweenMilliseconds(started.timestamp, terminal.timestamp);
+		const failed = terminal.kind === "child_workflow_failed";
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.childWorkflowOperation, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.stepId]: terminal.stepId,
+			[WORKFLOW_ATTRIBUTES.stepName]: terminal.stepName,
+			[WORKFLOW_ATTRIBUTES.stepKind]: "workflow",
+			[WORKFLOW_ATTRIBUTES.stepAttempt]: terminal.attempt,
+			[WORKFLOW_ATTRIBUTES.childWorkflowOperation]: failed ? "fail" : "complete",
+			[WORKFLOW_ATTRIBUTES.childWorkflowRunId]: terminal.childRunId,
+			[WORKFLOW_ATTRIBUTES.childWorkflowName]: started?.workflowName,
+			[WORKFLOW_ATTRIBUTES.childWorkflowVersion]: started?.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.childWorkflowStatus]: failed ? "failed" : "completed",
+			[WORKFLOW_ATTRIBUTES.childWorkflowDurationMs]: duration,
+			[WORKFLOW_ATTRIBUTES.errorKind]: failed ? terminal.error.name : void 0
+		}) });
+		if (failed) {
+			span.recordException(errorRecordToException(terminal.error));
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: terminal.error.message
+			});
+		} else span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordChildWorkflowStartedSpan(event) {
+		const started = event.event;
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.childWorkflowOperation, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.stepId]: started.stepId,
+			[WORKFLOW_ATTRIBUTES.stepName]: started.stepName,
+			[WORKFLOW_ATTRIBUTES.stepKind]: "workflow",
+			[WORKFLOW_ATTRIBUTES.stepAttempt]: started.attempt,
+			[WORKFLOW_ATTRIBUTES.childWorkflowOperation]: "start",
+			[WORKFLOW_ATTRIBUTES.childWorkflowRunId]: started.childRunId,
+			[WORKFLOW_ATTRIBUTES.childWorkflowName]: started.workflowName,
+			[WORKFLOW_ATTRIBUTES.childWorkflowVersion]: started.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.childWorkflowStatus]: "started"
+		}) });
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordMessageSentSpan(event) {
+		const parent = contextFromTraceContext(event.traceContext);
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.messageSend, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.messageId]: event.messageId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.system]: "temelj.workflow",
+			[WORKFLOW_MESSAGING_ATTRIBUTES.destinationName]: event.runId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.messageId]: event.messageId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.operationName]: "send",
+			[WORKFLOW_MESSAGING_ATTRIBUTES.operationType]: "publish"
+		}) }, parent);
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordHookResumeSpan(kind, event) {
+		const parent = contextFromTraceContext(event.traceContext);
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.hookResume, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.hookKind]: kind,
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.messageId]: event.messageId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.system]: "temelj.workflow",
+			[WORKFLOW_MESSAGING_ATTRIBUTES.destinationName]: event.runId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.messageId]: event.messageId,
+			[WORKFLOW_MESSAGING_ATTRIBUTES.operationName]: "resume",
+			[WORKFLOW_MESSAGING_ATTRIBUTES.operationType]: "publish"
+		}) }, parent);
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordScheduleRunCreatedSpan(event) {
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.scheduleRunCreate, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.workflowName]: event.workflowName,
+			[WORKFLOW_ATTRIBUTES.workflowVersion]: event.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.scheduleId]: event.scheduleId,
+			[WORKFLOW_ATTRIBUTES.scheduleFireAt]: event.fireAt.toString(),
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId
+		}) });
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordScheduleTickSpan(event) {
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.scheduleTick, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.scheduleTickedRuns]: event.result.ticked,
+			[WORKFLOW_ATTRIBUTES.scheduleTickedSchedules]: event.result.scheduleIds.length,
+			[WORKFLOW_ATTRIBUTES.scheduleNextAt]: event.result.nextScheduleAt === void 0 ? void 0 : event.result.nextScheduleAt.toString()
+		}) });
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordWorkerOperationSpan(event) {
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.workerOperation, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.workerId]: event.workerId,
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.workflowName]: event.run?.workflowName,
+			[WORKFLOW_ATTRIBUTES.workflowVersion]: event.run?.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.runStatus]: event.run?.status,
+			[WORKFLOW_ATTRIBUTES.workerOperation]: event.operation,
+			[WORKFLOW_ATTRIBUTES.workerOperationStatus]: event.status
+		}) });
+		if (event.status === "failure") {
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			if (event.error !== void 0) span.recordException(toException(event.error));
+		} else span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordCleanupOperationSpan(source, event) {
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.cleanupOperation, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.cleanupSource]: source,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedRuns]: event.result.deletedRuns,
+			[WORKFLOW_ATTRIBUTES.cleanupCreatedMarkers]: event.result.createdCleanupMarkers,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedMarkers]: event.result.deletedCleanupMarkers,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedEvents]: event.result.deletedEvents,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedStepAttempts]: event.result.deletedStepAttempts,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedIdempotencyKeys]: event.result.deletedIdempotencyKeys,
+			[WORKFLOW_ATTRIBUTES.cleanupDeletedMessageIdempotencyKeys]: event.result.deletedMessageIdempotencyKeys,
+			[WORKFLOW_ATTRIBUTES.cleanupDryRun]: event.result.dryRun,
+			[WORKFLOW_ATTRIBUTES.cleanupMatchedRuns]: event.result.matchedRuns ?? event.result.runIds.length
+		}) });
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	recordStreamOperationSpan(event) {
+		const span = this.#tracer.startSpan(WORKFLOW_SPAN_NAMES.streamOperation, { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.runId]: event.runId,
+			[WORKFLOW_ATTRIBUTES.streamId]: event.streamId,
+			[WORKFLOW_ATTRIBUTES.streamEventKind]: event.eventKind,
+			[WORKFLOW_ATTRIBUTES.streamStatus]: streamStatusFromEventKind(event.eventKind),
+			[WORKFLOW_ATTRIBUTES.stepId]: event.stepId,
+			[WORKFLOW_ATTRIBUTES.stepName]: event.stepName,
+			[WORKFLOW_ATTRIBUTES.streamIndex]: event.index,
+			[WORKFLOW_ATTRIBUTES.errorKind]: event.error?.name
+		}) });
+		if (event.error === void 0) span.setStatus({ code: SpanStatusCode.OK });
+		else {
+			span.recordException(errorRecordToException(event.error));
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: event.error.message
+			});
+		}
+		span.end();
+	}
+	recordMessageWaitSpan(completed, started, history) {
+		const message = history.messageSentByTimestamp(completed.messageId, completed.messageTimestamp);
+		const link = spanLinkFromTraceContext(completed.telemetryContext ?? message?.telemetryContext);
+		return this.#tracer.startActiveSpan(WORKFLOW_SPAN_NAMES.messageWait, {
+			attributes: this.#attributes({
+				[WORKFLOW_ATTRIBUTES.messageId]: completed.messageId,
+				[WORKFLOW_ATTRIBUTES.messageSource]: started.source ?? "message",
+				[WORKFLOW_ATTRIBUTES.stepId]: completed.stepId,
+				[WORKFLOW_ATTRIBUTES.stepName]: completed.stepName,
+				[WORKFLOW_MESSAGING_ATTRIBUTES.system]: "temelj.workflow",
+				[WORKFLOW_MESSAGING_ATTRIBUTES.messageId]: completed.messageId,
+				[WORKFLOW_MESSAGING_ATTRIBUTES.operationName]: "receive",
+				[WORKFLOW_MESSAGING_ATTRIBUTES.operationType]: "receive"
+			}),
+			links: link === void 0 ? [] : [link]
+		}, (span) => {
+			span.setStatus({ code: SpanStatusCode.OK });
+			span.end();
+		});
+	}
+};
+//#endregion
+export { SpanRecorder };

package/dist/otel/support.d.mts

@@ -1,18 +1,25 @@
+import { ExecutionResult } from "../types/result.mjs";
 import { TelemetryContext } from "../types/telemetry.mjs";
 import { StreamEventKind } from "../types/events.mjs";
 import { Context, Span, SpanContext } from "@opentelemetry/api";
 //#region src/otel/support.d.ts
-declare function withRunSpanStatus<T>(span: Span, callback: () => Promise<T>): Promise<T>;
-declare function withSpanStatus<T>(span: Span, callback: () => Promise<T>): Promise<T>;
-declare function contextFromTraceContext(traceContext: TelemetryContext | undefined): Context;
-declare function spanLinkFromTraceContext(traceContext: TelemetryContext | undefined): {
+interface SpanStatusHooks<T> {
+  /** Records a successful result; the span status defaults to OK when this is absent. */
+  readonly onSuccess?: (result: T) => void;
+  readonly onFailure?: () => void;
+}
+/** Runs `callback` in `span`, records its outcome, and ends the span. */
+export declare function withSpanStatus<T>(span: Span, callback: () => Promise<T>, hooks?: SpanStatusHooks<T>): Promise<T>;
+export declare function recordResultOnSpan(span: Span, result: ExecutionResult): void;
+export declare function contextFromTraceContext(traceContext: TelemetryContext | undefined): Context;
+export declare function spanLinkFromTraceContext(traceContext: TelemetryContext | undefined): {
   readonly context: SpanContext;
 } | undefined;
-declare function streamStatusFromEventKind(eventKind: StreamEventKind): "open" | "closed" | "failed";
-declare function errorRecordToException(error: {
+export declare function streamStatusFromEventKind(eventKind: StreamEventKind): "open" | "closed" | "failed";
+export declare function errorRecordToException(error: {
   readonly message: string;
   readonly name: string;
 }): Error;
-declare function toException(error: unknown): Error;
+export declare function toException(cause: unknown): Error;
 //#endregion
-export { contextFromTraceContext, errorRecordToException, spanLinkFromTraceContext, streamStatusFromEventKind, toException, withRunSpanStatus, withSpanStatus };
+export {};

package/dist/otel/support.mjs

@@ -1,25 +1,28 @@
+import { omitUndefined } from "../collection.mjs";
 import { WORKFLOW_ATTRIBUTES } from "../telemetry.mjs";
 import { SpanStatusCode, context, propagation } from "@opentelemetry/api";
 //#region src/otel/support.ts
-var WorkflowTelemetryException = class WorkflowTelemetryException extends Error {
-	constructor(message, name, context) {
+var TelemetryException = class TelemetryException extends Error {
+	constructor(message, name) {
 		super(message);
 		this.name = name;
-		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
 	}
 	static fromRecord(error) {
-		return new WorkflowTelemetryException(error.message, error.name, WorkflowTelemetryException.fromRecord);
+		return new TelemetryException(error.message, error.name);
 	}
-	static fromUnknown(error) {
-		return new WorkflowTelemetryException(String(error), "Error", WorkflowTelemetryException.fromUnknown);
+	static fromUnknown(cause) {
+		return new TelemetryException(String(cause), "Error");
 	}
 };
-async function withRunSpanStatus(span, callback) {
+/** Runs `callback` in `span`, records its outcome, and ends the span. */
+async function withSpanStatus(span, callback, hooks = {}) {
 	try {
 		const result = await callback();
-		recordWorkflowResultOnSpan(span, result);
+		if (hooks.onSuccess === void 0) span.setStatus({ code: SpanStatusCode.OK });
+		else hooks.onSuccess(result);
 		return result;
 	} catch (error) {
+		hooks.onFailure?.();
 		span.recordException(toException(error));
 		span.setStatus({ code: SpanStatusCode.ERROR });
 		throw error;
@@ -27,24 +30,7 @@ async function withRunSpanStatus(span, callback) {
 		span.end();
 	}
 }
-async function withSpanStatus(span, callback) {
-	try {
-		const result = await callback();
-		span.setStatus({ code: SpanStatusCode.OK });
-		return result;
-	} catch (error) {
-		span.recordException(toException(error));
-		span.setStatus({ code: SpanStatusCode.ERROR });
-		throw error;
-	} finally {
-		span.end();
-	}
-}
-function recordWorkflowResultOnSpan(span, result) {
-	if (!isExecutionResult(result)) {
-		span.setStatus({ code: SpanStatusCode.OK });
-		return;
-	}
+function recordResultOnSpan(span, result) {
 	span.setAttributes({
 		[WORKFLOW_ATTRIBUTES.runStatus]: result.run.status,
 		[WORKFLOW_ATTRIBUTES.runTransition]: result.run.lastTransitionReason
@@ -59,17 +45,9 @@ function recordWorkflowResultOnSpan(span, result) {
 	}
 	span.setStatus({ code: SpanStatusCode.OK });
 }
-function isExecutionResult(result) {
-	if (typeof result !== "object" || result === null || !("kind" in result) || !("run" in result)) return false;
-	const kind = result.kind;
-	return kind === "completed" || kind === "failed" || kind === "waiting";
-}
 function contextFromTraceContext(traceContext) {
 	if (traceContext === void 0) return context.active();
-	return propagation.extract(context.active(), {
-		...traceContext.traceparent === void 0 ? {} : { traceparent: traceContext.traceparent },
-		...traceContext.tracestate === void 0 ? {} : { tracestate: traceContext.tracestate }
-	});
+	return propagation.extract(context.active(), omitUndefined(traceContext));
 }
 function spanLinkFromTraceContext(traceContext) {
 	if (traceContext?.traceparent === void 0) return;
@@ -92,11 +70,11 @@ function streamStatusFromEventKind(eventKind) {
 	}
 }
 function errorRecordToException(error) {
-	return WorkflowTelemetryException.fromRecord(error);
+	return TelemetryException.fromRecord(error);
 }
-function toException(error) {
-	if (error instanceof Error) return error;
-	return WorkflowTelemetryException.fromUnknown(error);
+function toException(cause) {
+	if (cause instanceof Error) return cause;
+	return TelemetryException.fromUnknown(cause);
 }
 //#endregion
-export { contextFromTraceContext, errorRecordToException, spanLinkFromTraceContext, streamStatusFromEventKind, toException, withRunSpanStatus, withSpanStatus };
+export { contextFromTraceContext, errorRecordToException, recordResultOnSpan, spanLinkFromTraceContext, streamStatusFromEventKind, toException, withSpanStatus };

package/dist/{otel.d.mts → otel/telemetry.d.mts}

@@ -1,6 +1,6 @@
-import { Telemetry } from "./types/telemetry.mjs";
-//#region src/otel.d.ts
-interface OpenTelemetryWorkflowTelemetryOptions {
+import { Telemetry } from "../types/telemetry.mjs";
+//#region src/otel/telemetry.d.ts
+export interface OpenTelemetryWorkflowTelemetryOptions {
   readonly serviceNamespace?: string;
   readonly includeStepNameMetricAttribute?: boolean;
   /**
@@ -25,6 +25,5 @@ interface OpenTelemetryWorkflowTelemetryOptions {
    */
   readonly shutdown?: () => Promise<void> | void;
 }
-declare function createOpenTelemetryTelemetry(options?: OpenTelemetryWorkflowTelemetryOptions): Telemetry;
-//#endregion
-export { OpenTelemetryWorkflowTelemetryOptions, createOpenTelemetryTelemetry };
+export declare function createOpenTelemetryTelemetry(options?: OpenTelemetryWorkflowTelemetryOptions): Telemetry;
+//#endregion

package/dist/otel/telemetry.mjs

@@ -0,0 +1,305 @@
+import { optionalDurationBetweenMilliseconds } from "../temporal.mjs";
+import { omitUndefined } from "../collection.mjs";
+import { getEventDescriptor } from "../events/descriptors.mjs";
+import { History } from "../history/replay.mjs";
+import { WORKFLOW_ATTRIBUTES, WORKFLOW_INSTRUMENTATION_NAME, WORKFLOW_INSTRUMENTATION_VERSION, WORKFLOW_METRIC_NAMES, WORKFLOW_SPAN_NAMES, WORKFLOW_SYSTEM } from "../telemetry.mjs";
+import { createInstruments } from "./metrics.mjs";
+import { contextFromTraceContext, recordResultOnSpan, streamStatusFromEventKind, withSpanStatus } from "./support.mjs";
+import { SpanRecorder } from "./spans.mjs";
+import { SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
+//#region src/otel/telemetry.ts
+function createOpenTelemetryTelemetry(options = {}) {
+	return new OpenTelemetryTelemetry(options);
+}
+var OpenTelemetryTelemetry = class {
+	#tracer = trace.getTracer(WORKFLOW_INSTRUMENTATION_NAME, WORKFLOW_INSTRUMENTATION_VERSION);
+	#meter = metrics.getMeter(WORKFLOW_INSTRUMENTATION_NAME, WORKFLOW_INSTRUMENTATION_VERSION);
+	#options;
+	#metrics = createInstruments(this.#meter);
+	#spans = new SpanRecorder(this.#tracer, this.#metrics, (attributes) => this.#attributes(attributes));
+	#runGauge;
+	#workerActiveExecutionsGauge;
+	#engine;
+	constructor(options) {
+		this.#options = options;
+		this.#runGauge = this.#meter.createObservableGauge(WORKFLOW_METRIC_NAMES.runs, { description: "Current count of workflow runs by status." });
+		this.#workerActiveExecutionsGauge = this.#meter.createObservableGauge(WORKFLOW_METRIC_NAMES.workerActiveExecutions, { description: "Current count of workflow runs actively held by workers." });
+		this.#runGauge.addCallback(async (result) => {
+			if (this.#engine?.getRunSummary === void 0) return;
+			try {
+				const summary = await this.#engine.getRunSummary();
+				for (const [status, count] of Object.entries(summary.status)) result.observe(count, this.#attributes({ [WORKFLOW_ATTRIBUTES.runStatus]: status }));
+			} catch {
+				return;
+			}
+		});
+		this.#workerActiveExecutionsGauge.addCallback(async (result) => {
+			if (this.#engine?.getRunSummary === void 0) return;
+			try {
+				const summary = await this.#engine.getRunSummary();
+				result.observe(summary.status.running, this.#attributes({ [WORKFLOW_ATTRIBUTES.runStatus]: "running" }));
+			} catch {
+				return;
+			}
+		});
+	}
+	captureContext() {
+		const carrier = {};
+		propagation.inject(context.active(), carrier);
+		return Object.keys(carrier).length === 0 ? void 0 : omitUndefined({
+			traceparent: carrier.traceparent,
+			tracestate: carrier.tracestate
+		});
+	}
+	async withRunExecution(telemetryContext, callback) {
+		const parent = contextFromTraceContext(telemetryContext.traceContext);
+		return await this.#tracer.startActiveSpan(this.#runExecutionSpanName(telemetryContext), { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.workflowName]: telemetryContext.run.workflowName,
+			[WORKFLOW_ATTRIBUTES.workflowVersion]: telemetryContext.run.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.runId]: telemetryContext.run.id,
+			[WORKFLOW_ATTRIBUTES.namespace]: telemetryContext.run.namespace,
+			[WORKFLOW_ATTRIBUTES.runAttempt]: telemetryContext.run.attempts,
+			[WORKFLOW_ATTRIBUTES.workerId]: telemetryContext.run.workerId
+		}) }, parent, (span) => withSpanStatus(span, callback, { onSuccess: (result) => recordResultOnSpan(span, result) }));
+	}
+	async withStepExecution(telemetryContext, callback) {
+		return await this.#tracer.startActiveSpan(this.#stepExecutionSpanName(telemetryContext), { attributes: this.#attributes({
+			[WORKFLOW_ATTRIBUTES.workflowName]: telemetryContext.run.workflowName,
+			[WORKFLOW_ATTRIBUTES.workflowVersion]: telemetryContext.run.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.runId]: telemetryContext.run.id,
+			[WORKFLOW_ATTRIBUTES.stepId]: telemetryContext.step.id,
+			[WORKFLOW_ATTRIBUTES.stepName]: telemetryContext.step.name,
+			[WORKFLOW_ATTRIBUTES.stepKind]: telemetryContext.step.kind,
+			[WORKFLOW_ATTRIBUTES.stepAttempt]: telemetryContext.attempt,
+			[WORKFLOW_ATTRIBUTES.stepTimeoutAt]: telemetryContext.timeoutAt === void 0 ? void 0 : telemetryContext.timeoutAt.toString()
+		}) }, (span) => withSpanStatus(span, callback));
+	}
+	async withStorageOperation(telemetryContext, callback) {
+		const startedAt = Date.now();
+		const attributes = this.#attributes({
+			[WORKFLOW_ATTRIBUTES.storageOperation]: telemetryContext.operation,
+			[WORKFLOW_ATTRIBUTES.storageBackend]: telemetryContext.backend
+		});
+		if (this.#options.includeStorageOperationSpans === false) try {
+			const result = await callback();
+			this.#recordStorageOperationResult(startedAt, attributes, "success");
+			return result;
+		} catch (error) {
+			this.#recordStorageOperationResult(startedAt, attributes, "failure");
+			throw error;
+		}
+		return await this.#tracer.startActiveSpan(WORKFLOW_SPAN_NAMES.storageOperation, { attributes }, async (span) => {
+			const record = (status) => {
+				this.#recordStorageOperationResult(startedAt, attributes, status);
+				span.setAttribute(WORKFLOW_ATTRIBUTES.storageOperationStatus, status);
+			};
+			return await withSpanStatus(span, callback, {
+				onSuccess: () => {
+					record("success");
+					span.setStatus({ code: SpanStatusCode.OK });
+				},
+				onFailure: () => record("failure")
+			});
+		});
+	}
+	recordRunExecution(telemetryContext) {
+		const result = telemetryContext.result;
+		if (result?.kind === "completed" || result?.kind === "failed") {
+			const duration = optionalDurationBetweenMilliseconds(result.run.startedAt ?? result.run.createdAt, result.run.finishedAt);
+			if (duration !== void 0) this.#metrics.runDuration.record(duration, this.#attributes({
+				[WORKFLOW_ATTRIBUTES.workflowName]: result.run.workflowName,
+				[WORKFLOW_ATTRIBUTES.workflowVersion]: result.run.workflowVersion,
+				[WORKFLOW_ATTRIBUTES.runStatus]: result.run.status
+			}));
+		}
+	}
+	observe(...[name, event]) {
+		switch (name) {
+			case "workflow:run-created":
+			case "workflow:run-waiting":
+			case "workflow:run-rescheduled":
+			case "workflow:run-manual-retry":
+			case "workflow:run-completed":
+			case "workflow:run-canceled":
+				this.#recordRunTransition(event);
+				break;
+			case "workflow:run-failed":
+				this.#recordRunTransition(event);
+				this.#recordRetryExhausted(event);
+				break;
+			case "workflow:run-permanently-failed":
+				this.#recordRunTransition(event);
+				this.#recordRetryExhausted(event);
+				break;
+			case "workflow:run-claimed": {
+				this.#recordRunTransition(event);
+				const attributes = this.#runMetricAttributes(event, { [WORKFLOW_ATTRIBUTES.workerOperation]: event.reason });
+				this.#metrics.workerClaims.add(1, attributes);
+				const startedAt = event.previousRun?.availableAt ?? event.run.availableAt ?? event.run.createdAt;
+				const latency = optionalDurationBetweenMilliseconds(startedAt, event.timestamp);
+				if (latency !== void 0) this.#metrics.pendingToClaimedLatency.record(latency, attributes);
+				break;
+			}
+			case "workflow:run-started": {
+				this.#recordRunTransition(event);
+				if (event.previousRun?.status !== "waiting") break;
+				const startedAt = event.previousRun.availableAt ?? event.previousRun.lastTransitionAt;
+				const latency = optionalDurationBetweenMilliseconds(startedAt, event.timestamp);
+				if (latency !== void 0) this.#metrics.waitingToResumedLatency.record(latency, this.#runMetricAttributes(event));
+				break;
+			}
+			case "workflow:run-lease-released":
+				this.#recordRunTransition(event);
+				this.#metrics.workerLeaseReleases.add(1, this.#runMetricAttributes(event));
+				break;
+			case "workflow:run-retrying": {
+				this.#recordRunTransition(event);
+				const attributes = event.run.retryReason === void 0 ? this.#runMetricAttributes(event) : this.#runMetricAttributes(event, { [WORKFLOW_ATTRIBUTES.retryReason]: event.run.retryReason });
+				this.#metrics.retryScheduled.add(1, attributes);
+				const delay = optionalDurationBetweenMilliseconds(event.timestamp, event.run.retryAt);
+				if (delay !== void 0) this.#metrics.retryDelay.record(delay, attributes);
+				break;
+			}
+			case "workflow:durable-event-appended": {
+				const descriptor = getEventDescriptor(event.event.kind);
+				this.#metrics.eventsAppended.add(1, this.#attributes({
+					[WORKFLOW_ATTRIBUTES.eventKind]: descriptor.kind,
+					[WORKFLOW_ATTRIBUTES.eventCategory]: descriptor.category
+				}));
+				const history = new History(event.events);
+				this.#spans.recordDurableEventLatency(event, history);
+				this.#spans.recordDurableSleepSpan(event, history);
+				this.#spans.recordChildWorkflowOperationSpan(event, history);
+				break;
+			}
+			case "workflow:step-attempt-updated": {
+				const attributes = this.#attributes({
+					[WORKFLOW_ATTRIBUTES.stepKind]: event.attempt.kind,
+					[WORKFLOW_ATTRIBUTES.stepStatus]: event.attempt.status,
+					[WORKFLOW_ATTRIBUTES.stepName]: this.#options.includeStepNameMetricAttribute ? event.attempt.stepName : void 0
+				});
+				this.#metrics.stepAttempts.add(1, attributes);
+				if (event.attempt.status === "completed" || event.attempt.status === "failed") {
+					const duration = optionalDurationBetweenMilliseconds(event.attempt.startedAt, event.attempt.finishedAt);
+					if (duration !== void 0) this.#metrics.stepDuration.record(duration, attributes);
+				}
+				break;
+			}
+			case "workflow:message-sent":
+				this.#metrics.messagesSent.add(1, this.#attributes({}));
+				this.#spans.recordMessageSentSpan(event);
+				break;
+			case "workflow:hook-resumed":
+				this.#metrics.hooksResumed.add(1, this.#attributes({ [WORKFLOW_ATTRIBUTES.hookKind]: "hook" }));
+				this.#spans.recordHookResumeSpan("hook", event);
+				break;
+			case "workflow:webhook-resumed":
+				this.#metrics.hooksResumed.add(1, this.#attributes({ [WORKFLOW_ATTRIBUTES.hookKind]: "webhook" }));
+				this.#spans.recordHookResumeSpan("webhook", event);
+				break;
+			case "workflow:stream-updated":
+				this.#metrics.streamUpdates.add(1, this.#attributes({
+					[WORKFLOW_ATTRIBUTES.streamEventKind]: event.eventKind,
+					[WORKFLOW_ATTRIBUTES.streamStatus]: streamStatusFromEventKind(event.eventKind)
+				}));
+				this.#spans.recordStreamOperationSpan(event);
+				break;
+			case "workflow:child-workflow-started":
+				this.#spans.recordChildWorkflowStartedSpan(event);
+				break;
+			case "workflow:cleanup-completed":
+				this.#metrics.cleanupDeletedRuns.add(event.result.deletedRuns, this.#attributes({ [WORKFLOW_ATTRIBUTES.cleanupSource]: "cleanup" }));
+				this.#spans.recordCleanupOperationSpan("cleanup", event);
+				break;
+			case "workflow:retention-applied":
+				this.#metrics.cleanupDeletedRuns.add(event.result.deletedRuns, this.#attributes({ [WORKFLOW_ATTRIBUTES.cleanupSource]: "retention" }));
+				this.#spans.recordCleanupOperationSpan("retention", event);
+				break;
+			case "workflow:worker-operation": {
+				const attributes = this.#attributes({
+					[WORKFLOW_ATTRIBUTES.workerOperation]: event.operation,
+					[WORKFLOW_ATTRIBUTES.workerOperationStatus]: event.status
+				});
+				if (event.operation === "claim" && event.status === "failure") this.#metrics.workerClaimFailures.add(1, attributes);
+				if (event.operation === "heartbeat" && event.status === "failure") this.#metrics.workerHeartbeatFailures.add(1, attributes);
+				if (event.operation === "lease_extension") this.#metrics.workerLeaseExtensions.add(1, attributes);
+				if (event.operation === "lease_release") this.#metrics.workerLeaseReleases.add(1, attributes);
+				this.#spans.recordWorkerOperationSpan(event);
+				break;
+			}
+			case "workflow:schedule-ticked":
+				this.#spans.recordScheduleTickSpan(event);
+				break;
+			case "workflow:schedule-run-created": {
+				const attributes = this.#attributes({
+					[WORKFLOW_ATTRIBUTES.workflowName]: event.workflowName,
+					[WORKFLOW_ATTRIBUTES.workflowVersion]: event.workflowVersion
+				});
+				const latency = optionalDurationBetweenMilliseconds(event.fireAt, event.timestamp);
+				if (latency !== void 0) this.#metrics.scheduleDueToRunCreatedLatency.record(latency, attributes);
+				this.#spans.recordScheduleRunCreatedSpan(event);
+				break;
+			}
+		}
+	}
+	bindEngine(engine) {
+		this.#engine = engine;
+	}
+	async shutdown() {
+		const errors = [];
+		try {
+			await this.#options.forceFlush?.();
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			await this.#options.shutdown?.();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw errors[0];
+	}
+	#recordRunTransition(event) {
+		this.#metrics.runTransitions.add(1, this.#runMetricAttributes(event));
+	}
+	#recordRetryExhausted(event) {
+		const retryReason = event.previousRun?.retryReason ?? ((event.previousRun?.attempts ?? event.run.attempts ?? 1) > 1 ? "workflow" : void 0);
+		if (retryReason === void 0) return;
+		this.#metrics.retryExhausted.add(1, this.#runMetricAttributes(event, {
+			[WORKFLOW_ATTRIBUTES.retryReason]: retryReason,
+			[WORKFLOW_ATTRIBUTES.retryExhausted]: true
+		}));
+	}
+	#attributes(attributes) {
+		return omitUndefined({
+			"service.namespace": this.#options.serviceNamespace,
+			[WORKFLOW_ATTRIBUTES.system]: WORKFLOW_SYSTEM,
+			...attributes
+		});
+	}
+	#runExecutionSpanName(telemetryContext) {
+		return this.#options.includeNamesInSpanNames === true ? `${WORKFLOW_SPAN_NAMES.runExecution} ${telemetryContext.run.workflowName}` : WORKFLOW_SPAN_NAMES.runExecution;
+	}
+	#stepExecutionSpanName(telemetryContext) {
+		return this.#options.includeNamesInSpanNames === true ? `${WORKFLOW_SPAN_NAMES.stepExecution} ${telemetryContext.step.name}` : WORKFLOW_SPAN_NAMES.stepExecution;
+	}
+	#recordStorageOperationResult(startedAt, attributes, status) {
+		const resultAttributes = {
+			...attributes,
+			[WORKFLOW_ATTRIBUTES.storageOperationStatus]: status
+		};
+		this.#metrics.storageOperationDuration.record(Date.now() - startedAt, resultAttributes);
+		if (status === "failure") this.#metrics.storageOperationErrors.add(1, resultAttributes);
+	}
+	#runMetricAttributes(event, attributes = {}) {
+		return this.#attributes({
+			[WORKFLOW_ATTRIBUTES.workflowName]: event.workflowName,
+			[WORKFLOW_ATTRIBUTES.workflowVersion]: event.workflowVersion,
+			[WORKFLOW_ATTRIBUTES.runStatus]: event.status,
+			[WORKFLOW_ATTRIBUTES.runTransition]: event.reason,
+			...attributes
+		});
+	}
+};
+//#endregion
+export { createOpenTelemetryTelemetry };