@restatedev/restate-sdk-opentelemetry 0.0.0-SNAPSHOT-20260409150343

package/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,3 @@
+# @restatedev/restate-sdk-opentelemetry
+
+OpenTelemetry helpers for the Restate TypeScript SDK.

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,3 @@
+const require_opentelemetry = require('./opentelemetry.cjs');
+
+exports.openTelemetryHook = require_opentelemetry.openTelemetryHook;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { OpenTelemetryHookContext, OpenTelemetryHookOptions, openTelemetryHook } from "./opentelemetry.cjs";
+export { type OpenTelemetryHookContext, type OpenTelemetryHookOptions, openTelemetryHook };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { OpenTelemetryHookContext, OpenTelemetryHookOptions, openTelemetryHook } from "./opentelemetry.js";
+export { type OpenTelemetryHookContext, type OpenTelemetryHookOptions, openTelemetryHook };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { openTelemetryHook } from "./opentelemetry.js";
+
+export { openTelemetryHook };

package/dist/opentelemetry.cjs

@@ -0,0 +1,155 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let __opentelemetry_api = require("@opentelemetry/api");
+__opentelemetry_api = require_rolldown_runtime.__toESM(__opentelemetry_api);
+let __opentelemetry_core = require("@opentelemetry/core");
+__opentelemetry_core = require_rolldown_runtime.__toESM(__opentelemetry_core);
+let __restatedev_restate_sdk = require("@restatedev/restate-sdk");
+__restatedev_restate_sdk = require_rolldown_runtime.__toESM(__restatedev_restate_sdk);
+
+//#region src/opentelemetry.ts
+const HOOK_CONTEXT_IS_PROCESSING_SYMBOL = Symbol.for("@restatedev/restate-sdk/hooks.isProcessing");
+const attemptHeadersGetter = {
+	get(carrier, key) {
+		const value = carrier.get(key);
+		if (Array.isArray(value)) return value[0];
+		return value ?? void 0;
+	},
+	keys(carrier) {
+		return [...carrier.keys()];
+	}
+};
+const traceContextPropagator = new __opentelemetry_core.W3CTraceContextPropagator();
+function resolveTracer(tracer, ctx) {
+	return typeof tracer === "function" ? tracer(ctx) : tracer;
+}
+function resolveAttributes(source, ...args) {
+	if (typeof source === "function") return source(...args);
+	return source;
+}
+function getExceptionMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return "Unknown error";
+}
+function getExceptionValue(error) {
+	return error instanceof Error ? error : getExceptionMessage(error);
+}
+function getIsProcessing(ctx) {
+	const isProcessing = ctx[HOOK_CONTEXT_IS_PROCESSING_SYMBOL];
+	return typeof isProcessing === "function" ? isProcessing : () => true;
+}
+function wrapSpanSuppressingReplayEvents(span, isProcessing) {
+	const wrapped = {
+		spanContext: () => span.spanContext(),
+		setAttribute: (key, value) => {
+			span.setAttribute(key, value);
+			return wrapped;
+		},
+		setAttributes: (attributes) => {
+			span.setAttributes(attributes);
+			return wrapped;
+		},
+		addEvent: (name, attributesOrStartTime, startTime) => {
+			if (isProcessing()) span.addEvent(name, attributesOrStartTime, startTime);
+			return wrapped;
+		},
+		addLink: (link) => {
+			span.addLink(link);
+			return wrapped;
+		},
+		addLinks: (links) => {
+			span.addLinks(links);
+			return wrapped;
+		},
+		setStatus: (status) => {
+			span.setStatus(status);
+			return wrapped;
+		},
+		updateName: (name) => {
+			span.updateName(name);
+			return wrapped;
+		},
+		end: (endTime) => {
+			span.end(endTime);
+		},
+		isRecording: () => span.isRecording(),
+		recordException: (exception, time) => {
+			if (isProcessing()) span.recordException(exception, time);
+		}
+	};
+	return wrapped;
+}
+/**
+* Creates a HooksProvider that integrates Restate invocations with
+* OpenTelemetry tracing using the SDK hook system.
+*
+* The helper always creates one span per invocation attempt, with the standard
+* Restate attributes `restate.invocation.id` and
+* `restate.invocation.target`. Parent context extraction is always based on
+* W3C trace context headers from the Restate attempt headers.
+*
+* When `runSpans` is enabled, it also creates child spans for `ctx.run()`
+* closures that actually execute, adding the standard `restate.run.name`
+* attribute.
+*/
+function openTelemetryHook(options) {
+	return (ctx) => {
+		const runSpans = options.runSpans ?? true;
+		const suppressSpanEventsDuringReplay = options.suppressSpanEventsDuringReplay ?? true;
+		const tracer = resolveTracer(options.tracer, ctx);
+		const isProcessing = getIsProcessing(ctx);
+		const parentContext = traceContextPropagator.extract(__opentelemetry_api.context.active(), ctx.request.attemptHeaders, attemptHeadersGetter);
+		const target = String(ctx.request.target);
+		const attemptSpan = tracer.startSpan(`attempt ${target}`, { attributes: {
+			...resolveAttributes(options.additionalAttemptAttributes, ctx),
+			"restate.invocation.id": ctx.request.id,
+			"restate.invocation.target": target
+		} }, parentContext);
+		const attemptContext = __opentelemetry_api.trace.setSpan(parentContext, suppressSpanEventsDuringReplay ? wrapSpanSuppressingReplayEvents(attemptSpan, isProcessing) : attemptSpan);
+		const hooks = { interceptor: { handler: async (next) => {
+			try {
+				await __opentelemetry_api.context.with(attemptContext, next);
+				attemptSpan.setStatus({ code: __opentelemetry_api.SpanStatusCode.OK });
+			} catch (e) {
+				if (!__restatedev_restate_sdk.internal.isSuspendedError(e)) {
+					attemptSpan.setStatus({
+						code: __opentelemetry_api.SpanStatusCode.ERROR,
+						message: getExceptionMessage(e)
+					});
+					attemptSpan.recordException(getExceptionValue(e));
+				}
+				throw e;
+			} finally {
+				attemptSpan.end();
+			}
+		} } };
+		if (runSpans) hooks.interceptor.run = (name, next) => {
+			const runSpan = tracer.startSpan(`run (${name})`, { attributes: {
+				...resolveAttributes(options.additionalRunAttributes, ctx, name),
+				"restate.run.name": name
+			} }, attemptContext);
+			const runContext = __opentelemetry_api.trace.setSpan(attemptContext, runSpan);
+			return __opentelemetry_api.context.with(runContext, async () => {
+				try {
+					await next();
+					runSpan.setStatus({ code: __opentelemetry_api.SpanStatusCode.OK });
+				} catch (e) {
+					if (!__restatedev_restate_sdk.internal.isSuspendedError(e)) {
+						runSpan.setStatus({
+							code: __opentelemetry_api.SpanStatusCode.ERROR,
+							message: getExceptionMessage(e)
+						});
+						runSpan.recordException(getExceptionValue(e));
+					}
+					throw e;
+				} finally {
+					runSpan.end();
+				}
+			});
+		};
+		return hooks;
+	};
+}
+
+//#endregion
+exports.openTelemetryHook = openTelemetryHook;

