@equipe-tech/observability 0.1.0 → 0.2.0

package/dist/browser/index.js

@@ -1,5 +1,7 @@
-import { Clock, Context, Duration, Effect, Layer, Predicate, Ref, Schema } from "effect";
-import { BrowserEvent, BrowserEventBatch, encodeBrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+import { Cause, Context, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { BrowserEvent, BrowserEventBatch, encodeBrowserEventBatch, maxEventsPerBatch, } from "../BrowserEvents.js";
+import { BrowserClientEngine, normalizePositiveInteger } from "./BrowserClient.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
 export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
 export const defaultEventsEndpoint = "/_telemetry/events";
 export class BrowserEventDeliveryError extends Schema.TaggedError()("BrowserEventDeliveryError", {
@@ -42,62 +44,50 @@ export class BrowserEventTransport extends Context.Service()("@equipe-tech/obser
         }));
     };
 }
-const clampFields = (fields) => {
-    const clamped = {};
-    let count = 0;
-    for (const [key, value] of Object.entries(fields)) {
-        if (key === "" || count >= maxFieldsPerEvent) {
-            continue;
-        }
-        const boundedKey = key.slice(0, maxFieldKeyLength);
-        clamped[boundedKey] = Predicate.isString(value) ? value.slice(0, maxFieldValueLength) : value;
-        count += 1;
-    }
-    return clamped;
-};
 const makeBrowserTelemetry = Effect.fn("makeBrowserTelemetry")(function* (options) {
     const transport = yield* BrowserEventTransport;
-    const maxBatchSize = Math.min(options?.maxBatchSize ?? 32, maxEventsPerBatch);
-    const maxQueueSize = options?.maxQueueSize ?? 256;
     const flushInterval = Duration.fromInputUnsafe(options?.flushInterval ?? "5 seconds");
-    const queue = yield* Ref.make({ events: [], dropped: 0 });
-    const emit = (name, fields) => Effect.gen(function* () {
-        const occurredAt = yield* Clock.currentTimeMillis;
-        const event = new BrowserEvent({
-            id: crypto.randomUUID(),
-            name: name.slice(0, maxEventNameLength),
-            occurredAt,
-            fields: clampFields(fields ?? {}),
-        });
-        yield* Ref.update(queue, (state) => state.events.length >= maxQueueSize
-            ? { events: [...state.events.slice(1), event], dropped: state.dropped + 1 }
-            : { events: [...state.events, event], dropped: state.dropped });
+    const engine = new BrowserClientEngine({
+        disabled: false,
+        maxBatchSize: Math.min(normalizePositiveInteger(options?.maxBatchSize, 32), maxEventsPerBatch),
+        maxQueueSize: normalizePositiveInteger(options?.maxQueueSize, 256),
+        flushIntervalMs: normalizePositiveInteger(Duration.toMillis(flushInterval), 5_000),
+        shutdownTimeoutMs: 2_000,
+        transport: (batch) => new Promise((resolve, reject) => {
+            Effect.runCallback(transport.send(new BrowserEventBatch({
+                version: 1,
+                events: batch.events.map((event) => new BrowserEvent(event)),
+            })), {
+                onExit: (exit) => {
+                    if (Exit.isSuccess(exit)) {
+                        resolve();
+                        return;
+                    }
+                    const failure = Cause.findErrorOption(exit.cause);
+                    reject(Option.isSome(failure) ? failure.value : Cause.squash(exit.cause));
+                },
+            });
+        }),
+        startTimer: false,
     });
-    const flush = Effect.gen(function* () {
-        while (true) {
-            const batchEvents = yield* Ref.modify(queue, (state) => [
-                state.events.slice(0, maxBatchSize),
-                { events: state.events.slice(maxBatchSize), dropped: state.dropped },
-            ]);
-            if (batchEvents.length === 0) {
-                return;
-            }
-            yield* transport.send(new BrowserEventBatch({ version: 1, events: batchEvents })).pipe(Effect.tapError(() => Ref.update(queue, (state) => {
-                const requeued = [...batchEvents, ...state.events];
-                return {
-                    events: requeued.slice(0, maxQueueSize),
-                    dropped: state.dropped + Math.max(0, requeued.length - maxQueueSize),
-                };
-            })));
-        }
+    const flush = Effect.tryPromise({
+        try: () => engine.flush(),
+        catch: (cause) => cause instanceof BrowserEventDeliveryError
+            ? cause
+            : new BrowserEventDeliveryError({
+                code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
+                retryable: true,
+                cause,
+            }),
     });
     yield* Effect.forkScoped(flush.pipe(Effect.ignore, Effect.delay(flushInterval), Effect.forever));
-    yield* Effect.addFinalizer(() => flush.pipe(Effect.ignore));
+    yield* Effect.addFinalizer(() => Effect.tryPromise({ try: () => engine.dispose(), catch: () => undefined }).pipe(Effect.ignore));
     return {
-        emit,
+        emit: (name, fields) => Effect.sync(() => engine.emit(name, fields ?? {})),
         flush: () => flush,
-        pending: () => Ref.get(queue).pipe(Effect.map((state) => state.events.length)),
-        dropped: () => Ref.get(queue).pipe(Effect.map((state) => state.dropped)),
+        pending: () => Effect.sync(() => engine.pending()),
+        dropped: () => Effect.sync(() => engine.dropped()),
     };
 });
 export class BrowserTelemetry extends Context.Service()("@equipe-tech/observability/BrowserTelemetry") {

package/dist/nestjs/BrowserEventsController.d.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import type { ManagedRuntime } from "effect";
 import { type BrowserEventIngestReceipt } from "../node/BrowserEventIngest.js";
-import { type RequestReference } from "./TelemetryInterceptor.js";
+import type { RequestReference } from "./RequestWideEventTraceCorrelation.js";
 export declare const defaultBrowserEventsPath = "_telemetry/events";
 declare const BrowserEventsRejection_base: Schema.Class<BrowserEventsRejection, Schema.Struct<{
     readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_INVALID_BATCH">;

package/dist/nestjs/BrowserEventsController.js

@@ -9,6 +9,11 @@ export class BrowserEventsRejection extends Schema.Class("@equipe-tech/observabi
     correlationId: Schema.String,
 }) {
 }
+class BrowserEventsWiringDefect extends Schema.TaggedError()("BrowserEventsWiringDefect", {
+    code: Schema.Literal("OBS_BROWSER_EVENTS_WIRING_FAILED"),
+    message: Schema.String,
+}) {
+}
 const RequestWithBody = Schema.Struct({ body: Schema.Unknown });
 const decodeRequestWithBody = Schema.decodeUnknownOption(RequestWithBody);
 const correlationId = (request) => requestSpan(request).pipe(Option.map((span) => span.traceId), Option.getOrElse(() => crypto.randomUUID()));
@@ -34,7 +39,10 @@ export const createBrowserEventsController = (runtime, options) => {
     const prototype = BrowserEventsController.prototype;
     const descriptor = Object.getOwnPropertyDescriptor(prototype, "events");
     if (descriptor === undefined) {
-        throw new Error("The events handler is missing on the controller prototype.");
+        throw new BrowserEventsWiringDefect({
+            code: "OBS_BROWSER_EVENTS_WIRING_FAILED",
+            message: "The events handler is missing on the controller prototype.",
+        });
     }
     Controller()(BrowserEventsController);
     Post(options?.path ?? defaultBrowserEventsPath)(prototype, "events", descriptor);

package/dist/nestjs/HttpRoutePolicy.d.ts

@@ -0,0 +1,23 @@
+import { Option } from "effect";
+export type ProxyPolicy = "direct" | "framework";
+export type TelemetryRoutePolicyOptions = {
+    readonly healthRouteTemplates?: ReadonlyArray<string> | undefined;
+    readonly proxyPolicy?: ProxyPolicy | undefined;
+};
+export type HttpServerRequest = {
+    readonly method: string;
+    readonly methodOriginal: Option.Option<string>;
+    readonly route: Option.Option<string>;
+    readonly spanName: string;
+    readonly urlPath: Option.Option<string>;
+    readonly urlScheme: Option.Option<string>;
+    readonly clientAddress: Option.Option<string>;
+    readonly networkPeerAddress: Option.Option<string>;
+    readonly networkPeerPort: Option.Option<number>;
+    readonly serverAddress: Option.Option<string>;
+};
+export type TelemetryRoutePolicy = {
+    readonly inspect: (request: WeakKey) => Option.Option<HttpServerRequest>;
+};
+export declare const telemetryRoutePolicy: (options?: TelemetryRoutePolicyOptions) => TelemetryRoutePolicy;
+export declare const inspectHttpServerRequest: (request: WeakKey, options?: TelemetryRoutePolicyOptions) => Option.Option<HttpServerRequest>;

package/dist/nestjs/HttpRoutePolicy.js

@@ -0,0 +1,179 @@
+import { Option, Predicate, Schema } from "effect";
+import { isIP } from "node:net";
+const maxMethodLength = 32;
+const maxRouteLength = 256;
+const maxTargetLength = 2048;
+const maxAddressLength = 128;
+const HttpMethod = Schema.NonEmptyString.check(Schema.isMaxLength(maxMethodLength), Schema.isPattern(/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/));
+const RouteTemplate = Schema.NonEmptyString.check(Schema.isMaxLength(maxRouteLength), Schema.isPattern(/^\/[\x21-\x7e]*$/), Schema.makeFilter((route) => !route.includes("//") &&
+    !route.includes("\\") &&
+    !route.includes("?") &&
+    !route.includes("#") &&
+    !route.includes("@") &&
+    !route.includes("://"), { expected: "a bounded absolute route template without a URL authority or query" }));
+const RequestTarget = Schema.NonEmptyString.check(Schema.isMaxLength(maxTargetLength));
+const NetworkAddress = Schema.NonEmptyString.check(Schema.isMaxLength(maxAddressLength), Schema.makeFilter((address) => isIP(address) !== 0, { expected: "an IP address" }));
+const ServerAddress = Schema.NonEmptyString.check(Schema.isMaxLength(maxAddressLength), Schema.isPattern(/^[A-Za-z0-9.:[\]_-]+$/));
+const NetworkPort = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 65_535 }));
+const HttpRequestBoundary = Schema.Struct({ method: HttpMethod });
+const ExpressRouteBoundary = Schema.Struct({ route: Schema.Struct({ path: RouteTemplate }) });
+const FastifyRouteBoundary = Schema.Struct({
+    routeOptions: Schema.Struct({ url: RouteTemplate }),
+});
+const HttpTargetBoundary = Schema.Struct({
+    originalUrl: RequestTarget.pipe(Schema.optionalKey),
+    url: RequestTarget.pipe(Schema.optionalKey),
+});
+const FrameworkProtocol = Schema.Literals(["http", "https"]);
+const decodeHttpRequestBoundary = Schema.decodeUnknownOption(HttpRequestBoundary);
+const decodeExpressRouteBoundary = Schema.decodeUnknownOption(ExpressRouteBoundary);
+const decodeFastifyRouteBoundary = Schema.decodeUnknownOption(FastifyRouteBoundary);
+const decodeHttpTargetBoundary = Schema.decodeUnknownOption(HttpTargetBoundary);
+const decodeNetworkAddress = Schema.decodeUnknownOption(NetworkAddress);
+const decodeServerAddress = Schema.decodeUnknownOption(ServerAddress);
+const decodeNetworkPort = Schema.decodeUnknownOption(NetworkPort);
+const decodeEncryptedSocket = Schema.decodeUnknownOption(Schema.Boolean);
+const decodeFrameworkProtocol = Schema.decodeUnknownOption(FrameworkProtocol);
+const decodeRouteTemplates = Schema.decodeUnknownOption(Schema.Array(RouteTemplate));
+const knownMethods = new Set([
+    "CONNECT",
+    "DELETE",
+    "GET",
+    "HEAD",
+    "OPTIONS",
+    "PATCH",
+    "POST",
+    "PUT",
+    "TRACE",
+]);
+const defaultExcludedRoutes = ["/health", "/_telemetry/events"];
+const staticSegmentPattern = /^[A-Za-z0-9._~-]+$/;
+const parameterSegmentPattern = /^:[A-Za-z_][A-Za-z0-9_]*$/;
+const wildcardSegmentPattern = /^(?:\*[A-Za-z_][A-Za-z0-9_]*|\{\*[A-Za-z_][A-Za-z0-9_]*\})$/;
+const normalizeRoute = (route) => route.length > 1 && route.endsWith("/") ? route.slice(0, -1) : route;
+const normalizedRoute = (request) => decodeExpressRouteBoundary(request).pipe(Option.map((boundary) => normalizeRoute(boundary.route.path)), Option.orElse(() => decodeFastifyRouteBoundary(request).pipe(Option.map((boundary) => normalizeRoute(boundary.routeOptions.url)))));
+const normalizedMethod = (request) => decodeHttpRequestBoundary(request).pipe(Option.match({
+    onNone: () => ({ method: "_OTHER", original: Option.none() }),
+    onSome: (boundary) => {
+        const normalized = boundary.method.toUpperCase();
+        const method = knownMethods.has(normalized) ? normalized : "_OTHER";
+        return {
+            method,
+            original: boundary.method === method ? Option.none() : Option.some(boundary.method),
+        };
+    },
+}));
+const rawPath = (request) => decodeHttpTargetBoundary(request).pipe(Option.flatMap((boundary) => Option.fromNullishOr(boundary.originalUrl).pipe(Option.orElse(() => Option.fromNullishOr(boundary.url)))), Option.filter((target) => target.startsWith("/") &&
+    !target.startsWith("//") &&
+    !target.includes("#") &&
+    !target.includes("@") &&
+    !target.includes("://")), Option.map((target) => target.split("?", 1)[0] ?? "/"), Option.map(normalizeRoute));
+const scrubPath = (request, route) => rawPath(request).pipe(Option.flatMap((path) => {
+    if (route === "/") {
+        return path === "/" ? Option.some("/") : Option.none();
+    }
+    const routeSegments = route.split("/").slice(1);
+    const pathSegments = path.split("/").slice(1);
+    const scrubbed = [];
+    for (let index = 0; index < routeSegments.length; index++) {
+        const routeSegment = routeSegments[index] ?? "";
+        const pathSegment = pathSegments[index];
+        if (index === routeSegments.length - 1 &&
+            wildcardSegmentPattern.test(routeSegment) &&
+            pathSegment !== undefined) {
+            scrubbed.push("REDACTED");
+            return Option.some(`/${scrubbed.join("/")}`);
+        }
+        if (pathSegment === undefined) {
+            return Option.none();
+        }
+        if (parameterSegmentPattern.test(routeSegment)) {
+            scrubbed.push("REDACTED");
+        }
+        else if (staticSegmentPattern.test(routeSegment) && routeSegment === pathSegment) {
+            scrubbed.push(routeSegment);
+        }
+        else {
+            return Option.none();
+        }
+    }
+    if (pathSegments.length !== routeSegments.length) {
+        return Option.none();
+    }
+    return Option.some(scrubbed.length === 0 ? "/" : `/${scrubbed.join("/")}`);
+}));
+const directNetwork = (request) => {
+    if (!Predicate.hasProperty(request, "socket")) {
+        return {
+            urlScheme: Option.some("http"),
+            clientAddress: Option.none(),
+            networkPeerAddress: Option.none(),
+            networkPeerPort: Option.none(),
+            serverAddress: Option.none(),
+        };
+    }
+    const socket = request.socket;
+    const address = Predicate.hasProperty(socket, "remoteAddress")
+        ? decodeNetworkAddress(socket.remoteAddress)
+        : Option.none();
+    const port = Predicate.hasProperty(socket, "remotePort")
+        ? decodeNetworkPort(socket.remotePort)
+        : Option.none();
+    const encrypted = Predicate.hasProperty(socket, "encrypted")
+        ? decodeEncryptedSocket(socket.encrypted)
+        : Option.none();
+    return {
+        urlScheme: Option.some(Option.getOrElse(encrypted, () => false) ? "https" : "http"),
+        clientAddress: address,
+        networkPeerAddress: address,
+        networkPeerPort: port,
+        serverAddress: Option.none(),
+    };
+};
+const frameworkNetwork = (request) => {
+    const direct = directNetwork(request);
+    return {
+        urlScheme: Predicate.hasProperty(request, "protocol")
+            ? decodeFrameworkProtocol(request.protocol)
+            : Option.none(),
+        clientAddress: Predicate.hasProperty(request, "ip")
+            ? decodeNetworkAddress(request.ip)
+            : Option.none(),
+        networkPeerAddress: direct.networkPeerAddress,
+        networkPeerPort: direct.networkPeerPort,
+        serverAddress: Predicate.hasProperty(request, "hostname")
+            ? decodeServerAddress(request.hostname)
+            : Option.none(),
+    };
+};
+export const telemetryRoutePolicy = (options = {}) => {
+    const additionalExclusions = decodeRouteTemplates(options.healthRouteTemplates ?? []).pipe(Option.getOrThrowWith(() => new TypeError("Telemetry health route templates must be bounded absolute paths.")));
+    const exclusions = new Set([...defaultExcludedRoutes, ...additionalExclusions].map(normalizeRoute));
+    const proxyPolicy = options.proxyPolicy ?? "direct";
+    if (proxyPolicy !== "direct" && proxyPolicy !== "framework") {
+        throw new TypeError("Telemetry proxy policy must be direct or framework.");
+    }
+    return {
+        inspect: (request) => {
+            const route = normalizedRoute(request);
+            if (Option.isSome(route) && exclusions.has(route.value)) {
+                return Option.none();
+            }
+            const requestMethod = normalizedMethod(request);
+            const network = proxyPolicy === "framework" ? frameworkNetwork(request) : directNetwork(request);
+            const spanPrefix = requestMethod.method === "_OTHER" ? "HTTP" : requestMethod.method;
+            return Option.some({
+                method: requestMethod.method,
+                methodOriginal: requestMethod.original,
+                route,
+                spanName: Option.match(route, {
+                    onNone: () => spanPrefix,
+                    onSome: (routeTemplate) => `${spanPrefix} ${routeTemplate}`,
+                }),
+                urlPath: Option.flatMap(route, (routeTemplate) => scrubPath(request, routeTemplate)),
+                ...network,
+            });
+        },
+    };
+};
+export const inspectHttpServerRequest = (request, options = {}) => telemetryRoutePolicy(options).inspect(request);

package/dist/nestjs/HttpServerOtlpTracer.d.ts

@@ -0,0 +1,15 @@
+import { Duration, Layer } from "effect";
+import type { HttpClient } from "effect/unstable/http";
+import { OtlpExporter, OtlpSerialization } from "effect/unstable/observability";
+export type HttpServerOtlpTracerOptions = {
+    readonly url: string;
+    readonly resource: {
+        readonly serviceName: string;
+        readonly serviceVersion: string;
+        readonly attributes: {
+            readonly "deployment.environment.name": string;
+        };
+    };
+    readonly shutdownTimeout?: Duration.Input | undefined;
+};
+export declare const layerHttpServerOtlpTracer: (options: HttpServerOtlpTracerOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization>;

package/dist/nestjs/HttpServerOtlpTracer.js

@@ -0,0 +1,154 @@
+import { Cause, Duration, Effect, Layer, Option, Schema, Tracer } from "effect";
+import { OtlpExporter, OtlpResource, OtlpSerialization } from "effect/unstable/observability";
+const HttpStatusCode = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 100, maximum: 599 }));
+const decodeHttpStatusCode = Schema.decodeUnknownOption(HttpStatusCode);
+const statusCodeUnset = 0;
+const statusCodeOk = 1;
+const statusCodeError = 2;
+const spanKindCode = (kind) => {
+    switch (kind) {
+        case "internal":
+            return 1;
+        case "server":
+            return 2;
+        case "client":
+            return 3;
+        case "producer":
+            return 4;
+        case "consumer":
+            return 5;
+    }
+};
+class ExportingSpan extends Tracer.NativeSpan {
+    #exportSpan;
+    #ended = false;
+    constructor(options, exportSpan) {
+        super(options);
+        this.#exportSpan = exportSpan;
+    }
+    end(endTime, exit) {
+        if (this.#ended) {
+            return;
+        }
+        this.#ended = true;
+        super.end(endTime, exit);
+        if (this.sampled) {
+            this.#exportSpan(this);
+        }
+    }
+}
+const makeEvents = (span) => span.events.map(([name, startTime, attributes]) => ({
+    name,
+    timeUnixNano: String(startTime),
+    attributes: OtlpResource.entriesToAttributes(Object.entries(attributes)),
+    droppedAttributesCount: 0,
+}));
+const makeNonHttpStatus = (span, attributes, events) => {
+    if (span.status._tag !== "Ended") {
+        return { code: statusCodeUnset };
+    }
+    if (span.status.exit._tag === "Success") {
+        return { code: statusCodeOk };
+    }
+    if (Cause.hasInterruptsOnly(span.status.exit.cause)) {
+        attributes.push({
+            key: "span.label",
+            value: { stringValue: "⚠︎ Interrupted" },
+        }, {
+            key: "status.interrupted",
+            value: { boolValue: true },
+        });
+        return { code: statusCodeOk, message: "Interrupted" };
+    }
+    const errors = Cause.prettyErrors(span.status.exit.cause, { includeCauseInStack: true });
+    for (const error of errors) {
+        events.push({
+            name: "exception",
+            timeUnixNano: String(span.status.endTime),
+            droppedAttributesCount: 0,
+            attributes: OtlpResource.entriesToAttributes([
+                ["exception.type", error.name],
+                ["exception.message", error.message],
+                ["exception.stacktrace", error.stack ?? "No stack trace available"],
+            ]),
+        });
+    }
+    return errors.length === 0
+        ? { code: statusCodeError }
+        : { code: statusCodeError, message: errors[0]?.message };
+};
+const makeHttpStatus = (span) => {
+    if (span.attributes.has("error.type")) {
+        return { code: statusCodeError };
+    }
+    return decodeHttpStatusCode(span.attributes.get("http.response.status_code")).pipe(Option.match({
+        onNone: () => ({ code: statusCodeUnset }),
+        onSome: (status) => ({ code: status >= 500 ? statusCodeError : statusCodeUnset }),
+    }));
+};
+const makeOtlpSpan = (span) => {
+    if (span.status._tag !== "Ended") {
+        return Option.none();
+    }
+    const attributes = OtlpResource.entriesToAttributes(span.attributes.entries());
+    const events = makeEvents(span);
+    const isHttpServer = span.kind === "server" && span.attributes.has("http.request.method");
+    return Option.some({
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: Option.getOrUndefined(Option.map(span.parent, (parent) => parent.spanId)),
+        name: span.name,
+        kind: spanKindCode(span.kind),
+        startTimeUnixNano: String(span.status.startTime),
+        endTimeUnixNano: String(span.status.endTime),
+        attributes,
+        droppedAttributesCount: 0,
+        events,
+        droppedEventsCount: 0,
+        status: isHttpServer ? makeHttpStatus(span) : makeNonHttpStatus(span, attributes, events),
+        links: span.links.map((link) => ({
+            traceId: link.span.traceId,
+            spanId: link.span.spanId,
+            attributes: OtlpResource.entriesToAttributes(Object.entries(link.attributes)),
+            droppedAttributesCount: 0,
+        })),
+        droppedLinksCount: 0,
+    });
+};
+const makeHttpServerOtlpTracer = Effect.fn("makeHttpServerOtlpTracer")(function* (options) {
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const exporter = yield* OtlpExporter.make({
+        label: "HttpServerOtlpTracer",
+        url: options.url,
+        headers: undefined,
+        exportInterval: Duration.seconds(5),
+        maxBatchSize: 1000,
+        body: (spans) => [
+            serialization.traces({
+                resourceSpans: [
+                    {
+                        resource,
+                        scopeSpans: [
+                            {
+                                scope: { name: OtlpResource.serviceNameUnsafe(resource) },
+                                spans,
+                            },
+                        ],
+                    },
+                ],
+            }),
+            Effect.void,
+        ],
+        shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3),
+    });
+    return Tracer.make({
+        span: (spanOptions) => new ExportingSpan(spanOptions, (span) => {
+            const exported = makeOtlpSpan(span);
+            if (Option.isSome(exported)) {
+                exporter.push(exported.value);
+            }
+        }),
+    });
+});
+export const layerHttpServerOtlpTracer = (options) => Layer.effect(Tracer.Tracer, makeHttpServerOtlpTracer(options)).pipe(Layer.provideMerge(OtlpExporter.layerFlusher));

