@clickhouse/clickstack-node 0.0.0-stage → 1.0.0

package/dist/exception.cjs

@@ -0,0 +1,54 @@
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+// src/exception.ts
+const MAX_CAUSES = 5;
+/**
+* Builds the `exception.*` attributes of the crash record that the logs SDK does not derive from
+* the error itself. Attributes set here win over the SDK's.
+*
+* @remarks
+* An error's `cause` chain, up to five deep, is appended to its stack as `Caused by:` sections, the
+* layout of Java's `printStackTrace`, which ClickStack splits on. A thrown value that is not an
+* error is recorded as JSON text, because the logs SDK records only strings and numbers. Stacks
+* stay raw; ClickStack parses them.
+*
+* @param value - The uncaught exception.
+* @returns The attributes; empty when the SDK's own are complete.
+*/
+function exceptionAttributes(value) {
+	try {
+		if (typeof value === "string") return {};
+		if (!isErrorLike(value)) return { [_opentelemetry_semantic_conventions.ATTR_EXCEPTION_MESSAGE]: toText(value) };
+		const { cause } = value;
+		return cause === void 0 ? {} : { [_opentelemetry_semantic_conventions.ATTR_EXCEPTION_STACKTRACE]: stackWithCauses(value) };
+	} catch {
+		return {};
+	}
+}
+function isErrorLike(value) {
+	return typeof value === "object" && value !== null && ("message" in value || "stack" in value);
+}
+function stackWithCauses(error) {
+	let text = errorText(error);
+	const seen = /* @__PURE__ */ new Set([error]);
+	let { cause } = error;
+	for (let depth = 0; depth < MAX_CAUSES && cause !== void 0 && !seen.has(cause); depth++) {
+		seen.add(cause);
+		text += `\nCaused by: ${isErrorLike(cause) ? errorText(cause) : toText(cause)}`;
+		cause = isErrorLike(cause) ? cause.cause : void 0;
+	}
+	return text;
+}
+function errorText(error) {
+	const header = Error.prototype.toString.call(error);
+	const { stack } = error;
+	if (typeof stack !== "string") return header;
+	return stack.startsWith(header) ? stack : `${header}\n${stack}`;
+}
+function toText(value) {
+	try {
+		const json = JSON.stringify(value);
+		if (json !== void 0) return json;
+	} catch {}
+	return String(value);
+}
+exports.exceptionAttributes = exceptionAttributes;

package/dist/exception.mjs

@@ -0,0 +1,54 @@
+import { ATTR_EXCEPTION_MESSAGE, ATTR_EXCEPTION_STACKTRACE } from "@opentelemetry/semantic-conventions";
+// src/exception.ts
+const MAX_CAUSES = 5;
+/**
+* Builds the `exception.*` attributes of the crash record that the logs SDK does not derive from
+* the error itself. Attributes set here win over the SDK's.
+*
+* @remarks
+* An error's `cause` chain, up to five deep, is appended to its stack as `Caused by:` sections, the
+* layout of Java's `printStackTrace`, which ClickStack splits on. A thrown value that is not an
+* error is recorded as JSON text, because the logs SDK records only strings and numbers. Stacks
+* stay raw; ClickStack parses them.
+*
+* @param value - The uncaught exception.
+* @returns The attributes; empty when the SDK's own are complete.
+*/
+function exceptionAttributes(value) {
+	try {
+		if (typeof value === "string") return {};
+		if (!isErrorLike(value)) return { [ATTR_EXCEPTION_MESSAGE]: toText(value) };
+		const { cause } = value;
+		return cause === void 0 ? {} : { [ATTR_EXCEPTION_STACKTRACE]: stackWithCauses(value) };
+	} catch {
+		return {};
+	}
+}
+function isErrorLike(value) {
+	return typeof value === "object" && value !== null && ("message" in value || "stack" in value);
+}
+function stackWithCauses(error) {
+	let text = errorText(error);
+	const seen = /* @__PURE__ */ new Set([error]);
+	let { cause } = error;
+	for (let depth = 0; depth < MAX_CAUSES && cause !== void 0 && !seen.has(cause); depth++) {
+		seen.add(cause);
+		text += `\nCaused by: ${isErrorLike(cause) ? errorText(cause) : toText(cause)}`;
+		cause = isErrorLike(cause) ? cause.cause : void 0;
+	}
+	return text;
+}
+function errorText(error) {
+	const header = Error.prototype.toString.call(error);
+	const { stack } = error;
+	if (typeof stack !== "string") return header;
+	return stack.startsWith(header) ? stack : `${header}\n${stack}`;
+}
+function toText(value) {
+	try {
+		const json = JSON.stringify(value);
+		if (json !== void 0) return json;
+	} catch {}
+	return String(value);
+}
+export { exceptionAttributes };