package/dist/opentelemetry.d.cts

@@ -0,0 +1,60 @@
+import { Attributes, Tracer } from "@opentelemetry/api";
+import { HooksProvider, Request } from "@restatedev/restate-sdk";
+
+//#region src/opentelemetry.d.ts
+interface OpenTelemetryHookContext {
+  request: Request;
+}
+interface OpenTelemetryHookOptions {
+  /**
+   * Tracer used to create Restate spans.
+   *
+   * You can pass a single tracer instance, or resolve one per request
+   * (for example to vary the instrumentation scope by service).
+   */
+  tracer: Tracer | ((ctx: OpenTelemetryHookContext) => Tracer);
+  /**
+   * When `true`, create child spans for `ctx.run()` closures that actually
+   * execute. Replayed journaled runs are skipped by the hook system.
+   *
+   * @default true
+   */
+  runSpans?: boolean;
+  /**
+   * When `true`, suppress span events added to the attempt span while the
+   * invocation is replaying journaled work. Attributes are still recorded.
+   *
+   * This affects only the attempt span; `ctx.run()` spans are only created
+   * when the run closure actually executes.
+   *
+   * @default true
+   */
+  suppressSpanEventsDuringReplay?: boolean;
+  /**
+   * Additional attempt span attributes to attach alongside the standard
+   * Restate attributes.
+   */
+  additionalAttemptAttributes?: Attributes | ((ctx: OpenTelemetryHookContext) => Attributes | undefined);
+  /**
+   * Additional `ctx.run()` span attributes to attach alongside
+   * `restate.run.name`.
+   */
+  additionalRunAttributes?: Attributes | ((ctx: OpenTelemetryHookContext, name: string) => Attributes | undefined);
+}
+/**
+ * Creates a HooksProvider that integrates Restate invocations with
+ * OpenTelemetry tracing using the SDK hook system.
+ *
+ * The helper always creates one span per invocation attempt, with the standard
+ * Restate attributes `restate.invocation.id` and
+ * `restate.invocation.target`. Parent context extraction is always based on
+ * W3C trace context headers from the Restate attempt headers.
+ *
+ * When `runSpans` is enabled, it also creates child spans for `ctx.run()`
+ * closures that actually execute, adding the standard `restate.run.name`
+ * attribute.
+ */
+declare function openTelemetryHook(options: OpenTelemetryHookOptions): HooksProvider;
+//#endregion
+export { OpenTelemetryHookContext, OpenTelemetryHookOptions, openTelemetryHook };
+//# sourceMappingURL=opentelemetry.d.cts.map

