@vercube/telemetry 1.3.0

package/dist/Sdk.d.mts

@@ -0,0 +1,156 @@
+import { Context } from "@opentelemetry/api";
+import { TelemetryTypes } from "@vercube/core";
+import { AggregationTemporality, IMetricReader, IMetricReader as IMetricReader$1, InMemoryMetricExporter, MeterProvider, MeterProvider as MeterProvider$1, PeriodicExportingMetricReader, PushMetricExporter, ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor, NodeTracerProvider, NodeTracerProvider as NodeTracerProvider$1, Sampler, SpanExporter as SpanExporter$1, SpanProcessor as SpanProcessor$1 } from "@opentelemetry/sdk-trace-node";
+import { BasicTracerProvider, InMemorySpanExporter, ReadableSpan, ReadableSpan as ReadableSpan$1, SimpleSpanProcessor, Span as SdkSpan, Span as Span$1, SpanExporter, SpanProcessor, SpanProcessor as SpanProcessor$2 } from "@opentelemetry/sdk-trace-base";
+//#region src/Sdk/Composite.d.ts
+/**
+ * A span processor that other processors can be added to after the tracer
+ * provider has already been built.
+ *
+ * `BasicTracerProvider` takes its processors at construction and never exposes
+ * them again, which makes "the application configured OTLP export and devtools
+ * also wants to see the spans" unsolvable: whoever builds the provider second
+ * wins. Registering a single composite instead, and letting packages add to it
+ * whenever they initialise, removes the ordering problem entirely.
+ */
+export declare class CompositeSpanProcessor implements SpanProcessor$2 {
+  /** The processors this one fans out to. */
+  private readonly fProcessors;
+  /**
+   * Adds a processor.
+   *
+   * @param processor - The processor to add
+   * @returns A function that removes it again
+   */
+  add(processor: SpanProcessor$2): () => void;
+  /** Number of registered processors. */
+  get size(): number;
+  /** @inheritdoc */
+  onStart(span: Span$1, parentContext: Context): void;
+  /** @inheritdoc */
+  onEnd(span: ReadableSpan$1): void;
+  /** @inheritdoc */
+  forceFlush(): Promise<void>;
+  /** @inheritdoc */
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/Sdk.d.ts
+/**
+ * Options for {@link startNodeTelemetry}.
+ */
+export interface NodeTelemetryOptions {
+  /** `service.name` resource attribute. */
+  serviceName?: string;
+  /** `service.version` resource attribute. */
+  serviceVersion?: string;
+  /** `deployment.environment.name` resource attribute. */
+  environment?: string;
+  /** Extra resource attributes. */
+  resourceAttributes?: Record<string, string | number | boolean>;
+  /** Head sampling strategy. Defaults to `parent`. */
+  sampler?: TelemetryTypes.Sampler;
+  /**
+   * OTLP/HTTP endpoint, e.g. `http://localhost:4318`.
+   *
+   * Defaults to `OTEL_EXPORTER_OTLP_ENDPOINT`. When neither is set and no
+   * `exporter` or `spanProcessors` are given, nothing is exported.
+   */
+  endpoint?: string;
+  /** Headers sent with every OTLP request, for authenticated collectors. */
+  headers?: Record<string, string>;
+  /** A ready-made exporter, used instead of the OTLP one. */
+  exporter?: SpanExporter$1;
+  /** Extra span processors, appended after the exporting one. */
+  spanProcessors?: SpanProcessor$1[];
+}
+/**
+ * Handle returned by {@link startNodeTelemetry}.
+ */
+export interface NodeTelemetry {
+  /** The registered provider. */
+  provider: NodeTracerProvider$1;
+  /** Flushes pending spans and shuts the provider down. */
+  shutdown(): Promise<void>;
+}
+/**
+ * Wires a Node tracer provider and registers it as the global one.
+ *
+ * `@vercube/telemetry` on its own only speaks the OpenTelemetry **API**, which
+ * means no spans are recorded until something registers a provider. This is the
+ * batteries-included way to do that:
+ *
+ * ```ts
+ * import { startNodeTelemetry } from '@vercube/telemetry/sdk';
+ *
+ * const telemetry = await startNodeTelemetry({
+ *   serviceName: 'checkout',
+ *   endpoint: 'http://localhost:4318',
+ * });
+ * ```
+ *
+ * The context manager and the propagator are deliberately **not** registered
+ * here: `TelemetryPlugin` already installed ones backed by Vercube's request
+ * context, and letting the SDK replace them would open a second
+ * `AsyncLocalStorage` per request.
+ *
+ * Call it before `createApp()` so bootstrap work is traced too.
+ *
+ * @param options - Resource, sampling and exporter settings
+ * @returns Handle to the registered provider
+ */
+export declare function startNodeTelemetry(options?: NodeTelemetryOptions): Promise<NodeTelemetry>;
+/**
+ * Adds a span processor, whether or not a tracer provider exists yet.
+ *
+ * This is how a package can see spans without owning the SDK setup: devtools
+ * adds its recorder here, and it works the same whether the application called
+ * {@link startNodeTelemetry} first, later, or never.
+ *
+ * @param processor - The processor to add
+ * @returns A function that removes it again
+ */
+export declare function addSpanProcessor(processor: SpanProcessor$1): () => void;
+/**
+ * Registers a tracer provider around the shared processor, unless one has
+ * already been created here.
+ *
+ * @param options - Resource and sampling settings, used only on first call
+ * @returns Handle to the registered provider
+ */
+export declare function ensureTracerProvider(options?: NodeTelemetryOptions): NodeTelemetry;
+/**
+ * Registers a metric reader.
+ *
+ * Must be called before {@link ensureMeterProvider}. `MeterProvider` takes its
+ * readers at construction, a reader cannot be bound to a second provider, and
+ * the metrics API has no proxy meter - so the provider is built once, and
+ * instruments have to be created after it exists.
+ *
+ * Registering the same reader twice is a no-op, which matters because a plugin
+ * config phase can run more than once per process.
+ *
+ * @param reader - The reader to register
+ * @returns A function that unregisters it again
+ */
+export declare function addMetricReader(reader: IMetricReader$1): () => void;
+/**
+ * Registers a meter provider around the readers added so far, unless one has
+ * already been created here.
+ *
+ * @param options - Resource settings, used only on first call
+ * @returns The registered provider
+ */
+export declare function ensureMeterProvider(options?: NodeTelemetryOptions): MeterProvider$1;
+/**
+ * Drops every registered provider and reader.
+ *
+ * Meant for tests and for tearing an application down; a process that builds a
+ * second application afterwards starts from a clean slate.
+ *
+ * @returns Resolves once the providers have shut down
+ */
+export declare function resetTelemetryProviders(): Promise<void>;
+//#endregion
+export { AggregationTemporality, BasicTracerProvider, BatchSpanProcessor, type IMetricReader, InMemoryMetricExporter, InMemorySpanExporter, MeterProvider, NodeTracerProvider, PeriodicExportingMetricReader, type PushMetricExporter, type ReadableSpan, type ResourceMetrics, type Sampler, type SdkSpan, SimpleSpanProcessor, type SpanExporter, type SpanProcessor };

package/dist/Sdk.mjs

@@ -0,0 +1,229 @@
+import { createOtlpTraceExporter } from "./Otlp.mjs";
+import { metrics, trace } from "@opentelemetry/api";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { AggregationTemporality, InMemoryMetricExporter, MeterProvider, MeterProvider as MeterProvider$1, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { AlwaysOffSampler, AlwaysOnSampler, BatchSpanProcessor, BatchSpanProcessor as BatchSpanProcessor$1, NodeTracerProvider, NodeTracerProvider as NodeTracerProvider$1, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-node";
+import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+//#region src/Sdk/Composite.ts
+/**
+* A span processor that other processors can be added to after the tracer
+* provider has already been built.
+*
+* `BasicTracerProvider` takes its processors at construction and never exposes
+* them again, which makes "the application configured OTLP export and devtools
+* also wants to see the spans" unsolvable: whoever builds the provider second
+* wins. Registering a single composite instead, and letting packages add to it
+* whenever they initialise, removes the ordering problem entirely.
+*/
+var CompositeSpanProcessor = class {
+	/** The processors this one fans out to. */
+	fProcessors = [];
+	/**
+	* Adds a processor.
+	*
+	* @param processor - The processor to add
+	* @returns A function that removes it again
+	*/
+	add(processor) {
+		this.fProcessors.push(processor);
+		return () => {
+			const index = this.fProcessors.indexOf(processor);
+			if (index !== -1) this.fProcessors.splice(index, 1);
+		};
+	}
+	/** Number of registered processors. */
+	get size() {
+		return this.fProcessors.length;
+	}
+	/** @inheritdoc */
+	onStart(span, parentContext) {
+		for (const processor of this.fProcessors) processor.onStart(span, parentContext);
+	}
+	/** @inheritdoc */
+	onEnd(span) {
+		for (const processor of this.fProcessors) processor.onEnd(span);
+	}
+	/** @inheritdoc */
+	async forceFlush() {
+		await Promise.all(this.fProcessors.map((processor) => processor.forceFlush()));
+	}
+	/** @inheritdoc */
+	async shutdown() {
+		await Promise.all(this.fProcessors.map((processor) => processor.shutdown()));
+	}
+};
+//#endregion
+//#region src/Sdk.ts
+/**
+* Wires a Node tracer provider and registers it as the global one.
+*
+* `@vercube/telemetry` on its own only speaks the OpenTelemetry **API**, which
+* means no spans are recorded until something registers a provider. This is the
+* batteries-included way to do that:
+*
+* ```ts
+* import { startNodeTelemetry } from '@vercube/telemetry/sdk';
+*
+* const telemetry = await startNodeTelemetry({
+*   serviceName: 'checkout',
+*   endpoint: 'http://localhost:4318',
+* });
+* ```
+*
+* The context manager and the propagator are deliberately **not** registered
+* here: `TelemetryPlugin` already installed ones backed by Vercube's request
+* context, and letting the SDK replace them would open a second
+* `AsyncLocalStorage` per request.
+*
+* Call it before `createApp()` so bootstrap work is traced too.
+*
+* @param options - Resource, sampling and exporter settings
+* @returns Handle to the registered provider
+*/
+async function startNodeTelemetry(options = {}) {
+	const exporter = options.exporter ?? await createOtlpExporter(options);
+	if (exporter) addSpanProcessor(new BatchSpanProcessor$1(exporter));
+	for (const processor of options.spanProcessors ?? []) addSpanProcessor(processor);
+	return ensureTracerProvider(options);
+}
+/** The one processor every provider created here is built around. */
+const composite = new CompositeSpanProcessor();
+/** The provider created by {@link ensureTracerProvider}, if any. */
+let started;
+/**
+* Adds a span processor, whether or not a tracer provider exists yet.
+*
+* This is how a package can see spans without owning the SDK setup: devtools
+* adds its recorder here, and it works the same whether the application called
+* {@link startNodeTelemetry} first, later, or never.
+*
+* @param processor - The processor to add
+* @returns A function that removes it again
+*/
+function addSpanProcessor(processor) {
+	return composite.add(processor);
+}
+/**
+* Registers a tracer provider around the shared processor, unless one has
+* already been created here.
+*
+* @param options - Resource and sampling settings, used only on first call
+* @returns Handle to the registered provider
+*/
+function ensureTracerProvider(options = {}) {
+	if (started) return started;
+	const provider = new NodeTracerProvider$1({
+		resource: resourceFromAttributes({
+			"service.name": options.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "vercube",
+			"service.version": options.serviceVersion,
+			"deployment.environment.name": options.environment ?? process.env.NODE_ENV,
+			...options.resourceAttributes
+		}),
+		sampler: toSampler(options.sampler),
+		spanProcessors: [composite]
+	});
+	provider.register({
+		contextManager: null,
+		propagator: null
+	});
+	started = {
+		provider,
+		shutdown: async () => {
+			started = void 0;
+			await provider.shutdown();
+			trace.disable();
+		}
+	};
+	return started;
+}
+/**
+* Builds the OTLP/HTTP exporter, when an endpoint is configured.
+*
+* @param options - The telemetry options
+* @returns The exporter, or undefined when no endpoint is configured
+*/
+async function createOtlpExporter(options) {
+	const endpoint = options.endpoint ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (!endpoint) return;
+	return createOtlpTraceExporter({
+		endpoint,
+		headers: options.headers
+	});
+}
+/**
+* Translates the framework's sampler shorthand into an SDK sampler.
+*
+* @param sampler - The configured strategy
+* @returns The SDK sampler
+*/
+function toSampler(sampler = "parent") {
+	if (sampler === "always") return new AlwaysOnSampler();
+	if (sampler === "never") return new AlwaysOffSampler();
+	if (sampler === "parent") return new ParentBasedSampler({ root: new AlwaysOnSampler() });
+	return new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampler.ratio) });
+}
+/** Metric readers registered before the meter provider was built. */
+const metricReaders = [];
+/** The meter provider created by {@link ensureMeterProvider}, if any. */
+let meterProvider;
+/**
+* Registers a metric reader.
+*
+* Must be called before {@link ensureMeterProvider}. `MeterProvider` takes its
+* readers at construction, a reader cannot be bound to a second provider, and
+* the metrics API has no proxy meter - so the provider is built once, and
+* instruments have to be created after it exists.
+*
+* Registering the same reader twice is a no-op, which matters because a plugin
+* config phase can run more than once per process.
+*
+* @param reader - The reader to register
+* @returns A function that unregisters it again
+*/
+function addMetricReader(reader) {
+	if (!metricReaders.includes(reader)) metricReaders.push(reader);
+	return () => {
+		const index = metricReaders.indexOf(reader);
+		if (index !== -1) metricReaders.splice(index, 1);
+	};
+}
+/**
+* Registers a meter provider around the readers added so far, unless one has
+* already been created here.
+*
+* @param options - Resource settings, used only on first call
+* @returns The registered provider
+*/
+function ensureMeterProvider(options = {}) {
+	if (meterProvider) return meterProvider;
+	meterProvider = new MeterProvider$1({
+		resource: resourceFromAttributes({
+			"service.name": options.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "vercube",
+			"service.version": options.serviceVersion,
+			"deployment.environment.name": options.environment ?? process.env.NODE_ENV,
+			...options.resourceAttributes
+		}),
+		readers: metricReaders
+	});
+	metrics.setGlobalMeterProvider(meterProvider);
+	return meterProvider;
+}
+/**
+* Drops every registered provider and reader.
+*
+* Meant for tests and for tearing an application down; a process that builds a
+* second application afterwards starts from a clean slate.
+*
+* @returns Resolves once the providers have shut down
+*/
+async function resetTelemetryProviders() {
+	const provider = meterProvider;
+	meterProvider = void 0;
+	metricReaders.length = 0;
+	started = void 0;
+	metrics.disable();
+	trace.disable();
+	await provider?.shutdown().catch(() => {});
+}
+//#endregion
+export { AggregationTemporality, BasicTracerProvider, BatchSpanProcessor, CompositeSpanProcessor, InMemoryMetricExporter, InMemorySpanExporter, MeterProvider, NodeTracerProvider, PeriodicExportingMetricReader, SimpleSpanProcessor, addMetricReader, addSpanProcessor, ensureMeterProvider, ensureTracerProvider, resetTelemetryProviders, startNodeTelemetry };