package/dist/nestjs/RequestWideEventTraceCorrelation.d.ts

@@ -0,0 +1,15 @@
+export type RequestReference = WeakKey;
+export type ServerSpanCorrelation = {
+    readonly traceId: string;
+    readonly spanId: string;
+};
+export type RequestWideEventLogger = {
+    readonly set: (correlation: ServerSpanCorrelation) => void;
+};
+export type RequestWideEventLoggerResolver = (request: RequestReference) => RequestWideEventLogger | undefined;
+export declare class RequestWideEventTraceCorrelation {
+    #private;
+    constructor(resolveLogger: RequestWideEventLoggerResolver);
+    correlate(request: RequestReference, correlation: ServerSpanCorrelation): void;
+}
+export declare const createRequestWideEventTraceCorrelation: (resolveLogger: RequestWideEventLoggerResolver) => RequestWideEventTraceCorrelation;

package/dist/nestjs/RequestWideEventTraceCorrelation.js

@@ -0,0 +1,13 @@
+export class RequestWideEventTraceCorrelation {
+    #resolveLogger;
+    constructor(resolveLogger) {
+        this.#resolveLogger = resolveLogger;
+    }
+    correlate(request, correlation) {
+        try {
+            this.#resolveLogger(request)?.set(correlation);
+        }
+        catch { }
+    }
+}
+export const createRequestWideEventTraceCorrelation = (resolveLogger) => new RequestWideEventTraceCorrelation(resolveLogger);

