@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/nestjs/HttpServerOtlpTracer.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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,31 +0,0 @@
-import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
-import { Effect, Option, Tracer } from "effect";
-import type { ManagedRuntime } from "effect";
-import { Observable } from "rxjs";
-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>, options?: TelemetryInterceptorOptions);
-    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
-}
-export {};

package/dist/nestjs/TelemetryInterceptor.js

@@ -1,268 +0,0 @@
-import { Context, Effect, Exit, Option, Predicate, Schema, Tracer } from "effect";
-import { EventEmitter } from "node:events";
-import { Observable } from "rxjs";
-import { telemetryRoutePolicy, } from "./HttpRoutePolicy.js";
-const TraceparentRequest = Schema.Struct({
-    headers: Schema.Struct({
-        traceparent: Schema.String.check(Schema.isPattern(/^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/), Schema.makeFilter((traceparent) => traceparent.slice(3, 35) !== "00000000000000000000000000000000" &&
-            traceparent.slice(36, 52) !== "0000000000000000")),
-    }),
-});
-const parseTraceparentRequest = Schema.decodeUnknownOption(TraceparentRequest);
-const HttpResponseBoundary = Schema.Struct({
-    statusCode: Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 100, maximum: 599 })),
-});
-const decodeHttpResponseBoundary = Schema.decodeUnknownOption(HttpResponseBoundary);
-const HttpErrorBoundary = Schema.Struct({
-    status: Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 100, maximum: 599 })).pipe(Schema.optionalKey),
-});
-const ErrorType = Schema.NonEmptyString.check(Schema.isMaxLength(128));
-const decodeHttpErrorBoundary = Schema.decodeUnknownOption(HttpErrorBoundary);
-const decodeErrorType = Schema.decodeUnknownOption(ErrorType);
-const decodeHeadersSent = Schema.decodeUnknownOption(Schema.Boolean);
-const decodeResponseEmitter = Schema.decodeUnknownOption(Schema.instanceOf(EventEmitter));
-const requestSpans = new WeakMap();
-export const requestSpan = (request) => Option.fromNullishOr(requestSpans.get(request));
-export const withRequestSpan = (request) => (effect) => Option.match(requestSpan(request), {
-    onNone: () => effect,
-    onSome: (span) => Effect.withParentSpan(effect, span),
-});
-export class TelemetryRequestTracker {
-    #accepting = true;
-    #active = new Set();
-    #idleWaiters = new Set();
-    get accepting() {
-        return this.#accepting;
-    }
-    register(activeRequest) {
-        if (!this.#accepting) {
-            return Option.none();
-        }
-        this.#active.add(activeRequest);
-        return Option.some(() => {
-            if (!this.#active.delete(activeRequest) || this.#active.size !== 0) {
-                return;
-            }
-            for (const resolve of this.#idleWaiters) {
-                resolve();
-            }
-            this.#idleWaiters.clear();
-        });
-    }
-    closeAdmission() {
-        this.#accepting = false;
-    }
-    waitForIdle() {
-        if (this.#active.size === 0) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => this.#idleWaiters.add(resolve));
-    }
-    interruptActive() {
-        for (const activeRequest of this.#active) {
-            activeRequest.interrupt();
-        }
-    }
-}
-export class TelemetryInterceptor {
-    #runtime;
-    #routePolicy;
-    #requestTracker;
-    #requestWideEventTraceCorrelation;
-    #tracer;
-    #clock;
-    constructor(runtime, options = {}) {
-        this.#runtime = runtime;
-        this.#routePolicy = telemetryRoutePolicy({
-            healthRouteTemplates: options.healthRouteTemplates,
-            proxyPolicy: options.proxyPolicy,
-        });
-        this.#requestTracker = options.requestTracker ?? new TelemetryRequestTracker();
-        this.#requestWideEventTraceCorrelation = options.requestWideEventTraceCorrelation;
-    }
-    intercept(context, next) {
-        if (context.getType() !== "http" || !this.#requestTracker.accepting) {
-            return next.handle();
-        }
-        try {
-            return this.#instrument(context, next);
-        }
-        catch {
-            return next.handle();
-        }
-    }
-    #instrument(context, next) {
-        const httpContext = context.switchToHttp();
-        const request = httpContext.getRequest();
-        if (requestSpans.has(request)) {
-            return next.handle();
-        }
-        const requestDetails = this.#routePolicy.inspect(request);
-        if (Option.isNone(requestDetails)) {
-            return next.handle();
-        }
-        const tracer = (this.#tracer ??= this.#runtime.runSync(Effect.tracer));
-        const clock = (this.#clock ??= this.#runtime.runSync(Effect.clockWith(Effect.succeed)));
-        const traceparentRequest = httpContext.getRequest();
-        const parent = parseTraceparentRequest({ headers: traceparentRequest.headers }).pipe(Option.map(({ headers }) => {
-            const traceparent = headers.traceparent;
-            return Tracer.externalSpan({
-                traceId: traceparent.slice(3, 35),
-                spanId: traceparent.slice(36, 52),
-                sampled: Number.parseInt(traceparent.slice(53, 55), 16) % 2 === 1,
-            });
-        }));
-        const details = requestDetails.value;
-        const span = tracer.span({
-            name: details.spanName,
-            parent,
-            annotations: Context.empty(),
-            links: [],
-            startTime: clock.currentTimeNanosUnsafe(),
-            kind: "server",
-            root: Option.isNone(parent),
-            sampled: Option.match(parent, {
-                onNone: () => true,
-                onSome: (remoteParent) => remoteParent.sampled,
-            }),
-        });
-        span.attribute("http.request.method", details.method);
-        if (Option.isSome(details.methodOriginal)) {
-            span.attribute("http.request.method_original", details.methodOriginal.value);
-        }
-        if (Option.isSome(details.route)) {
-            span.attribute("http.route", details.route.value);
-        }
-        if (Option.isSome(details.urlPath)) {
-            span.attribute("url.path", details.urlPath.value);
-        }
-        if (Option.isSome(details.urlScheme)) {
-            span.attribute("url.scheme", details.urlScheme.value);
-        }
-        if (Option.isSome(details.clientAddress)) {
-            span.attribute("client.address", details.clientAddress.value);
-        }
-        if (Option.isSome(details.networkPeerAddress)) {
-            span.attribute("network.peer.address", details.networkPeerAddress.value);
-        }
-        if (Option.isSome(details.networkPeerPort)) {
-            span.attribute("network.peer.port", details.networkPeerPort.value);
-        }
-        if (Option.isSome(details.serverAddress)) {
-            span.attribute("server.address", details.serverAddress.value);
-        }
-        requestSpans.set(request, span);
-        this.#requestWideEventTraceCorrelation?.correlate(request, {
-            traceId: span.traceId,
-            spanId: span.spanId,
-        });
-        const response = httpContext.getResponse();
-        const responseEmitter = decodeResponseEmitter(response);
-        return new Observable((subscriber) => {
-            let ended = false;
-            let responseFinished = false;
-            let observableSettled = false;
-            let pendingExit = Exit.succeed(undefined);
-            let pendingErrorType = Option.none();
-            let release = () => { };
-            const responseStatus = (requireSent = false) => {
-                if (requireSent) {
-                    const headersSent = Predicate.hasProperty(response, "headersSent")
-                        ? decodeHeadersSent(response.headersSent)
-                        : Option.none();
-                    if (!Option.getOrElse(headersSent, () => false)) {
-                        return Option.none();
-                    }
-                }
-                return decodeHttpResponseBoundary(response).pipe(Option.map((boundary) => boundary.statusCode));
-            };
-            const removeResponseListeners = () => {
-                if (Option.isSome(responseEmitter)) {
-                    responseEmitter.value.off("finish", onResponseFinish);
-                    responseEmitter.value.off("close", onResponseClose);
-                }
-            };
-            const finish = (exit, status, errorType) => {
-                if (ended) {
-                    return;
-                }
-                ended = true;
-                removeResponseListeners();
-                if (Option.isSome(status)) {
-                    span.attribute("http.response.status_code", status.value);
-                }
-                const finalErrorType = Option.contains(errorType, "connection_closed")
-                    ? errorType
-                    : Option.match(status, {
-                        onNone: () => errorType,
-                        onSome: (statusCode) => {
-                            if (statusCode >= 500) {
-                                return Option.some(String(statusCode));
-                            }
-                            if (statusCode >= 400) {
-                                return Option.none();
-                            }
-                            return errorType;
-                        },
-                    });
-                if (Option.isSome(finalErrorType)) {
-                    span.attribute("error.type", finalErrorType.value);
-                }
-                requestSpans.delete(request);
-                release();
-                span.end(clock.currentTimeNanosUnsafe(), exit);
-            };
-            const onResponseFinish = () => {
-                responseFinished = true;
-                finish(pendingExit, responseStatus(), pendingErrorType);
-            };
-            const onResponseClose = () => {
-                if (!responseFinished) {
-                    finish(Exit.interrupt(), responseStatus(true), Option.some("connection_closed"));
-                }
-            };
-            const registered = this.#requestTracker.register({
-                interrupt: () => finish(Exit.interrupt(), responseStatus(true), Option.none()),
-            });
-            if (Option.isNone(registered)) {
-                requestSpans.delete(request);
-                span.end(clock.currentTimeNanosUnsafe(), Exit.interrupt());
-                return next.handle().subscribe(subscriber);
-            }
-            release = registered.value;
-            if (Option.isSome(responseEmitter)) {
-                responseEmitter.value.on("finish", onResponseFinish);
-                responseEmitter.value.on("close", onResponseClose);
-            }
-            const subscription = next.handle().subscribe({
-                next: (value) => subscriber.next(value),
-                error: (cause) => {
-                    observableSettled = true;
-                    const errorBoundary = decodeHttpErrorBoundary(cause);
-                    pendingExit = Exit.die(cause);
-                    pendingErrorType = Predicate.hasProperty(cause, "name")
-                        ? decodeErrorType(cause.name).pipe(Option.orElse(() => Option.some("exception")))
-                        : Option.some("exception");
-                    if (Option.isNone(responseEmitter)) {
-                        const status = errorBoundary.pipe(Option.flatMap((boundary) => Option.fromNullishOr(boundary.status)));
-                        finish(pendingExit, status, pendingErrorType);
-                    }
-                    subscriber.error(cause);
-                },
-                complete: () => {
-                    observableSettled = true;
-                    if (Option.isNone(responseEmitter)) {
-                        finish(Exit.succeed(undefined), responseStatus(), Option.none());
-                    }
-                    subscriber.complete();
-                },
-            });
-            return () => {
-                if (!observableSettled && Option.isNone(responseEmitter)) {
-                    finish(Exit.interrupt(), responseStatus(), Option.none());
-                }
-                subscription.unsubscribe();
-            };
-        });
-    }
-}