package/dist/opentelemetry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.d.cts","names":[],"sources":["../src/opentelemetry.ts"],"sourcesContent":[],"mappings":";;;;UA2BiB,wBAAA;WACN;AADX;AAIiB,UAAA,wBAAA,CAAwB;EAO/B;;;;;;EAkCJ,MAAA,EAlCI,MAkCJ,GAAA,CAAA,CAAA,GAAA,EAlCoB,wBAkCpB,EAAA,GAlCiD,MAkCjD,CAAA;EACO;;;AAkIb;;;;;;;;;;;;;;;;;;gCA3IM,oBACO,6BAA6B;;;;;4BAOpC,oBACO,2CAA2C;;;;;;;;;;;;;;;iBAkIxC,iBAAA,UACL,2BACR"}

package/dist/opentelemetry.d.ts

@@ -0,0 +1,60 @@
+import { Attributes, Tracer } from "@opentelemetry/api";
+import { HooksProvider, Request } from "@restatedev/restate-sdk";
+
+//#region src/opentelemetry.d.ts
+interface OpenTelemetryHookContext {
+  request: Request;
+}
+interface OpenTelemetryHookOptions {
+  /**
+   * Tracer used to create Restate spans.
+   *
+   * You can pass a single tracer instance, or resolve one per request
+   * (for example to vary the instrumentation scope by service).
+   */
+  tracer: Tracer | ((ctx: OpenTelemetryHookContext) => Tracer);
+  /**
+   * When `true`, create child spans for `ctx.run()` closures that actually
+   * execute. Replayed journaled runs are skipped by the hook system.
+   *
+   * @default true
+   */
+  runSpans?: boolean;
+  /**
+   * When `true`, suppress span events added to the attempt span while the
+   * invocation is replaying journaled work. Attributes are still recorded.
+   *
+   * This affects only the attempt span; `ctx.run()` spans are only created
+   * when the run closure actually executes.
+   *
+   * @default true
+   */
+  suppressSpanEventsDuringReplay?: boolean;
+  /**
+   * Additional attempt span attributes to attach alongside the standard
+   * Restate attributes.
+   */
+  additionalAttemptAttributes?: Attributes | ((ctx: OpenTelemetryHookContext) => Attributes | undefined);
+  /**
+   * Additional `ctx.run()` span attributes to attach alongside
+   * `restate.run.name`.
+   */
+  additionalRunAttributes?: Attributes | ((ctx: OpenTelemetryHookContext, name: string) => Attributes | undefined);
+}
+/**
+ * Creates a HooksProvider that integrates Restate invocations with
+ * OpenTelemetry tracing using the SDK hook system.
+ *
+ * The helper always creates one span per invocation attempt, with the standard
+ * Restate attributes `restate.invocation.id` and
+ * `restate.invocation.target`. Parent context extraction is always based on
+ * W3C trace context headers from the Restate attempt headers.
+ *
+ * When `runSpans` is enabled, it also creates child spans for `ctx.run()`
+ * closures that actually execute, adding the standard `restate.run.name`
+ * attribute.
+ */
+declare function openTelemetryHook(options: OpenTelemetryHookOptions): HooksProvider;
+//#endregion
+export { OpenTelemetryHookContext, OpenTelemetryHookOptions, openTelemetryHook };
+//# sourceMappingURL=opentelemetry.d.ts.map

