@equipe-tech/observability 0.2.0 → 0.3.5

package/dist/trace/HttpServerOtlpTracer.js

@@ -0,0 +1,301 @@
+import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Tracer } from "effect";
+import { OtlpExporter, OtlpResource, OtlpSerialization } from "effect/unstable/observability";
+import { sanitizeText, transformSignalFields } from "../policy/PolicyTransform.js";
+import { effectDroppedAttributesKey } from "../policy/PolicyVocabulary.js";
+const HttpStatusCode = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 100, maximum: 599 }));
+const decodeHttpStatusCode = Schema.decodeUnknownOption(HttpStatusCode);
+const SpanScalar = Schema.Union([
+    Schema.String,
+    Schema.Number.check(Schema.isFinite()),
+    Schema.Boolean,
+]);
+const decodeSpanScalar = Schema.decodeUnknownOption(SpanScalar);
+const maxSpanEvents = 128;
+const maxSpanLinks = 128;
+const sanitizeEntries = (policy, fields, unsupported = 0) => {
+    const decision = transformSignalFields(policy, "span", fields);
+    return {
+        attributes: OtlpResource.entriesToAttributes(Object.entries(decision.value)),
+        dropped: decision.dropped + unsupported,
+    };
+};
+const scalarFields = (entries, canonicalizeEffectKeys = false) => {
+    const fields = {};
+    let unsupported = 0;
+    for (const [key, value] of entries) {
+        const decoded = decodeSpanScalar(value);
+        if (key === effectDroppedAttributesKey && Option.isSome(decoded)) {
+            if (Predicate.isNumber(decoded.value))
+                unsupported += decoded.value;
+            continue;
+        }
+        if (Option.isNone(decoded)) {
+            unsupported += 1;
+            continue;
+        }
+        const canonicalKey = canonicalizeEffectKeys
+            ? key === "effect.fiberId"
+                ? "effect.fiber.id"
+                : key === "effect.logLevel"
+                    ? "effect.log.level"
+                    : key
+            : key;
+        fields[canonicalKey] = decoded.value;
+    }
+    return { fields, unsupported };
+};
+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 = (policy, span) => span.events.map(([name, startTime, attributes]) => {
+    const canonicalizeEffectKeys = Object.hasOwn(attributes, "effect.fiberId") && Object.hasOwn(attributes, "effect.logLevel");
+    const input = scalarFields(Object.entries(attributes), canonicalizeEffectKeys);
+    const decision = sanitizeEntries(policy, input.fields, input.unsupported);
+    return {
+        name: sanitizeText(policy, name, "span"),
+        timeUnixNano: String(startTime),
+        attributes: decision.attributes,
+        droppedAttributesCount: decision.dropped,
+    };
+});
+const makeNonHttpStatus = (policy, span) => {
+    if (span.status._tag !== "Ended") {
+        return { status: { code: statusCodeUnset }, attributes: [], events: [] };
+    }
+    if (span.status.exit._tag === "Success") {
+        return { status: { code: statusCodeOk }, attributes: [], events: [] };
+    }
+    if (Cause.hasInterruptsOnly(span.status.exit.cause)) {
+        return {
+            status: { code: statusCodeOk, message: "Interrupted" },
+            attributes: [
+                ["span.label", "⚠︎ Interrupted"],
+                ["status.interrupted", true],
+            ],
+            events: [],
+        };
+    }
+    const errors = Cause.prettyErrors(span.status.exit.cause, { includeCauseInStack: true });
+    const endTime = span.status.endTime;
+    const events = errors.map((error) => {
+        const decision = sanitizeEntries(policy, {
+            "exception.type": error.name,
+            "exception.message": error.message,
+            "exception.stacktrace": error.stack ?? "No stack trace available",
+        });
+        return {
+            name: "exception",
+            timeUnixNano: String(endTime),
+            attributes: decision.attributes,
+            droppedAttributesCount: decision.dropped,
+        };
+    });
+    return {
+        status: errors.length === 0
+            ? { code: statusCodeError }
+            : {
+                code: statusCodeError,
+                message: sanitizeText(policy, errors[0]?.message ?? "Error", "span"),
+            },
+        attributes: [],
+        events,
+    };
+};
+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 = (policy, span) => {
+    if (span.status._tag !== "Ended")
+        return Option.none();
+    const isHttpServer = span.kind === "server" && span.attributes.has("http.request.method");
+    const nonHttp = isHttpServer
+        ? { status: makeHttpStatus(span), attributes: [], events: [] }
+        : makeNonHttpStatus(policy, span);
+    const spanInput = scalarFields(span.attributes);
+    for (const [key, value] of nonHttp.attributes)
+        spanInput.fields[key] = value;
+    const attributeDecision = sanitizeEntries(policy, spanInput.fields, spanInput.unsupported);
+    const allEvents = [...makeEvents(policy, span), ...nonHttp.events];
+    const events = allEvents.slice(0, maxSpanEvents);
+    const allLinks = span.links.map((link) => {
+        const input = scalarFields(Object.entries(link.attributes));
+        const decision = sanitizeEntries(policy, input.fields, input.unsupported);
+        return {
+            traceId: link.span.traceId,
+            spanId: link.span.spanId,
+            attributes: decision.attributes,
+            droppedAttributesCount: decision.dropped,
+        };
+    });
+    const links = allLinks.slice(0, maxSpanLinks);
+    return Option.some({
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: Option.getOrUndefined(Option.map(span.parent, (parent) => parent.spanId)),
+        name: sanitizeText(policy, span.name, "span"),
+        kind: spanKindCode(span.kind),
+        startTimeUnixNano: String(span.status.startTime),
+        endTimeUnixNano: String(span.status.endTime),
+        attributes: attributeDecision.attributes,
+        droppedAttributesCount: attributeDecision.dropped,
+        events,
+        droppedEventsCount: allEvents.length - events.length,
+        status: nonHttp.status,
+        links,
+        droppedLinksCount: allLinks.length - links.length,
+    });
+};
+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(options.policy, span);
+            if (Option.isSome(exported))
+                exporter.push(exported.value);
+        }),
+    });
+});
+export const layerHttpServerOtlpTracer = (options) => Layer.effect(Tracer.Tracer, makeHttpServerOtlpTracer(options)).pipe(Layer.provideMerge(OtlpExporter.layerFlusher));
+export class BrowserSignalExporter extends Context.Reference("@equipe-tech/observability/BrowserSignalExporter", {
+    defaultValue: () => ({
+        export: () => Effect.void,
+    }),
+}) {
+}
+const unixNanos = (millis) => String(BigInt(Math.trunc(millis)) * 1000000n);
+const browserResource = (base, policy, identity) => {
+    if (identity === undefined)
+        return base;
+    const replaced = new Set([
+        "service.name",
+        "service.version",
+        "deployment.environment.name",
+        "deployment.environment",
+    ]);
+    const decision = transformSignalFields(policy, "resource", {
+        "service.name": identity.serviceName,
+        "service.version": identity.serviceVersion,
+        "deployment.environment.name": identity.environment,
+        "deployment.environment": identity.environment,
+    });
+    return {
+        attributes: [
+            ...base.attributes.filter((attribute) => !replaced.has(attribute.key)),
+            ...OtlpResource.entriesToAttributes(Object.entries(decision.value)),
+        ],
+        droppedAttributesCount: base.droppedAttributesCount + decision.dropped,
+    };
+};
+export const layerBrowserSignalExporter = (options) => Layer.effect(BrowserSignalExporter, Effect.gen(function* () {
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const traces = yield* OtlpExporter.make({
+        label: "BrowserSignalTracer",
+        url: options.tracesUrl,
+        headers: undefined,
+        exportInterval: Duration.seconds(5),
+        maxBatchSize: 1_000,
+        body: (exports) => [
+            serialization.traces({
+                resourceSpans: exports.map((entry) => ({
+                    resource: entry.resource,
+                    scopeSpans: [
+                        {
+                            scope: { name: OtlpResource.serviceNameUnsafe(entry.resource) },
+                            spans: [entry.span],
+                        },
+                    ],
+                })),
+            }),
+            Effect.void,
+        ],
+        shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3),
+    });
+    return BrowserSignalExporter.of({
+        export: (signals) => Effect.sync(() => {
+            const selectedResource = browserResource(resource, options.policy, signals.resource);
+            for (const span of signals.spans) {
+                const decision = transformSignalFields(options.policy, "span", span.fields);
+                traces.push({
+                    resource: selectedResource,
+                    span: {
+                        traceId: span.traceId,
+                        spanId: span.spanId,
+                        parentSpanId: span.parentSpanId,
+                        name: sanitizeText(options.policy, span.name, "span"),
+                        kind: 1,
+                        startTimeUnixNano: unixNanos(span.startedAt),
+                        endTimeUnixNano: unixNanos(span.endedAt),
+                        attributes: OtlpResource.entriesToAttributes(Object.entries(decision.value)),
+                        droppedAttributesCount: decision.dropped,
+                        events: [],
+                        droppedEventsCount: 0,
+                        status: { code: 1 },
+                        links: [],
+                        droppedLinksCount: 0,
+                    },
+                });
+            }
+        }),
+    });
+})).pipe(Layer.provideMerge(OtlpExporter.layerFlusher));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@equipe-tech/observability",
-  "version": "0.2.0",
-  "description": "Contrato OpenTelemetry da Equipe Tech: configuracao, layer OTLP e wide events sobre Effect",
+  "version": "0.3.5",
+  "description": "Nucleo neutro de observabilidade da Equipe Tech para OpenTelemetry, contratos, politicas e ciclo de vida",
   "homepage": "https://github.com/equipe-tech/observability#readme",
   "bugs": {
     "url": "https://github.com/equipe-tech/observability/issues"
@@ -21,6 +21,14 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./effect": {
+      "types": "./dist/effect/index.d.ts",
+      "import": "./dist/effect/index.js"
+    },
+    "./policy": {
+      "types": "./dist/policy/entrypoint.d.ts",
+      "import": "./dist/policy/entrypoint.js"
+    },
     "./metrics": {
       "types": "./dist/Metrics.d.ts",
       "import": "./dist/Metrics.js"
@@ -29,10 +37,6 @@
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.js"
     },