package/dist/SpanUtils-t3NCeswB.mjs

@@ -0,0 +1,147 @@
+import { r as HTTP_RESPONSE_STATUS_CODE, t as ERROR_TYPE } from "./Attributes-QVHj8ZgV.mjs";
+import { SpanStatusCode, context, trace } from "@opentelemetry/api";
+//#region src/Common/SpanUtils.ts
+/** Lowest HTTP status code that marks a *server* span as failed. */
+const SERVER_ERROR_STATUS = 500;
+/**
+* Starts a span, runs `fn` inside it and ends it once the work settles.
+*
+* The result of `fn` is returned unchanged. That matters more than it looks:
+* a Vercube route without middlewares produces its `Response` synchronously,
+* and wrapping it in a promise would add a microtask to every request.
+*
+* @param tracer - Tracer to start the span on
+* @param name - Span name
+* @param options - Span options (kind, attributes, links)
+* @param parent - Context the span is a child of
+* @param fn - The work to trace
+* @param onSettle - Called with the outcome just before the span ends. Returning a
+*   promise keeps the span open until it settles, without extending its duration.
+* @returns Whatever `fn` returned
+*/
+function runInSpan(tracer, name, options, parent, fn, onSettle) {
+	const span = tracer.startSpan(name, options, parent);
+	const settle = (value, error) => {
+		if (error === void 0) completeSpan(span, value);
+		else failSpan(span, error);
+		const pending = onSettle?.(span, value, error);
+		if (pending !== void 0) {
+			const endTime = Date.now();
+			pending.then(() => span.end(endTime), () => span.end(endTime));
+			return;
+		}
+		span.end();
+	};
+	return context.with(trace.setSpan(parent, span), () => {
+		let result;
+		try {
+			result = fn(span);
+		} catch (error) {
+			settle(void 0, error ?? /* @__PURE__ */ new Error("Unknown error"));
+			throw error;
+		}
+		if (isPromiseLike(result)) return result.then((value) => {
+			settle(value, void 0);
+			return value;
+		}, (error) => {
+			settle(void 0, error ?? /* @__PURE__ */ new Error("Unknown error"));
+			throw error;
+		});
+		settle(result, void 0);
+		return result;
+	});
+}
+/**
+* Applies the outcome of a successful call to a span.
+*
+* When the value is a `Response` the HTTP status is recorded, and a 5xx marks
+* the span as failed - a 4xx does not, because on a server span it describes
+* the caller's request rather than a fault of the handler.
+*
+* @param span - The span to update
+* @param value - The value the traced work produced
+*/
+function completeSpan(span, value) {
+	if (!(value instanceof Response)) return;
+	span.setAttribute(HTTP_RESPONSE_STATUS_CODE, value.status);
+	if (value.status >= SERVER_ERROR_STATUS) span.setStatus({ code: SpanStatusCode.ERROR });
+}
+/**
+* Records a thrown value on a span and marks the span as failed, whatever the
+* error looks like.
+*
+* This is the variant for spans that carry no HTTP status semantics - the
+* `CLIENT`, `PRODUCER` and `CONSUMER` spans an instrumented package produces.
+* `failSpan` is the server-span variant and deliberately behaves differently;
+* see the comment there before merging the two.
+*
+* @param span - The span to update
+* @param error - The thrown value
+*/
+function recordFailure(span, error) {
+	span.recordException(error);
+	span.setAttribute(ERROR_TYPE, errorType(error));
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: errorMessage(error)
+	});
+}
+/**
+* Records a thrown value on a *server* span and marks it failed only when the
+* failure is the server's own.
+*
+* @param span - The span to update
+* @param error - The thrown value
+*/
+function failSpan(span, error) {
+	if (httpStatusOf(error) < SERVER_ERROR_STATUS) {
+		span.recordException(error);
+		span.setAttribute(ERROR_TYPE, errorType(error));
+		return;
+	}
+	recordFailure(span, error);
+}
+/**
+* Reads the HTTP status a thrown value carries, if any.
+*
+* Duck-typed rather than imported: the framework's `HttpError` lives in core,
+* and an application is free to throw its own error type with a `status`.
+*
+* @param error - The thrown value
+* @returns The status, or 500 when the value carries none
+*/
+function httpStatusOf(error) {
+	const status = error?.status ?? error?.statusCode;
+	return typeof status === "number" ? status : SERVER_ERROR_STATUS;
+}
+/**
+* Names the type of a thrown value for the `error.type` attribute.
+*
+* @param error - The thrown value
+* @returns The error type name
+*/
+function errorType(error) {
+	if (!(error instanceof Error)) return typeof error;
+	if (error.name && error.name !== "Error") return error.name;
+	return error.constructor?.name || "Error";
+}
+/**
+* Extracts a message from a thrown value.
+*
+* @param error - The thrown value
+* @returns The message, or an empty string
+*/
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error ?? "");
+}
+/**
+* Whether a value can be awaited.
+*
+* @param value - The value to test
+* @returns True for thenables
+*/
+function isPromiseLike(value) {
+	return value instanceof Promise || typeof value?.then === "function";
+}
+//#endregion
+export { recordFailure as a, isPromiseLike as i, errorType as n, runInSpan as o, failSpan as r, errorMessage as t };

