@temelj/workflow 0.0.0-alpha.1

package/dist/otel/support.mjs

@@ -0,0 +1,102 @@
+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) {
+		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);
+	}
+	static fromUnknown(error) {
+		return new WorkflowTelemetryException(String(error), "Error", WorkflowTelemetryException.fromUnknown);
+	}
+};
+async function withRunSpanStatus(span, callback) {
+	try {
+		const result = await callback();
+		recordWorkflowResultOnSpan(span, result);
+		return result;
+	} catch (error) {
+		span.recordException(toException(error));
+		span.setStatus({ code: SpanStatusCode.ERROR });
+		throw error;
+	} finally {
+		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;
+	}
+	span.setAttributes({
+		[WORKFLOW_ATTRIBUTES.runStatus]: result.run.status,
+		[WORKFLOW_ATTRIBUTES.runTransition]: result.run.lastTransitionReason
+	});
+	if (result.kind === "failed") {
+		span.recordException(result.error);
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: result.error.message
+		});
+		return;
+	}
+	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 }
+	});
+}
+function spanLinkFromTraceContext(traceContext) {
+	if (traceContext?.traceparent === void 0) return;
+	const match = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/iu.exec(traceContext.traceparent);
+	if (match === null) return;
+	const [, traceId, spanId, flags] = match;
+	if (traceId === "0".repeat(32) || spanId === "0".repeat(16)) return;
+	return { context: {
+		traceId,
+		spanId,
+		traceFlags: Number.parseInt(flags, 16) & 1
+	} };
+}
+function streamStatusFromEventKind(eventKind) {
+	switch (eventKind) {
+		case "stream_started":
+		case "stream_chunk": return "open";
+		case "stream_closed": return "closed";
+		case "stream_failed": return "failed";
+	}
+}
+function errorRecordToException(error) {
+	return WorkflowTelemetryException.fromRecord(error);
+}
+function toException(error) {
+	if (error instanceof Error) return error;
+	return WorkflowTelemetryException.fromUnknown(error);
+}
+//#endregion
+export { contextFromTraceContext, errorRecordToException, spanLinkFromTraceContext, streamStatusFromEventKind, toException, withRunSpanStatus, withSpanStatus };

package/dist/otel.d.mts

@@ -0,0 +1,30 @@
+import { Telemetry } from "./types/telemetry.mjs";
+//#region src/otel.d.ts
+interface OpenTelemetryWorkflowTelemetryOptions {
+  readonly serviceNamespace?: string;
+  readonly includeStepNameMetricAttribute?: boolean;
+  /**
+   * Adds workflow and step names to span names so trace UIs can distinguish rows
+   * even when they do not show attributes by default.
+   */
+  readonly includeNamesInSpanNames?: boolean;
+  /**
+   * Emits a span around every workflow storage/backend operation.
+   * Disable this in demos or high-volume services when these low-level spans
+   * drown out workflow run and step spans in trace search results.
+   */
+  readonly includeStorageOperationSpans?: boolean;
+  /**
+   * Optional callback used by `Telemetry.shutdown` to flush SDK processors/exporters.
+   * Pass your tracer or meter provider's `forceFlush` when the workflow engine owns shutdown.
+   */
+  readonly forceFlush?: () => Promise<void> | void;
+  /**
+   * Optional callback used by `Telemetry.shutdown` to release SDK resources.
+   * The adapter stays SDK-agnostic, so provider shutdown is supplied by the caller.
+   */
+  readonly shutdown?: () => Promise<void> | void;
+}
+declare function createOpenTelemetryTelemetry(options?: OpenTelemetryWorkflowTelemetryOptions): Telemetry;
+//#endregion
+export { OpenTelemetryWorkflowTelemetryOptions, createOpenTelemetryTelemetry };