-    "./nestjs": {
-      "types": "./dist/nestjs/index.d.ts",
-      "import": "./dist/nestjs/index.js"
-    },
     "./browser": {
       "types": "./dist/browser/index.d.ts",
       "import": "./dist/browser/index.js"
@@ -41,6 +45,10 @@
       "types": "./dist/browser/client.d.ts",
       "import": "./dist/browser/client.js"
     },
+    "./react-web-profile": {
+      "types": "./dist/profile/ReactWebProfile.d.ts",
+      "import": "./dist/profile/ReactWebProfile.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
@@ -50,31 +58,10 @@
     "build": "bun ../../scripts/build-packages.ts",
     "prepack": "bun run build"
   },
-  "dependencies": {
-    "effect": "4.0.0-rc.111"
-  },
   "devDependencies": {
-    "@nestjs/common": "^11.2.1",
-    "@nestjs/core": "^11.2.1",
-    "@nestjs/platform-express": "^11.2.1",
-    "evlog": "2.27.1",
-    "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.2"
+    "effect": "4.0.0-rc.111"
   },
   "peerDependencies": {
-    "@nestjs/common": "^10.0.0 || ^11.0.0",
-    "@nestjs/core": "^10.0.0 || ^11.0.0",
-    "rxjs": "^7.2.0"
-  },
-  "peerDependenciesMeta": {
-    "@nestjs/common": {
-      "optional": true
-    },
-    "@nestjs/core": {
-      "optional": true
-    },
-    "rxjs": {
-      "optional": true
-    }
+    "effect": "4.0.0-rc.111"
   }
 }