package/dist/Testing.d.mts

@@ -0,0 +1,53 @@
+import { MeterProvider, ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider, InMemorySpanExporter, ReadableSpan } from "@opentelemetry/sdk-trace-base";
+//#region src/Testing.d.ts
+/**
+ * A tracer provider that keeps finished spans in memory.
+ */
+export interface TestTelemetry {
+  /** The registered provider. */
+  provider: BasicTracerProvider;
+  /** The registered meter provider. */
+  meterProvider: MeterProvider;
+  /** The exporter holding the finished spans. */
+  exporter: InMemorySpanExporter;
+  /** Finished spans, oldest first. */
+  spans(): ReadableSpan[];
+  /** Finds a finished span by name. */
+  span(name: string): ReadableSpan | undefined;
+  /** Clears the collected spans. */
+  reset(): void;
+  /**
+   * Waits for spans whose end was deferred - body capture defers it - to be
+   * exported, then flushes the provider.
+   */
+  settle(): Promise<void>;
+  /**
+   * Collects the registered instruments and returns what they reported.
+   *
+   * @returns The collected metrics, newest batch last
+   */
+  collect(): Promise<ResourceMetrics[]>;
+  /** Unregisters the providers and releases their resources. */
+  shutdown(): Promise<void>;
+}
+/**
+ * Registers an in-memory tracer provider as the global one.
+ *
+ * Spans are exported synchronously when they end - `SimpleSpanProcessor`, not
+ * `BatchSpanProcessor` - so a test can assert on them immediately after the
+ * traced call returns.
+ *
+ * ```ts
+ * const telemetry = createTestTelemetry();
+ * afterEach(() => telemetry.reset());
+ * afterAll(() => telemetry.shutdown());
+ *
+ * await app.fetch(new Request('http://localhost/users/1'));
+ * expect(telemetry.span('GET /users/:id')).toBeDefined();
+ * ```
+ *
+ * @returns Handle to the registered provider and its collected spans
+ */
+export declare function createTestTelemetry(): TestTelemetry;
+//#endregion

