@equipe-tech/observability 0.2.0 → 0.3.5

package/dist/testing/conformance/index.js

@@ -0,0 +1,6 @@
+export { conformanceChecks } from "./ConformanceRegistry.js";
+export { ConformanceAssertionError, ConformanceFailure, InvalidConformanceSuite, conformanceFailureCodes, } from "./ConformanceFailure.js";
+export { assertConformanceFailure, assertConforms } from "./ConformanceAssertions.js";
+export { runConformance, runConformanceSuite } from "./ConformanceRunner.js";
+export { ConformanceViolation, defineConformanceEvidenceProvider } from "./ConformanceModel.js";
+export { applicationDeployedTelemetryDestinationReceipt, auditCanaryConformance, auditConformance, contractConformance, conformanceTargetBinding, correlationConformance, identityConformance, libraryLifecycleConformance, lifecycleConformance, policyConformance, producersConformance, profileConformance, telemetryCanaryConformance, telemetryDestinationMatches, telemetryDestinationTelemetry, } from "./TelemetryEvidence.js";

package/dist/testing/contract.d.ts

@@ -0,0 +1,81 @@
+import { Effect, Layer } from "effect";
+import { TelemetryEventSink, type BrowserTelemetryEvent, type EventPayloadOf, type EventProducer, type TelemetryContract, type TelemetryContractInput } from "../contract/index.js";
+import { ContractIssueCode } from "../contract/TelemetryContractError.js";
+import type { TelemetryEvent } from "../contract/TelemetryEvent.js";
+export type OrganizationEventFixture = {
+    readonly alias: string;
+    readonly name: string;
+    readonly kind: string;
+};
+export declare const organizationEventFixtures: ReadonlyArray<OrganizationEventFixture>;
+export declare const contractIssueFixtures: readonly ["OBS_CONTRACT_INVALID_DOCUMENT", "OBS_CONTRACT_INVALID_VERSION", "OBS_CONTRACT_INVALID_EVENT_NAME", "OBS_CONTRACT_DUPLICATE_EVENT_NAME", "OBS_CONTRACT_INVALID_EVENT_KIND", "OBS_CONTRACT_INVALID_DEFAULT_SEVERITY", "OBS_CONTRACT_INVALID_ATTRIBUTE_NAME", "OBS_CONTRACT_RESERVED_ATTRIBUTE_NAME", "OBS_CONTRACT_INVALID_ATTRIBUTE_DEFINITION", "OBS_CONTRACT_INVALID_SAMPLING_RATE", "OBS_CONTRACT_INVALID_AUDIT_ACTION", "OBS_CONTRACT_DUPLICATE_AUDIT_ACTION", "OBS_CONTRACT_INVALID_AUDIT_REASON_CODE", "OBS_CONTRACT_INVALID_METRIC_NAME", "OBS_CONTRACT_DUPLICATE_METRIC_NAME", "OBS_CONTRACT_INVALID_METRIC_KIND", "OBS_CONTRACT_INVALID_METRIC_UNIT", "OBS_CONTRACT_INVALID_METRIC_DESCRIPTION", "OBS_CONTRACT_INVALID_METRIC_BOUNDARIES", "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_NAME", "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_DEFINITION", "OBS_CONTRACT_INVALID_METRIC_ALLOWED_VALUES", "OBS_CONTRACT_INVALID_METRIC_CARDINALITY"];
+export declare const telemetryEventErrorFixtures: readonly ["OBS_EVENT_UNKNOWN_NAME", "OBS_EVENT_UNDECLARED_ATTRIBUTE", "OBS_EVENT_MISSING_ATTRIBUTE", "OBS_EVENT_INVALID_FIELD", "OBS_EVENT_INVALID_OUTCOME", "OBS_EVENT_RESTRICTED_ATTRIBUTE", "OBS_EVENT_SENSITIVE_METRIC_LABEL", "OBS_EVENT_UNKNOWN_AUDIT_ACTION", "OBS_EVENT_INVALID_AUDIT_RESOURCE", "OBS_EVENT_INVALID_AUDIT_OUTCOME", "OBS_EVENT_INVALID_AUDIT_REASON"];
+export declare const auditRecordErrorFixtures: readonly ["OBS_AUDIT_UNKNOWN_ACTION", "OBS_AUDIT_INVALID_ACTOR", "OBS_AUDIT_INVALID_RESOURCE", "OBS_AUDIT_INVALID_OUTCOME", "OBS_AUDIT_UNKNOWN_REASON_CODE", "OBS_AUDIT_INVALID_FIELD"];
+export declare const metricDefinitionFixtures: {
+    Counter: {
+        name: string;
+        description: string;
+        unit: string;
+        kind: "counter";
+        attributes: {};
+    };
+    Histogram: {
+        name: string;
+        description: string;
+        unit: string;
+        kind: "histogram";
+        boundaries: number[];
+        attributes: {};
+    };
+    ObservableGauge: {
+        name: string;
+        description: string;
+        unit: string;
+        kind: "observable_gauge";
+        attributes: {};
+    };
+};
+type MetricDefinitionIssueCode = Extract<ContractIssueCode, `OBS_CONTRACT_${string}METRIC${string}`>;
+export type InvalidMetricDefinitionFixture = {
+    readonly issue: MetricDefinitionIssueCode;
+    readonly metricsDocument: string;
+};
+export declare const invalidMetricDefinitionFixtures: ({
+    issue: "OBS_CONTRACT_INVALID_METRIC_NAME";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_DUPLICATE_METRIC_NAME";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_KIND";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_DESCRIPTION";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_UNIT";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_BOUNDARIES";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_NAME";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_DEFINITION";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_CARDINALITY";
+    metricsDocument: string;
+} | {
+    issue: "OBS_CONTRACT_INVALID_METRIC_ALLOWED_VALUES";
+    metricsDocument: string;
+})[];
+export type CollectingTelemetryEventSink = {
+    readonly layer: Layer.Layer<TelemetryEventSink>;
+    readonly events: Effect.Effect<ReadonlyArray<TelemetryEvent>>;
+    readonly browserEvents: Effect.Effect<ReadonlyArray<BrowserTelemetryEvent>>;
+};
+export declare const makeCollectingTelemetryEventSink: () => Effect.Effect<CollectingTelemetryEventSink, never, never>;
+export declare const withFixedSampling: <A, E, R>(program: Effect.Effect<A, E, R>, draw: number) => Effect.Effect<A, E, R>;
+export type { EventPayloadOf, EventProducer, TelemetryContract, TelemetryContractInput };

