brass-runtime 1.15.0 → 1.16.0

package/dist/server-C8hDXA74.d.ts

@@ -0,0 +1,674 @@
+import { a as MetricExemplar, b as MetricSnapshot, M as MetricsRegistry, T as TraceSampler, c as TraceSamplingInput, C as CircuitBreakerStats, E as EventBus, B as BrassEnv, I as InMemoryTracer, d as Tracer, R as RuntimeSpan, e as InMemoryTracerOptions } from './tracer-B5tRH9H7.js';
+import { T as TraceContext, R as RuntimeHooks, A as Async, J as JSONValue, B as Baggage, f as Runtime, g as RuntimeRegistry, h as RuntimeOptions } from './effect-CGNl5Rqp.js';
+import { A as AdaptiveLimiterStats } from './client-CtFmoDvM.js';
+
+declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+declare const OTLP_JSON_CONTENT_TYPE = "application/json";
+type PrometheusMetricsOptions = {
+    readonly prefix?: string;
+    readonly includeTimestamp?: boolean;
+    readonly includeExemplars?: boolean;
+    readonly help?: Record<string, string>;
+    readonly now?: () => number;
+};
+type PrometheusMetricsExporter = {
+    readonly contentType: string;
+    readonly export: () => string;
+};
+type OtlpAttributeValue = string | number | boolean;
+type OtlpExportOptions = {
+    readonly resource?: Record<string, OtlpAttributeValue>;
+    readonly scopeName?: string;
+    readonly scopeVersion?: string;
+    readonly now?: () => number;
+};
+type OtlpHttpResponse = {
+    readonly ok?: boolean;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly text?: () => Promise<string>;
+};
+type OtlpFetch = (url: string, init: {
+    readonly method: "POST";
+    readonly headers: Record<string, string>;
+    readonly body: string;
+}) => Promise<OtlpHttpResponse>;
+type OtlpHttpExporterOptions = OtlpExportOptions & {
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+    readonly fetch?: OtlpFetch;
+};
+type OtlpHttpExportResult = {
+    readonly status?: number;
+    readonly body: string;
+};
+type RuntimeMetricsSinkOptions = {
+    readonly durationBuckets?: readonly number[];
+    readonly clock?: () => number;
+    readonly includeEventTotals?: boolean;
+    readonly includeSpanNameLabel?: boolean;
+};
+declare function makePrometheusMetricsExporter(registry: MetricsRegistry, options?: PrometheusMetricsOptions): PrometheusMetricsExporter;
+declare function formatPrometheusMetrics(snapshot: MetricSnapshot, options?: PrometheusMetricsOptions): string;
+declare function metricsSnapshotToOtlp(snapshot: MetricSnapshot, options?: OtlpExportOptions): {
+    resourceMetrics: {
+        resource: {
+            attributes: {
+                key: string;
+                value: {
+                    boolValue: boolean;
+                    doubleValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    doubleValue: number;
+                    boolValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    stringValue: string;
+                    boolValue?: undefined;
+                    doubleValue?: undefined;
+                };
+            }[];
+        };
+        scopeMetrics: {
+            scope: Record<string, unknown>;
+            metrics: Record<string, unknown>[];
+        }[];
+    }[];
+};
+declare function makeOtlpHttpMetricsExporter(registry: MetricsRegistry, options: OtlpHttpExporterOptions): {
+    export: () => Promise<OtlpHttpExportResult>;
+};
+declare function makeRuntimeMetricsSink(metrics: MetricsRegistry, options?: RuntimeMetricsSinkOptions): RuntimeHooks;
+declare function exemplarFromTraceContext(trace: Pick<Partial<TraceContext>, "traceId" | "spanId"> | undefined, value: number, timestamp?: number, labels?: Record<string, string>): MetricExemplar | undefined;
+declare function toOtlpAttributes(labels: Record<string, OtlpAttributeValue>): {
+    key: string;
+    value: {
+        boolValue: boolean;
+        doubleValue?: undefined;
+        stringValue?: undefined;
+    } | {
+        doubleValue: number;
+        boolValue?: undefined;
+        stringValue?: undefined;
+    } | {
+        stringValue: string;
+        boolValue?: undefined;
+        doubleValue?: undefined;
+    };
+}[];
+declare function otlpAnyValue(value: OtlpAttributeValue): {
+    boolValue: boolean;
+    doubleValue?: undefined;
+    stringValue?: undefined;
+} | {
+    doubleValue: number;
+    boolValue?: undefined;
+    stringValue?: undefined;
+} | {
+    stringValue: string;
+    boolValue?: undefined;
+    doubleValue?: undefined;
+};
+declare function postOtlpJson(options: OtlpHttpExporterOptions, body: string): Promise<OtlpHttpResponse>;
+declare function unixNanoFromMs(ms: number): string;
+
+type RedactionOptions = {
+    readonly keys?: readonly (string | RegExp)[];
+    readonly headers?: readonly (string | RegExp)[];
+    readonly replacement?: string;
+    readonly redactUrlQuery?: boolean;
+    readonly maxDepth?: number;
+    readonly maxStringLength?: number;
+};
+type ObservabilityRedactor = {
+    readonly value: (value: unknown) => unknown;
+    readonly fields: (fields: Record<string, unknown>) => Record<string, unknown>;
+    readonly attributes: (fields: Record<string, unknown>) => Record<string, unknown>;
+    readonly headers: (headers: Record<string, string>) => Record<string, string>;
+    readonly url: (url: string) => string;
+};
+type RedactionConfig = false | RedactionOptions | ObservabilityRedactor;
+declare function makeObservabilityRedactor(config: RedactionConfig | undefined): ObservabilityRedactor;
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+type StructuredLogRecord = {
+    readonly ts: string;
+    readonly wallTs: number;
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly fields: Record<string, unknown>;
+    readonly fiberId?: number;
+    readonly scopeId?: number;
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly parentSpanId?: string;
+    readonly traceState?: string;
+};
+type StructuredLogSinkOptions = {
+    readonly minLevel?: LogLevel;
+    readonly clock?: () => number;
+    readonly write?: (record: StructuredLogRecord) => void;
+    readonly redact?: RedactionConfig;
+};
+type StructuredLogSource = {
+    readonly exportRecords: () => readonly StructuredLogRecord[];
+} | (() => readonly StructuredLogRecord[]);
+declare function makeStructuredLogSink(options?: StructuredLogSinkOptions): RuntimeHooks;
+declare function formatStructuredLog(record: StructuredLogRecord): string;
+declare function structuredLogsToOtlp(records: readonly StructuredLogRecord[], options?: OtlpExportOptions): {
+    resourceLogs: {
+        resource: {
+            attributes: {
+                key: string;
+                value: {
+                    boolValue: boolean;
+                    doubleValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    doubleValue: number;
+                    boolValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    stringValue: string;
+                    boolValue?: undefined;
+                    doubleValue?: undefined;
+                };
+            }[];
+        };
+        scopeLogs: {
+            scope: Record<string, unknown>;
+            logRecords: {
+                attributes: {
+                    key: string;
+                    value: {
+                        boolValue: boolean;
+                        doubleValue?: undefined;
+                        stringValue?: undefined;
+                    } | {
+                        doubleValue: number;
+                        boolValue?: undefined;
+                        stringValue?: undefined;
+                    } | {
+                        stringValue: string;
+                        boolValue?: undefined;
+                        doubleValue?: undefined;
+                    };
+                }[];
+                spanId?: string | undefined;
+                traceId?: string | undefined;
+                timeUnixNano: string;
+                severityText: string;
+                severityNumber: number;
+                body: {
+                    stringValue: string;
+                };
+            }[];
+        }[];
+    }[];
+};
+declare function makeOtlpHttpLogExporter(source: StructuredLogSource, options: OtlpHttpExporterOptions): {
+    export: () => Promise<{
+        status: number | undefined;
+        body: string;
+        logCount: number;
+    }>;
+};
+declare function logEffect(level: LogLevel, message: string, fields?: Record<string, unknown>): Async<unknown, never, void>;
+declare function withLogContext<R, E, A>(patch: Record<string, JSONValue>, effect: Async<R, E, A>): Async<R, E, A>;
+declare function defaultStructuredLogWriter(record: StructuredLogRecord): void;
+
+type TraceContextHeaderValue = string | readonly string[] | undefined;
+type TraceContextCarrier = Record<string, TraceContextHeaderValue> | Iterable<readonly [string, string]> | {
+    get(name: string): string | null | undefined;
+};
+type InjectTraceContextOptions = {
+    readonly overwrite?: boolean;
+};
+declare function parseTraceparent(value: string | null | undefined): TraceContext | undefined;
+declare function formatTraceparent(trace: TraceContext): string;
+declare function extractTraceContext(headers: TraceContextCarrier | undefined): TraceContext | undefined;
+declare function injectTraceContext(headers: Record<string, string> | undefined, trace: TraceContext, options?: InjectTraceContextOptions): Record<string, string>;
+declare function parseBaggage(value: string | null | undefined): Baggage | undefined;
+declare function formatBaggage(baggage: Baggage | undefined): string;
+declare function extractBaggage(headers: TraceContextCarrier | undefined): Baggage | undefined;
+declare function injectBaggage(headers: Record<string, string> | undefined, baggage: Baggage | undefined, options?: InjectTraceContextOptions): Record<string, string>;
+declare function normalizeTraceId(id: string): string;
+declare function normalizeSpanId(id: string): string;
+
+type ExportSignal = "metrics" | "traces" | "logs";
+type ExportRetryOptions = {
+    readonly attempts?: number;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly jitterRatio?: number;
+    readonly sleep?: (ms: number) => Promise<void>;
+};
+type ExportPipelineTuning = {
+    readonly maxQueueSize?: number;
+    readonly batchSize?: number;
+    readonly timeoutMs?: number;
+    readonly retry?: ExportRetryOptions;
+    readonly dropPolicy?: "drop-oldest" | "drop-newest";
+    readonly shutdownTimeoutMs?: number;
+};
+type ExportBatchResult = {
+    readonly status?: number;
+    readonly body?: string;
+};
+type ExportPipelineOptions<T> = ExportPipelineTuning & {
+    readonly signal: ExportSignal;
+    readonly metrics?: MetricsRegistry;
+    readonly clock?: () => number;
+    readonly exportBatch: (items: readonly T[]) => Promise<ExportBatchResult>;
+    readonly onDrop?: (items: readonly T[]) => void;
+};
+type ExportPipelineFlushOptions = {
+    readonly deadlineMs?: number;
+};
+type ExportPipelineFlushResult = {
+    readonly exported: number;
+    readonly dropped: number;
+    readonly failed: number;
+    readonly batchCount: number;
+    readonly attempts: number;
+    readonly queueSize: number;
+    readonly status?: number;
+    readonly body?: string;
+    readonly errors: readonly unknown[];
+};
+type ExportPipelineStats = {
+    readonly queueSize: number;
+    readonly dropped: number;
+};
+type ExportPipeline<T> = {
+    readonly enqueue: (items: readonly T[]) => number;
+    readonly flush: (options?: ExportPipelineFlushOptions) => Promise<ExportPipelineFlushResult>;
+    readonly shutdown: (timeoutMs?: number) => Promise<ExportPipelineFlushResult>;
+    readonly stats: () => ExportPipelineStats;
+};
+declare function makeExportPipeline<T>(options: ExportPipelineOptions<T>): ExportPipeline<T>;
+declare function exportWithRetry<T>(operation: () => Promise<T>, options: {
+    readonly signal: ExportSignal;
+    readonly metrics?: MetricsRegistry;
+    readonly retry?: ExportRetryOptions;
+}): Promise<{
+    value: T;
+    attempts: number;
+}>;
+declare function withTimeout<T>(operation: () => Promise<T>, timeoutMs: number): Promise<T>;
+
+type CardinalityLimiterOptions = {
+    readonly maxValuesPerLabel?: number;
+    readonly overflowValue?: string;
+};
+type CardinalityConfig = false | CardinalityLimiterOptions;
+declare function makeCardinalityLimitedMetrics(registry: MetricsRegistry, options?: CardinalityLimiterOptions): MetricsRegistry;
+declare function normalizeHttpRoute(path: string | undefined): string | undefined;
+declare function sanitizeHttpTarget(url: string | undefined): string | undefined;
+
+type TraceSamplingRule = {
+    readonly name?: string | RegExp;
+    readonly route?: string | RegExp;
+    readonly ratio?: number;
+    readonly sampled?: boolean;
+};
+type TraceSamplingOptions = {
+    readonly ratio?: number;
+    readonly rules?: readonly TraceSamplingRule[];
+    readonly sampler?: TraceSampler;
+    readonly respectRemoteSampled?: boolean;
+    readonly forceSampleOnError?: boolean;
+};
+type ResolvedTraceSampling = {
+    readonly sampler: TraceSampler;
+    readonly respectRemoteSampled: boolean;
+    readonly forceSampleOnError: boolean;
+};
+type TraceSamplingConfig = false | number | TraceSampler | TraceSamplingOptions;
+declare const alwaysOnSampler: TraceSampler;
+declare const alwaysOffSampler: TraceSampler;
+declare function ratioSampler(ratio: number): TraceSampler;
+declare function makeTraceSampler(options?: TraceSamplingOptions): TraceSampler;
+declare function resolveTraceSampling(config: TraceSamplingConfig | undefined): ResolvedTraceSampling;
+declare function shouldSampleWith(sampler: TraceSampler | undefined, input: TraceSamplingInput): boolean;
+
+type HealthStatus = "ok" | "degraded" | "down";
+type HealthCheckResult = {
+    readonly status: HealthStatus;
+    readonly message?: string;
+    readonly details?: Record<string, unknown>;
+};
+type HealthCheck = () => HealthCheckResult;
+type RuntimeHealthOptions = {
+    readonly runtime?: Runtime<any>;
+    readonly registry?: RuntimeRegistry;
+    readonly metrics?: MetricsRegistry;
+    readonly circuitBreakers?: Record<string, {
+        stats: () => CircuitBreakerStats;
+    }>;
+    readonly adaptiveLimiters?: Record<string, {
+        stats: () => AdaptiveLimiterStats;
+    }>;
+    readonly checks?: Record<string, HealthCheck>;
+    readonly clock?: () => number;
+    readonly readiness?: {
+        readonly failOnDegraded?: boolean;
+    };
+};
+type RuntimeHealthReport = {
+    readonly status: HealthStatus;
+    readonly ready: boolean;
+    readonly checkedAt: string;
+    readonly fibers?: {
+        readonly active: number;
+        readonly suspended: number;
+        readonly done: number;
+    };
+    readonly scopes?: {
+        readonly open: number;
+        readonly closed: number;
+    };
+    readonly runtime?: {
+        readonly engine?: string;
+        readonly fiberStats?: unknown;
+        readonly scheduler?: unknown;
+    };
+    readonly metrics?: {
+        readonly counters: number;
+        readonly gauges: number;
+        readonly histograms: number;
+        readonly activeFibers?: number;
+        readonly activeScopes?: number;
+        readonly activeSpans?: number;
+    };
+    readonly circuitBreakers: Record<string, CircuitBreakerStats & {
+        readonly status: HealthStatus;
+    }>;
+    readonly adaptiveLimiters: Record<string, AdaptiveLimiterStats & {
+        readonly status: HealthStatus;
+    }>;
+    readonly checks: Record<string, HealthCheckResult>;
+};
+type HealthHttpResponse = {
+    readonly status: number;
+    readonly headers: Record<string, string>;
+    readonly body: string;
+};
+declare function snapshotRuntimeHealth(options?: RuntimeHealthOptions): RuntimeHealthReport;
+declare function makeRuntimeHealth(options?: RuntimeHealthOptions): Async<unknown, never, RuntimeHealthReport>;
+declare const runtimeHealth: typeof makeRuntimeHealth;
+declare function readiness(options?: RuntimeHealthOptions): Async<unknown, never, boolean>;
+declare function healthToHttpResponse(report: RuntimeHealthReport): HealthHttpResponse;
+
+type ObservabilityOtlpOptions = {
+    readonly metricsUrl?: string;
+    readonly tracesUrl?: string;
+    readonly logsUrl?: string;
+    readonly headers?: Record<string, string>;
+    readonly fetch?: OtlpFetch;
+    readonly timeoutMs?: number;
+    readonly retry?: ExportRetryOptions;
+    readonly pipeline?: ExportPipelineTuning;
+};
+type ObservabilityOptions = {
+    readonly serviceName?: string;
+    readonly serviceVersion?: string;
+    readonly resource?: Record<string, OtlpAttributeValue>;
+    readonly eventBus?: EventBus;
+    readonly metrics?: false | (RuntimeMetricsSinkOptions & {
+        readonly prometheus?: PrometheusMetricsOptions;
+    });
+    readonly logs?: false | StructuredLogSinkOptions;
+    readonly traces?: false | Omit<InMemoryTracerOptions, "sanitizeAttributes" | "sanitizeError">;
+    readonly sampling?: TraceSamplingConfig;
+    readonly redaction?: RedactionConfig;
+    readonly cardinality?: CardinalityConfig;
+    readonly otlp?: ObservabilityOtlpOptions;
+    readonly flushIntervalMs?: number;
+    readonly autoStart?: boolean;
+    readonly traceSeed?: TraceContext;
+    readonly childName?: (parentName?: string) => string | undefined;
+    readonly onFlushError?: (error: unknown, signal: "metrics" | "traces" | "logs") => void;
+};
+type ObservabilityRequestEnvInput = TraceContextCarrier | {
+    readonly headers?: TraceContextCarrier;
+    readonly trace?: TraceContext;
+    readonly traceparent?: string;
+    readonly tracestate?: string;
+    readonly baggage?: Baggage | string;
+};
+type ObservabilityFlushError = {
+    readonly signal: "metrics" | "traces" | "logs";
+    readonly error: unknown;
+};
+type ObservabilityTraceExportResult = OtlpHttpExportResult & {
+    readonly spanCount: number;
+};
+type ObservabilityLogExportResult = OtlpHttpExportResult & {
+    readonly logCount: number;
+};
+type ObservabilityFlushResult = {
+    readonly metrics?: OtlpHttpExportResult;
+    readonly traces?: ObservabilityTraceExportResult;
+    readonly logs?: ObservabilityLogExportResult;
+    readonly errors: readonly ObservabilityFlushError[];
+};
+type ObservabilityExporters = {
+    readonly prometheus: PrometheusMetricsExporter;
+    readonly otlpMetrics?: {
+        readonly export: () => Promise<OtlpHttpExportResult>;
+    };
+    readonly otlpTraces?: {
+        readonly export: () => Promise<ObservabilityTraceExportResult>;
+        readonly pipeline: ExportPipeline<RuntimeSpan>;
+    };
+    readonly otlpLogs?: {
+        readonly export: () => Promise<ObservabilityLogExportResult>;
+        readonly pipeline: ExportPipeline<StructuredLogRecord>;
+    };
+};
+type ObservabilityRuntimeEnv = BrassEnv;
+type Observability = {
+    readonly hooks: EventBus;
+    readonly eventBus: EventBus;
+    readonly env: ObservabilityRuntimeEnv;
+    readonly envForRequest: (input?: ObservabilityRequestEnvInput) => ObservabilityRuntimeEnv;
+    readonly metrics: MetricsRegistry;
+    readonly tracer: InMemoryTracer;
+    readonly traceIdGenerator: Tracer;
+    readonly exporters: ObservabilityExporters;
+    readonly prometheus: PrometheusMetricsExporter;
+    readonly health: (options?: Omit<RuntimeHealthOptions, "metrics">) => RuntimeHealthReport;
+    readonly readiness: (options?: Omit<RuntimeHealthOptions, "metrics">) => boolean;
+    readonly flush: () => Promise<ObservabilityFlushResult>;
+    readonly start: () => void;
+    readonly stop: () => void;
+    readonly shutdown: () => Promise<ObservabilityFlushResult>;
+};
+declare function makeObservability(options?: ObservabilityOptions): Observability;
+declare function resolveRequestTraceSeed(input?: ObservabilityRequestEnvInput): TraceContext | undefined;
+declare function resolveRequestBaggage(input?: ObservabilityRequestEnvInput): Baggage | undefined;
+
+type SpanAttributes = Record<string, string | number | boolean>;
+type SpanLink = {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly traceState?: string;
+    readonly attributes?: SpanAttributes;
+};
+type SpanOptions = {
+    readonly attributes?: SpanAttributes;
+    readonly links?: readonly SpanLink[];
+};
+type SpanSource = {
+    readonly exportFinished: () => readonly RuntimeSpan[];
+} | (() => readonly RuntimeSpan[]);
+declare function withSpan<R, E, A>(name: string, effect: Async<R, E, A>, attributesOrOptions?: SpanAttributes | SpanOptions): Async<R, E, A>;
+declare function spanLink(trace: TraceContext, attributes?: SpanAttributes): SpanLink;
+declare function currentSpanLink(attributes?: SpanAttributes): SpanLink | undefined;
+declare function withBaggage<R, E, A>(baggage: Baggage, effect: Async<R, E, A>): Async<R, E, A>;
+declare function currentBaggage(): Baggage | undefined;
+declare function spanEvent(name: string, attributes?: SpanAttributes): Async<unknown, never, void>;
+declare function spansToOtlp(spans: readonly RuntimeSpan[], options?: OtlpExportOptions): {
+    resourceSpans: {
+        resource: {
+            attributes: {
+                key: string;
+                value: {
+                    boolValue: boolean;
+                    doubleValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    doubleValue: number;
+                    boolValue?: undefined;
+                    stringValue?: undefined;
+                } | {
+                    stringValue: string;
+                    boolValue?: undefined;
+                    doubleValue?: undefined;
+                };
+            }[];
+        };
+        scopeSpans: {
+            scope: Record<string, unknown>;
+            spans: {
+                name: string;
+                kind: number;
+                startTimeUnixNano: string;
+                endTimeUnixNano: string;
+                attributes: {
+                    key: string;
+                    value: {
+                        boolValue: boolean;
+                        doubleValue?: undefined;
+                        stringValue?: undefined;
+                    } | {
+                        doubleValue: number;
+                        boolValue?: undefined;
+                        stringValue?: undefined;
+                    } | {
+                        stringValue: string;
+                        boolValue?: undefined;
+                        doubleValue?: undefined;
+                    };
+                }[];
+                events: {
+                    name: string;
+                    timeUnixNano: string;
+                    attributes: {
+                        key: string;
+                        value: {
+                            boolValue: boolean;
+                            doubleValue?: undefined;
+                            stringValue?: undefined;
+                        } | {
+                            doubleValue: number;
+                            boolValue?: undefined;
+                            stringValue?: undefined;
+                        } | {
+                            stringValue: string;
+                            boolValue?: undefined;
+                            doubleValue?: undefined;
+                        };
+                    }[];
+                }[];
+                links: {
+                    attributes: {
+                        key: string;
+                        value: {
+                            boolValue: boolean;
+                            doubleValue?: undefined;
+                            stringValue?: undefined;
+                        } | {
+                            doubleValue: number;
+                            boolValue?: undefined;
+                            stringValue?: undefined;
+                        } | {
+                            stringValue: string;
+                            boolValue?: undefined;
+                            doubleValue?: undefined;
+                        };
+                    }[];
+                    traceState?: string | undefined;
+                    traceId: string;
+                    spanId: string;
+                }[];
+                status: {
+                    code: number;
+                    message: any;
+                } | {
+                    code: number;
+                    message?: undefined;
+                };
+                traceState?: string | undefined;
+                parentSpanId?: string | undefined;
+                traceId: string;
+                spanId: string;
+            }[];
+        }[];
+    }[];
+};
+declare function makeOtlpHttpSpanExporter(source: SpanSource, options: OtlpHttpExporterOptions): {
+    export: () => Promise<{
+        status: number | undefined;
+        body: string;
+    }>;
+};
+
+type RequestObservabilityContextInput = {
+    readonly headers?: TraceContextCarrier;
+    readonly trace?: TraceContext;
+    readonly traceparent?: string;
+    readonly tracestate?: string;
+    readonly baggage?: Baggage | string;
+    readonly method?: string;
+    readonly target?: string;
+    readonly route?: string;
+    readonly spanName?: string;
+    readonly attributes?: SpanAttributes;
+};
+type RequestObservabilityRuntimeOptions<R extends object> = Omit<RuntimeOptions<R & ObservabilityRuntimeEnv>, "env" | "hooks">;
+type RequestObservabilityContext = {
+    readonly env: ObservabilityRuntimeEnv;
+    readonly trace?: TraceContext;
+    readonly route?: string;
+    readonly attributes: SpanAttributes;
+    readonly makeRuntime: <R extends object = {}>(env?: R, options?: RequestObservabilityRuntimeOptions<R>) => Runtime<R & ObservabilityRuntimeEnv>;
+    readonly run: <R extends object = {}, E = never, A = never>(effect: Async<R & ObservabilityRuntimeEnv, E, A>, env?: R, options?: RequestObservabilityRuntimeOptions<R>) => Promise<A>;
+    readonly span: <R, E, A>(name: string, effect: Async<R, E, A>, attributes?: SpanAttributes) => Async<R, E, A>;
+    readonly withRequestSpan: <R, E, A>(effect: Async<R, E, A>, attributes?: SpanAttributes) => Async<R, E, A>;
+    readonly flush: () => Promise<ObservabilityFlushResult>;
+    readonly shutdown: () => Promise<ObservabilityFlushResult>;
+};
+declare function makeRequestObservabilityContext(observability: Observability, input?: RequestObservabilityContextInput): RequestObservabilityContext;
+
+type HttpServerOutcome = "success" | "error" | "exception";
+type HttpServerObservabilityLogOptions = {
+    readonly requestLevel?: LogLevel | false;
+    readonly responseLevel?: LogLevel | false;
+    readonly errorLevel?: LogLevel | false;
+};
+type HttpServerObservabilitySpanOptions = {
+    readonly name?: string | ((input: RequestObservabilityContextInput) => string);
+    readonly attributes?: SpanAttributes | ((input: RequestObservabilityContextInput) => SpanAttributes);
+};
+type HttpServerObservabilityOptions<A = unknown> = {
+    readonly metrics?: MetricsRegistry | false;
+    readonly logs?: false | HttpServerObservabilityLogOptions;
+    readonly spans?: false | HttpServerObservabilitySpanOptions;
+    readonly includeRouteLabel?: boolean;
+    readonly clock?: () => number;
+    readonly durationBuckets?: readonly number[];
+    readonly statusCode?: (value: A) => number | undefined;
+};
+type ObservedHttpServerResult<A> = {
+    readonly value: A;
+    readonly ctx: RequestObservabilityContext;
+    readonly statusCode: number;
+    readonly durationMs: number;
+};
+declare function runObservedHttpServerEffect<R extends object = {}, E = never, A = never>(observability: Observability, input: RequestObservabilityContextInput, effect: Async<R, E, A>, options?: HttpServerObservabilityOptions<A>, env?: R, runtimeOptions?: RequestObservabilityRuntimeOptions<R>): Promise<ObservedHttpServerResult<A>>;
+declare function observeHttpServerRequest<A>(observability: Observability, input: RequestObservabilityContextInput, handler: (ctx: RequestObservabilityContext) => Promise<A>, options?: HttpServerObservabilityOptions<A>): Promise<ObservedHttpServerResult<A>>;
+
+export { type RuntimeMetricsSinkOptions as $, type ObservabilityRuntimeEnv as A, type ObservabilityTraceExportResult as B, type CardinalityConfig as C, type ObservedHttpServerResult as D, type ExportBatchResult as E, type OtlpAttributeValue as F, type OtlpExportOptions as G, type HealthCheck as H, type InjectTraceContextOptions as I, type OtlpFetch as J, type OtlpHttpExportResult as K, type LogLevel as L, type OtlpHttpExporterOptions as M, type OtlpHttpResponse as N, type Observability as O, PROMETHEUS_CONTENT_TYPE as P, type PrometheusMetricsExporter as Q, type RequestObservabilityContextInput as R, type SpanAttributes as S, type TraceContextCarrier as T, type PrometheusMetricsOptions as U, type RedactionConfig as V, type RedactionOptions as W, type RequestObservabilityRuntimeOptions as X, type ResolvedTraceSampling as Y, type RuntimeHealthOptions as Z, type RuntimeHealthReport as _, type RequestObservabilityContext as a, toOtlpAttributes as a$, type SpanLink as a0, type SpanOptions as a1, type SpanSource as a2, type StructuredLogRecord as a3, type StructuredLogSinkOptions as a4, type StructuredLogSource as a5, type TraceContextHeaderValue as a6, type TraceSamplingConfig as a7, type TraceSamplingOptions as a8, type TraceSamplingRule as a9, makeRuntimeHealth as aA, makeRuntimeMetricsSink as aB, makeStructuredLogSink as aC, makeTraceSampler as aD, metricsSnapshotToOtlp as aE, normalizeHttpRoute as aF, normalizeSpanId as aG, normalizeTraceId as aH, observeHttpServerRequest as aI, otlpAnyValue as aJ, parseBaggage as aK, parseTraceparent as aL, postOtlpJson as aM, ratioSampler as aN, readiness as aO, resolveRequestBaggage as aP, resolveRequestTraceSeed as aQ, resolveTraceSampling as aR, runObservedHttpServerEffect as aS, runtimeHealth as aT, sanitizeHttpTarget as aU, shouldSampleWith as aV, snapshotRuntimeHealth as aW, spanEvent as aX, spanLink as aY, spansToOtlp as aZ, structuredLogsToOtlp as a_, alwaysOffSampler as aa, alwaysOnSampler as ab, currentBaggage as ac, currentSpanLink as ad, defaultStructuredLogWriter as ae, exemplarFromTraceContext as af, exportWithRetry as ag, extractBaggage as ah, extractTraceContext as ai, formatBaggage as aj, formatPrometheusMetrics as ak, formatStructuredLog as al, formatTraceparent as am, healthToHttpResponse as an, injectBaggage as ao, injectTraceContext as ap, logEffect as aq, makeCardinalityLimitedMetrics as ar, makeExportPipeline as as, makeObservability as at, makeObservabilityRedactor as au, makeOtlpHttpLogExporter as av, makeOtlpHttpMetricsExporter as aw, makeOtlpHttpSpanExporter as ax, makePrometheusMetricsExporter as ay, makeRequestObservabilityContext as az, type ObservabilityOptions as b, unixNanoFromMs as b0, withBaggage as b1, withLogContext as b2, withSpan as b3, withTimeout as b4, type CardinalityLimiterOptions as c, type ExportPipeline as d, type ExportPipelineFlushOptions as e, type ExportPipelineFlushResult as f, type ExportPipelineOptions as g, type ExportPipelineStats as h, type ExportPipelineTuning as i, type ExportRetryOptions as j, type ExportSignal as k, type HealthCheckResult as l, type HealthHttpResponse as m, type HealthStatus as n, type HttpServerObservabilityLogOptions as o, type HttpServerObservabilityOptions as p, type HttpServerObservabilitySpanOptions as q, type HttpServerOutcome as r, OTLP_JSON_CONTENT_TYPE as s, type ObservabilityExporters as t, type ObservabilityFlushError as u, type ObservabilityFlushResult as v, type ObservabilityLogExportResult as w, type ObservabilityOtlpOptions as x, type ObservabilityRedactor as y, type ObservabilityRequestEnvInput as z };

package/dist/{stream-FQm9h4Mg.d.ts → stream-dvSs0QS5.d.ts}

@@ -1,4 +1,4 @@
-import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-CMOQKX8y.js';
+import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-CGNl5Rqp.js';
 
 type Empty<R, E, A> = {
     readonly _tag: "Empty";