package/dist/Testing.mjs

@@ -0,0 +1,63 @@
+import { n as W3CTraceContextPropagator, t as VercubeContextManager } from "./VercubeContextManager-n4jHlB-w.mjs";
+import { context, metrics, propagation, trace } from "@opentelemetry/api";
+import { RequestContext } from "@vercube/core";
+import { AggregationTemporality, InMemoryMetricExporter, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+//#region src/Testing.ts
+/**
+* Registers an in-memory tracer provider as the global one.
+*
+* Spans are exported synchronously when they end - `SimpleSpanProcessor`, not
+* `BatchSpanProcessor` - so a test can assert on them immediately after the
+* traced call returns.
+*
+* ```ts
+* const telemetry = createTestTelemetry();
+* afterEach(() => telemetry.reset());
+* afterAll(() => telemetry.shutdown());
+*
+* await app.fetch(new Request('http://localhost/users/1'));
+* expect(telemetry.span('GET /users/:id')).toBeDefined();
+* ```
+*
+* @returns Handle to the registered provider and its collected spans
+*/
+function createTestTelemetry() {
+	const exporter = new InMemorySpanExporter();
+	const provider = new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] });
+	const metricExporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+	const metricReader = new PeriodicExportingMetricReader({
+		exporter: metricExporter,
+		exportIntervalMillis: 2147483647
+	});
+	const meterProvider = new MeterProvider({ readers: [metricReader] });
+	trace.setGlobalTracerProvider(provider);
+	metrics.setGlobalMeterProvider(meterProvider);
+	context.setGlobalContextManager(new VercubeContextManager(new RequestContext()).enable());
+	propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+	return {
+		provider,
+		meterProvider,
+		exporter,
+		spans: () => exporter.getFinishedSpans(),
+		span: (name) => exporter.getFinishedSpans().find((span) => span.name === name),
+		reset: () => exporter.reset(),
+		settle: async () => {
+			await new Promise((resolve) => setImmediate(resolve));
+			await provider.forceFlush();
+		},
+		collect: async () => {
+			await metricReader.forceFlush();
+			return metricExporter.getMetrics();
+		},
+		shutdown: async () => {
+			trace.disable();
+			metrics.disable();
+			context.disable();
+			propagation.disable();
+			await Promise.all([provider.shutdown(), meterProvider.shutdown()]);
+		}
+	};
+}
+//#endregion
+export { createTestTelemetry };