package/dist/hook.cjs

@@ -0,0 +1,47 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_module = require("node:module");
+node_module = require_runtime.__toESM(node_module, 1);
+let node_url = require("node:url");
+// src/hook.ts
+const restoreFormat = (specifier, context, nextResolve) => {
+	const isEntry = context.parentURL === void 0;
+	const result = nextResolve(specifier, context);
+	if (result.format !== "commonjs") return result;
+	if (result.url.startsWith("node:")) return {
+		...result,
+		format: "builtin"
+	};
+	return isEntry && result.url.startsWith("file:") && !/\.[cm]?[jt]s$/.test(result.url) ? {
+		...result,
+		format: void 0
+	} : result;
+};
+/**
+* Installs the import-in-the-middle ESM loader hook in this thread.
+*
+* import-in-the-middle is loaded from `@opentelemetry/instrumentation`'s own location: only the
+* copy next to it sees the `Hook()` calls instrumentations make. The package's own dependency on
+* it is never imported; it raises that copy to the 3.5 line, whose behavior the repair above
+* expects (`@opentelemetry/instrumentation` accepts any 3.x). Synchronous hooks
+* (`module.registerHooks`) are used where import-in-the-middle supports them; `module.register`,
+* which Node 26 deprecates (DEP0205), is the fallback for older Node versions and for runtimes
+* that disable `require(esm)` (AWS Lambda).
+*
+* @returns `'sync'` for `module.registerHooks`, `'async'` for `module.register`.
+* @throws If `@opentelemetry/instrumentation/hook.mjs` cannot be resolved or Node rejects the hook.
+*/
+function installEsmHook() {
+	const hookFile = node_module.createRequire(require("url").pathToFileURL(__filename).href).resolve("@opentelemetry/instrumentation/hook.mjs");
+	let syncHooks;
+	try {
+		syncHooks = node_module.createRequire(hookFile)("import-in-the-middle/register-hooks.mjs");
+	} catch {}
+	if (syncHooks?.supportsSyncHooks() === true) {
+		syncHooks.register();
+		node_module.registerHooks({ resolve: restoreFormat });
+		return "sync";
+	}
+	node_module.register((0, node_url.pathToFileURL)(hookFile));
+	return "async";
+}
+exports.installEsmHook = installEsmHook;

package/dist/hook.mjs

