@equipe-tech/observability 0.1.0 → 0.2.1

package/dist/RedactionPolicy.d.ts

@@ -0,0 +1,9 @@
+import { type BrowserEventFields } from "./BrowserEvents.js";
+import type { WideEventFields } from "./WideEvent.js";
+export declare const sensitiveFieldReplacement = "****";
+export declare const sensitiveTextReplacement = "[REDACTED]";
+export declare const collectorBlockedKeyPattern: string;
+export declare const collectorBlockedValuePatterns: string[];
+export declare const isSensitiveFieldKey: (key: string) => boolean;
+export declare const sanitizeBrowserFields: (fields: WideEventFields) => BrowserEventFields;
+export declare const sanitizeBrowserEventName: (name: string) => string;

package/dist/RedactionPolicy.js

@@ -0,0 +1,246 @@
+import { Option, Predicate, Schema } from "effect";
+import { maxEventNameLength, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "./BrowserEvents.js";
+export const sensitiveFieldReplacement = "****";
+export const sensitiveTextReplacement = "[REDACTED]";
+const sensitiveTermSources = [
+    "authorization",
+    "proxy[._-]?authorization",
+    "cookie",
+    "set[._-]?cookie",
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "api[._-]?key",
+    "apikey",
+    "access[._-]?key",
+    "client[._-]?secret",
+    "private[._-]?key",
+    "email",
+    "phone",
+    "cpf",
+    "cnpj",
+    "document",
+];
+export const collectorBlockedKeyPattern = `(?i:${sensitiveTermSources.join("|")})(?:[._-]|[A-Z0-9]|$)`;
+export const collectorBlockedValuePatterns = [
+    "(?i)Bearer[[:space:]]+[A-Za-z0-9._~+/=-]+",
+    "(?:sk|rk)[_-][A-Za-z0-9_*.-]{3,}",
+    "eyJ[A-Za-z0-9_-]+[.]eyJ[A-Za-z0-9_-]+[.][A-Za-z0-9_-]+",
+    "(?i)[A-Z0-9._%+-]+@[A-Z0-9.-]+[.][A-Z]{2,}",
+    "(?s)-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----.*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----",
+];
+const maxOriginalFieldKeyLength = 2_048;
+const maxOriginalStringLength = 16_384;
+const maxJsonDepth = 32;
+const maxJsonValues = 1_024;
+const SensitiveScalar = Schema.Union([
+    Schema.String,
+    Schema.Number.check(Schema.isFinite()),
+    Schema.Boolean,
+]);
+const decodeSensitiveScalar = Schema.decodeUnknownOption(SensitiveScalar);
+const decodeJsonText = Schema.decodeOption(Schema.fromJsonString(Schema.Json));
+const decodeJsonObject = Schema.decodeUnknownOption(Schema.JsonObject);
+const asciiCaseInsensitive = (source) => source.replace(/[A-Za-z]/g, (letter) => `[${letter.toLowerCase()}${letter.toUpperCase()}]`);
+const sensitiveTerms = sensitiveTermSources.map(asciiCaseInsensitive).join("|");
+const sensitiveKeyPattern = new RegExp(`(?:${sensitiveTerms})(?=[._-]|[A-Z0-9]|$)`);
+const sensitiveTextTermPattern = new RegExp(`(?:${sensitiveTerms})(?=[._-]|[A-Z0-9]|[^A-Za-z0-9._-]|$)`);
+const coreValuePatterns = [
+    /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+    /(?:sk|rk)[_-][A-Za-z0-9_*.-]{3,}/g,
+    /eyJ[A-Za-z0-9_-]+[.]eyJ[A-Za-z0-9_-]+[.][A-Za-z0-9_-]+/g,
+    /[A-Z0-9._%+-]+@[A-Z0-9.-]+[.][A-Z]{2,}/gi,
+    /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
+];
+const structuredAssignmentPattern = /([A-Za-z0-9_.-]+)(\s*[=:]\s*)(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^,;\s]+))/g;
+export const isSensitiveFieldKey = (key) => sensitiveKeyPattern.test(key);
+const replaceCoreValues = (value) => {
+    let sanitized = value;
+    for (const pattern of coreValuePatterns) {
+        pattern.lastIndex = 0;
+        sanitized = sanitized.replace(pattern, sensitiveTextReplacement);
+    }
+    return sanitized;
+};
+const containsCoreValue = (value) => {
+    for (const pattern of coreValuePatterns) {
+        pattern.lastIndex = 0;
+        if (pattern.test(value)) {
+            pattern.lastIndex = 0;
+            return true;
+        }
+    }
+    return false;
+};
+const replaceStructuredAssignments = (value) => {
+    structuredAssignmentPattern.lastIndex = 0;
+    let sanitized = "";
+    let offset = 0;
+    for (const match of value.matchAll(structuredAssignmentPattern)) {
+        const index = match.index;
+        const full = match[0];
+        const key = match[1];
+        const separator = match[2];
+        if (!Predicate.isNumber(index) || !Predicate.isString(full) || !Predicate.isString(key)) {
+            continue;
+        }
+        sanitized += value.slice(offset, index);
+        if (!isSensitiveFieldKey(key) || !Predicate.isString(separator)) {
+            sanitized += full;
+            offset = index + full.length;
+            continue;
+        }
+        if (Predicate.isString(match[3])) {
+            sanitized += `${key}${separator}"${sensitiveTextReplacement}"`;
+        }
+        else if (Predicate.isString(match[4])) {
+            sanitized += `${key}${separator}'${sensitiveTextReplacement}'`;
+        }
+        else {
+            sanitized += `${key}${separator}${sensitiveTextReplacement}`;
+        }
+        offset = index + full.length;
+    }
+    return sanitized + value.slice(offset);
+};
+const containsStructuredAssignment = (value) => replaceStructuredAssignments(value) !== value;
+const sanitizeJson = (source) => {
+    const root = { value: null };
+    const stack = [
+        {
+            source,
+            depth: 0,
+            sensitive: false,
+            assign: (value) => {
+                root.value = value;
+            },
+        },
+    ];
+    let visited = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!Predicate.isNotUndefined(current)) {
+            continue;
+        }
+        visited += 1;
+        if (visited > maxJsonValues || current.depth > maxJsonDepth) {
+            return Option.none();
+        }
+        if (current.sensitive) {
+            current.assign(sensitiveTextReplacement);
+            continue;
+        }
+        if (current.source === null ||
+            Predicate.isNumber(current.source) ||
+            Predicate.isBoolean(current.source)) {
+            current.assign(current.source);
+            continue;
+        }
+        if (Predicate.isString(current.source)) {
+            current.assign(replaceCoreValues(replaceStructuredAssignments(current.source)));
+            continue;
+        }
+        if (Array.isArray(current.source)) {
+            const output = current.source.map(() => null);
+            current.assign(output);
+            for (let index = current.source.length - 1; index >= 0; index -= 1) {
+                const child = current.source[index];
+                if (!Predicate.isNotUndefined(child)) {
+                    continue;
+                }
+                stack.push({
+                    source: child,
+                    depth: current.depth + 1,
+                    sensitive: false,
+                    assign: (value) => {
+                        output[index] = value;
+                    },
+                });
+            }
+            continue;
+        }
+        const sourceObject = decodeJsonObject(current.source);
+        if (Option.isNone(sourceObject)) {
+            return Option.none();
+        }
+        const output = Object.create(null);
+        const outputKeys = new Set();
+        current.assign(output);
+        const keys = Object.keys(sourceObject.value);
+        for (const key of keys) {
+            if (key.length > maxOriginalFieldKeyLength ||
+                containsCoreValue(key) ||
+                containsStructuredAssignment(key)) {
+                continue;
+            }
+            output[key] = null;
+            outputKeys.add(key);
+        }
+        for (let index = keys.length - 1; index >= 0; index -= 1) {
+            const key = keys[index];
+            if (!Predicate.isString(key) || !outputKeys.has(key)) {
+                continue;
+            }
+            const child = sourceObject.value[key];
+            if (!Predicate.isNotUndefined(child)) {
+                continue;
+            }
+            stack.push({
+                source: child,
+                depth: current.depth + 1,
+                sensitive: isSensitiveFieldKey(key),
+                assign: (value) => {
+                    output[key] = value;
+                },
+            });
+        }
+    }
+    return Option.some(JSON.stringify(root.value));
+};
+const sanitizeString = (value, outputLimit) => {
+    if (value.length > maxOriginalStringLength) {
+        return sensitiveTextReplacement;
+    }
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        const parsed = decodeJsonText(value);
+        if (Option.isSome(parsed)) {
+            const sanitizedJson = Option.getOrElse(sanitizeJson(parsed.value), () => sensitiveTextReplacement);
+            return sanitizedJson.length <= outputLimit ? sanitizedJson : sensitiveTextReplacement;
+        }
+        if (sensitiveTextTermPattern.test(value)) {
+            return sensitiveTextReplacement;
+        }
+    }
+    return replaceCoreValues(replaceStructuredAssignments(value));
+};
+const shouldDropKey = (key) => key.length > maxOriginalFieldKeyLength ||
+    containsCoreValue(key) ||
+    containsStructuredAssignment(key);
+export const sanitizeBrowserFields = (fields) => {
+    const sanitized = [];
+    const boundedKeys = new Set();
+    for (const [key, runtimeValue] of Object.entries(fields)) {
+        const decoded = decodeSensitiveScalar(runtimeValue);
+        if (Option.isNone(decoded) || key === "" || shouldDropKey(key)) {
+            continue;
+        }
+        const boundedKey = key.slice(0, maxFieldKeyLength);
+        if (boundedKeys.has(boundedKey)) {
+            continue;
+        }
+        const value = isSensitiveFieldKey(key)
+            ? sensitiveFieldReplacement
+            : Predicate.isString(decoded.value)
+                ? sanitizeString(decoded.value, maxFieldValueLength).slice(0, maxFieldValueLength)
+                : decoded.value;
+        sanitized.push([boundedKey, value]);
+        boundedKeys.add(boundedKey);
+        if (boundedKeys.size >= maxFieldsPerEvent) {
+            break;
+        }
+    }
+    return Object.fromEntries(sanitized);
+};
+export const sanitizeBrowserEventName = (name) => sanitizeString(name, maxEventNameLength).slice(0, maxEventNameLength);