package/dist/WideEvent.d.ts

@@ -1,5 +0,0 @@
-import { Effect } from "effect";
-export type WideEventFields = {
-    readonly [attribute: string]: string | number | boolean;
-};
-export declare const emit: (name: string, fields: WideEventFields) => Effect.Effect<void>;

package/dist/WideEvent.js

@@ -1,6 +0,0 @@
-import { Effect } from "effect";
-export const emit = (name, fields) => Effect.logInfo(name).pipe(Effect.annotateLogs({
-    ...fields,
-    "event.name": name,
-    "event.kind": "wide",
-}));

package/dist/nestjs/BrowserEventsController.d.ts

@@ -1,21 +0,0 @@
-import { Schema } from "effect";
-import type { ManagedRuntime } from "effect";
-import { type BrowserEventIngestReceipt } from "../node/BrowserEventIngest.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">;
-    readonly message: Schema.String;
-    readonly correlationId: Schema.String;
-}>, {}>;
-export declare class BrowserEventsRejection extends BrowserEventsRejection_base {
-}
-export type BrowserEventsControllerOptions = {
-    readonly path?: string;
-};
-export declare const createBrowserEventsController: <RuntimeError>(runtime: ManagedRuntime.ManagedRuntime<never, RuntimeError>, options?: BrowserEventsControllerOptions) => {
-    new (): {
-        events(request: RequestReference): Promise<BrowserEventIngestReceipt>;
-    };
-};
-export {};