@@ -0,0 +1,45 @@
+import * as nodeModule from "node:module";
+import { pathToFileURL } from "node:url";
+// src/hook.ts
+const restoreFormat = (specifier, context, nextResolve) => {
+	const isEntry = context.parentURL === void 0;
+	const result = nextResolve(specifier, context);
+	if (result.format !== "commonjs") return result;
+	if (result.url.startsWith("node:")) return {
+		...result,
+		format: "builtin"
+	};
+	return isEntry && result.url.startsWith("file:") && !/\.[cm]?[jt]s$/.test(result.url) ? {
+		...result,
+		format: void 0
+	} : result;
+};
+/**
+* Installs the import-in-the-middle ESM loader hook in this thread.
+*
+* import-in-the-middle is loaded from `@opentelemetry/instrumentation`'s own location: only the
+* copy next to it sees the `Hook()` calls instrumentations make. The package's own dependency on
+* it is never imported; it raises that copy to the 3.5 line, whose behavior the repair above
+* expects (`@opentelemetry/instrumentation` accepts any 3.x). Synchronous hooks
+* (`module.registerHooks`) are used where import-in-the-middle supports them; `module.register`,
+* which Node 26 deprecates (DEP0205), is the fallback for older Node versions and for runtimes
+* that disable `require(esm)` (AWS Lambda).
+*
+* @returns `'sync'` for `module.registerHooks`, `'async'` for `module.register`.
+* @throws If `@opentelemetry/instrumentation/hook.mjs` cannot be resolved or Node rejects the hook.
+*/
+function installEsmHook() {
+	const hookFile = nodeModule.createRequire(import.meta.url).resolve("@opentelemetry/instrumentation/hook.mjs");
+	let syncHooks;
+	try {
+		syncHooks = nodeModule.createRequire(hookFile)("import-in-the-middle/register-hooks.mjs");
+	} catch {}
+	if (syncHooks?.supportsSyncHooks() === true) {
+		syncHooks.register();
+		nodeModule.registerHooks({ resolve: restoreFormat });
+		return "sync";
+	}
+	nodeModule.register(pathToFileURL(hookFile));
+	return "async";
+}
+export { installEsmHook };

package/dist/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_lifecycle = require("./lifecycle.cjs");
+const require_init = require("./init.cjs");
+exports.flush = require_lifecycle.flush;
+exports.init = require_init.init;
+exports.shutdown = require_lifecycle.shutdown;
+exports.withFlush = require_lifecycle.withFlush;

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+import { ClickStackNodeOptions } from "./config.cjs";
+import { init } from "./init.cjs";
+import { flush, shutdown, withFlush } from "./lifecycle.cjs";
+export { type ClickStackNodeOptions, flush, init, shutdown, withFlush };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { ClickStackNodeOptions } from "./config.mjs";
+import { init } from "./init.mjs";
+import { flush, shutdown, withFlush } from "./lifecycle.mjs";
+export { type ClickStackNodeOptions, flush, init, shutdown, withFlush };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { flush, shutdown, withFlush } from "./lifecycle.mjs";
+import { init } from "./init.mjs";
+export { flush, init, shutdown, withFlush };

package/dist/init.cjs

