@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/browser/BrowserClient.js

@@ -1,4 +1,5 @@
-import { sanitizeBrowserEventName, sanitizeBrowserFields } from "../RedactionPolicy.js";
+import { browserEnvelopeVersion, browserRequestByteBudget, maxEventIdLength, maxFieldValueLength, } from "./BrowserEventLimits.js";
+import { sanitizeClientEventName, sanitizeClientFields } from "./ClientPolicy.js";
 export class BrowserTelemetryClientDeliveryError extends Error {
     retryable;
     code = "OBS_BROWSER_EVENTS_DELIVERY_FAILED";
@@ -13,7 +14,7 @@ export class BrowserTelemetryClientShutdownError extends Error {
     code = "OBS_BROWSER_EVENTS_SHUTDOWN_TIMEOUT";
     retryable = true;
     constructor(timeoutMs) {
-        super(`Browser telemetry shutdown exceeded ${timeoutMs} milliseconds. The client aborted active delivery and retained its sanitized batch.`);
+        super(`Browser telemetry shutdown exceeded ${timeoutMs} milliseconds; pending sanitized events were dropped.`);
         this.timeoutMs = timeoutMs;
         this.name = "BrowserTelemetryClientShutdownError";
     }
@@ -25,8 +26,62 @@ const defaultFlushIntervalMs = 5_000;
 const defaultShutdownTimeoutMs = 2_000;
 const maxBatchSizeLimit = 64;
 const fallbackEventName = "browser.event";
+const browserFieldValueByteBudget = 2_048;
+const browserKeepaliveByteBudget = 64 * 1_024;
+const textEncoder = new TextEncoder();
+const boundedOperationalText = (value, fallback) => {
+    try {
+        return String(value ?? fallback).slice(0, maxFieldValueLength);
+    }
+    catch {
+        return fallback;
+    }
+};
+export const browserBatchByteLength = (batch) => textEncoder.encode(JSON.stringify(batch)).byteLength;
+const fitStringToByteBudget = (value) => {
+    if (textEncoder.encode(value).byteLength <= browserFieldValueByteBudget)
+        return value;
+    let output = "";
+    let bytes = 0;
+    for (const character of value) {
+        const characterBytes = textEncoder.encode(character).byteLength;
+        if (bytes + characterBytes > browserFieldValueByteBudget)
+            break;
+        output += character;
+        bytes += characterBytes;
+    }
+    return output;
+};
+const fitFieldValueToByteBudget = (value) => {
+    try {
+        return String(value) === value ? fitStringToByteBudget(value) : value;
+    }
+    catch {
+        return "[REDACTED]";
+    }
+};
+const fitEventToRequestBudget = (event) => {
+    const byteBoundedEvent = {
+        ...event,
+        fields: Object.fromEntries(Object.entries(event.fields).map(([key, value]) => [key, fitFieldValueToByteBudget(value)])),
+    };
+    if (browserBatchByteLength({ version: browserEnvelopeVersion, events: [byteBoundedEvent] }) <=
+        browserRequestByteBudget) {
+        return byteBoundedEvent;
+    }
+    const fields = {};
+    for (const [key, value] of Object.entries(byteBoundedEvent.fields)) {
+        const candidate = { ...fields, [key]: value };
+        if (browserBatchByteLength({
+            version: browserEnvelopeVersion,
+            events: [{ ...byteBoundedEvent, fields: candidate }],
+        }) <= browserRequestByteBudget) {
+            fields[key] = value;
+        }
+    }
+    return { ...byteBoundedEvent, fields };
+};
 export const normalizePositiveInteger = (value, fallback) => value === undefined || !Number.isSafeInteger(value) || value <= 0 ? fallback : value;
-const positiveInteger = normalizePositiveInteger;
 const fetchTransport = (endpoint) => async (batch, signal) => {
     let response;
     try {
@@ -34,20 +89,29 @@ const fetchTransport = (endpoint) => async (batch, signal) => {
             method: "POST",
             headers: { "content-type": "application/json" },
             body: JSON.stringify(batch),
-            keepalive: true,
+            keepalive: browserBatchByteLength(batch) <= browserKeepaliveByteBudget,
             signal,
         });
     }
     catch (cause) {
-        throw new BrowserTelemetryClientDeliveryError("The browser events could not be sent. The events stay queued and the next flush retries the same batch.", true, { cause });
+        throw new BrowserTelemetryClientDeliveryError("Browser delivery failed; sanitized events remain queued.", true, { cause });
     }
     if (!response.ok) {
-        throw new BrowserTelemetryClientDeliveryError(`The telemetry endpoint rejected the batch with status ${response.status}. Check the /_telemetry/events route of the project API.`, response.status === 429 || response.status >= 500, { cause: response.status });
+        throw new BrowserTelemetryClientDeliveryError(`Telemetry returned ${response.status}; verify /_telemetry/events.`, response.status === 429 || response.status >= 500, { cause: response.status });
     }
 };
+const randomHex = (length) => {
+    let value = "";
+    while (value.length < length)
+        value += crypto.randomUUID().replaceAll("-", "");
+    return value.slice(0, length);
+};
 export class BrowserClientEngine {
     options;
     events = [];
+    spans = [];
+    metricPoints = [];
+    activeSpans = new Map();
     activeFlush;
     activeDelivery;
     activeControllers = new Set();
@@ -63,21 +127,149 @@ export class BrowserClientEngine {
             }, options.flushIntervalMs);
         }
     }
