autotel-adapters 0.3.19 → 2.0.0

package/dist/integration-guh7BHTF.cjs

@@ -0,0 +1,412 @@
+const require_toolkit_storage = require('./toolkit/storage.cjs');
+let autotel = require("autotel");
+let autotel_edge = require("autotel-edge");
+
+//#region src/toolkit/deferred-drain.ts
+/**
+* Extend drain lifetime on serverless runtimes without blocking the HTTP response.
+*
+* The drain always runs in the background (its rejection is logged, never
+* thrown). When `waitUntil` is provided, the promise is also handed to the
+* platform so the isolate stays alive until the drain settles. When it is
+* omitted there is no keep-alive guarantee: on a freezing runtime the drain may
+* not finish, so callers that need delivery must supply `waitUntil`.
+*/
+function extendDeferredDrain(drainPromise, waitUntil) {
+	drainPromise.catch((err) => {
+		console.error("[autotel-adapters] background drain failed:", err);
+	});
+	if (typeof waitUntil === "function") waitUntil(drainPromise);
+}
+
+//#endregion
+//#region src/toolkit/stream-response.ts
+function isStreamingResponse(response) {
+	return response.body !== null;
+}
+/**
+* Whether framework integrations should defer wide-event emit until the response
+* body finishes. Static string/JSON bodies are excluded even though they use a
+* ReadableStream under the hood in the Fetch API.
+*/
+function shouldDeferEmitForResponse(response) {
+	if (!response.body) return false;
+	const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+	if (contentType.includes("text/event-stream")) return true;
+	if (contentType.includes("application/x-ndjson")) return true;
+	if (response.headers.has("x-vercel-ai-ui-message-stream")) return true;
+	if (response.headers.get("transfer-encoding")?.toLowerCase().includes("chunked")) return true;
+	return false;
+}
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+function createObservedBody(body, onDone, onError) {
+	if (body.locked) {
+		Promise.resolve(onError(/* @__PURE__ */ new TypeError("stream is already locked"))).catch((err) => {
+			console.error("[autotel-adapters] stream error handling failed:", err);
+		});
+		return null;
+	}
+	const reader = body.getReader();
+	let settled = false;
+	const settle = (fn) => {
+		if (settled) return;
+		settled = true;
+		Promise.resolve(fn()).catch((err) => {
+			console.error("[autotel-adapters] stream completion handling failed:", err);
+		});
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					settle(onDone);
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (err) {
+				settle(() => onError(err));
+				controller.error(err);
+			}
+		},
+		async cancel(reason) {
+			try {
+				await reader.cancel(reason);
+			} finally {
+				settle(onDone);
+			}
+		}
+	});
+}
+/**
+* Observe a streaming Response body and invoke `onComplete` once when the body
+* closes, errors, or is cancelled.
+*/
+function bindStreamingResponseLifecycle(response, onComplete) {
+	if (!response.body) {
+		Promise.resolve(onComplete({ status: response.status })).catch((err) => {
+			console.error("[autotel-adapters] stream completion handling failed:", err);
+		});
+		return response;
+	}
+	const body = createObservedBody(response.body, () => onComplete({ status: response.status }), (err) => onComplete({
+		status: response.status,
+		error: toError(err)
+	}));
+	if (!body) return response;
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+
+//#endregion
+//#region src/toolkit/middleware.ts
+const noopResult = {
+	logger: (0, autotel.createNoopRequestLogger)(),
+	finish: () => Promise.resolve(null),
+	finishResponse: (response) => Promise.resolve(response),
+	skipped: true
+};
+function mergeRequestLoggerOptions(base, waitUntil) {
+	if (!waitUntil) return base;
+	const userOnEmit = base?.onEmit;
+	return {
+		...base,
+		onEmit: (snapshot) => {
+			extendDeferredDrain(userOnEmit ? Promise.resolve(userOnEmit(snapshot)) : Promise.resolve(), waitUntil);
+		}
+	};
+}
+async function performFinish(logger, options, startedAt, opts) {
+	const { status, error, overrides } = opts ?? {};
+	if (error) {
+		logger.error(error);
+		logger.set({
+			"http.response.status_code": status ?? 500,
+			error_message: error.message
+		});
+	} else if (status !== void 0) logger.set({ "http.response.status_code": status });
+	const durationMs = Date.now() - startedAt;
+	logger.set({ duration_ms: durationMs });
+	const tailCtx = {
+		status: status ?? logger.getContext()["http.response.status_code"],
+		durationMs,
+		path: options.path,
+		method: options.method,
+		context: logger.getContext(),
+		shouldKeep: false
+	};
+	if (options.keep) await options.keep(tailCtx);
+	if (options.onFinish) try {
+		await options.onFinish({
+			logger,
+			method: options.method,
+			path: options.path,
+			status: tailCtx.status,
+			durationMs
+		});
+	} catch (err) {
+		console.error("[autotel-adapters] onFinish failed:", err);
+	}
+	const mergedOverrides = {
+		...overrides ?? {},
+		...tailCtx.shouldKeep ? { "autotel.sampling.tail.keep": true } : {}
+	};
+	return logger.emitNow(Object.keys(mergedOverrides).length > 0 ? mergedOverrides : void 0);
+}
+/**
+* Create a request logger handle for use inside an active autotel trace span.
+* Call `finish()` or `finishResponse()` when the request completes.
+*/
+function createMiddlewareLogger(logger, options) {
+	if (!(0, autotel_edge.shouldInstrumentPath)(options.path, options)) return noopResult;
+	const routeService = (0, autotel_edge.getServiceForPath)(options.path, options.routes);
+	if (routeService) logger.set({ service: routeService });
+	if (options.requestId) logger.set({ "http.request.id": options.requestId });
+	const startedAt = Date.now();
+	return {
+		logger,
+		skipped: false,
+		finish: (opts) => performFinish(logger, options, startedAt, opts),
+		finishResponse: async (response, opts) => {
+			const status = opts?.status ?? response.status;
+			if (!shouldDeferEmitForResponse(response)) {
+				await performFinish(logger, options, startedAt, {
+					status,
+					overrides: opts?.overrides
+				});
+				return response;
+			}
+			return bindStreamingResponseLifecycle(response, async (meta) => {
+				await performFinish(logger, options, startedAt, {
+					status: meta.status ?? status,
+					error: meta.error,
+					overrides: opts?.overrides
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/toolkit/fork.ts
+/**
+* Wrap an existing request logger's `fork()` so adapter lifecycle hooks run
+* for background work spawned after the response returns.
+*/
+function attachForkToLogger(logger, lifecycle) {
+	const originalFork = logger.fork.bind(logger);
+	logger.fork = (label, fn, options) => {
+		originalFork(label, fn, { lifecycle: {
+			onChildEnter: (child) => {
+				lifecycle.onChildEnter?.(child);
+				options?.lifecycle?.onChildEnter?.(child);
+			},
+			onChildExit: (child) => {
+				lifecycle.onChildExit?.(child);
+				options?.lifecycle?.onChildExit?.(child);
+			}
+		} });
+	};
+}
+
+//#endregion
+//#region src/toolkit/integration.ts
+function applyLoggerEnrichment(logger, ...attributeSets) {
+	for (const attrs of attributeSets) if (attrs && Object.keys(attrs).length > 0) logger.set(attrs);
+}
+async function completeIntegratedRequest(handle, options, result) {
+	if (handle.skipped || options?.autoEmit === false) return result;
+	if (result instanceof Response) return handle.finishResponse(result);
+	await handle.finish({});
+	return result;
+}
+async function runWithIntegratedHandle(handle, options, fn) {
+	if (handle.skipped) return handle.runWith(fn);
+	try {
+		return completeIntegratedRequest(handle, options, await handle.runWith(fn));
+	} catch (error) {
+		if (options?.autoEmit !== false) await handle.finish({ error: error instanceof Error ? error : new Error(String(error)) });
+		throw error;
+	}
+}
+function toRouteAdapterOptions(options) {
+	if (!options) return {};
+	const { include, exclude, routes, waitUntil, keep, requestLoggerOptions } = options;
+	return {
+		include,
+		exclude,
+		routes,
+		waitUntil,
+		keep,
+		requestLoggerOptions
+	};
+}
+function buildTracedOptions(options, spanName) {
+	return {
+		...toRouteAdapterOptions(options),
+		requestLoggerOptions: options?.requestLoggerOptions,
+		autoEmit: options?.autoEmit,
+		spanName
+	};
+}
+function resolveSpanName(spec, ctx, request) {
+	if (typeof spec.spanName === "function") return spec.spanName(ctx, request);
+	if (typeof spec.spanName === "string") return spec.spanName;
+	return `http.${request.method.toLowerCase() || "request"}`;
+}
+function buildHandle(spec, ctx, traceCtx, options = {}) {
+	const extracted = spec.extractRequest(ctx);
+	const waitUntil = options.waitUntil ?? spec.extractWaitUntil?.(ctx);
+	const middlewareOptions = {
+		method: extracted.method,
+		path: extracted.path,
+		requestId: extracted.requestId,
+		...toRouteAdapterOptions(options),
+		waitUntil,
+		requestLoggerOptions: mergeRequestLoggerOptions(options.requestLoggerOptions, waitUntil)
+	};
+	const log = (0, autotel.getRequestLogger)(traceCtx, middlewareOptions.requestLoggerOptions);
+	log.set({
+		"http.request.method": extracted.method,
+		"http.route": extracted.path,
+		...extracted.requestId ? { "http.request.id": extracted.requestId } : {}
+	});
+	if (spec.storage) attachForkToLogger(log, spec.forkLifecycle ?? require_toolkit_storage.createStorageForkLifecycle(spec.storage));
+	spec.attachLogger(ctx, log);
+	const result = createMiddlewareLogger(log, middlewareOptions);
+	const storage = spec.storage;
+	return {
+		...result,
+		middlewareOptions,
+		runWith: async (fn) => {
+			if (!storage || result.skipped) return fn();
+			return storage.run(log, fn);
+		}
+	};
+}
+function buildSkippedHandle(spec, ctx, extracted, options = {}) {
+	const waitUntil = options.waitUntil ?? spec.extractWaitUntil?.(ctx);
+	const middlewareOptions = {
+		method: extracted.method,
+		path: extracted.path,
+		requestId: extracted.requestId,
+		...toRouteAdapterOptions(options),
+		waitUntil
+	};
+	const logger = (0, autotel.createNoopRequestLogger)();
+	spec.attachLogger(ctx, logger);
+	return {
+		logger,
+		middlewareOptions,
+		skipped: true,
+		finish: async () => null,
+		finishResponse: async (response) => response,
+		runWith: async (fn) => {
+			if (!spec.storage) return fn();
+			return spec.storage.run(logger, fn);
+		}
+	};
+}
+function defineFrameworkIntegration(spec) {
+	return {
+		begin(traceCtx, ctx, options = {}) {
+			const extracted = spec.extractRequest(ctx);
+			if (!(0, autotel_edge.shouldInstrumentPath)(extracted.path, toRouteAdapterOptions(options))) return buildSkippedHandle(spec, ctx, extracted, options);
+			return buildHandle(spec, ctx, traceCtx, options);
+		},
+		runTraced(ctx, options, handler) {
+			const extracted = spec.extractRequest(ctx);
+			if (!(0, autotel_edge.shouldInstrumentPath)(extracted.path, toRouteAdapterOptions(options))) return handler(buildSkippedHandle(spec, ctx, extracted, options));
+			return (0, autotel.withTracing)({ name: options?.spanName ?? resolveSpanName(spec, ctx, extracted) })((traceCtx) => async () => {
+				return handler(buildHandle(spec, ctx, traceCtx, options ?? {}));
+			})();
+		}
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'applyLoggerEnrichment', {
+  enumerable: true,
+  get: function () {
+    return applyLoggerEnrichment;
+  }
+});
+Object.defineProperty(exports, 'attachForkToLogger', {
+  enumerable: true,
+  get: function () {
+    return attachForkToLogger;
+  }
+});
+Object.defineProperty(exports, 'bindStreamingResponseLifecycle', {
+  enumerable: true,
+  get: function () {
+    return bindStreamingResponseLifecycle;
+  }
+});
+Object.defineProperty(exports, 'buildTracedOptions', {
+  enumerable: true,
+  get: function () {
+    return buildTracedOptions;
+  }
+});
+Object.defineProperty(exports, 'completeIntegratedRequest', {
+  enumerable: true,
+  get: function () {
+    return completeIntegratedRequest;
+  }
+});
+Object.defineProperty(exports, 'createMiddlewareLogger', {
+  enumerable: true,
+  get: function () {
+    return createMiddlewareLogger;
+  }
+});
+Object.defineProperty(exports, 'defineFrameworkIntegration', {
+  enumerable: true,
+  get: function () {
+    return defineFrameworkIntegration;
+  }
+});
+Object.defineProperty(exports, 'extendDeferredDrain', {
+  enumerable: true,
+  get: function () {
+    return extendDeferredDrain;
+  }
+});
+Object.defineProperty(exports, 'isStreamingResponse', {
+  enumerable: true,
+  get: function () {
+    return isStreamingResponse;
+  }
+});
+Object.defineProperty(exports, 'mergeRequestLoggerOptions', {
+  enumerable: true,
+  get: function () {
+    return mergeRequestLoggerOptions;
+  }
+});
+Object.defineProperty(exports, 'runWithIntegratedHandle', {
+  enumerable: true,
+  get: function () {
+    return runWithIntegratedHandle;
+  }
+});
+Object.defineProperty(exports, 'shouldDeferEmitForResponse', {
+  enumerable: true,
+  get: function () {
+    return shouldDeferEmitForResponse;
+  }
+});
+Object.defineProperty(exports, 'toRouteAdapterOptions', {
+  enumerable: true,
+  get: function () {
+    return toRouteAdapterOptions;
+  }
+});
+//# sourceMappingURL=integration-guh7BHTF.cjs.map

package/dist/integration-guh7BHTF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-guh7BHTF.cjs","names":["createStorageForkLifecycle"],"sources":["../src/toolkit/deferred-drain.ts","../src/toolkit/stream-response.ts","../src/toolkit/middleware.ts","../src/toolkit/fork.ts","../src/toolkit/integration.ts"],"sourcesContent":["/**\n * Extend drain lifetime on serverless runtimes without blocking the HTTP response.\n *\n * The drain always runs in the background (its rejection is logged, never\n * thrown). When `waitUntil` is provided, the promise is also handed to the\n * platform so the isolate stays alive until the drain settles. When it is\n * omitted there is no keep-alive guarantee: on a freezing runtime the drain may\n * not finish, so callers that need delivery must supply `waitUntil`.\n */\nexport function extendDeferredDrain(\n  drainPromise: Promise<unknown>,\n  waitUntil?: (promise: Promise<unknown>) => void,\n): void {\n  void drainPromise.catch((err) => {\n    console.error('[autotel-adapters] background drain failed:', err);\n  });\n  if (typeof waitUntil === 'function') {\n    waitUntil(drainPromise);\n  }\n}\n","export interface StreamCompleteMeta {\n  status: number;\n  error?: Error;\n}\n\nexport function isStreamingResponse(response: Response): boolean {\n  return response.body !== null;\n}\n\n/**\n * Whether framework integrations should defer wide-event emit until the response\n * body finishes. Static string/JSON bodies are excluded even though they use a\n * ReadableStream under the hood in the Fetch API.\n */\nexport function shouldDeferEmitForResponse(response: Response): boolean {\n  if (!response.body) return false;\n\n  const contentType = (\n    response.headers.get('content-type') ?? ''\n  ).toLowerCase();\n\n  if (contentType.includes('text/event-stream')) return true;\n  if (contentType.includes('application/x-ndjson')) return true;\n  if (response.headers.has('x-vercel-ai-ui-message-stream')) return true;\n  if (\n    response.headers.get('transfer-encoding')?.toLowerCase().includes('chunked')\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n\nfunction createObservedBody(\n  body: ReadableStream<Uint8Array>,\n  onDone: () => void | Promise<void>,\n  onError: (error: unknown) => void | Promise<void>,\n): ReadableStream<Uint8Array> | null {\n  if (body.locked) {\n    void Promise.resolve(\n      onError(new TypeError('stream is already locked')),\n    ).catch((err: unknown) => {\n      console.error('[autotel-adapters] stream error handling failed:', err);\n    });\n    return null;\n  }\n\n  const reader = body.getReader();\n  let settled = false;\n\n  const settle = (fn: () => void | Promise<void>) => {\n    if (settled) return;\n    settled = true;\n    void Promise.resolve(fn()).catch((err: unknown) => {\n      console.error(\n        '[autotel-adapters] stream completion handling failed:',\n        err,\n      );\n    });\n  };\n\n  return new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const { done, value } = await reader.read();\n        if (done) {\n          settle(onDone);\n          controller.close();\n          return;\n        }\n        controller.enqueue(value);\n      } catch (err) {\n        settle(() => onError(err));\n        controller.error(err);\n      }\n    },\n\n    async cancel(reason) {\n      try {\n        await reader.cancel(reason);\n      } finally {\n        settle(onDone);\n      }\n    },\n  });\n}\n\n/**\n * Observe a streaming Response body and invoke `onComplete` once when the body\n * closes, errors, or is cancelled.\n */\nexport function bindStreamingResponseLifecycle(\n  response: Response,\n  onComplete: (meta: StreamCompleteMeta) => void | Promise<void>,\n): Response {\n  if (!response.body) {\n    void Promise.resolve(onComplete({ status: response.status })).catch(\n      (err: unknown) => {\n        console.error(\n          '[autotel-adapters] stream completion handling failed:',\n          err,\n        );\n      },\n    );\n    return response;\n  }\n\n  const body = createObservedBody(\n    response.body,\n    () => onComplete({ status: response.status }),\n    (err) => onComplete({ status: response.status, error: toError(err) }),\n  );\n  if (!body) return response;\n\n  return new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  });\n}\n","import type {\n  ForkLifecycle,\n  RequestLogger,\n  RequestLoggerOptions,\n  RequestLogSnapshot,\n} from 'autotel';\nimport { createNoopRequestLogger } from 'autotel';\nimport type { RouteFilterOptions, RouteServiceConfig } from 'autotel-edge';\nimport {\n  getServiceForPath,\n  matchesRoutePattern,\n  shouldInstrumentPath,\n} from 'autotel-edge';\nimport { extendDeferredDrain } from './deferred-drain';\nimport {\n  bindStreamingResponseLifecycle,\n  shouldDeferEmitForResponse,\n} from './stream-response';\n\nexport type Awaitable<T> = T | Promise<T>;\n\nexport type { RouteFilterOptions, RouteServiceConfig };\nexport { getServiceForPath, matchesRoutePattern, shouldInstrumentPath };\n\nexport interface RouteAdapterOptions {\n  include?: string[];\n  exclude?: string[];\n  routes?: Record<string, RouteServiceConfig>;\n  waitUntil?: (promise: Promise<unknown>) => void;\n  keep?: (ctx: TailSamplingContext) => Awaitable<void>;\n  requestLoggerOptions?: RequestLoggerOptions;\n}\n\n/** @deprecated Use {@link RouteAdapterOptions}. */\nexport type BaseAdapterOptions = RouteAdapterOptions;\n\nexport interface TailSamplingContext {\n  status?: number;\n  durationMs: number;\n  path: string;\n  method: string;\n  context: Record<string, unknown>;\n  shouldKeep: boolean;\n}\n\nexport interface MiddlewareLoggerOptions extends RouteAdapterOptions {\n  onFinish?: (ctx: {\n    logger: RequestLogger;\n    method: string;\n    path: string;\n    status?: number;\n    durationMs: number;\n  }) => Awaitable<void>;\n  method: string;\n  path: string;\n  requestId?: string;\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: RequestLogger;\n  finish: (opts?: {\n    status?: number;\n    error?: Error;\n    overrides?: Record<string, unknown>;\n  }) => Promise<RequestLogSnapshot | null>;\n  finishResponse: (\n    response: Response,\n    opts?: { status?: number; overrides?: Record<string, unknown> },\n  ) => Promise<Response>;\n  skipped: boolean;\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: createNoopRequestLogger(),\n  finish: () => Promise.resolve(null),\n  finishResponse: (response) => Promise.resolve(response),\n  skipped: true,\n};\n\nexport function mergeRequestLoggerOptions(\n  base: RequestLoggerOptions | undefined,\n  waitUntil?: (promise: Promise<unknown>) => void,\n): RequestLoggerOptions | undefined {\n  if (!waitUntil) return base;\n\n  const userOnEmit = base?.onEmit;\n  return {\n    ...base,\n    onEmit: (snapshot) => {\n      const drain = userOnEmit\n        ? Promise.resolve(userOnEmit(snapshot))\n        : Promise.resolve();\n      extendDeferredDrain(drain, waitUntil);\n    },\n  };\n}\n\nasync function performFinish(\n  logger: RequestLogger,\n  options: MiddlewareLoggerOptions,\n  startedAt: number,\n  opts?: {\n    status?: number;\n    error?: Error;\n    overrides?: Record<string, unknown>;\n  },\n): Promise<RequestLogSnapshot | null> {\n  const { status, error, overrides } = opts ?? {};\n\n  if (error) {\n    logger.error(error);\n    logger.set({\n      'http.response.status_code': status ?? 500,\n      error_message: error.message,\n    });\n  } else if (status !== undefined) {\n    logger.set({ 'http.response.status_code': status });\n  }\n\n  const durationMs = Date.now() - startedAt;\n  logger.set({ duration_ms: durationMs });\n\n  const tailCtx: TailSamplingContext = {\n    status:\n      status ??\n      (logger.getContext()['http.response.status_code'] as number | undefined),\n    durationMs,\n    path: options.path,\n    method: options.method,\n    context: logger.getContext(),\n    shouldKeep: false,\n  };\n\n  if (options.keep) {\n    await options.keep(tailCtx);\n  }\n\n  if (options.onFinish) {\n    try {\n      await options.onFinish({\n        logger,\n        method: options.method,\n        path: options.path,\n        status: tailCtx.status,\n        durationMs,\n      });\n    } catch (err) {\n      console.error('[autotel-adapters] onFinish failed:', err);\n    }\n  }\n\n  const mergedOverrides = {\n    ...(overrides ?? {}),\n    ...(tailCtx.shouldKeep ? { 'autotel.sampling.tail.keep': true } : {}),\n  };\n\n  return logger.emitNow(\n    Object.keys(mergedOverrides).length > 0 ? mergedOverrides : undefined,\n  );\n}\n\n/**\n * Create a request logger handle for use inside an active autotel trace span.\n * Call `finish()` or `finishResponse()` when the request completes.\n */\nexport function createMiddlewareLogger(\n  logger: RequestLogger,\n  options: MiddlewareLoggerOptions,\n): MiddlewareLoggerResult {\n  if (!shouldInstrumentPath(options.path, options)) {\n    return noopResult;\n  }\n\n  const routeService = getServiceForPath(options.path, options.routes);\n  if (routeService) {\n    logger.set({ service: routeService });\n  }\n\n  if (options.requestId) {\n    logger.set({ 'http.request.id': options.requestId });\n  }\n\n  const startedAt = Date.now();\n\n  return {\n    logger,\n    skipped: false,\n    finish: (opts) => performFinish(logger, options, startedAt, opts),\n    finishResponse: async (response, opts) => {\n      const status = opts?.status ?? response.status;\n      if (!shouldDeferEmitForResponse(response)) {\n        await performFinish(logger, options, startedAt, {\n          status,\n          overrides: opts?.overrides,\n        });\n        return response;\n      }\n\n      return bindStreamingResponseLifecycle(response, async (meta) => {\n        await performFinish(logger, options, startedAt, {\n          status: meta.status ?? status,\n          error: meta.error,\n          overrides: opts?.overrides,\n        });\n      });\n    },\n  };\n}\n\nexport type { ForkLifecycle };\n","import type { ForkLifecycle, RequestLogger } from 'autotel';\n\n/**\n * Wrap an existing request logger's `fork()` so adapter lifecycle hooks run\n * for background work spawned after the response returns.\n */\nexport function attachForkToLogger(\n  logger: RequestLogger,\n  lifecycle: ForkLifecycle,\n): void {\n  const originalFork = logger.fork.bind(logger);\n  logger.fork = (\n    label: string,\n    fn: () => void | Promise<void>,\n    options?: { lifecycle?: ForkLifecycle },\n  ) => {\n    originalFork(label, fn, {\n      lifecycle: {\n        onChildEnter: (child) => {\n          lifecycle.onChildEnter?.(child);\n          options?.lifecycle?.onChildEnter?.(child);\n        },\n        onChildExit: (child) => {\n          lifecycle.onChildExit?.(child);\n          options?.lifecycle?.onChildExit?.(child);\n        },\n      },\n    });\n  };\n}\n","import type { AsyncLocalStorage } from 'node:async_hooks';\nimport type {\n  ForkLifecycle,\n  RequestLogger,\n  RequestLoggerOptions,\n  TraceContext,\n} from 'autotel';\nimport {\n  createNoopRequestLogger,\n  getRequestLogger,\n  withTracing,\n} from 'autotel';\nimport { attachForkToLogger } from './fork';\nimport { createStorageForkLifecycle } from './storage';\nimport {\n  createMiddlewareLogger,\n  mergeRequestLoggerOptions,\n  shouldInstrumentPath,\n  type MiddlewareLoggerOptions,\n  type MiddlewareLoggerResult,\n  type RouteAdapterOptions,\n} from './middleware';\n\nexport interface ExtractedRequest {\n  method: string;\n  path: string;\n  headers?:\n    | Headers\n    | Record<string, string | string[] | undefined>\n    | { get(name: string): string | null };\n  requestId?: string;\n}\n\nexport interface IntegratedCompletionOptions {\n  autoEmit?: boolean;\n}\n\nexport type TracedOptionInput = RouteAdapterOptions & {\n  requestLoggerOptions?: RequestLoggerOptions;\n  autoEmit?: boolean;\n};\n\nexport interface FrameworkHandlerOptions extends TracedOptionInput {\n  spanName?: string;\n}\n\nexport interface FrameworkIntegrationSpec<TCtx> {\n  name: string;\n  extractRequest: (ctx: TCtx) => ExtractedRequest;\n  attachLogger: (ctx: TCtx, logger: RequestLogger) => void;\n  storage?: AsyncLocalStorage<RequestLogger>;\n  forkLifecycle?: ForkLifecycle;\n  extractWaitUntil?: (\n    ctx: TCtx,\n  ) => ((promise: Promise<unknown>) => void) | undefined;\n  spanName?: string | ((ctx: TCtx, request: ExtractedRequest) => string);\n}\n\nexport interface FrameworkRequestHandle extends MiddlewareLoggerResult {\n  middlewareOptions: MiddlewareLoggerOptions;\n  runWith: <T>(fn: () => T | Promise<T>) => Promise<T>;\n}\n\nexport interface FrameworkIntegrationHelpers<TCtx> {\n  begin: (\n    traceCtx: TraceContext,\n    ctx: TCtx,\n    options?: FrameworkHandlerOptions,\n  ) => FrameworkRequestHandle;\n  runTraced: <T>(\n    ctx: TCtx,\n    options: FrameworkHandlerOptions | undefined,\n    handler: (handle: FrameworkRequestHandle) => Promise<T>,\n  ) => Promise<T>;\n}\n\nexport function applyLoggerEnrichment(\n  logger: RequestLogger,\n  ...attributeSets: Array<Record<string, unknown> | undefined | null>\n): void {\n  for (const attrs of attributeSets) {\n    if (attrs && Object.keys(attrs).length > 0) {\n      logger.set(attrs);\n    }\n  }\n}\n\nexport async function completeIntegratedRequest<T>(\n  handle: FrameworkRequestHandle,\n  options: IntegratedCompletionOptions | undefined,\n  result: T,\n): Promise<T> {\n  if (handle.skipped || options?.autoEmit === false) {\n    return result;\n  }\n\n  if (result instanceof Response) {\n    return handle.finishResponse(result) as unknown as T;\n  }\n\n  await handle.finish({});\n  return result;\n}\n\nexport async function runWithIntegratedHandle<T>(\n  handle: FrameworkRequestHandle,\n  options: IntegratedCompletionOptions | undefined,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  if (handle.skipped) {\n    return handle.runWith(fn);\n  }\n\n  try {\n    const result = await handle.runWith(fn);\n    return completeIntegratedRequest(handle, options, result);\n  } catch (error) {\n    if (options?.autoEmit !== false) {\n      await handle.finish({\n        error: error instanceof Error ? error : new Error(String(error)),\n      });\n    }\n    throw error;\n  }\n}\n\nexport function toRouteAdapterOptions(\n  options?: Pick<\n    FrameworkHandlerOptions,\n    keyof RouteAdapterOptions | 'requestLoggerOptions'\n  >,\n): RouteAdapterOptions {\n  if (!options) return {};\n  const { include, exclude, routes, waitUntil, keep, requestLoggerOptions } =\n    options;\n  return { include, exclude, routes, waitUntil, keep, requestLoggerOptions };\n}\n\nexport function buildTracedOptions(\n  options: TracedOptionInput | undefined,\n  spanName: string,\n): FrameworkHandlerOptions {\n  return {\n    ...toRouteAdapterOptions(options),\n    requestLoggerOptions: options?.requestLoggerOptions,\n    autoEmit: options?.autoEmit,\n    spanName,\n  };\n}\n\nfunction resolveSpanName<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n  ctx: TCtx,\n  request: ExtractedRequest,\n): string {\n  if (typeof spec.spanName === 'function') {\n    return spec.spanName(ctx, request);\n  }\n  if (typeof spec.spanName === 'string') {\n    return spec.spanName;\n  }\n  return `http.${request.method.toLowerCase() || 'request'}`;\n}\n\nfunction buildHandle<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n  ctx: TCtx,\n  traceCtx: TraceContext,\n  options: FrameworkHandlerOptions = {},\n): FrameworkRequestHandle {\n  const extracted = spec.extractRequest(ctx);\n  const waitUntil = options.waitUntil ?? spec.extractWaitUntil?.(ctx);\n  const middlewareOptions: MiddlewareLoggerOptions = {\n    method: extracted.method,\n    path: extracted.path,\n    requestId: extracted.requestId,\n    ...toRouteAdapterOptions(options),\n    waitUntil,\n    requestLoggerOptions: mergeRequestLoggerOptions(\n      options.requestLoggerOptions,\n      waitUntil,\n    ),\n  };\n\n  const log = getRequestLogger(\n    traceCtx,\n    middlewareOptions.requestLoggerOptions,\n  );\n  log.set({\n    'http.request.method': extracted.method,\n    'http.route': extracted.path,\n    ...(extracted.requestId ? { 'http.request.id': extracted.requestId } : {}),\n  });\n\n  if (spec.storage) {\n    attachForkToLogger(\n      log,\n      spec.forkLifecycle ?? createStorageForkLifecycle(spec.storage),\n    );\n  }\n\n  spec.attachLogger(ctx, log);\n\n  const result = createMiddlewareLogger(log, middlewareOptions);\n  const storage = spec.storage;\n\n  return {\n    ...result,\n    middlewareOptions,\n    runWith: async (fn) => {\n      if (!storage || result.skipped) return fn();\n      return storage.run(log, fn);\n    },\n  };\n}\n\nfunction buildSkippedHandle<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n  ctx: TCtx,\n  extracted: ExtractedRequest,\n  options: FrameworkHandlerOptions = {},\n): FrameworkRequestHandle {\n  const waitUntil = options.waitUntil ?? spec.extractWaitUntil?.(ctx);\n  const middlewareOptions: MiddlewareLoggerOptions = {\n    method: extracted.method,\n    path: extracted.path,\n    requestId: extracted.requestId,\n    ...toRouteAdapterOptions(options),\n    waitUntil,\n  };\n\n  const logger = createNoopRequestLogger();\n  spec.attachLogger(ctx, logger);\n\n  return {\n    logger,\n    middlewareOptions,\n    skipped: true,\n    finish: async () => null,\n    finishResponse: async (response) => response,\n    runWith: async (fn) => {\n      if (!spec.storage) return fn();\n      return spec.storage.run(logger, fn);\n    },\n  };\n}\n\nexport function defineFrameworkIntegration<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n): FrameworkIntegrationHelpers<TCtx> {\n  return {\n    begin(traceCtx, ctx, options = {}) {\n      const extracted = spec.extractRequest(ctx);\n      if (\n        !shouldInstrumentPath(extracted.path, toRouteAdapterOptions(options))\n      ) {\n        return buildSkippedHandle(spec, ctx, extracted, options);\n      }\n      return buildHandle(spec, ctx, traceCtx, options);\n    },\n\n    runTraced(ctx, options, handler) {\n      const extracted = spec.extractRequest(ctx);\n      if (\n        !shouldInstrumentPath(extracted.path, toRouteAdapterOptions(options))\n      ) {\n        return handler(buildSkippedHandle(spec, ctx, extracted, options));\n      }\n\n      const spanName =\n        options?.spanName ?? resolveSpanName(spec, ctx, extracted);\n\n      // The wrapped factory is async, so the call always yields a Promise.\n      return withTracing({ name: spanName })((traceCtx) => async () => {\n        const handle = buildHandle(spec, ctx, traceCtx, options ?? {});\n        return handler(handle);\n      })() as ReturnType<typeof handler>;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/integration-rYoX8QLk.d.ts

@@ -0,0 +1,100 @@
+import { ForkLifecycle, ForkLifecycle as ForkLifecycle$1, RequestLogSnapshot, RequestLogger, RequestLoggerOptions, TraceContext } from "autotel";
+import { RouteFilterOptions, RouteServiceConfig, getServiceForPath, matchesRoutePattern, shouldInstrumentPath } from "autotel-edge";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/toolkit/middleware.d.ts
+type Awaitable<T> = T | Promise<T>;
+interface RouteAdapterOptions {
+  include?: string[];
+  exclude?: string[];
+  routes?: Record<string, RouteServiceConfig>;
+  waitUntil?: (promise: Promise<unknown>) => void;
+  keep?: (ctx: TailSamplingContext) => Awaitable<void>;
+  requestLoggerOptions?: RequestLoggerOptions;
+}
+/** @deprecated Use {@link RouteAdapterOptions}. */
+type BaseAdapterOptions = RouteAdapterOptions;
+interface TailSamplingContext {
+  status?: number;
+  durationMs: number;
+  path: string;
+  method: string;
+  context: Record<string, unknown>;
+  shouldKeep: boolean;
+}
+interface MiddlewareLoggerOptions extends RouteAdapterOptions {
+  onFinish?: (ctx: {
+    logger: RequestLogger;
+    method: string;
+    path: string;
+    status?: number;
+    durationMs: number;
+  }) => Awaitable<void>;
+  method: string;
+  path: string;
+  requestId?: string;
+}
+interface MiddlewareLoggerResult {
+  logger: RequestLogger;
+  finish: (opts?: {
+    status?: number;
+    error?: Error;
+    overrides?: Record<string, unknown>;
+  }) => Promise<RequestLogSnapshot | null>;
+  finishResponse: (response: Response, opts?: {
+    status?: number;
+    overrides?: Record<string, unknown>;
+  }) => Promise<Response>;
+  skipped: boolean;
+}
+declare function mergeRequestLoggerOptions(base: RequestLoggerOptions | undefined, waitUntil?: (promise: Promise<unknown>) => void): RequestLoggerOptions | undefined;
+/**
+ * Create a request logger handle for use inside an active autotel trace span.
+ * Call `finish()` or `finishResponse()` when the request completes.
+ */
+declare function createMiddlewareLogger(logger: RequestLogger, options: MiddlewareLoggerOptions): MiddlewareLoggerResult;
+//#endregion
+//#region src/toolkit/integration.d.ts
+interface ExtractedRequest {
+  method: string;
+  path: string;
+  headers?: Headers | Record<string, string | string[] | undefined> | {
+    get(name: string): string | null;
+  };
+  requestId?: string;
+}
+interface IntegratedCompletionOptions {
+  autoEmit?: boolean;
+}
+type TracedOptionInput = RouteAdapterOptions & {
+  requestLoggerOptions?: RequestLoggerOptions;
+  autoEmit?: boolean;
+};
+interface FrameworkHandlerOptions extends TracedOptionInput {
+  spanName?: string;
+}
+interface FrameworkIntegrationSpec<TCtx> {
+  name: string;
+  extractRequest: (ctx: TCtx) => ExtractedRequest;
+  attachLogger: (ctx: TCtx, logger: RequestLogger) => void;
+  storage?: AsyncLocalStorage<RequestLogger>;
+  forkLifecycle?: ForkLifecycle;
+  extractWaitUntil?: (ctx: TCtx) => ((promise: Promise<unknown>) => void) | undefined;
+  spanName?: string | ((ctx: TCtx, request: ExtractedRequest) => string);
+}
+interface FrameworkRequestHandle extends MiddlewareLoggerResult {
+  middlewareOptions: MiddlewareLoggerOptions;
+  runWith: <T>(fn: () => T | Promise<T>) => Promise<T>;
+}
+interface FrameworkIntegrationHelpers<TCtx> {
+  begin: (traceCtx: TraceContext, ctx: TCtx, options?: FrameworkHandlerOptions) => FrameworkRequestHandle;
+  runTraced: <T>(ctx: TCtx, options: FrameworkHandlerOptions | undefined, handler: (handle: FrameworkRequestHandle) => Promise<T>) => Promise<T>;
+}
+declare function applyLoggerEnrichment(logger: RequestLogger, ...attributeSets: Array<Record<string, unknown> | undefined | null>): void;
+declare function completeIntegratedRequest<T>(handle: FrameworkRequestHandle, options: IntegratedCompletionOptions | undefined, result: T): Promise<T>;
+declare function runWithIntegratedHandle<T>(handle: FrameworkRequestHandle, options: IntegratedCompletionOptions | undefined, fn: () => T | Promise<T>): Promise<T>;
+declare function toRouteAdapterOptions(options?: Pick<FrameworkHandlerOptions, keyof RouteAdapterOptions | 'requestLoggerOptions'>): RouteAdapterOptions;
+declare function buildTracedOptions(options: TracedOptionInput | undefined, spanName: string): FrameworkHandlerOptions;
+declare function defineFrameworkIntegration<TCtx>(spec: FrameworkIntegrationSpec<TCtx>): FrameworkIntegrationHelpers<TCtx>;
+//#endregion
+export { matchesRoutePattern as C, getServiceForPath as S, shouldInstrumentPath as T, RouteAdapterOptions as _, FrameworkRequestHandle as a, TailSamplingContext as b, buildTracedOptions as c, runWithIntegratedHandle as d, toRouteAdapterOptions as f, MiddlewareLoggerResult as g, MiddlewareLoggerOptions as h, FrameworkIntegrationSpec as i, completeIntegratedRequest as l, ForkLifecycle$1 as m, FrameworkHandlerOptions as n, IntegratedCompletionOptions as o, BaseAdapterOptions as p, FrameworkIntegrationHelpers as r, applyLoggerEnrichment as s, ExtractedRequest as t, defineFrameworkIntegration as u, RouteFilterOptions as v, mergeRequestLoggerOptions as w, createMiddlewareLogger as x, RouteServiceConfig as y };
+//# sourceMappingURL=integration-rYoX8QLk.d.ts.map

package/dist/integration-rYoX8QLk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-rYoX8QLk.d.ts","names":[],"sources":["../src/toolkit/middleware.ts","../src/toolkit/integration.ts"],"mappings":";;;;KAmBY,UAAU,KAAK,IAAI,QAAQ;UAKtB;EACf;EACA;EACA,SAAS,eAAe;EACxB,aAAa,SAAS;EACtB,QAAQ,KAAK,wBAAwB;EACrC,uBAAuB;;;KAIb,qBAAqB;UAEhB;EACf;EACA;EACA;EACA;EACA,SAAS;EACT;;UAGe,gCAAgC;EAC/C,YAAY;IACV,QAAQ;IACR;IACA;IACA;IACA;QACI;EACN;EACA;EACA;;UAGe;EACf,QAAQ;EACR,SAAS;IACP;IACA,QAAQ;IACR,YAAY;QACR,QAAQ;EACd,iBACE,UAAU,UACV;IAAS;IAAiB,YAAY;QACnC,QAAQ;EACb;;iBAUc,0BACd,MAAM,kCACN,aAAa,SAAS,4BACrB;;;;;iBAmFa,uBACd,QAAQ,eACR,SAAS,0BACR;;;UCjJc;EACf;EACA;EACA,UACI,UACA;IACE,IAAI;;EACV;;UAGe;EACf;;KAGU,oBAAoB;EAC9B,uBAAuB;EACvB;;UAGe,gCAAgC;EAC/C;;UAGe,yBAAyB;EACxC;EACA,iBAAiB,KAAK,SAAS;EAC/B,eAAe,KAAK,MAAM,QAAQ;EAClC,UAAU,kBAAkB;EAC5B,gBAAgB;EAChB,oBACE,KAAK,WACA,SAAS;EAChB,sBAAsB,KAAK,MAAM,SAAS;;UAG3B,+BAA+B;EAC9C,mBAAmB;EACnB,UAAU,GAAG,UAAU,IAAI,QAAQ,OAAO,QAAQ;;UAGnC,4BAA4B;EAC3C,QACE,UAAU,cACV,KAAK,MACL,UAAU,4BACP;EACL,YAAY,GACV,KAAK,MACL,SAAS,qCACT,UAAU,QAAQ,2BAA2B,QAAQ,OAClD,QAAQ;;iBAGC,sBACd,QAAQ,kBACL,eAAe,MAAM;iBASJ,0BAA0B,GAC9C,QAAQ,wBACR,SAAS,yCACT,QAAQ,IACP,QAAQ;iBAaW,wBAAwB,GAC5C,QAAQ,wBACR,SAAS,yCACT,UAAU,IAAI,QAAQ,KACrB,QAAQ;iBAkBK,sBACd,UAAU,KACR,+BACM,gDAEP;iBAOa,mBACd,SAAS,+BACT,mBACC;iBA0Ga,2BAA2B,MACzC,MAAM,yBAAyB,QAC9B,4BAA4B"}