@@ -0,0 +1,139 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_state = require("./state.cjs");
+const require_env = require("./env.cjs");
+const require_lifecycle = require("./lifecycle.cjs");
+const require_compose = require("./compose.cjs");
+const require_config = require("./config.cjs");
+const require_exception = require("./exception.cjs");
+const require_hook = require("./hook.cjs");
+const require_version = require("./version.cjs");
+let node_worker_threads = require("node:worker_threads");
+node_worker_threads = require_runtime.__toESM(node_worker_threads, 1);
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+let _opentelemetry_core = require("@opentelemetry/core");
+let _opentelemetry_instrumentation_console = require("@opentelemetry/instrumentation-console");
+let _opentelemetry_resources = require("@opentelemetry/resources");
+let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+// src/init.ts
+/**
+* Starts the OpenTelemetry SDK with ClickStack defaults: traces, metrics and logs over OTLP,
+* `console` capture, and a flush on shutdown, termination signals and crashes.
+*
+* Options with an environment variable are written to `process.env` only when that variable is
+* unset, so a variable set by an operator always wins. A second call, or a call after another
+* OpenTelemetry SDK registered a tracer provider, logs a warning and does nothing. With
+* `OTEL_SDK_DISABLED=true` it does nothing at all. It never throws.
+*
+* Call it before the app loads the modules to instrument. In an ES module entry, static imports
+* run first, so start the process with the register entry instead:
+* `node --import @clickhouse/clickstack-node/register app.mjs` (it also works with `--require` and
+* in `NODE_OPTIONS`); that entry calls `init()` without options.
+*
+* @param options - Code options; each loses to its environment variable.
+* @example
+* At the top of a CommonJS entry, before anything else is required:
+* ```js
+* const { init } = require('@clickhouse/clickstack-node');
+*
+* init({ serviceName: 'checkout', endpoint: 'https://otel.example.com:4318', apiKey: process.env.KEY });
+*
+* const express = require('express');
+* ```
+* @public
+*/
+function init(options = {}) {
+	try {
+		start(options);
+	} catch (err) {
+		require_state.getState().unsubscribeUndici?.();
+		require_env.report("error", "init() failed; the application is not instrumented", err);
+	}
+}
+function start(options) {
+	if (node_worker_threads.isInternalThread) return;
+	if ((0, _opentelemetry_core.getBooleanFromEnv)("OTEL_SDK_DISABLED")) return;
+	const state = require_state.getState();
+	const registry = require_env.apiRegistry();
+	if (state.initialized === true || registry?.trace !== void 0) {
+		require_env.report("warn", "an OpenTelemetry SDK is already started; init() does nothing");
+		return;
+	}
+	state.initialized = true;
+	require_config.applyOptions(options);
+	try {
+		state.esmHook = require_hook.installEsmHook();
+	} catch (err) {
+		state.esmHook = "failed";
+		require_env.warnOnce("esm-hook", "ESM loader hook not installed; ES modules are not instrumented", err);
+	}
+	const bodies = (0, _opentelemetry_core.getBooleanFromEnv)("CLICKSTACK_CAPTURE_HTTP_BODY");
+	const { map, unsubscribe } = require_compose.composeInstrumentationConfig(options.instrumentations, bodies);
+	if (unsubscribe !== void 0) state.unsubscribeUndici = unsubscribe;
+	const runtimeNode = "@opentelemetry/instrumentation-runtime-node";
+	const runtime = map[runtimeNode] ?? {};
+	map[runtimeNode] = {
+		captureUncaughtException: true,
+		...runtime,
+		applyCustomExceptionAttributes: (error, eventType) => ({
+			...require_exception.exceptionAttributes(error),
+			...runtime.applyCustomExceptionAttributes?.(error, eventType)
+		})
+	};
+	const disabled = (0, _opentelemetry_core.getStringListFromEnv)("OTEL_NODE_DISABLED_INSTRUMENTATIONS");
+	const enabled = (0, _opentelemetry_core.getStringListFromEnv)("OTEL_NODE_ENABLED_INSTRUMENTATIONS");
+	const router = "@opentelemetry/instrumentation-router";
+	if (enabled === void 0) map[router] = {
+		enabled: false,
+		...map[router]
+	};
+	const consoleListed = disabled?.includes("console") !== true && (enabled?.includes("console") ?? true);
+	const consoleExporter = [
+		"OTEL_TRACES_EXPORTER",
+		"OTEL_METRICS_EXPORTER",
+		"OTEL_LOGS_EXPORTER"
+	].find((name) => (0, _opentelemetry_core.getStringListFromEnv)(name)?.includes("console"));
+	if (consoleListed && consoleExporter !== void 0) require_env.warnOnce("console-exporter", `console capture is off because ${consoleExporter} includes console`);
+	const consoleCapture = consoleListed && consoleExporter === void 0;
+	const instrumentations = [
+		...require_env.withStartupLogger(() => (0, _opentelemetry_auto_instrumentations_node.getNodeAutoInstrumentations)(map)),
+		...consoleCapture ? [new _opentelemetry_instrumentation_console.ConsoleInstrumentation()] : [],
+		...options.additionalInstrumentations ?? []
+	];
+	const build = () => new _opentelemetry_sdk_node.NodeSDK({
+		resource: (0, _opentelemetry_resources.defaultResource)().merge((0, _opentelemetry_resources.resourceFromAttributes)({
+			...options.environment ? { [_opentelemetry_semantic_conventions.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: options.environment } : {},
+			[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_DISTRO_NAME]: "clickstack-node",
+			[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_DISTRO_VERSION]: require_version.VERSION
+		})),
+		resourceDetectors: withDefault("OTEL_NODE_RESOURCE_DETECTORS", "container,host,os,process,serviceinstance,env", () => require_env.withStartupLogger(_opentelemetry_auto_instrumentations_node.getResourceDetectors)),
+		instrumentations
+	});
+	const sdk = registry?.diag === void 0 ? withDefault("OTEL_LOG_LEVEL", "warn", build) : build();
+	sdk.start();
+	state.sdk = sdk;
+	if (consoleCapture) {
+		state.consoleLog = console.log;
+		state.repatchConsole = () => {
+			new _opentelemetry_instrumentation_console.ConsoleInstrumentation();
+		};
+	}
+	require_lifecycle.installLifecycle();
+	const provider = _opentelemetry_api.trace.getTracerProvider();
+	const bounded = {
+		getTracer: (...args) => provider.getTracer(...args),
+		forceFlush: () => require_lifecycle.flush()
+	};
+	for (const instrumentation of instrumentations) if (instrumentation.instrumentationName === "@opentelemetry/instrumentation-aws-lambda") instrumentation.setTracerProvider(bounded);
+}
+function withDefault(name, value, call) {
+	if ((0, _opentelemetry_core.getStringFromEnv)(name) !== void 0) return call();
+	process.env[name] = value;
+	try {
+		return call();
+	} finally {
+		Reflect.deleteProperty(process.env, name);
+	}
+}
+exports.init = init;

package/dist/init.d.cts

@@ -0,0 +1,28 @@
+import { ClickStackNodeOptions } from "./config.cjs";
+/**
+ * Starts the OpenTelemetry SDK with ClickStack defaults: traces, metrics and logs over OTLP,
+ * `console` capture, and a flush on shutdown, termination signals and crashes.
+ *
+ * Options with an environment variable are written to `process.env` only when that variable is
+ * unset, so a variable set by an operator always wins. A second call, or a call after another
+ * OpenTelemetry SDK registered a tracer provider, logs a warning and does nothing. With
+ * `OTEL_SDK_DISABLED=true` it does nothing at all. It never throws.
+ *
+ * Call it before the app loads the modules to instrument. In an ES module entry, static imports
+ * run first, so start the process with the register entry instead:
+ * `node --import @clickhouse/clickstack-node/register app.mjs` (it also works with `--require` and
+ * in `NODE_OPTIONS`); that entry calls `init()` without options.
+ *
+ * @param options - Code options; each loses to its environment variable.
+ * @example
+ * At the top of a CommonJS entry, before anything else is required:
+ * ```js
+ * const { init } = require('@clickhouse/clickstack-node');
+ *
+ * init({ serviceName: 'checkout', endpoint: 'https://otel.example.com:4318', apiKey: process.env.KEY });
+ *
+ * const express = require('express');
+ * ```
+ * @public
+ */
+export declare function init(options?: ClickStackNodeOptions): void;

package/dist/init.d.mts

@@ -0,0 +1,28 @@
+import { ClickStackNodeOptions } from "./config.mjs";
+/**
+ * Starts the OpenTelemetry SDK with ClickStack defaults: traces, metrics and logs over OTLP,
+ * `console` capture, and a flush on shutdown, termination signals and crashes.
+ *
+ * Options with an environment variable are written to `process.env` only when that variable is
+ * unset, so a variable set by an operator always wins. A second call, or a call after another
+ * OpenTelemetry SDK registered a tracer provider, logs a warning and does nothing. With
+ * `OTEL_SDK_DISABLED=true` it does nothing at all. It never throws.
+ *
+ * Call it before the app loads the modules to instrument. In an ES module entry, static imports
+ * run first, so start the process with the register entry instead:
+ * `node --import @clickhouse/clickstack-node/register app.mjs` (it also works with `--require` and
+ * in `NODE_OPTIONS`); that entry calls `init()` without options.
+ *
+ * @param options - Code options; each loses to its environment variable.
+ * @example
+ * At the top of a CommonJS entry, before anything else is required:
+ * ```js
+ * const { init } = require('@clickhouse/clickstack-node');
+ *
+ * init({ serviceName: 'checkout', endpoint: 'https://otel.example.com:4318', apiKey: process.env.KEY });
+ *
+ * const express = require('express');
+ * ```
+ * @public
+ */
+export declare function init(options?: ClickStackNodeOptions): void;

package/dist/init.mjs

@@ -0,0 +1,137 @@
+import { getState } from "./state.mjs";
+import { apiRegistry, report, warnOnce, withStartupLogger } from "./env.mjs";
+import { flush, installLifecycle } from "./lifecycle.mjs";
+import { composeInstrumentationConfig } from "./compose.mjs";
+import { applyOptions } from "./config.mjs";
+import { exceptionAttributes } from "./exception.mjs";
+import { installEsmHook } from "./hook.mjs";
+import { VERSION } from "./version.mjs";
+import * as workerThreads from "node:worker_threads";
+import { trace } from "@opentelemetry/api";
+import { getNodeAutoInstrumentations, getResourceDetectors } from "@opentelemetry/auto-instrumentations-node";
+import { getBooleanFromEnv, getStringFromEnv, getStringListFromEnv } from "@opentelemetry/core";
+import { ConsoleInstrumentation } from "@opentelemetry/instrumentation-console";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { ATTR_DEPLOYMENT_ENVIRONMENT_NAME, ATTR_TELEMETRY_DISTRO_NAME, ATTR_TELEMETRY_DISTRO_VERSION } from "@opentelemetry/semantic-conventions";
+// src/init.ts
+/**
+* Starts the OpenTelemetry SDK with ClickStack defaults: traces, metrics and logs over OTLP,
+* `console` capture, and a flush on shutdown, termination signals and crashes.
+*
+* Options with an environment variable are written to `process.env` only when that variable is
+* unset, so a variable set by an operator always wins. A second call, or a call after another
+* OpenTelemetry SDK registered a tracer provider, logs a warning and does nothing. With
+* `OTEL_SDK_DISABLED=true` it does nothing at all. It never throws.
+*
+* Call it before the app loads the modules to instrument. In an ES module entry, static imports
+* run first, so start the process with the register entry instead:
+* `node --import @clickhouse/clickstack-node/register app.mjs` (it also works with `--require` and
+* in `NODE_OPTIONS`); that entry calls `init()` without options.
+*
+* @param options - Code options; each loses to its environment variable.
+* @example
+* At the top of a CommonJS entry, before anything else is required:
+* ```js
+* const { init } = require('@clickhouse/clickstack-node');
+*
+* init({ serviceName: 'checkout', endpoint: 'https://otel.example.com:4318', apiKey: process.env.KEY });
+*
+* const express = require('express');
+* ```
+* @public
+*/
+function init(options = {}) {
+	try {
+		start(options);
+	} catch (err) {
+		getState().unsubscribeUndici?.();
+		report("error", "init() failed; the application is not instrumented", err);
+	}
+}
+function start(options) {
+	if (workerThreads.isInternalThread) return;
+	if (getBooleanFromEnv("OTEL_SDK_DISABLED")) return;
+	const state = getState();
+	const registry = apiRegistry();
+	if (state.initialized === true || registry?.trace !== void 0) {
+		report("warn", "an OpenTelemetry SDK is already started; init() does nothing");
+		return;
+	}
+	state.initialized = true;
+	applyOptions(options);
+	try {
+		state.esmHook = installEsmHook();
+	} catch (err) {
+		state.esmHook = "failed";
+		warnOnce("esm-hook", "ESM loader hook not installed; ES modules are not instrumented", err);
+	}
+	const bodies = getBooleanFromEnv("CLICKSTACK_CAPTURE_HTTP_BODY");
+	const { map, unsubscribe } = composeInstrumentationConfig(options.instrumentations, bodies);
+	if (unsubscribe !== void 0) state.unsubscribeUndici = unsubscribe;
+	const runtimeNode = "@opentelemetry/instrumentation-runtime-node";
+	const runtime = map[runtimeNode] ?? {};
+	map[runtimeNode] = {
+		captureUncaughtException: true,
+		...runtime,
+		applyCustomExceptionAttributes: (error, eventType) => ({
+			...exceptionAttributes(error),
+			...runtime.applyCustomExceptionAttributes?.(error, eventType)
+		})
+	};
+	const disabled = getStringListFromEnv("OTEL_NODE_DISABLED_INSTRUMENTATIONS");
+	const enabled = getStringListFromEnv("OTEL_NODE_ENABLED_INSTRUMENTATIONS");
+	const router = "@opentelemetry/instrumentation-router";
+	if (enabled === void 0) map[router] = {
+		enabled: false,
+		...map[router]
+	};
+	const consoleListed = disabled?.includes("console") !== true && (enabled?.includes("console") ?? true);
+	const consoleExporter = [
+		"OTEL_TRACES_EXPORTER",
+		"OTEL_METRICS_EXPORTER",
+		"OTEL_LOGS_EXPORTER"
+	].find((name) => getStringListFromEnv(name)?.includes("console"));
+	if (consoleListed && consoleExporter !== void 0) warnOnce("console-exporter", `console capture is off because ${consoleExporter} includes console`);
+	const consoleCapture = consoleListed && consoleExporter === void 0;
+	const instrumentations = [
+		...withStartupLogger(() => getNodeAutoInstrumentations(map)),
+		...consoleCapture ? [new ConsoleInstrumentation()] : [],
+		...options.additionalInstrumentations ?? []
+	];
+	const build = () => new NodeSDK({
+		resource: defaultResource().merge(resourceFromAttributes({
+			...options.environment ? { [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: options.environment } : {},
+			[ATTR_TELEMETRY_DISTRO_NAME]: "clickstack-node",
+			[ATTR_TELEMETRY_DISTRO_VERSION]: VERSION
+		})),
+		resourceDetectors: withDefault("OTEL_NODE_RESOURCE_DETECTORS", "container,host,os,process,serviceinstance,env", () => withStartupLogger(getResourceDetectors)),
+		instrumentations
+	});
+	const sdk = registry?.diag === void 0 ? withDefault("OTEL_LOG_LEVEL", "warn", build) : build();
+	sdk.start();
+	state.sdk = sdk;
+	if (consoleCapture) {
+		state.consoleLog = console.log;
+		state.repatchConsole = () => {
+			new ConsoleInstrumentation();
+		};
+	}
+	installLifecycle();
+	const provider = trace.getTracerProvider();
+	const bounded = {
+		getTracer: (...args) => provider.getTracer(...args),
+		forceFlush: () => flush()
+	};
+	for (const instrumentation of instrumentations) if (instrumentation.instrumentationName === "@opentelemetry/instrumentation-aws-lambda") instrumentation.setTracerProvider(bounded);
+}
+function withDefault(name, value, call) {
+	if (getStringFromEnv(name) !== void 0) return call();
+	process.env[name] = value;
+	try {
+		return call();
+	} finally {
+		Reflect.deleteProperty(process.env, name);
+	}
+}
+export { init };