package/dist/nestjs/TelemetryModule.d.ts

@@ -1,53 +0,0 @@
-import type { DynamicModule, InjectionToken, ModuleMetadata, OptionalFactoryDependency } from "@nestjs/common";
-import { type ProxyPolicy } from "./HttpRoutePolicy.js";
-import { RequestWideEventTraceCorrelation } from "./RequestWideEventTraceCorrelation.js";
-export type TelemetryModuleOptions = {
-    readonly enabled: false;
-} | {
-    readonly enabled: true;
-    readonly serviceName: string;
-    readonly serviceVersion: string;
-    readonly environment: string;
-    readonly otlpEndpoint: string;
-    readonly healthRouteTemplates?: ReadonlyArray<string> | undefined;
-    readonly proxyPolicy?: ProxyPolicy | undefined;
-    readonly requestWideEventTraceCorrelation?: RequestWideEventTraceCorrelation | undefined;
-    readonly shutdownTimeoutMilliseconds?: number | undefined;
-};
-export interface TelemetryModuleAsyncOptions {
-    readonly imports?: ModuleMetadata["imports"] | undefined;
-    readonly inject?: Array<InjectionToken | OptionalFactoryDependency> | undefined;
-    readonly useFactory: (...dependencies: Array<never>) => TelemetryModuleOptions | Promise<TelemetryModuleOptions>;
-}
-export declare class InvalidTelemetryModuleOptions extends Error {
-    readonly _tag = "InvalidTelemetryModuleOptions";
-    readonly code = "OBS_TELEMETRY_INVALID_MODULE_OPTIONS";
-    readonly cause: unknown;
-    constructor(cause: unknown);
-}
-export declare class TelemetryStartupError extends Error {
-    readonly _tag = "TelemetryStartupError";
-    readonly code = "OBS_TELEMETRY_STARTUP_FAILED";
-    readonly cause: unknown;
-    constructor(cause: unknown);
-}
-export declare class TelemetryShutdownError extends Error {
-    readonly _tag = "TelemetryShutdownError";
-    readonly code = "OBS_TELEMETRY_SHUTDOWN_FAILED";
-    readonly cause: unknown;
-    constructor(cause: unknown);
-}
-export interface TelemetryModuleTestingOverrides {
-    readonly scopedResource?: {
-        readonly acquire: () => void | Promise<void>;
-        readonly release: () => void | Promise<void>;
-    } | undefined;
-    readonly startupProbe?: (() => void | Promise<void>) | undefined;
-    readonly beforeRequestDrain?: (() => void | Promise<void>) | undefined;
-    readonly beforeRuntimeDispose?: (() => void | Promise<void>) | undefined;
-    readonly onRuntimeDisposed?: (() => void) | undefined;
-}
-export declare const telemetryModuleForTesting: (options: TelemetryModuleAsyncOptions, overrides: TelemetryModuleTestingOverrides) => DynamicModule;
-export declare class TelemetryModule {
-    static forRootAsync(options: TelemetryModuleAsyncOptions): DynamicModule;
-}