package/dist/testing/contract.js

@@ -0,0 +1,93 @@
+import { Effect, Layer, Random, Ref } from "effect";
+import { AuditRecordErrorCode } from "../audit/InvalidAuditRecord.js";
+import { TelemetryEventSink, } from "../contract/index.js";
+import { ContractIssueCode, TelemetryEventErrorCode } from "../contract/TelemetryContractError.js";
+import { organizationEvents } from "../contract/OrganizationEvents.js";
+export const organizationEventFixtures = Object.entries(organizationEvents).map(([alias, definition]) => ({ alias, name: definition.name, kind: definition.kind }));
+export const contractIssueFixtures = ContractIssueCode.literals;
+export const telemetryEventErrorFixtures = TelemetryEventErrorCode.literals;
+export const auditRecordErrorFixtures = AuditRecordErrorCode.literals;
+export const metricDefinitionFixtures = {
+    Counter: {
+        name: "fixture.counter",
+        description: "Counter fixture",
+        unit: "1",
+        kind: "counter",
+        attributes: {},
+    },
+    Histogram: {
+        name: "fixture.histogram",
+        description: "Histogram fixture",
+        unit: "ms",
+        kind: "histogram",
+        boundaries: [1, 10],
+        attributes: {},
+    },
+    ObservableGauge: {
+        name: "fixture.gauge",
+        description: "Observable gauge fixture",
+        unit: "1",
+        kind: "observable_gauge",
+        attributes: {},
+    },
+};
+const exhaustiveMetricDefinitionFixtures = (fixtures) => fixtures;
+export const invalidMetricDefinitionFixtures = exhaustiveMetricDefinitionFixtures([
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_NAME",
+        metricsDocument: `{"Metric":{"name":"invalid","description":"Fixture","unit":"1","kind":"counter","attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_DUPLICATE_METRIC_NAME",
+        metricsDocument: `{"First":{"name":"fixture.duplicate","description":"Fixture","unit":"1","kind":"counter","attributes":{}},"Second":{"name":"fixture.duplicate","description":"Fixture","unit":"1","kind":"counter","attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_KIND",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"1","kind":"summary","attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_DESCRIPTION",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"","unit":"1","kind":"counter","attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_UNIT",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"bad unit","kind":"counter","attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_BOUNDARIES",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"ms","kind":"histogram","boundaries":[],"attributes":{}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_NAME",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"1","kind":"counter","attributes":{"Invalid":{"classification":"public","maximumCardinality":1}}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_ATTRIBUTE_DEFINITION",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"1","kind":"counter","attributes":{"fixture.label":{"classification":"sensitive","maximumCardinality":1}}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_CARDINALITY",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"1","kind":"counter","attributes":{"fixture.label":{"classification":"public","maximumCardinality":0}}}}`,
+    },
+    {
+        issue: "OBS_CONTRACT_INVALID_METRIC_ALLOWED_VALUES",
+        metricsDocument: `{"Metric":{"name":"fixture.metric","description":"Fixture","unit":"1","kind":"counter","attributes":{"fixture.label":{"classification":"public","maximumCardinality":1,"allowedValues":[]}}}}`,
+    },
+]);
+export const makeCollectingTelemetryEventSink = Effect.fn("makeCollectingTelemetryEventSink")(function* () {
+    const store = yield* Ref.make([]);
+    const browserStore = yield* Ref.make([]);
+    const record = (event) => Ref.update(store, (events) => [...events, event]);
+    const admitBrowserBatch = (events) => Effect.succeed({
+        commit: Ref.update(browserStore, (captured) => [...captured, ...events]),
+    });
+    return {
+        layer: Layer.succeed(TelemetryEventSink, TelemetryEventSink.of({ record, admitBrowserBatch })),
+        events: Ref.get(store),
+        browserEvents: Ref.get(browserStore),
+    };
+});
+export const withFixedSampling = (program, draw) => Effect.provideService(program, Random.Random, {
+    nextIntUnsafe: () => 0,
+    nextDoubleUnsafe: () => draw,
+});

package/dist/testing/deployedCanary.d.ts

@@ -0,0 +1 @@
+export declare const deployedCanarySuiteTimeoutMilliseconds = 480000;

package/dist/testing/deployedCanary.js

@@ -0,0 +1 @@
+export const deployedCanarySuiteTimeoutMilliseconds = 480_000;

package/dist/testing/index.d.ts

@@ -1,8 +1,28 @@
 import { Effect, Layer, Option, type Exit } from "effect";
 import { OtlpExporter } from "effect/unstable/observability";
 import { TelemetryConfig } from "../TelemetryConfig.js";
+import type { DataPolicy } from "../policy/DataPolicy.js";
+import type { InvalidDataPolicy } from "../policy/DataPolicyError.js";
+import type { ResourceAttribute } from "../policy/ResourceAttributePolicy.js";
+import type { ContractRegistry } from "../profile/ObservabilityAdapter.js";
+export * from "./contract.js";
+export * from "./conformance/index.js";
+export * from "./deployedCanary.js";
+export * from "../node/LocalCollector.js";
+export { registerTestingAdapter, type TestingAdapterRegistration, } from "../profile/ObservabilityAdapter.js";
+export { createTestingNodeObservabilityFromConfig } from "../node/Observability.js";
 export type CapturedAttributeValue = string | number | boolean;
 export type CapturedAttributes = ReadonlyMap<string, CapturedAttributeValue>;
+export type CapturedSpanEvent = {
+    readonly name: string;
+    readonly attributes: CapturedAttributes;
+    readonly droppedAttributesCount: number;
+};
+export type CapturedSpanLink = {
+    readonly spanId: string;
+    readonly attributes: CapturedAttributes;
+    readonly droppedAttributesCount: number;
+};
 export type CapturedSpan = {
     readonly traceId: string;
     readonly spanId: string;
@@ -12,6 +32,11 @@ export type CapturedSpan = {
     readonly statusCode: number;
     readonly statusMessage: Option.Option<string>;
     readonly attributes: CapturedAttributes;
+    readonly droppedAttributesCount: number;
+    readonly events: ReadonlyArray<CapturedSpanEvent>;
+    readonly droppedEventsCount: number;
+    readonly links: ReadonlyArray<CapturedSpanLink>;
+    readonly droppedLinksCount: number;
     readonly eventNames: ReadonlyArray<string>;
     readonly linkedSpanIds: ReadonlyArray<string>;
     readonly resourceAttributes: CapturedAttributes;
@@ -20,6 +45,7 @@ export type CapturedLog = {
     readonly traceId: Option.Option<string>;
     readonly spanId: Option.Option<string>;
     readonly severityText: Option.Option<string>;
+    readonly droppedAttributesCount: number;
     readonly body: Option.Option<string>;
     readonly attributes: CapturedAttributes;
     readonly resourceAttributes: CapturedAttributes;
@@ -74,13 +100,24 @@ export type CapturedRequest = {
     readonly path: string;
     readonly payload: unknown;
 };
+export declare const decodeCapturedTelemetry: (requests: readonly CapturedRequest[]) => Effect.Effect<CapturedTelemetry, never, never>;
 export type RunOptions = {
     readonly config?: TelemetryConfig;
+    readonly policy?: DataPolicy;
+    readonly resourceAttributes?: ReadonlyArray<ResourceAttribute>;
+    readonly contract?: ContractRegistry;
 };
 export type TelemetryCapture = {
-    readonly layer: Layer.Layer<OtlpExporter.Flusher>;
+    readonly layer: Layer.Layer<OtlpExporter.Flusher, InvalidDataPolicy>;
     readonly telemetry: Effect.Effect<CapturedTelemetry>;
 };
+export type OtlpCaptureServer = {
+    readonly endpoint: URL;
+    readonly telemetry: () => CapturedTelemetry;
+    readonly stop: () => Promise<void>;
+};
+export declare const startOtlpCaptureServer: (options?: {
+    readonly host?: string;
+}) => Promise<OtlpCaptureServer>;
 export declare const makeCapture: (options?: RunOptions | undefined) => Effect.Effect<TelemetryCapture, never, never>;
-export declare const run: <A, E, R>(program: Effect.Effect<A, E, R>, options?: RunOptions) => Effect.Effect<TelemetryRun<A, E>, never, R>;
-export {};
+export declare const run: <A, E, R>(program: Effect.Effect<A, E, R>, options?: RunOptions) => Effect.Effect<TelemetryRun<A, E | InvalidDataPolicy>, never, R>;

package/dist/testing/index.js

@@ -1,7 +1,15 @@
 import { Effect, Layer, Option, Ref, Schema } from "effect";
 import { HttpClient, HttpClientResponse } from "effect/unstable/http";
+import { parseResourceIdentity } from "../ResourceIdentity.js";
 import { layerOtlp } from "../Telemetry.js";
 import { TelemetryConfig } from "../TelemetryConfig.js";
+import { createServer } from "node:http";
+export * from "./contract.js";
+export * from "./conformance/index.js";
+export * from "./deployedCanary.js";
+export * from "../node/LocalCollector.js";
+export { registerTestingAdapter, } from "../profile/ObservabilityAdapter.js";
+export { createTestingNodeObservabilityFromConfig } from "../node/Observability.js";
 const AttributeValue = Schema.Struct({
     stringValue: Schema.String.pipe(Schema.optionalKey),
     boolValue: Schema.Boolean.pipe(Schema.optionalKey),
@@ -27,8 +35,19 @@ const ExportedSpan = Schema.Struct({
         message: Schema.String.pipe(Schema.optionalKey),
     }).pipe(Schema.withDecodingDefault(Effect.succeed({ code: 0 }))),
     attributes: Attributes,
-    events: Schema.Array(Schema.Struct({ name: Schema.String })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
-    links: Schema.Array(Schema.Struct({ spanId: Schema.String })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+    droppedAttributesCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+    events: Schema.Array(Schema.Struct({
+        name: Schema.String,
+        attributes: Attributes,
+        droppedAttributesCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+    })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+    droppedEventsCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+    links: Schema.Array(Schema.Struct({
+        spanId: Schema.String,
+        attributes: Attributes,
+        droppedAttributesCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+    })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+    droppedLinksCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
 });
 const SpanExport = Schema.Struct({
     resourceSpans: Schema.Array(Schema.Struct({
@@ -40,6 +59,7 @@ const ExportedLogRecord = Schema.Struct({
     traceId: Schema.String.pipe(Schema.optionalKey),
     spanId: Schema.String.pipe(Schema.optionalKey),
     severityText: Schema.String.pipe(Schema.optionalKey),
+    droppedAttributesCount: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
     body: Schema.Struct({ stringValue: Schema.String.pipe(Schema.optionalKey) }).pipe(Schema.optionalKey),
     attributes: Attributes,
 });
@@ -130,7 +150,7 @@ const captureClient = (store) => HttpClient.make((request, url) => Effect.gen(fu
     }
     return HttpClientResponse.fromWeb(request, new Response("{}", { status: 200 }));
 }));
-const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (requests) {
+export const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (requests) {
     const spans = [];
     const logs = [];
     const metrics = [];
@@ -150,6 +170,19 @@ const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (
                             statusCode: span.status.code,
                             statusMessage: Option.fromNullishOr(span.status.message),
                             attributes: toAttributes(span.attributes),
+                            droppedAttributesCount: span.droppedAttributesCount,
+                            events: span.events.map((event) => ({
+                                name: event.name,
+                                attributes: toAttributes(event.attributes),
+                                droppedAttributesCount: event.droppedAttributesCount,
+                            })),
+                            droppedEventsCount: span.droppedEventsCount,
+                            links: span.links.map((link) => ({
+                                spanId: link.spanId,
+                                attributes: toAttributes(link.attributes),
+                                droppedAttributesCount: link.droppedAttributesCount,
+                            })),
+                            droppedLinksCount: span.droppedLinksCount,
                             eventNames: span.events.map((event) => event.name),
                             linkedSpanIds: span.links.map((link) => link.spanId),
                             resourceAttributes,
@@ -168,6 +201,7 @@ const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (
                             traceId: Option.fromNullishOr(log.traceId),
                             spanId: Option.fromNullishOr(log.spanId),
                             severityText: Option.fromNullishOr(log.severityText),
+                            droppedAttributesCount: log.droppedAttributesCount,
                             body: Option.fromNullishOr(log.body?.stringValue),
                             attributes: toAttributes(log.attributes),
                             resourceAttributes,
@@ -246,15 +280,98 @@ const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (
     }
     return { spans, logs, metrics };
 });
-const defaultConfig = new TelemetryConfig({
+const defaultIdentity = Effect.runSync(parseResourceIdentity({
     serviceName: "telemetry-testing",
     serviceVersion: "0.0.0",
     environment: "test",
+}));
+const defaultConfig = new TelemetryConfig({
+    identity: defaultIdentity,
     otlpEndpoint: new URL("http://telemetry.invalid"),
 });
+const ServerAddress = Schema.Struct({ address: Schema.String, port: Schema.Number });
+const decodeServerAddress = Schema.decodeUnknownSync(ServerAddress);
+const listenForCapture = (server, host) => new Promise((resolve, reject) => {
+    const onError = (cause) => {
+        server.off("listening", onListening);
+        reject(cause);
+    };
+    const onListening = () => {
+        server.off("error", onError);
+        resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    try {
+        server.listen(0, host);
+    }
+    catch (cause) {
+        server.off("error", onError);
+        server.off("listening", onListening);
+        reject(cause);
+    }
+});
+const closeCaptureServer = (server) => new Promise((resolve, reject) => {
+    server.close((cause) => (cause === undefined ? resolve() : reject(cause)));
+    server.closeAllConnections();
+});
+const captureEndpoint = (host, port) => {
+    const hostname = host.includes(":") ? `[${host}]` : host;
+    return new URL(`http://${hostname}:${port}`);
+};
+const capturePayloadDecoders = new Map([
+    ["/v1/traces", Schema.decodeUnknownOption(Schema.fromJsonString(SpanExport))],
+    ["/v1/logs", Schema.decodeUnknownOption(Schema.fromJsonString(LogExport))],
+    ["/v1/metrics", Schema.decodeUnknownOption(Schema.fromJsonString(MetricExport))],
+]);
+export const startOtlpCaptureServer = async (options) => {
+    const requests = [];
+    const server = createServer((request, response) => {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+            const path = request.url ?? "";
+            const decodePayload = capturePayloadDecoders.get(path);
+            if (decodePayload !== undefined) {
+                const payload = decodePayload(Buffer.concat(chunks).toString("utf8"));
+                if (Option.isNone(payload)) {
+                    response.writeHead(400, { "content-type": "application/json" });
+                    response.end(JSON.stringify({ code: 3, message: "Invalid OTLP JSON payload." }));
+                    return;
+                }
+                requests.push({ path, payload: payload.value });
+            }
+            response.writeHead(200, { "content-type": "application/json" });
+            response.end("{}");
+        });
+    });
+    const host = options?.host ?? "127.0.0.1";
+    await listenForCapture(server, host);
+    try {
+        const address = decodeServerAddress(server.address());
+        const endpoint = captureEndpoint(address.address, address.port);
+        let stopPromise;
+        return {
+            endpoint,
+            telemetry: () => Effect.runSync(decodeCapturedTelemetry(requests)),
+            stop: () => {
+                stopPromise ??= closeCaptureServer(server);
+                return stopPromise;
+            },
+        };
+    }
+    catch (cause) {
+        await closeCaptureServer(server).catch(() => undefined);
+        throw cause;
+    }
+};
 export const makeCapture = Effect.fn("makeCapture")(function* (options) {
     const store = yield* Ref.make([]);
-    const layer = layerOtlp(options?.config ?? defaultConfig).pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, captureClient(store))));
+    const layer = layerOtlp(options?.config ?? defaultConfig, {
+        policy: options?.policy,
+        resourceAttributes: options?.resourceAttributes,
+        contract: options?.contract,
+    }).pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, captureClient(store))));
     const telemetry = Ref.get(store).pipe(Effect.flatMap(decodeCapturedTelemetry));
     return { layer, telemetry };
 });

package/dist/trace/HttpServerOtlpTracer.d.ts

@@ -0,0 +1,42 @@
+import { Context, Duration, Effect, Layer } from "effect";
+import type { HttpClient } from "effect/unstable/http";
+import { OtlpExporter, OtlpSerialization } from "effect/unstable/observability";
+import type { BrowserTraceSpan } from "../BrowserEvents.js";
+import type { ResourceAttributes } from "../ResourceIdentity.js";
+import type { DataPolicy } from "../policy/DataPolicy.js";
+export type HttpServerOtlpTracerOptions = {
+    readonly url: string;
+    readonly policy: DataPolicy;
+    readonly resource: {
+        readonly serviceName: string;
+        readonly serviceVersion: string;
+        readonly attributes: ResourceAttributes;
+    };
+    readonly shutdownTimeout?: Duration.Input | undefined;
+};
+export declare const layerHttpServerOtlpTracer: (options: HttpServerOtlpTracerOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization>;
+export type BrowserSignals = {
+    readonly resource?: {
+        readonly serviceName: string;
+        readonly serviceVersion: string;
+        readonly environment: string;
+    };
+    readonly spans: ReadonlyArray<BrowserTraceSpan>;
+};
+declare const BrowserSignalExporter_base: Context.Reference<{
+    readonly export: (signals: BrowserSignals) => Effect.Effect<void>;
+}>;
+export declare class BrowserSignalExporter extends BrowserSignalExporter_base {
+}
+export type BrowserSignalExporterOptions = {
+    readonly tracesUrl: string;
+    readonly policy: DataPolicy;
+    readonly resource: {
+        readonly serviceName: string;
+        readonly serviceVersion: string;
+        readonly attributes: ResourceAttributes;
+    };
+    readonly shutdownTimeout?: Duration.Input | undefined;
+};
+export declare const layerBrowserSignalExporter: (options: BrowserSignalExporterOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization>;
+export {};