package/dist/opentelemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.d.ts","names":[],"sources":["../src/opentelemetry.ts"],"sourcesContent":[],"mappings":";;;;UA2BiB,wBAAA;WACN;AADX;AAIiB,UAAA,wBAAA,CAAwB;EAO/B;;;;;;EAkCJ,MAAA,EAlCI,MAkCJ,GAAA,CAAA,CAAA,GAAA,EAlCoB,wBAkCpB,EAAA,GAlCiD,MAkCjD,CAAA;EACO;;;AAkIb;;;;;;;;;;;;;;;;;;gCA3IM,oBACO,6BAA6B;;;;;4BAOpC,oBACO,2CAA2C;;;;;;;;;;;;;;;iBAkIxC,iBAAA,UACL,2BACR"}

package/dist/opentelemetry.js

@@ -0,0 +1,152 @@
+import { SpanStatusCode, context, trace } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { internal } from "@restatedev/restate-sdk";
+
+//#region src/opentelemetry.ts
+const HOOK_CONTEXT_IS_PROCESSING_SYMBOL = Symbol.for("@restatedev/restate-sdk/hooks.isProcessing");
+const attemptHeadersGetter = {
+	get(carrier, key) {
+		const value = carrier.get(key);
+		if (Array.isArray(value)) return value[0];
+		return value ?? void 0;
+	},
+	keys(carrier) {
+		return [...carrier.keys()];
+	}
+};
+const traceContextPropagator = new W3CTraceContextPropagator();
+function resolveTracer(tracer, ctx) {
+	return typeof tracer === "function" ? tracer(ctx) : tracer;
+}
+function resolveAttributes(source, ...args) {
+	if (typeof source === "function") return source(...args);
+	return source;
+}
+function getExceptionMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return "Unknown error";
+}
+function getExceptionValue(error) {
+	return error instanceof Error ? error : getExceptionMessage(error);
+}
+function getIsProcessing(ctx) {
+	const isProcessing = ctx[HOOK_CONTEXT_IS_PROCESSING_SYMBOL];
+	return typeof isProcessing === "function" ? isProcessing : () => true;
+}
+function wrapSpanSuppressingReplayEvents(span, isProcessing) {
+	const wrapped = {
+		spanContext: () => span.spanContext(),
+		setAttribute: (key, value) => {
+			span.setAttribute(key, value);
+			return wrapped;
+		},
+		setAttributes: (attributes) => {
+			span.setAttributes(attributes);
+			return wrapped;
+		},
+		addEvent: (name, attributesOrStartTime, startTime) => {
+			if (isProcessing()) span.addEvent(name, attributesOrStartTime, startTime);
+			return wrapped;
+		},
+		addLink: (link) => {
+			span.addLink(link);
+			return wrapped;
+		},
+		addLinks: (links) => {
+			span.addLinks(links);
+			return wrapped;
+		},
+		setStatus: (status) => {
+			span.setStatus(status);
+			return wrapped;
+		},
+		updateName: (name) => {
+			span.updateName(name);
+			return wrapped;
+		},
+		end: (endTime) => {
+			span.end(endTime);
+		},
+		isRecording: () => span.isRecording(),
+		recordException: (exception, time) => {
+			if (isProcessing()) span.recordException(exception, time);
+		}
+	};
+	return wrapped;
+}
+/**
+* Creates a HooksProvider that integrates Restate invocations with
+* OpenTelemetry tracing using the SDK hook system.
+*
+* The helper always creates one span per invocation attempt, with the standard
+* Restate attributes `restate.invocation.id` and
+* `restate.invocation.target`. Parent context extraction is always based on
+* W3C trace context headers from the Restate attempt headers.
+*
+* When `runSpans` is enabled, it also creates child spans for `ctx.run()`
+* closures that actually execute, adding the standard `restate.run.name`
+* attribute.
+*/
+function openTelemetryHook(options) {
+	return (ctx) => {
+		const runSpans = options.runSpans ?? true;
+		const suppressSpanEventsDuringReplay = options.suppressSpanEventsDuringReplay ?? true;
+		const tracer = resolveTracer(options.tracer, ctx);
+		const isProcessing = getIsProcessing(ctx);
+		const parentContext = traceContextPropagator.extract(context.active(), ctx.request.attemptHeaders, attemptHeadersGetter);
+		const target = String(ctx.request.target);
+		const attemptSpan = tracer.startSpan(`attempt ${target}`, { attributes: {
+			...resolveAttributes(options.additionalAttemptAttributes, ctx),
+			"restate.invocation.id": ctx.request.id,
+			"restate.invocation.target": target
+		} }, parentContext);
+		const attemptContext = trace.setSpan(parentContext, suppressSpanEventsDuringReplay ? wrapSpanSuppressingReplayEvents(attemptSpan, isProcessing) : attemptSpan);
+		const hooks = { interceptor: { handler: async (next) => {
+			try {
+				await context.with(attemptContext, next);
+				attemptSpan.setStatus({ code: SpanStatusCode.OK });
+			} catch (e) {
+				if (!internal.isSuspendedError(e)) {
+					attemptSpan.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: getExceptionMessage(e)
+					});
+					attemptSpan.recordException(getExceptionValue(e));
+				}
+				throw e;
+			} finally {
+				attemptSpan.end();
+			}
+		} } };
+		if (runSpans) hooks.interceptor.run = (name, next) => {
+			const runSpan = tracer.startSpan(`run (${name})`, { attributes: {
+				...resolveAttributes(options.additionalRunAttributes, ctx, name),
+				"restate.run.name": name
+			} }, attemptContext);
+			const runContext = trace.setSpan(attemptContext, runSpan);
+			return context.with(runContext, async () => {
+				try {
+					await next();
+					runSpan.setStatus({ code: SpanStatusCode.OK });
+				} catch (e) {
+					if (!internal.isSuspendedError(e)) {
+						runSpan.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: getExceptionMessage(e)
+						});
+						runSpan.recordException(getExceptionValue(e));
+					}
+					throw e;
+				} finally {
+					runSpan.end();
+				}
+			});
+		};
+		return hooks;
+	};
+}
+
+//#endregion
+export { openTelemetryHook };
+//# sourceMappingURL=opentelemetry.js.map