package/dist/nestjs/TelemetryInterceptor.d.ts

@@ -1,12 +1,31 @@
 import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
-import { Effect, Option } from "effect";
-import type { ManagedRuntime, Tracer } from "effect";
+import { Effect, Option, Tracer } from "effect";
+import type { ManagedRuntime } from "effect";
 import { Observable } from "rxjs";
-export type RequestReference = WeakKey;
+import { type ProxyPolicy } from "./HttpRoutePolicy.js";
+import type { RequestReference, RequestWideEventTraceCorrelation } from "./RequestWideEventTraceCorrelation.js";
 export declare const requestSpan: (request: RequestReference) => Option.Option<Tracer.Span>;
 export declare const withRequestSpan: (request: RequestReference) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+type ActiveRequest = {
+    readonly interrupt: () => void;
+};
+export declare class TelemetryRequestTracker {
+    #private;
+    get accepting(): boolean;
+    register(activeRequest: ActiveRequest): Option.Option<() => void>;
+    closeAdmission(): void;
+    waitForIdle(): Promise<void>;
+    interruptActive(): void;
+}
+export type TelemetryInterceptorOptions = {
+    readonly healthRouteTemplates?: ReadonlyArray<string> | undefined;
+    readonly proxyPolicy?: ProxyPolicy | undefined;
+    readonly requestTracker?: TelemetryRequestTracker | undefined;
+    readonly requestWideEventTraceCorrelation?: RequestWideEventTraceCorrelation | undefined;
+};
 export declare class TelemetryInterceptor<RuntimeError> implements NestInterceptor {
     #private;
-    constructor(runtime: ManagedRuntime.ManagedRuntime<never, RuntimeError>);
+    constructor(runtime: ManagedRuntime.ManagedRuntime<never, RuntimeError>, options?: TelemetryInterceptorOptions);
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
 }
+export {};