@vercube/telemetry 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present - Vercube
+
+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,87 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/vercube/vercube/refs/heads/main/.github/assets/cover.png" width="100%" alt="Vercube - Unleash your server development." />
+  <br>
+  <br>
+
+# @vercube/telemetry
+
+### OpenTelemetry for Vercube apps
+
+[![Ask DeepWiki](<https://img.shields.io/badge/ask-deepwiki-%20blue?style=for-the-badge&logo=bookstack&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)](https://deepwiki.com/vercube/vercube)
+![NPM Version](<https://img.shields.io/npm/v/%40vercube%2Ftelemetry?style=for-the-badge&logo=npm&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232e2e2e&link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F%40vercube%2Ftelemetry>)
+![GitHub License](<https://img.shields.io/github/license/vercube/vercube?style=for-the-badge&logo=gitbook&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
+![Codecov](<https://img.shields.io/codecov/c/github/vercube/vercube?style=for-the-badge&logo=vitest&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
+
+**Standards-first observability: every request becomes an OpenTelemetry span, W3C trace context flows in and out, and any OTLP backend works. Off in production until you opt in, and free when it is off.**
+
+[Website](https://vercube.dev) • [Documentation](https://vercube.dev/docs/getting-started)
+
+</div>
+
+## ✨ Features
+
+- **A span per request** - route template, controller, handler and the stable HTTP semantic conventions
+- **W3C trace context** - `traceparent` read on the way in, injectable on the way out
+- **One AsyncLocalStorage** - trace context rides in the request context Vercube already opens, not a second frame
+- **One OpenTelemetry dependency** - this is the only package in the framework that declares one; everything else reaches OpenTelemetry through a subpath here
+- **Zero cost when off** - core sees a `null` check, and the allocation-free route fast path stays synchronous
+
+## 📦 Installation
+
+```bash
+pnpm add @vercube/telemetry
+```
+
+That is the whole installation: the tracer and meter providers, the samplers and the in-memory test providers all ship with it. Exporting to an OTLP collector is the one thing that needs more, because the exporter pulls a protobuf stack an application doing local tracing has no use for:
+
+```bash
+pnpm add @opentelemetry/exporter-trace-otlp-http
+```
+
+## 📖 Usage
+
+```ts
+// vercube.config.ts
+import { defineConfig } from '@vercube/core';
+import { TelemetryPlugin } from '@vercube/telemetry';
+
+export default defineConfig({
+  telemetry: true,
+  plugins: [TelemetryPlugin],
+});
+```
+
+```ts
+// src/index.ts
+import { startNodeTelemetry } from '@vercube/telemetry/sdk';
+
+await startNodeTelemetry({
+  serviceName: 'checkout',
+  endpoint: 'http://localhost:4318',
+});
+```
+
+Annotate your own work with the `Telemetry` token:
+
+```ts
+import { Inject } from '@vercube/di';
+import { Telemetry } from '@vercube/telemetry';
+
+class InvoiceService {
+  @Inject(Telemetry)
+  private gTelemetry!: Telemetry;
+
+  public refund(id: string) {
+    return this.gTelemetry.span('invoice.refund', (span) => {
+      span.setAttribute('invoice.id', id);
+      return this.process(id);
+    });
+  }
+}
+```
+
+Check out the full [documentation](https://vercube.dev/docs/modules/telemetry/overview)
+
+## 📜 License
+
+[MIT](https://github.com/vercube/vercube/blob/main/LICENSE)

package/dist/Api.d.mts

@@ -0,0 +1 @@
+export * from "@opentelemetry/api";

package/dist/Api.mjs

@@ -0,0 +1,2 @@
+export * from "@opentelemetry/api";
+export {};

package/dist/Attributes-QVHj8ZgV.mjs

@@ -0,0 +1,48 @@
+//#region src/Common/Attributes.ts
+/**
+* Attribute keys used by Vercube's instrumentation.
+*
+* The HTTP names are the stable OpenTelemetry semantic conventions. They are
+* written out here as plain constants rather than imported from
+* `@opentelemetry/semantic-conventions` so that installing `@vercube/telemetry`
+* does not drag in a second package for a handful of strings; the values are
+* asserted against the published conventions in the package tests.
+*/
+/** HTTP request method, e.g. `GET`. */
+const HTTP_REQUEST_METHOD = "http.request.method";
+/** Matched route template, e.g. `/users/:id`. */
+const HTTP_ROUTE = "http.route";
+/** HTTP response status code. */
+const HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+/** Request path, without the query string. */
+const URL_PATH = "url.path";
+/** Query string, without the leading `?`. */
+const URL_QUERY = "url.query";
+/** URL scheme, `http` or `https`. */
+const URL_SCHEME = "url.scheme";
+/** Host the request was addressed to. */
+const SERVER_ADDRESS = "server.address";
+/** Port the request was addressed to. */
+const SERVER_PORT = "server.port";
+/** Raw `User-Agent` header. */
+const USER_AGENT_ORIGINAL = "user_agent.original";
+/** Class name or type of the error that made the operation fail. */
+const ERROR_TYPE = "error.type";
+/** Controller class that owns the matched handler. */
+const VERCUBE_CONTROLLER = "vercube.controller";
+/** Handler method that served the request. */
+const VERCUBE_HANDLER = "vercube.handler";
+/** Middleware class name. */
+const VERCUBE_MIDDLEWARE = "vercube.middleware";
+/** Middleware phase, `before` or `after`. */
+const VERCUBE_MIDDLEWARE_PHASE = "vercube.middleware.phase";
+/** Dependency-injection service key. */
+const VERCUBE_DI_KEY = "vercube.di.key";
+/** Dependency-injection binding kind: `singleton`, `transient` or `instance`. */
+const VERCUBE_DI_KIND = "vercube.di.kind";
+/** Whether the route was served by the allocation-free fast path. */
+const VERCUBE_ROUTE_SIMPLE = "vercube.route.simple";
+/** Instrumentation scope name reported for framework spans. */
+const INSTRUMENTATION_SCOPE = "@vercube/telemetry";
+//#endregion
+export { VERCUBE_MIDDLEWARE_PHASE as _, INSTRUMENTATION_SCOPE as a, URL_PATH as c, USER_AGENT_ORIGINAL as d, VERCUBE_CONTROLLER as f, VERCUBE_MIDDLEWARE as g, VERCUBE_HANDLER as h, HTTP_ROUTE as i, URL_QUERY as l, VERCUBE_DI_KIND as m, HTTP_REQUEST_METHOD as n, SERVER_ADDRESS as o, VERCUBE_DI_KEY as p, HTTP_RESPONSE_STATUS_CODE as r, SERVER_PORT as s, ERROR_TYPE as t, URL_SCHEME as u, VERCUBE_ROUTE_SIMPLE as v };

package/dist/Attributes.d.mts

@@ -0,0 +1,47 @@
+//#region src/Common/Attributes.d.ts
+/**
+ * Attribute keys used by Vercube's instrumentation.
+ *
+ * The HTTP names are the stable OpenTelemetry semantic conventions. They are
+ * written out here as plain constants rather than imported from
+ * `@opentelemetry/semantic-conventions` so that installing `@vercube/telemetry`
+ * does not drag in a second package for a handful of strings; the values are
+ * asserted against the published conventions in the package tests.
+ */
+/** HTTP request method, e.g. `GET`. */
+export declare const HTTP_REQUEST_METHOD = "http.request.method";
+/** Matched route template, e.g. `/users/:id`. */
+export declare const HTTP_ROUTE = "http.route";
+/** HTTP response status code. */
+export declare const HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+/** Request path, without the query string. */
+export declare const URL_PATH = "url.path";
+/** Query string, without the leading `?`. */
+export declare const URL_QUERY = "url.query";
+/** URL scheme, `http` or `https`. */
+export declare const URL_SCHEME = "url.scheme";
+/** Host the request was addressed to. */
+export declare const SERVER_ADDRESS = "server.address";
+/** Port the request was addressed to. */
+export declare const SERVER_PORT = "server.port";
+/** Raw `User-Agent` header. */
+export declare const USER_AGENT_ORIGINAL = "user_agent.original";
+/** Class name or type of the error that made the operation fail. */
+export declare const ERROR_TYPE = "error.type";
+/** Controller class that owns the matched handler. */
+export declare const VERCUBE_CONTROLLER = "vercube.controller";
+/** Handler method that served the request. */
+export declare const VERCUBE_HANDLER = "vercube.handler";
+/** Middleware class name. */
+export declare const VERCUBE_MIDDLEWARE = "vercube.middleware";
+/** Middleware phase, `before` or `after`. */
+export declare const VERCUBE_MIDDLEWARE_PHASE = "vercube.middleware.phase";
+/** Dependency-injection service key. */
+export declare const VERCUBE_DI_KEY = "vercube.di.key";
+/** Dependency-injection binding kind: `singleton`, `transient` or `instance`. */
+export declare const VERCUBE_DI_KIND = "vercube.di.kind";
+/** Whether the route was served by the allocation-free fast path. */
+export declare const VERCUBE_ROUTE_SIMPLE = "vercube.route.simple";
+/** Instrumentation scope name reported for framework spans. */
+export declare const INSTRUMENTATION_SCOPE = "@vercube/telemetry";
+//#endregion

package/dist/Attributes.mjs

@@ -0,0 +1,2 @@
+import { _ as VERCUBE_MIDDLEWARE_PHASE, a as INSTRUMENTATION_SCOPE, c as URL_PATH, d as USER_AGENT_ORIGINAL, f as VERCUBE_CONTROLLER, g as VERCUBE_MIDDLEWARE, h as VERCUBE_HANDLER, i as HTTP_ROUTE, l as URL_QUERY, m as VERCUBE_DI_KIND, n as HTTP_REQUEST_METHOD, o as SERVER_ADDRESS, p as VERCUBE_DI_KEY, r as HTTP_RESPONSE_STATUS_CODE, s as SERVER_PORT, t as ERROR_TYPE, u as URL_SCHEME, v as VERCUBE_ROUTE_SIMPLE } from "./Attributes-QVHj8ZgV.mjs";
+export { ERROR_TYPE, HTTP_REQUEST_METHOD, HTTP_RESPONSE_STATUS_CODE, HTTP_ROUTE, INSTRUMENTATION_SCOPE, SERVER_ADDRESS, SERVER_PORT, URL_PATH, URL_QUERY, URL_SCHEME, USER_AGENT_ORIGINAL, VERCUBE_CONTROLLER, VERCUBE_DI_KEY, VERCUBE_DI_KIND, VERCUBE_HANDLER, VERCUBE_MIDDLEWARE, VERCUBE_MIDDLEWARE_PHASE, VERCUBE_ROUTE_SIMPLE };

package/dist/Instrument.d.mts

@@ -0,0 +1,132 @@
+import { Attributes, Context, Context as Context$1, Counter, Counter as Counter$1, Exception, Histogram, Histogram as Histogram$1, Link, MetricOptions, MetricOptions as MetricOptions$1, Span, Span as Span$1, SpanContext, SpanKind, SpanOptions, SpanOptions as SpanOptions$1, SpanStatusCode, Tracer, UpDownCounter, UpDownCounter as UpDownCounter$1, ValueType } from "@opentelemetry/api";
+//#region src/Instrument/Factory.d.ts
+/**
+ * The instrumentation toolkit an instrumented package works against.
+ *
+ * Every method is a no-op until the application registers a provider, which is
+ * what lets a package produce telemetry unconditionally.
+ */
+interface Instrument {
+  /**
+   * Runs `fn` in a new span parented on the active context.
+   *
+   * The result is returned unchanged, so wrapping synchronous code does not
+   * make it asynchronous. A synchronous throw, a rejection and a plain return
+   * all end the span.
+   *
+   * @param name - Span name
+   * @param options - Span kind, attributes and links
+   * @param fn - The work to trace
+   * @returns Whatever `fn` returned
+   */
+  span<T>(name: string, options: SpanOptions$1, fn: (span: Span$1) => T): T;
+  /**
+   * Same as {@link Instrument.span}, parented on an explicit context.
+   *
+   * This is how a background job continues the trace of the request that
+   * queued it: the parent comes from {@link Instrument.extract} rather than
+   * from whatever happens to be active in the worker.
+   *
+   * @param name - Span name
+   * @param options - Span kind, attributes and links
+   * @param parent - Context the span is a child of
+   * @param fn - The work to trace
+   * @returns Whatever `fn` returned
+   */
+  spanFrom<T>(name: string, options: SpanOptions$1, parent: Context$1, fn: (span: Span$1) => T): T;
+  /**
+   * A monotonic counter, created on first use and memoized by name.
+   *
+   * @param name - Instrument name
+   * @param options - Description, unit and value type
+   * @returns The counter
+   */
+  counter(name: string, options?: MetricOptions$1): Counter$1;
+  /**
+   * A counter that can go down, created on first use and memoized by name.
+   *
+   * @param name - Instrument name
+   * @param options - Description, unit and value type
+   * @returns The counter
+   */
+  upDownCounter(name: string, options?: MetricOptions$1): UpDownCounter$1;
+  /**
+   * A histogram, created on first use and memoized by name.
+   *
+   * @param name - Instrument name
+   * @param options - Description, unit and value type
+   * @returns The histogram
+   */
+  histogram(name: string, options?: MetricOptions$1): Histogram$1;
+  /** The span active on this async execution path, if any. */
+  activeSpan(): Span$1 | undefined;
+  /**
+   * Writes W3C trace context for the active span into a carrier.
+   *
+   * @param carrier - Header record to write into
+   */
+  inject(carrier: Record<string, string>): void;
+  /**
+   * Reads W3C trace context out of a carrier into a context usable as a parent.
+   *
+   * @param carrier - Header record the message arrived with
+   * @returns A context carrying the remote parent
+   */
+  extract(carrier: Record<string, string> | undefined): Context$1;
+}
+/**
+ * Builds the instrumentation toolkit for one instrumentation scope.
+ *
+ * A `@vercube/*` package calls this once at module level and uses the result
+ * everywhere it produces telemetry:
+ *
+ * ```ts
+ * import { createInstrument, SpanKind } from '@vercube/telemetry/instrument';
+ *
+ * const instrument = createInstrument('@vercube/storage');
+ *
+ * export function traceOperation<T>(name: string, attributes: Attributes, fn: () => Promise<T>): Promise<T> {
+ *   return instrument.span(name, { kind: SpanKind.CLIENT, attributes }, fn);
+ * }
+ * ```
+ *
+ * Creating the toolkit creates nothing: the tracer is resolved lazily and the
+ * instruments only on first use. That matters for metrics, because the
+ * OpenTelemetry metrics API has no proxy meter and an instrument created before
+ * a `MeterProvider` is registered stays a no-op for the life of the process.
+ *
+ * @param scope - Instrumentation scope, conventionally the package name
+ * @returns The toolkit bound to that scope
+ */
+export declare function createInstrument(scope: string): Instrument;
+//#endregion
+//#region src/Common/SpanUtils.d.ts
+/**
+ * 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
+ */
+export declare function recordFailure(span: Span$1, error: unknown): void;
+/**
+ * Names the type of a thrown value for the `error.type` attribute.
+ *
+ * @param error - The thrown value
+ * @returns The error type name
+ */
+export declare function errorType(error: unknown): string;
+/**
+ * Extracts a message from a thrown value.
+ *
+ * @param error - The thrown value
+ * @returns The message, or an empty string
+ */
+export declare function errorMessage(error: unknown): string;
+//#endregion
+export { type Attributes, type Context, type Counter, type Exception, type Histogram, type Instrument, type Link, type MetricOptions, type Span, type SpanContext, SpanKind, type SpanOptions, SpanStatusCode, type UpDownCounter, ValueType };

package/dist/Instrument.mjs

@@ -0,0 +1,103 @@
+import { a as recordFailure, i as isPromiseLike, n as errorType, t as errorMessage } from "./SpanUtils-t3NCeswB.mjs";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, ValueType, context, metrics, propagation, trace } from "@opentelemetry/api";
+//#region src/Instrument/Factory.ts
+/**
+* Builds the instrumentation toolkit for one instrumentation scope.
+*
+* A `@vercube/*` package calls this once at module level and uses the result
+* everywhere it produces telemetry:
+*
+* ```ts
+* import { createInstrument, SpanKind } from '@vercube/telemetry/instrument';
+*
+* const instrument = createInstrument('@vercube/storage');
+*
+* export function traceOperation<T>(name: string, attributes: Attributes, fn: () => Promise<T>): Promise<T> {
+*   return instrument.span(name, { kind: SpanKind.CLIENT, attributes }, fn);
+* }
+* ```
+*
+* Creating the toolkit creates nothing: the tracer is resolved lazily and the
+* instruments only on first use. That matters for metrics, because the
+* OpenTelemetry metrics API has no proxy meter and an instrument created before
+* a `MeterProvider` is registered stays a no-op for the life of the process.
+*
+* @param scope - Instrumentation scope, conventionally the package name
+* @returns The toolkit bound to that scope
+*/
+function createInstrument(scope) {
+	let tracer;
+	const counters = /* @__PURE__ */ new Map();
+	const upDownCounters = /* @__PURE__ */ new Map();
+	const histograms = /* @__PURE__ */ new Map();
+	/**
+	* Starts a span, runs the work inside it and ends it once the work settles.
+	*
+	* @param name - Span name
+	* @param options - Span kind, attributes and links
+	* @param parent - Context the span is a child of
+	* @param fn - The work to trace
+	* @returns Whatever the work returned
+	*/
+	function run(name, options, parent, fn) {
+		tracer ??= trace.getTracer(scope);
+		const span = tracer.startSpan(name, options, parent);
+		return context.with(trace.setSpan(parent, span), () => {
+			let result;
+			try {
+				result = fn(span);
+			} catch (error) {
+				recordFailure(span, error);
+				span.end();
+				throw error;
+			}
+			if (!isPromiseLike(result)) {
+				span.end();
+				return result;
+			}
+			return result.then((value) => {
+				span.end();
+				return value;
+			}, (error) => {
+				recordFailure(span, error);
+				span.end();
+				throw error;
+			});
+		});
+	}
+	return {
+		span: (name, options, fn) => run(name, options, context.active(), fn),
+		spanFrom: (name, options, parent, fn) => run(name, options, parent, fn),
+		counter(name, options) {
+			let instrument = counters.get(name);
+			if (!instrument) {
+				instrument = metrics.getMeter(scope).createCounter(name, options);
+				counters.set(name, instrument);
+			}
+			return instrument;
+		},
+		upDownCounter(name, options) {
+			let instrument = upDownCounters.get(name);
+			if (!instrument) {
+				instrument = metrics.getMeter(scope).createUpDownCounter(name, options);
+				upDownCounters.set(name, instrument);
+			}
+			return instrument;
+		},
+		histogram(name, options) {
+			let instrument = histograms.get(name);
+			if (!instrument) {
+				instrument = metrics.getMeter(scope).createHistogram(name, options);
+				histograms.set(name, instrument);
+			}
+			return instrument;
+		},
+		activeSpan: () => trace.getActiveSpan(),
+		inject(carrier) {
+			propagation.inject(context.active(), carrier);
+		},
+		extract: (carrier) => propagation.extract(ROOT_CONTEXT, carrier ?? {})
+	};
+}
+//#endregion
+export { SpanKind, SpanStatusCode, ValueType, createInstrument, errorMessage, errorType, recordFailure };

package/dist/Otlp.d.mts

@@ -0,0 +1,31 @@
+import { JsonMetricsSerializer, JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
+import { PushMetricExporter } from "@opentelemetry/sdk-metrics";
+import { SpanExporter } from "@opentelemetry/sdk-trace-base";
+//#region src/Otlp.d.ts
+/**
+ * Where and how to reach an OTLP/HTTP collector.
+ */
+export interface OtlpExporterOptions {
+  /** OTLP/HTTP endpoint root, e.g. `http://localhost:4318`. */
+  endpoint: string;
+  /** Headers sent with every request, for authenticated collectors. */
+  headers?: Record<string, string>;
+}
+/**
+ * Builds an OTLP/HTTP span exporter.
+ *
+ * @param options - Endpoint and headers
+ * @returns The exporter
+ * @throws When `@opentelemetry/exporter-trace-otlp-http` is not installed
+ */
+export declare function createOtlpTraceExporter(options: OtlpExporterOptions): Promise<SpanExporter>;
+/**
+ * Builds an OTLP/HTTP metric exporter.
+ *
+ * @param options - Endpoint and headers
+ * @returns The exporter
+ * @throws When `@opentelemetry/exporter-metrics-otlp-http` is not installed
+ */
+export declare function createOtlpMetricExporter(options: OtlpExporterOptions): Promise<PushMetricExporter>;
+//#endregion
+export { JsonMetricsSerializer, JsonTraceSerializer };

package/dist/Otlp.mjs

@@ -0,0 +1,52 @@
+import { JsonMetricsSerializer, JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
+//#region src/Otlp.ts
+/**
+* Builds an OTLP/HTTP span exporter.
+*
+* @param options - Endpoint and headers
+* @returns The exporter
+* @throws When `@opentelemetry/exporter-trace-otlp-http` is not installed
+*/
+async function createOtlpTraceExporter(options) {
+	let module;
+	try {
+		module = await import("@opentelemetry/exporter-trace-otlp-http");
+	} catch {
+		throw new Error("An OTLP endpoint is configured but @opentelemetry/exporter-trace-otlp-http is not installed. Install it, or pass your own `exporter` to startNodeTelemetry().");
+	}
+	return new module.OTLPTraceExporter({
+		url: signalUrl(options.endpoint, "traces"),
+		headers: options.headers
+	});
+}
+/**
+* Builds an OTLP/HTTP metric exporter.
+*
+* @param options - Endpoint and headers
+* @returns The exporter
+* @throws When `@opentelemetry/exporter-metrics-otlp-http` is not installed
+*/
+async function createOtlpMetricExporter(options) {
+	let module;
+	try {
+		module = await import("@opentelemetry/exporter-metrics-otlp-http");
+	} catch {
+		throw new Error("An OTLP endpoint is configured for metrics but @opentelemetry/exporter-metrics-otlp-http is not installed. Install it, or pass your own reader to addMetricReader().");
+	}
+	return new module.OTLPMetricExporter({
+		url: signalUrl(options.endpoint, "metrics"),
+		headers: options.headers
+	});
+}
+/**
+* Joins an endpoint root with an OTLP signal path.
+*
+* @param endpoint - Endpoint root, with or without a trailing slash
+* @param signal - The signal path segment
+* @returns The full URL
+*/
+function signalUrl(endpoint, signal) {
+	return `${endpoint.replace(/\/$/, "")}/v1/${signal}`;
+}
+//#endregion
+export { JsonMetricsSerializer, JsonTraceSerializer, createOtlpMetricExporter, createOtlpTraceExporter };