package/dist/opentelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.js","names":["attemptHeadersGetter: TextMapGetter<\n  ReadonlyMap<string, string | string[] | undefined>\n>","wrapped: Span","hooks: ReturnType<HooksProvider>"],"sources":["../src/opentelemetry.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nimport {\n  context,\n  trace,\n  SpanStatusCode,\n  type Attributes,\n  type Span,\n  type TextMapGetter,\n  type Tracer,\n} from \"@opentelemetry/api\";\nimport { W3CTraceContextPropagator } from \"@opentelemetry/core\";\nimport {\n  internal,\n  type HooksProvider,\n  type Request,\n} from \"@restatedev/restate-sdk\";\n\nexport interface OpenTelemetryHookContext {\n  request: Request;\n}\n\nexport interface OpenTelemetryHookOptions {\n  /**\n   * Tracer used to create Restate spans.\n   *\n   * You can pass a single tracer instance, or resolve one per request\n   * (for example to vary the instrumentation scope by service).\n   */\n  tracer: Tracer | ((ctx: OpenTelemetryHookContext) => Tracer);\n\n  /**\n   * When `true`, create child spans for `ctx.run()` closures that actually\n   * execute. Replayed journaled runs are skipped by the hook system.\n   *\n   * @default true\n   */\n  runSpans?: boolean;\n\n  /**\n   * When `true`, suppress span events added to the attempt span while the\n   * invocation is replaying journaled work. Attributes are still recorded.\n   *\n   * This affects only the attempt span; `ctx.run()` spans are only created\n   * when the run closure actually executes.\n   *\n   * @default true\n   */\n  suppressSpanEventsDuringReplay?: boolean;\n\n  /**\n   * Additional attempt span attributes to attach alongside the standard\n   * Restate attributes.\n   */\n  additionalAttemptAttributes?:\n    | Attributes\n    | ((ctx: OpenTelemetryHookContext) => Attributes | undefined);\n\n  /**\n   * Additional `ctx.run()` span attributes to attach alongside\n   * `restate.run.name`.\n   */\n  additionalRunAttributes?:\n    | Attributes\n    | ((ctx: OpenTelemetryHookContext, name: string) => Attributes | undefined);\n}\n\n// Hidden symbol key injected by the Restate SDK when instantiating hooks.\n// This is intentionally not part of the public hook context contract.\nconst HOOK_CONTEXT_IS_PROCESSING_SYMBOL = Symbol.for(\n  \"@restatedev/restate-sdk/hooks.isProcessing\"\n);\n\nconst attemptHeadersGetter: TextMapGetter<\n  ReadonlyMap<string, string | string[] | undefined>\n> = {\n  get(carrier, key) {\n    const value = carrier.get(key);\n    if (Array.isArray(value)) {\n      return value[0];\n    }\n    return value ?? undefined;\n  },\n\n  keys(carrier) {\n    return [...carrier.keys()];\n  },\n};\n\nconst traceContextPropagator = new W3CTraceContextPropagator();\n\nfunction resolveTracer(\n  tracer: OpenTelemetryHookOptions[\"tracer\"],\n  ctx: OpenTelemetryHookContext\n): Tracer {\n  return typeof tracer === \"function\" ? tracer(ctx) : tracer;\n}\n\nfunction resolveAttributes<TArgs extends unknown[]>(\n  source: Attributes | ((...args: TArgs) => Attributes | undefined) | undefined,\n  ...args: TArgs\n): Attributes | undefined {\n  if (typeof source === \"function\") {\n    return source(...args);\n  }\n  return source;\n}\n\nfunction getExceptionMessage(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n  if (typeof error === \"string\") {\n    return error;\n  }\n  return \"Unknown error\";\n}\n\nfunction getExceptionValue(error: unknown): Error | string {\n  return error instanceof Error ? error : getExceptionMessage(error);\n}\n\nfunction getIsProcessing(ctx: OpenTelemetryHookContext): () => boolean {\n  const isProcessing = (ctx as unknown as Record<PropertyKey, unknown>)[\n    HOOK_CONTEXT_IS_PROCESSING_SYMBOL\n  ];\n  return typeof isProcessing === \"function\"\n    ? (isProcessing as () => boolean)\n    : () => true;\n}\n\nfunction wrapSpanSuppressingReplayEvents(\n  span: Span,\n  isProcessing: () => boolean\n): Span {\n  const wrapped: Span = {\n    spanContext: () => span.spanContext(),\n    setAttribute: (key, value) => {\n      span.setAttribute(key, value);\n      return wrapped;\n    },\n    setAttributes: (attributes) => {\n      span.setAttributes(attributes);\n      return wrapped;\n    },\n    addEvent: (name, attributesOrStartTime, startTime) => {\n      if (isProcessing()) {\n        span.addEvent(name, attributesOrStartTime, startTime);\n      }\n      return wrapped;\n    },\n    addLink: (link) => {\n      span.addLink(link);\n      return wrapped;\n    },\n    addLinks: (links) => {\n      span.addLinks(links);\n      return wrapped;\n    },\n    setStatus: (status) => {\n      span.setStatus(status);\n      return wrapped;\n    },\n    updateName: (name) => {\n      span.updateName(name);\n      return wrapped;\n    },\n    end: (endTime) => {\n      span.end(endTime);\n    },\n    isRecording: () => span.isRecording(),\n    recordException: (exception, time) => {\n      if (isProcessing()) {\n        span.recordException(exception, time);\n      }\n    },\n  };\n\n  return wrapped;\n}\n\n/**\n * Creates a HooksProvider that integrates Restate invocations with\n * OpenTelemetry tracing using the SDK hook system.\n *\n * The helper always creates one span per invocation attempt, with the standard\n * Restate attributes `restate.invocation.id` and\n * `restate.invocation.target`. Parent context extraction is always based on\n * W3C trace context headers from the Restate attempt headers.\n *\n * When `runSpans` is enabled, it also creates child spans for `ctx.run()`\n * closures that actually execute, adding the standard `restate.run.name`\n * attribute.\n */\nexport function openTelemetryHook(\n  options: OpenTelemetryHookOptions\n): HooksProvider {\n  return (ctx) => {\n    const runSpans = options.runSpans ?? true;\n    const suppressSpanEventsDuringReplay =\n      options.suppressSpanEventsDuringReplay ?? true;\n    const tracer = resolveTracer(options.tracer, ctx);\n    const isProcessing = getIsProcessing(ctx);\n    const parentContext = traceContextPropagator.extract(\n      context.active(),\n      ctx.request.attemptHeaders,\n      attemptHeadersGetter\n    );\n\n    const target = String(ctx.request.target);\n    const attemptSpan = tracer.startSpan(\n      `attempt ${target}`,\n      {\n        attributes: {\n          ...resolveAttributes(options.additionalAttemptAttributes, ctx),\n          \"restate.invocation.id\": ctx.request.id,\n          \"restate.invocation.target\": target,\n        },\n      },\n      parentContext\n    );\n    const attemptContext = trace.setSpan(\n      parentContext,\n      suppressSpanEventsDuringReplay\n        ? wrapSpanSuppressingReplayEvents(attemptSpan, isProcessing)\n        : attemptSpan\n    );\n\n    const hooks: ReturnType<HooksProvider> = {\n      interceptor: {\n        handler: async (next) => {\n          try {\n            await context.with(attemptContext, next);\n            attemptSpan.setStatus({ code: SpanStatusCode.OK });\n          } catch (e) {\n            if (!internal.isSuspendedError(e)) {\n              attemptSpan.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: getExceptionMessage(e),\n              });\n              attemptSpan.recordException(getExceptionValue(e));\n            }\n            throw e;\n          } finally {\n            attemptSpan.end();\n          }\n        },\n      },\n    };\n\n    if (runSpans) {\n      hooks.interceptor!.run = (name, next) => {\n        const runSpan = tracer.startSpan(\n          `run (${name})`,\n          {\n            attributes: {\n              ...resolveAttributes(options.additionalRunAttributes, ctx, name),\n              \"restate.run.name\": name,\n            },\n          },\n          attemptContext\n        );\n        const runContext = trace.setSpan(attemptContext, runSpan);\n\n        return context.with(runContext, async () => {\n          try {\n            await next();\n            runSpan.setStatus({ code: SpanStatusCode.OK });\n          } catch (e) {\n            if (!internal.isSuspendedError(e)) {\n              runSpan.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: getExceptionMessage(e),\n              });\n              runSpan.recordException(getExceptionValue(e));\n            }\n            throw e;\n          } finally {\n            runSpan.end();\n          }\n        });\n      };\n    }\n\n    return hooks;\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@restatedev/restate-sdk-opentelemetry",
+  "version": "0.0.0-SNAPSHOT-20260409150343",
+  "description": "OpenTelemetry helpers for the Restate TypeScript SDK",
+  "author": "Restate Developers",
+  "email": "code@restate.dev",
+  "license": "MIT",
+  "homepage": "https://github.com/restatedev/sdk-typescript#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/restatedev/sdk-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/restatedev/sdk-typescript/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.6.0",
+    "@restatedev/restate-sdk": "0.0.0-SNAPSHOT-20260409150343"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0",
+    "@opentelemetry/core": ">=2.6.0",
+    "@restatedev/restate-sdk": "^1.11.1"
+  },
+  "scripts": {
+    "test": "turbo run _test --filter={.}...",
+    "_test": "vitest run",
+    "build": "turbo run _build --filter={.}...",
+    "_build": "tsc --noEmit && tsdown",
+    "dev": "tsc --noEmit --watch",
+    "clean": "rm -rf dist *.tsbuildinfo .turbo",
+    "check:types": "turbo run _check:types --filter={.}...",
+    "_check:types": "tsc --noEmit --project tsconfig.build.json",
+    "lint": "eslint .",
+    "check:exports": "turbo run _check:exports --filter={.}...",
+    "_check:exports": "attw --pack .",
+    "check:api": "turbo run _check:api --filter={.}...",
+    "_check:api": "api-extractor run --local"
+  }
+}