package/dist/nestjs/BrowserEventsController.js

@@ -1,52 +0,0 @@
-import { Controller, HttpCode, HttpException, Post, Req } from "@nestjs/common";
-import { Cause, Exit, Option, Schema } from "effect";
-import { ingestBrowserEvents, InvalidBrowserEventBatch, } from "../node/BrowserEventIngest.js";
-import { requestSpan, withRequestSpan } from "./TelemetryInterceptor.js";
-export const defaultBrowserEventsPath = "_telemetry/events";
-export class BrowserEventsRejection extends Schema.Class("@equipe-tech/observability/BrowserEventsRejection")({
-    code: Schema.Literal("OBS_BROWSER_EVENTS_INVALID_BATCH"),
-    message: Schema.String,
-    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()));
-export const createBrowserEventsController = (runtime, options) => {
-    class BrowserEventsController {
-        async events(request) {
-            const body = decodeRequestWithBody(request).pipe(Option.map((parsed) => parsed.body), Option.getOrUndefined);
-            const exit = await runtime.runPromiseExit(ingestBrowserEvents(body).pipe(withRequestSpan(request)));
-            if (Exit.isSuccess(exit)) {
-                return exit.value;
-            }
-            const error = Cause.findErrorOption(exit.cause);
-            if (Option.isSome(error) && error.value instanceof InvalidBrowserEventBatch) {
-                throw new HttpException(new BrowserEventsRejection({
-                    code: error.value.code,
-                    message: error.value.message,
-                    correlationId: correlationId(request),
-                }), 400);
-            }
-            throw Cause.squash(exit.cause);
-        }
-    }
-    const prototype = BrowserEventsController.prototype;
-    const descriptor = Object.getOwnPropertyDescriptor(prototype, "events");
-    if (descriptor === undefined) {
-        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);
-    HttpCode(202)(prototype, "events", descriptor);
-    Req()(prototype, "events", 0);
-    return BrowserEventsController;
-};

package/dist/nestjs/HttpRoutePolicy.d.ts

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

@@ -1,179 +0,0 @@
-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);