-    emit(name, fields = {}) {
+    traces = {
+        startSpan: (name, fields = {}, parent) => {
+            const context = { traceId: parent?.traceId ?? randomHex(32), spanId: randomHex(16) };
+            const startedAt = Date.now();
+            const active = {
+                ...context,
+                name: sanitizeClientEventName(name) || fallbackEventName,
+                startedAt,
+                fields: this.sanitizeFields(fields),
+            };
+            if (parent !== undefined)
+                Object.assign(active, { parentSpanId: parent.spanId });
+            if (!this.options.disabled && !this.disposed)
+                this.activeSpans.set(context.spanId, active);
+            return {
+                context,
+                end: (endFields = {}) => {
+                    const current = this.activeSpans.get(context.spanId);
+                    if (current === undefined || this.options.disabled || this.disposed)
+                        return;
+                    this.activeSpans.delete(context.spanId);
+                    this.enqueueSpan({
+                        ...current,
+                        endedAt: Date.now(),
+                        fields: this.sanitizeFields({ ...current.fields, ...endFields }),
+                    });
+                },
+            };
+        },
+    };
+    metrics = {
+        counter: (name) => ({
+            add: (value = 1, fields = {}) => {
+                if (this.options.disabled ||
+                    this.disposed ||
+                    !this.options.metrics ||
+                    !Number.isFinite(value) ||
+                    value < 0) {
+                    return;
+                }
+                this.enqueueMetric({
+                    name: sanitizeClientEventName(name) || fallbackEventName,
+                    value,
+                    occurredAt: Date.now(),
+                    fields: this.sanitizeFields(fields),
+                });
+            },
+        }),
+    };
+    emit(name, fields = {}, trace) {
         if (this.options.disabled || this.disposed)
             return;
-        const sanitizedName = sanitizeBrowserEventName(name);
+        const sanitizedName = sanitizeClientEventName(name);
         const event = {
             id: crypto.randomUUID(),
             name: sanitizedName.length === 0 ? fallbackEventName : sanitizedName,
             occurredAt: Date.now(),
-            fields: sanitizeBrowserFields(fields),
+            fields: this.sanitizeFields(fields),
         };
-        if (this.events.length >= this.options.maxQueueSize) {
-            this.events.shift();
+        this.enqueue(trace === undefined ? event : { ...event, trace });
+    }
+    emitDefect(input) {
+        if (this.options.disabled || this.disposed)
+            return;
+        const sanitizedName = sanitizeClientEventName(input.name);
+        const id = input.id ?? crypto.randomUUID().replaceAll("-", "");
+        const operationalError = this.sanitizeFields({
+            "error.type": input.error.type,
+            "error.message": input.error.message,
+        });
+        const type = operationalError["error.type"];
+        const message = operationalError["error.message"];
+        this.enqueue({
+            id: id.slice(0, maxEventIdLength),
+            name: sanitizedName.length === 0 ? fallbackEventName : sanitizedName,
+            occurredAt: Date.now(),
+            fields: this.sanitizeFields(input.fields ?? {}),
+            error: {
+                type: boundedOperationalText(type, "Error"),
+                message: boundedOperationalText(message, ""),
+                retryable: input.error.retryable,
+            },
+        });
+    }
+    sanitizeFields(fields) {
+        if (this.options.policy === undefined)
+            return sanitizeClientFields(fields);
+        return this.options.policy(fields);
+    }
+    batchWithResource(batch) {
+        return this.options.resource === undefined
+            ? batch
+            : { ...batch, resource: this.options.resource };
+    }
+    deliveryBatch(events, spans, metrics) {
+        let batch = this.batchWithResource({ version: browserEnvelopeVersion, events });
+        if (spans.length > 0)
+            batch = { ...batch, spans };
+        if (metrics.length > 0)
+            batch = { ...batch, metrics };
+        return batch;
+    }
+    enqueue(event) {
+        const fitted = fitEventToRequestBudget(event);
+        if (browserBatchByteLength(this.batchWithResource({ version: browserEnvelopeVersion, events: [fitted] })) > browserRequestByteBudget) {
+            this.droppedEvents += 1;
+            return;
+        }
+        this.ensureQueueCapacity();
+        this.events.push(fitted);
+    }
+    enqueueSpan(span) {
+        const fitted = { ...span, fields: this.sanitizeFields(span.fields) };
+        if (browserBatchByteLength(this.batchWithResource({ version: browserEnvelopeVersion, events: [], spans: [fitted] })) > browserRequestByteBudget) {
+            this.droppedEvents += 1;
+            return;
+        }
+        this.ensureQueueCapacity();
+        this.spans.push(fitted);
+    }
+    enqueueMetric(metric) {
+        const fitted = { ...metric, fields: this.sanitizeFields(metric.fields) };
+        if (browserBatchByteLength(this.batchWithResource({
+            version: browserEnvelopeVersion,
+            events: [],
+            metrics: [fitted],
+        })) > browserRequestByteBudget) {
             this.droppedEvents += 1;
+            return;
         }
-        this.events.push(event);
+        this.ensureQueueCapacity();
+        this.metricPoints.push(fitted);
+    }
+    ensureQueueCapacity() {
+        if (this.pending() < this.options.maxQueueSize)
+            return;
+        if (this.events.length > 0)
+            this.events.shift();
+        else if (this.spans.length > 0)
+            this.spans.shift();
+        else
+            this.metricPoints.shift();
+        this.droppedEvents += 1;
     }
     flush() {
         if (this.options.disabled || this.disposed)
@@ -85,7 +277,9 @@ export class BrowserClientEngine {
         return this.flushQueued();
     }
     pending() {
-        return this.options.disabled ? 0 : this.events.length;
+        return this.options.disabled
+            ? 0
+            : this.events.length + this.spans.length + this.metricPoints.length;
     }
     dropped() {
         return this.droppedEvents;
@@ -93,12 +287,25 @@ export class BrowserClientEngine {
     dispose() {
         if (this.disposal !== undefined)
             return this.disposal;
+        for (const span of this.activeSpans.values()) {
+            this.enqueueSpan({
+                ...span,
+                endedAt: Date.now(),
+                fields: this.sanitizeFields({ ...span.fields, "span.forced_end": true }),
+            });
+        }
+        this.activeSpans.clear();
         this.disposed = true;
         if (this.timer !== undefined) {
             clearInterval(this.timer);
             this.timer = undefined;
         }
-        this.disposal = this.options.disabled ? Promise.resolve() : this.shutdown();
+        this.disposal = this.options.disabled
+            ? Promise.resolve()
+            : this.shutdown().catch((cause) => {
+                this.dropPending();
+                throw cause;
+            });
         return this.disposal;
     }
     async shutdown() {
@@ -122,6 +329,8 @@ export class BrowserClientEngine {
                 }
             }
             await Promise.race([this.flushQueued(true), deadline]);
+            if (this.pending() > 0)
+                this.dropPending();
         }
         finally {
             if (deadlineTimer !== undefined)
@@ -132,34 +341,116 @@ export class BrowserClientEngine {
         if (this.activeDelivery === undefined || this.activeDelivery.abandoned)
             return;
         this.activeDelivery.abandoned = true;
-        const requeued = [...this.activeDelivery.events, ...this.events];
-        this.events = requeued.slice(0, this.options.maxQueueSize);
-        this.droppedEvents += Math.max(0, requeued.length - this.options.maxQueueSize);
+        this.events = [...this.activeDelivery.batch.events, ...this.events];
+        this.spans = [...(this.activeDelivery.batch.spans ?? []), ...this.spans];
+        this.metricPoints = [...(this.activeDelivery.batch.metrics ?? []), ...this.metricPoints];
         this.activeDelivery = undefined;
         this.activeControllers.clear();
         this.activeFlush = undefined;
     }
+    dropPending() {
+        this.droppedEvents += this.pending();
+        this.events.length = 0;
+        this.spans.length = 0;
+        this.metricPoints.length = 0;
+    }
     flushQueued(allowDisposed = false) {
         if (this.activeFlush !== undefined)
             return this.activeFlush;
         const run = async () => {
-            while (this.events.length > 0 && (!this.disposed || allowDisposed)) {
-                const batchEvents = this.events.splice(0, this.options.maxBatchSize);
-                const delivery = { events: batchEvents, abandoned: false };
+            while (this.pending() > 0 && (!this.disposed || allowDisposed)) {
+                const batchEvents = [];
+                const batchSpans = [];
+                const batchMetrics = [];
+                const candidateBatch = () => this.deliveryBatch(batchEvents, batchSpans, batchMetrics);
+                const activeTraceIds = new Set(Array.from(this.activeSpans.values(), (span) => span.traceId));
+                const queuedTraceIds = new Set(this.spans.map((span) => span.traceId));
+                const staleCorrelatedEvents = this.events.filter((event) => event.trace !== undefined &&
+                    !queuedTraceIds.has(event.trace.traceId) &&
+                    !activeTraceIds.has(event.trace.traceId));
+                if (staleCorrelatedEvents.length > 0) {
+                    const staleIds = new Set(staleCorrelatedEvents.map((event) => event.id));
+                    this.events = this.events.filter((event) => !staleIds.has(event.id));
+                    this.droppedEvents += staleCorrelatedEvents.length;
+                }
+                const readySpan = this.spans.find((span) => !activeTraceIds.has(span.traceId));
+                if (readySpan !== undefined) {
+                    const traceId = readySpan.traceId;
+                    const traceSpans = this.spans.filter((span) => span.traceId === traceId);
+                    const traceEvents = this.events.filter((event) => event.trace?.traceId === traceId);
+                    batchSpans.push(...traceSpans);
+                    batchEvents.push(...traceEvents);
+                    if (batchSpans.length > maxBatchSizeLimit ||
+                        batchEvents.length > maxBatchSizeLimit ||
+                        browserBatchByteLength(candidateBatch()) > browserRequestByteBudget) {
+                        this.spans = this.spans.filter((span) => span.traceId !== traceId);
+                        this.events = this.events.filter((event) => event.trace?.traceId !== traceId);
+                        this.droppedEvents += traceSpans.length + traceEvents.length;
+                        continue;
+                    }
+                    this.spans = this.spans.filter((span) => span.traceId !== traceId);
+                    this.events = this.events.filter((event) => event.trace?.traceId !== traceId);
+                }
+                for (const event of this.events) {
+                    if (event.trace !== undefined)
+                        continue;
+                    if (batchEvents.length + batchSpans.length >= this.options.maxBatchSize)
+                        break;
+                    batchEvents.push(event);
+                    if (browserBatchByteLength(candidateBatch()) > browserRequestByteBudget) {
+                        batchEvents.pop();
+                        break;
+                    }
+                }
+                if (batchEvents.length > 0) {
+                    const selectedEventIds = new Set(batchEvents.map((event) => event.id));
+                    this.events = this.events.filter((event) => !selectedEventIds.has(event.id));
+                }
+                while (batchEvents.length + batchSpans.length + batchMetrics.length <
+                    this.options.maxBatchSize &&
+                    this.metricPoints.length > 0) {
+                    const metric = this.metricPoints[0];
+                    if (metric === undefined)
+                        break;
+                    batchMetrics.push(metric);
+                    if (browserBatchByteLength(candidateBatch()) > browserRequestByteBudget) {
+                        batchMetrics.pop();
+                        break;
+                    }
+                    this.metricPoints.shift();
+                }
+                if (batchEvents.length === 0 && batchSpans.length === 0 && batchMetrics.length === 0)
+                    return;
+                const batch = candidateBatch();
+                const delivery = { batch, abandoned: false };
                 const controller = new AbortController();
                 this.activeDelivery = delivery;
                 this.activeControllers.add(controller);
                 try {
-                    await this.options.transport({ version: 1, events: batchEvents }, controller.signal);
+                    await this.options.transport(batch, controller.signal);
                     if (delivery.abandoned)
                         return;
                 }
                 catch (cause) {
                     if (delivery.abandoned)
                         return;
-                    const requeued = [...batchEvents, ...this.events];
-                    this.events = requeued.slice(0, this.options.maxQueueSize);
-                    this.droppedEvents += Math.max(0, requeued.length - this.options.maxQueueSize);
+                    if (cause instanceof BrowserTelemetryClientDeliveryError && !cause.retryable) {
+                        this.droppedEvents += batchEvents.length + batchSpans.length + batchMetrics.length;
+                    }
+                    else {
+                        this.events = [...batchEvents, ...this.events];
+                        this.spans = [...batchSpans, ...this.spans];
+                        this.metricPoints = [...batchMetrics, ...this.metricPoints];
+                        while (this.pending() > this.options.maxQueueSize) {
+                            if (this.metricPoints.length > 0)
+                                this.metricPoints.pop();
+                            else if (this.spans.length > 0)
+                                this.spans.pop();
+                            else
+                                this.events.pop();
+                            this.droppedEvents += 1;
+                        }
+                    }
                     throw cause;
                 }
                 finally {
@@ -176,14 +467,17 @@ export class BrowserClientEngine {
     }
 }
 export const createBrowserTelemetryClient = (config = {}) => {
-    const maxBatchSize = Math.min(positiveInteger(config.maxBatchSize, defaultMaxBatchSize), maxBatchSizeLimit);
+    const maxBatchSize = Math.min(normalizePositiveInteger(config.maxBatchSize, defaultMaxBatchSize), maxBatchSizeLimit);
     return new BrowserClientEngine({
         disabled: config.disabled ?? false,
         maxBatchSize,
-        maxQueueSize: positiveInteger(config.maxQueueSize, defaultMaxQueueSize),
-        flushIntervalMs: positiveInteger(config.flushIntervalMs, defaultFlushIntervalMs),
-        shutdownTimeoutMs: positiveInteger(config.shutdownTimeoutMs, defaultShutdownTimeoutMs),
+        maxQueueSize: normalizePositiveInteger(config.maxQueueSize, defaultMaxQueueSize),
+        flushIntervalMs: normalizePositiveInteger(config.flushIntervalMs, defaultFlushIntervalMs),
+        shutdownTimeoutMs: normalizePositiveInteger(config.shutdownTimeoutMs, defaultShutdownTimeoutMs),
+        metrics: config.metrics ?? false,
+        resource: config.resource,
         transport: config.transport ?? fetchTransport(config.endpoint ?? defaultEndpoint),
+        policy: config.policy,
         startTimer: true,
     });
 };

package/dist/browser/BrowserEventLimits.d.ts

@@ -0,0 +1,8 @@
+export declare const browserEnvelopeVersion = 2;
+export declare const browserRequestByteBudget = 90000;
+export declare const maxEventsPerBatch = 64;
+export declare const maxFieldsPerEvent = 32;
+export declare const maxFieldKeyLength = 128;
+export declare const maxFieldValueLength = 1024;
+export declare const maxEventNameLength = 128;
+export declare const maxEventIdLength = 64;

package/dist/browser/BrowserEventLimits.js

@@ -0,0 +1,8 @@
+export const browserEnvelopeVersion = 2;
+export const browserRequestByteBudget = 90_000;
+export const maxEventsPerBatch = 64;
+export const maxFieldsPerEvent = 32;
+export const maxFieldKeyLength = 128;
+export const maxFieldValueLength = 1024;
+export const maxEventNameLength = 128;
+export const maxEventIdLength = 64;

package/dist/browser/BrowserMetricRecorder.d.ts

@@ -0,0 +1,17 @@
+import { Context, Layer } from "effect";
+import type { BrowserMetricPoint } from "../BrowserEvents.js";
+import { LayerMetricsRuntime } from "../MetricsRuntime.js";
+import type { ContractRegistry } from "../profile/ObservabilityAdapter.js";
+export type BrowserMetricBatchAdmission = {
+    readonly commit: () => void;
+};
+declare const BrowserMetricRecorder_base: Context.ServiceClass<BrowserMetricRecorder, "@equipe-tech/observability/node/BrowserMetricRecorder", {
+    readonly admit: (metrics: ReadonlyArray<BrowserMetricPoint>) => BrowserMetricBatchAdmission;
+}>;
+export declare class BrowserMetricRecorder extends BrowserMetricRecorder_base {
+}
+export declare const unavailableBrowserMetricRecorder: {
+    readonly admit: (metrics: ReadonlyArray<BrowserMetricPoint>) => BrowserMetricBatchAdmission;
+};
+export declare const layerBrowserMetricRecorder: (contract: ContractRegistry | undefined) => Layer.Layer<BrowserMetricRecorder, never, LayerMetricsRuntime>;
+export {};

package/dist/browser/BrowserMetricRecorder.js

@@ -0,0 +1,35 @@
+import { Context, Effect, Layer } from "effect";
+import { InvalidMetricMeasurement } from "../contract/MetricContractError.js";
+import { prepareContractCounterBatchByName } from "../contract/MetricProducer.js";
+import { LayerMetricsRuntime, releaseMetricsLease } from "../MetricsRuntime.js";
+export class BrowserMetricRecorder extends Context.Service()("@equipe-tech/observability/node/BrowserMetricRecorder") {
+}
+export const unavailableBrowserMetricRecorder = BrowserMetricRecorder.of({
+    admit: () => {
+        throw new InvalidMetricMeasurement({
+            code: "OBS_METRIC_UNKNOWN_ALIAS",
+            operation: "counter",
+            message: "Browser metric admission requires a compiled telemetry contract. Configure the owning contract before sending metrics.",
+            metricAlias: "browser",
+        });
+    },
+});
+export const layerBrowserMetricRecorder = (contract) => {
+    if (contract === undefined)
+        return Layer.succeed(BrowserMetricRecorder, unavailableBrowserMetricRecorder);
+    return Layer.effect(BrowserMetricRecorder, Effect.acquireRelease(Effect.map(LayerMetricsRuntime, (runtime) => {
+        const metrics = runtime.acquireMetrics();
+        return {
+            service: BrowserMetricRecorder.of({
+                admit: (points) => ({
+                    commit: prepareContractCounterBatchByName(contract, metrics, points.map((point) => ({
+                        name: point.name,
+                        value: point.value,
+                        attributes: point.fields,
+                    }))),
+                }),
+            }),
+            metrics,
+        };
+    }), ({ metrics }) => Effect.promise(() => releaseMetricsLease(metrics)).pipe(Effect.asVoid)).pipe(Effect.map(({ service }) => service)));
+};

package/dist/browser/BrowserTelemetry.d.ts

@@ -0,0 +1,40 @@
+import { Cause, Context, Duration, Effect, Layer, Schema } from "effect";
+import { BrowserEventBatch } from "../BrowserEvents.js";
+import type { EventAttributes } from "../contract/TelemetryEvent.js";
+import { type DataPolicyInput } from "../policy/DataPolicy.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientError, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientMetric, BrowserTelemetryClientResource, BrowserTelemetryClientSpan, BrowserTelemetryDefectInput, BrowserCounter, BrowserTraceContext, BrowserTraceHandle, BrowserTelemetryFieldTransform, BrowserTelemetryClientTransport, } from "./BrowserClient.js";
+export { BrowserEvent, BrowserEventBatch, BrowserEventError, BrowserMetricPoint, BrowserResourceIdentity, BrowserTraceContext as BrowserTraceContextSchema, BrowserTraceSpan, browserRequestByteBudget, maxEventNameLength, maxEventsPerBatch, maxBrowserEventOccurredAt, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+export declare const defaultEventsEndpoint = "/_telemetry/events";
+declare const BrowserEventDeliveryError_base: Schema.Class<BrowserEventDeliveryError, Schema.TaggedStruct<"BrowserEventDeliveryError", {
+    readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_DELIVERY_FAILED">;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly cause: Schema.Defect;
+}>, Cause.YieldableError>;
+export declare class BrowserEventDeliveryError extends BrowserEventDeliveryError_base {
+}
+declare const BrowserEventTransport_base: Context.ServiceClass<BrowserEventTransport, "@equipe-tech/observability/BrowserEventTransport", {
+    send(batch: BrowserEventBatch): Effect.Effect<void, BrowserEventDeliveryError>;
+}>;
+export declare class BrowserEventTransport extends BrowserEventTransport_base {
+    static readonly layerFetch: (options?: {
+        readonly endpoint?: string;
+    }) => Layer.Layer<BrowserEventTransport>;
+}
+export type BrowserTelemetryOptions = {
+    readonly maxBatchSize?: number;
+    readonly maxQueueSize?: number;
+    readonly flushInterval?: Duration.Input;
+    readonly metrics?: boolean;
+    readonly policy?: DataPolicyInput;
+};
+declare const BrowserTelemetry_base: Context.ServiceClass<BrowserTelemetry, "@equipe-tech/observability/BrowserTelemetry", {
+    emit(name: string, fields?: EventAttributes): Effect.Effect<void>;
+    flush(): Effect.Effect<void, BrowserEventDeliveryError>;
+    pending(): Effect.Effect<number>;
+    dropped(): Effect.Effect<number>;
+}>;
+export declare class BrowserTelemetry extends BrowserTelemetry_base {
+    static readonly layer: (options?: BrowserTelemetryOptions) => Layer.Layer<BrowserTelemetry, never, BrowserEventTransport>;
+}