package/dist/Telemetry.d.ts

@@ -1,7 +1,11 @@
-import { Layer } from "effect";
+import { Duration, Layer } from "effect";
 import { type HttpClient } from "effect/unstable/http";
+import { OtlpExporter } from "effect/unstable/observability";
 import type { EnvironmentVariables, InvalidTelemetryEnvironment } from "./TelemetryConfig.js";
 import { type TelemetryConfig } from "./TelemetryConfig.js";
-export declare const layerOtlp: (config: TelemetryConfig) => Layer.Layer<never, never, HttpClient.HttpClient>;
-export declare const layer: (config: TelemetryConfig) => Layer.Layer<never>;
-export declare const layerFromEnv: (env: EnvironmentVariables) => Layer.Layer<never, InvalidTelemetryEnvironment>;
+export type OtlpLayerOptions = {
+    readonly shutdownTimeout?: Duration.Input | undefined;
+};
+export declare const layerOtlp: (config: TelemetryConfig, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient>;
+export declare const layer: (config: TelemetryConfig, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
+export declare const layerFromEnv: (env: EnvironmentVariables, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher, InvalidTelemetryEnvironment>;

package/dist/Telemetry.js

@@ -1,16 +1,31 @@
-import { Effect, Layer } from "effect";
-import { FetchHttpClient } from "effect/unstable/http";
-import { Otlp } from "effect/unstable/observability";
+import { Duration, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpClientRequest } from "effect/unstable/http";
+import { OtlpLogger, OtlpSerialization } from "effect/unstable/observability";
 import { telemetryConfigFromEnv } from "./TelemetryConfig.js";
-export const layerOtlp = (config) => Otlp.layerJson({
-    baseUrl: config.otlpEndpoint.toString(),
-    resource: {
+import { layerMetricsRuntime } from "./MetricsRuntime.js";
+import { layerHttpServerOtlpTracer } from "./nestjs/HttpServerOtlpTracer.js";
+export const layerOtlp = (config, options = {}) => {
+    const base = HttpClientRequest.get(config.otlpEndpoint.toString());
+    const url = (path) => HttpClientRequest.appendUrl(base, path).url;
+    const resource = {
         serviceName: config.serviceName,
         serviceVersion: config.serviceVersion,
         attributes: {
             "deployment.environment.name": config.environment,
         },
-    },
-});
-export const layer = (config) => layerOtlp(config).pipe(Layer.provide(FetchHttpClient.layer));
-export const layerFromEnv = (env) => Layer.unwrap(Effect.map(telemetryConfigFromEnv(env), layer));
+    };
+    const metrics = layerMetricsRuntime(config, {
+        shutdownTimeoutMilliseconds: Duration.toMillis(options.shutdownTimeout ?? "3 seconds"),
+    });
+    return Layer.mergeAll(OtlpLogger.layer({
+        url: url("/v1/logs"),
+        resource,
+        shutdownTimeout: options.shutdownTimeout,
+    }), metrics, layerHttpServerOtlpTracer({
+        url: url("/v1/traces"),
+        resource,
+        shutdownTimeout: options.shutdownTimeout,
+    })).pipe(Layer.provide(OtlpSerialization.layerJson));
+};
+export const layer = (config, options = {}) => layerOtlp(config, options).pipe(Layer.provide(FetchHttpClient.layer));
+export const layerFromEnv = (env, options = {}) => Layer.unwrap(Effect.map(telemetryConfigFromEnv(env), (config) => layer(config, options)));

package/dist/TelemetryConfig.d.ts

@@ -1,4 +1,5 @@
 import { Effect, Schema } from "effect";
+export declare const OtlpEndpoint: Schema.URLFromString;
 declare const TelemetryConfig_base: Schema.Class<TelemetryConfig, Schema.Struct<{
     readonly serviceName: Schema.NonEmptyString;
     readonly serviceVersion: Schema.NonEmptyString;

package/dist/TelemetryConfig.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-const OtlpEndpoint = Schema.URLFromString.check(Schema.makeFilter((url) => (url.protocol === "http:" || url.protocol === "https:") &&
+export const OtlpEndpoint = Schema.URLFromString.check(Schema.makeFilter((url) => (url.protocol === "http:" || url.protocol === "https:") &&
     url.username === "" &&
     url.password === "", { expected: "an HTTP or HTTPS URL without credentials" }));
 export class TelemetryConfig extends Schema.Class("@equipe-tech/observability/TelemetryConfig")({

package/dist/browser/BrowserClient.d.ts

@@ -0,0 +1,74 @@
+export type BrowserTelemetryClientFields = {
+    readonly [field: string]: string | number | boolean;
+};
+export type BrowserTelemetryClientEvent = {
+    readonly id: string;
+    readonly name: string;
+    readonly occurredAt: number;
+    readonly fields: BrowserTelemetryClientFields;
+};
+export type BrowserTelemetryClientBatch = {
+    readonly version: 1;
+    readonly events: ReadonlyArray<BrowserTelemetryClientEvent>;
+};
+export type BrowserTelemetryClientTransport = (batch: BrowserTelemetryClientBatch, signal: AbortSignal) => Promise<void>;
+export type BrowserTelemetryClientConfig = {
+    readonly disabled?: boolean;
+    readonly endpoint?: string;
+    readonly maxBatchSize?: number;
+    readonly maxQueueSize?: number;
+    readonly flushIntervalMs?: number;
+    readonly shutdownTimeoutMs?: number;
+    readonly transport?: BrowserTelemetryClientTransport;
+};
+export type BrowserTelemetryClient = {
+    emit(name: string, fields?: BrowserTelemetryClientFields): void;
+    flush(): Promise<void>;
+    pending(): number;
+    dispose(): Promise<void>;
+};
+export declare class BrowserTelemetryClientDeliveryError extends Error {
+    readonly retryable: boolean;
+    readonly code = "OBS_BROWSER_EVENTS_DELIVERY_FAILED";
+    constructor(message: string, retryable: boolean, options: {
+        readonly cause: unknown;
+    });
+}
+export declare class BrowserTelemetryClientShutdownError extends Error {
+    readonly timeoutMs: number;
+    readonly code = "OBS_BROWSER_EVENTS_SHUTDOWN_TIMEOUT";
+    readonly retryable = true;
+    constructor(timeoutMs: number);
+}
+export declare const normalizePositiveInteger: (value: number | undefined, fallback: number) => number;
+type BrowserClientEngineOptions = {
+    readonly disabled: boolean;
+    readonly maxBatchSize: number;
+    readonly maxQueueSize: number;
+    readonly flushIntervalMs: number;
+    readonly shutdownTimeoutMs: number;
+    readonly transport: BrowserTelemetryClientTransport;
+    readonly startTimer: boolean;
+};
+export declare class BrowserClientEngine implements BrowserTelemetryClient {
+    private readonly options;
+    private events;
+    private activeFlush;
+    private activeDelivery;
+    private readonly activeControllers;
+    private disposal;
+    private disposed;
+    private timer;
+    private droppedEvents;
+    constructor(options: BrowserClientEngineOptions);
+    emit(name: string, fields?: BrowserTelemetryClientFields): void;
+    flush(): Promise<void>;
+    pending(): number;
+    dropped(): number;
+    dispose(): Promise<void>;
+    private shutdown;
+    private abandonActiveDelivery;
+    private flushQueued;
+}
+export declare const createBrowserTelemetryClient: (config?: BrowserTelemetryClientConfig) => BrowserTelemetryClient;
+export {};

package/dist/browser/BrowserClient.js

@@ -0,0 +1,189 @@
+import { sanitizeBrowserEventName, sanitizeBrowserFields } from "../RedactionPolicy.js";
+export class BrowserTelemetryClientDeliveryError extends Error {
+    retryable;
+    code = "OBS_BROWSER_EVENTS_DELIVERY_FAILED";
+    constructor(message, retryable, options) {
+        super(message, options);
+        this.retryable = retryable;
+        this.name = "BrowserTelemetryClientDeliveryError";
+    }
+}
+export class BrowserTelemetryClientShutdownError extends Error {
+    timeoutMs;
+    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.`);
+        this.timeoutMs = timeoutMs;
+        this.name = "BrowserTelemetryClientShutdownError";
+    }
+}
+const defaultEndpoint = "/_telemetry/events";
+const defaultMaxBatchSize = 32;
+const defaultMaxQueueSize = 256;
+const defaultFlushIntervalMs = 5_000;
+const defaultShutdownTimeoutMs = 2_000;
+const maxBatchSizeLimit = 64;
+const fallbackEventName = "browser.event";
+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 {
+        response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(batch),
+            keepalive: true,
+            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 });
+    }
+    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 });
+    }
+};
+export class BrowserClientEngine {
+    options;
+    events = [];
+    activeFlush;
+    activeDelivery;
+    activeControllers = new Set();
+    disposal;
+    disposed = false;
+    timer;
+    droppedEvents = 0;
+    constructor(options) {
+        this.options = options;
+        if (!options.disabled && options.startTimer) {
+            this.timer = setInterval(() => {
+                this.flush().catch(() => undefined);
+            }, options.flushIntervalMs);
+        }
+    }
+    emit(name, fields = {}) {
+        if (this.options.disabled || this.disposed)
+            return;
+        const sanitizedName = sanitizeBrowserEventName(name);
+        const event = {
+            id: crypto.randomUUID(),
+            name: sanitizedName.length === 0 ? fallbackEventName : sanitizedName,
+            occurredAt: Date.now(),
+            fields: sanitizeBrowserFields(fields),
+        };
+        if (this.events.length >= this.options.maxQueueSize) {
+            this.events.shift();
+            this.droppedEvents += 1;
+        }
+        this.events.push(event);
+    }
+    flush() {
+        if (this.options.disabled || this.disposed)
+            return Promise.resolve();
+        return this.flushQueued();
+    }
+    pending() {
+        return this.options.disabled ? 0 : this.events.length;
+    }
+    dropped() {
+        return this.droppedEvents;
+    }
+    dispose() {
+        if (this.disposal !== undefined)
+            return this.disposal;
+        this.disposed = true;
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        this.disposal = this.options.disabled ? Promise.resolve() : this.shutdown();
+        return this.disposal;
+    }
+    async shutdown() {
+        let deadlineTimer;
+        const deadline = new Promise((_, reject) => {
+            deadlineTimer = setTimeout(() => {
+                for (const controller of this.activeControllers)
+                    controller.abort();
+                this.abandonActiveDelivery();
+                reject(new BrowserTelemetryClientShutdownError(this.options.shutdownTimeoutMs));
+            }, this.options.shutdownTimeoutMs);
+        });
+        try {
+            if (this.activeFlush !== undefined) {
+                try {
+                    await Promise.race([this.activeFlush, deadline]);
+                }
+                catch (cause) {
+                    if (cause instanceof BrowserTelemetryClientShutdownError)
+                        throw cause;
+                }
+            }
+            await Promise.race([this.flushQueued(true), deadline]);
+        }
+        finally {
+            if (deadlineTimer !== undefined)
+                clearTimeout(deadlineTimer);
+        }
+    }
+    abandonActiveDelivery() {
+        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.activeDelivery = undefined;
+        this.activeControllers.clear();
+        this.activeFlush = undefined;
+    }
+    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 };
+                const controller = new AbortController();
+                this.activeDelivery = delivery;
+                this.activeControllers.add(controller);
+                try {
+                    await this.options.transport({ version: 1, events: batchEvents }, 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);
+                    throw cause;
+                }
+                finally {
+                    this.activeControllers.delete(controller);
+                    if (this.activeDelivery === delivery)
+                        this.activeDelivery = undefined;
+                }
+            }
+        };
+        this.activeFlush = run().finally(() => {
+            this.activeFlush = undefined;
+        });
+        return this.activeFlush;
+    }
+}
+export const createBrowserTelemetryClient = (config = {}) => {
+    const maxBatchSize = Math.min(positiveInteger(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),
+        transport: config.transport ?? fetchTransport(config.endpoint ?? defaultEndpoint),
+        startTimer: true,
+    });
+};

package/dist/browser/client.d.ts

@@ -0,0 +1,2 @@
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientTransport, } from "./BrowserClient.js";

package/dist/browser/client.js

@@ -0,0 +1 @@
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";

package/dist/browser/index.d.ts

@@ -1,6 +1,8 @@
-import { Context, Duration, Effect, Layer, Schema } from "effect";
+import { Cause, Context, Duration, Effect, Layer, Schema } from "effect";
 import { BrowserEventBatch } from "../BrowserEvents.js";
 import type { WideEventFields } from "../WideEvent.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientTransport, } from "./BrowserClient.js";
 export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
 export declare const defaultEventsEndpoint = "/_telemetry/events";
 declare const BrowserEventDeliveryError_base: Schema.Class<BrowserEventDeliveryError, Schema.TaggedStruct<"BrowserEventDeliveryError", {
@@ -8,7 +10,7 @@ declare const BrowserEventDeliveryError_base: Schema.Class<BrowserEventDeliveryE
     readonly message: Schema.String;
     readonly retryable: Schema.Boolean;
     readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
+}>, Cause.YieldableError>;
 export declare class BrowserEventDeliveryError extends BrowserEventDeliveryError_base {
 }
 declare const BrowserEventTransport_base: Context.ServiceClass<BrowserEventTransport, "@equipe-tech/observability/BrowserEventTransport", {