@genn-inc/cluebase-frontend-sdk 0.0.1

package/dist/provider/sdk-event-pipeline.js

@@ -0,0 +1,478 @@
+import { TraceManager } from "../context/trace.js";
+import { generateViewId } from "../exporter/event-id.js";
+import { rawEventToSourceSignalEvent } from "../exporter/raw-event-to-source-signal.js";
+import { createFrontendResourceAttributes } from "../exporter/frontend-resource.js";
+import { sanitizeObject, } from "../exporter/sanitize.js";
+import { DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK, hasUsageGovernorFeedbackChanged, isCostCapabilityDisabled, normalizeIngestUsageGovernorFeedback, } from "./usage-governor.js";
+import { DEFAULT_LIFECYCLE_INTERACTION_GRACE_WINDOW_MS, } from "./constants.js";
+import { FRONTEND_EVENT_NAME } from "./contracts.js";
+import { shouldSampleSession } from "./sampling.js";
+import { stripQueryAndHashFromUrl, toStringOrNull, toSubjectProfile, } from "./sdk-input-normalization.js";
+const TRACE_ROOT_EVENTS = new Set([
+    "page_view",
+    "route_change",
+    "element_clicked",
+    "form_submitted",
+    "input_committed",
+    "toggle_changed",
+    "selection_committed",
+    "file_selected",
+    "drag_drop_completed",
+    "custom_emitted",
+]);
+const SUBJECT_PROFILE_TRAIT_KEYS = new Set([
+    "name",
+    "displayName",
+    "email",
+    "emailAddress",
+    "avatarUrl",
+]);
+export const OFFICIAL_CUSTOM_EVENT_NAME = {
+    identityIdentified: "identity_identified",
+    identityReset: "identity_reset",
+    organizationAssociated: "organization_associated",
+    sdkInitialized: "sdk_initialized",
+};
+const OFFICIAL_CUSTOM_EVENT_NAMES = new Set(Object.values(OFFICIAL_CUSTOM_EVENT_NAME));
+const SUMMARY_EVENT_NAMES = new Set([
+    FRONTEND_EVENT_NAME.performanceSummaryObserved,
+]);
+const INTERACTION_METADATA_BY_EVENT = {
+    element_clicked: { initiator: "click", startEventKind: "click" },
+    form_submitted: { initiator: "submit", startEventKind: "submit" },
+    input_committed: { initiator: "input_commit", startEventKind: "change" },
+    toggle_changed: { initiator: "toggle", startEventKind: "change" },
+    selection_committed: { initiator: "selection", startEventKind: "change" },
+    file_selected: { initiator: "file", startEventKind: "change" },
+    drag_drop_completed: { initiator: "drag_drop", startEventKind: "drop" },
+    custom_emitted: { initiator: "custom", startEventKind: "custom" },
+};
+export const readCurrentLifecycleUrl = () => {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    return stripQueryAndHashFromUrl(window.location.href);
+};
+const readCurrentPath = () => {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    return window.location.pathname || "/";
+};
+const isOfficialCustomLifecycleEvent = (event) => {
+    if (event.type !== "custom_emitted") {
+        return false;
+    }
+    const customEventName = event.payload.eventName;
+    const customEventOrigin = event.payload.customEventOrigin;
+    return (customEventOrigin === "official_sdk_lifecycle" &&
+        typeof customEventName === "string" &&
+        OFFICIAL_CUSTOM_EVENT_NAMES.has(customEventName));
+};
+const sessionCaptureEligibilityByTransport = new WeakMap();
+const registerSessionCaptureEligibility = (transport, getEligibility) => {
+    sessionCaptureEligibilityByTransport.set(transport, getEligibility);
+    return () => {
+        if (sessionCaptureEligibilityByTransport.get(transport) === getEligibility) {
+            sessionCaptureEligibilityByTransport.delete(transport);
+        }
+    };
+};
+export const getSessionCaptureEligibility = (transport) => sessionCaptureEligibilityByTransport.get(transport)?.();
+export class ProviderEventPipeline {
+    constructor() {
+        this.runtime = null;
+        this.currentViewId = null;
+        this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
+        this.sessionCaptureEligible = true;
+        this.unregisterSessionCaptureEligibility = null;
+    }
+    configure(runtime) {
+        this.unregisterSessionCaptureEligibility?.();
+        this.runtime = runtime;
+        this.unregisterSessionCaptureEligibility =
+            registerSessionCaptureEligibility(runtime.transport, () => this.sessionCaptureEligible);
+        this.currentViewId = generateViewId();
+        this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
+        this.refreshSessionCaptureEligibility();
+    }
+    clearRuntime() {
+        this.unregisterSessionCaptureEligibility?.();
+        this.unregisterSessionCaptureEligibility = null;
+        this.runtime = null;
+        this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
+        this.sessionCaptureEligible = true;
+    }
+    resetViewId() {
+        this.currentViewId = generateViewId();
+    }
+    getViewId() {
+        if (!this.currentViewId) {
+            this.currentViewId = generateViewId();
+        }
+        return this.currentViewId;
+    }
+    getObservationContext() {
+        const identity = this.runtime?.identityManager.getContext();
+        const organization = this.runtime?.organizationManager.getContext();
+        const session = this.runtime?.sessionManager.getContext();
+        return {
+            anonymousId: identity?.anonymousId ?? null,
+            userId: identity?.userId ?? null,
+            organizationId: organization?.organizationId ?? null,
+            sessionId: session?.sessionId ?? null,
+            tabId: this.runtime?.tabManager.getTabId() ?? null,
+        };
+    }
+    enqueueRawEvent(event, skipSessionTouch = false) {
+        const runtime = this.runtime;
+        if (!runtime) {
+            return;
+        }
+        if (runtime.getConsent() === "denied") {
+            return;
+        }
+        if (!skipSessionTouch &&
+            event.type !== "session_started" &&
+            event.type !== "session_ended") {
+            this.handleSessionLifecycle(Date.now());
+        }
+        const eventWithInteraction = this.attachInteractionContext(event);
+        const eventWithLocation = this.attachCurrentLocation(eventWithInteraction);
+        if (eventWithLocation.type === "page_view") {
+            const nextViewId = toStringOrNull(eventWithLocation.payload.viewId);
+            if (nextViewId) {
+                this.currentViewId = nextViewId;
+            }
+        }
+        try {
+            const context = this.buildContext();
+            if (SUMMARY_EVENT_NAMES.has(eventWithLocation.type)) {
+                const summaryCount = eventWithLocation.payload.summaryCount;
+                const droppedCount = eventWithLocation.payload.droppedCount;
+                if (typeof summaryCount === "number" && summaryCount > 0) {
+                    runtime.internalMetrics.increment("events_summarized_count", summaryCount);
+                }
+                if (typeof droppedCount === "number" && droppedCount > 0) {
+                    runtime.internalMetrics.increment("sampling_dropped_count", droppedCount);
+                }
+            }
+            if (isCostCapabilityDisabled(this.usageGovernorFeedback, "event_collection")) {
+                runtime.internalMetrics.increment("dropped_count");
+                return;
+            }
+            const sourceSignal = rawEventToSourceSignalEvent(eventWithLocation, {
+                context,
+                resource: createFrontendResourceAttributes(runtime.config),
+                deniedKeys: runtime.config.privacy.deniedKeys,
+                onMaskingError: () => {
+                    runtime.internalMetrics.increment("masking_error_count");
+                },
+            });
+            if (!this.shouldCaptureEvent(eventWithLocation)) {
+                runtime.internalMetrics.increment("dropped_count");
+                return;
+            }
+            const eventBytes = this.measureSerializedBytes(sourceSignal);
+            if (eventBytes > runtime.config.batch.maxEventBytes) {
+                runtime.internalMetrics.increment("dropped_count");
+                runtime.internalMetrics.increment("oversized_event_count");
+                runtime.internalMetrics.increment("oversized_event_dropped_count");
+                runtime.logger.warn("browser sdk dropped oversized event", {
+                    eventType: eventWithInteraction.type,
+                    eventBytes,
+                    maxEventBytes: runtime.config.batch.maxEventBytes,
+                });
+                return;
+            }
+            this.updateActiveTraceSpan(eventWithLocation, sourceSignal.event_id);
+            runtime.transport.enqueue(sourceSignal);
+        }
+        catch {
+            runtime.logger.error("enqueueRawEvent failed", {
+                eventType: eventWithLocation.type,
+                error_code: "sdk_event_enqueue_failed",
+            });
+        }
+    }
+    applyUsageGovernorFeedback(feedback) {
+        const nextFeedback = normalizeIngestUsageGovernorFeedback(feedback);
+        if (!hasUsageGovernorFeedbackChanged(this.usageGovernorFeedback, nextFeedback)) {
+            return;
+        }
+        this.usageGovernorFeedback = nextFeedback;
+    }
+    refreshSessionCaptureEligibility() {
+        const config = this.runtime?.config;
+        if (!config) {
+            this.sessionCaptureEligible = true;
+            return;
+        }
+        const rate = config.sampling.sessionSampleRate;
+        this.sessionCaptureEligible = shouldSampleSession(rate);
+    }
+    buildContext() {
+        const runtime = this.runtime;
+        if (!runtime) {
+            throw new Error("SDK is not initialized");
+        }
+        const identity = runtime.identityManager.getContext();
+        const session = runtime.sessionManager.getContext();
+        const organization = runtime.organizationManager.getContext();
+        const environment = runtime.environmentManager.getContext();
+        const trace = runtime.traceManager.getSnapshot();
+        const requestContext = runtime.traceManager.createRequestContext() ??
+            new TraceManager().createRequestContext();
+        const privacySummary = {
+            maskedValueCount: 0,
+            droppedFieldCount: 0,
+            maskedFields: new Set(),
+        };
+        const subjectTraits = sanitizeContextTraits(identity.traits, runtime.config.privacy.deniedKeys, SUBJECT_PROFILE_TRAIT_KEYS, privacySummary, "subject.trait");
+        const organizationTraits = sanitizeContextTraits(organization.traits, runtime.config.privacy.deniedKeys, new Set(), privacySummary, "organization.trait");
+        const contextTraits = sanitizeContextTraits(environment.contextTraits, runtime.config.privacy.deniedKeys, new Set(), privacySummary, "context.trait");
+        return {
+            producer_id: runtime.config.producerId,
+            anonymous_id: identity.anonymousId,
+            user_id: identity.userId,
+            organization_id: organization.organizationId,
+            user_profile: toSubjectProfile(identity.traits),
+            session_id: session.sessionId,
+            tab_id: runtime.tabManager.getTabId(),
+            trace_id: trace.traceId ?? requestContext.traceId,
+            request_id: requestContext.requestId,
+            request_span_id: requestContext.requestSpanId,
+            interaction_id: runtime.traceManager.getActiveInteractionId() ??
+                requestContext.interactionId,
+            correlation_id: null,
+            sdk_collection_mode: runtime.config.collection.mode,
+            frontend_release: environment.frontendRelease,
+            locale: environment.locale,
+            country: environment.country,
+            device_type: environment.deviceType,
+            browser: environment.browser,
+            os: environment.os,
+            referrer: environment.referrer,
+            browser_family: environment.browserFamily,
+            browser_major_version: environment.browserMajorVersion,
+            browser_engine: environment.browserEngine,
+            os_family: environment.osFamily,
+            os_major_version: environment.osMajorVersion,
+            timezone: environment.timezone,
+            pointer_type_candidate: environment.pointerTypeCandidate,
+            touch_capable: environment.touchCapable,
+            cookies_enabled: environment.cookiesEnabled,
+            local_storage_available: environment.localStorageAvailable,
+            session_storage_available: environment.sessionStorageAvailable,
+            service_worker_supported: environment.serviceWorkerSupported,
+            webgl_supported: environment.webglSupported,
+            reduced_motion: environment.reducedMotion,
+            color_scheme: environment.colorScheme,
+            subject_traits: subjectTraits,
+            organization_traits: organizationTraits,
+            context_traits: contextTraits,
+            privacy_summary: {
+                level: "masked",
+                masked_value_count: privacySummary.maskedValueCount,
+                dropped_field_count: privacySummary.droppedFieldCount,
+                masked_fields: [...privacySummary.maskedFields].sort(),
+                rule_set_version: null,
+            },
+        };
+    }
+    attachInteractionContext(event) {
+        const traceManager = this.runtime?.traceManager;
+        const nowMs = event.occurredAtMs ?? Date.now();
+        const payloadInteractionId = toStringOrNull(event.payload.interactionId);
+        const occurrenceKind = "frontend_action";
+        if (event.type === "page_view") {
+            const interactionId = traceManager?.startFrontendAction({
+                interactionId: payloadInteractionId,
+                interactionInitiator: toStringOrNull(event.payload.interactionInitiator) ?? "page_visit",
+                interactionStartEventKind: toStringOrNull(event.payload.interactionStartEventKind) ??
+                    "page_view",
+                viewId: toStringOrNull(event.payload.viewId),
+                nowMs,
+            }) ?? payloadInteractionId;
+            if (!interactionId)
+                return event;
+            return {
+                ...event,
+                payload: {
+                    ...event.payload,
+                    interactionId,
+                    interactionInitiator: toStringOrNull(event.payload.interactionInitiator) ?? "page_visit",
+                    interactionStartEventKind: toStringOrNull(event.payload.interactionStartEventKind) ??
+                        "page_view",
+                    occurrenceKind,
+                },
+            };
+        }
+        if (event.type === "page_leave") {
+            const interactionId = payloadInteractionId ??
+                traceManager?.getActiveInteractionId() ??
+                null;
+            if (!interactionId)
+                return event;
+            traceManager?.endFrontendAction(interactionId);
+            return {
+                ...event,
+                payload: {
+                    ...event.payload,
+                    interactionId,
+                    occurrenceKind,
+                },
+            };
+        }
+        if (isOfficialCustomLifecycleEvent(event)) {
+            const lifecycleInteraction = traceManager?.getRecentInteractionSnapshot(nowMs, DEFAULT_LIFECYCLE_INTERACTION_GRACE_WINDOW_MS) ?? null;
+            const interactionId = payloadInteractionId ?? lifecycleInteraction?.interactionId ?? null;
+            if (!interactionId)
+                return event;
+            return {
+                ...event,
+                payload: {
+                    ...event.payload,
+                    interactionId,
+                    occurrenceKind,
+                    interactionInitiator: toStringOrNull(event.payload.interactionInitiator) ??
+                        lifecycleInteraction?.interactionInitiator ??
+                        null,
+                    interactionStartEventKind: toStringOrNull(event.payload.interactionStartEventKind) ??
+                        lifecycleInteraction?.interactionStartEventKind ??
+                        null,
+                },
+            };
+        }
+        const interactionMetadata = INTERACTION_METADATA_BY_EVENT[event.type];
+        if (interactionMetadata || event.type === "custom_emitted") {
+            const interactionId = traceManager?.joinOrStartInteraction({
+                interactionId: payloadInteractionId,
+                interactionInitiator: toStringOrNull(event.payload.interactionInitiator) ??
+                    interactionMetadata?.initiator,
+                interactionStartEventKind: toStringOrNull(event.payload.interactionStartEventKind) ??
+                    interactionMetadata?.startEventKind,
+                targetStableKey: toStringOrNull(event.payload.stableKey),
+                formKey: toStringOrNull(event.payload.formKey),
+                interactionScopeKind: toStringOrNull(event.payload.interactionScopeKind),
+                interactionScopeKey: toStringOrNull(event.payload.interactionScopeKey),
+                nowMs,
+            }) ?? payloadInteractionId;
+            if (!interactionId)
+                return event;
+            return {
+                ...event,
+                payload: {
+                    ...event.payload,
+                    interactionId,
+                    occurrenceKind,
+                    interactionInitiator: toStringOrNull(event.payload.interactionInitiator) ??
+                        interactionMetadata?.initiator,
+                    interactionStartEventKind: toStringOrNull(event.payload.interactionStartEventKind) ??
+                        interactionMetadata?.startEventKind,
+                },
+            };
+        }
+        const activeInteractionId = payloadInteractionId ??
+            traceManager?.getActiveInteractionId() ??
+            null;
+        if (!activeInteractionId || activeInteractionId === payloadInteractionId) {
+            return event;
+        }
+        return {
+            ...event,
+            payload: {
+                ...event.payload,
+                interactionId: activeInteractionId,
+                occurrenceKind,
+            },
+        };
+    }
+    attachCurrentLocation(event) {
+        const payload = event.payload;
+        if (payload.url !== undefined ||
+            payload.currentUrl !== undefined ||
+            payload.pageUrl !== undefined ||
+            payload.entryUrl !== undefined ||
+            payload.exitUrl !== undefined ||
+            payload.toUrl !== undefined) {
+            return event;
+        }
+        const currentUrl = readCurrentLifecycleUrl();
+        const path = payload.path ?? payload.toPath ?? readCurrentPath();
+        if (!currentUrl && !path) {
+            return event;
+        }
+        return {
+            ...event,
+            payload: {
+                ...payload,
+                ...(currentUrl ? { currentUrl } : {}),
+                ...(path ? { path } : {}),
+            },
+        };
+    }
+    handleSessionLifecycle(nowMs) {
+        const runtime = this.runtime;
+        if (!runtime) {
+            return;
+        }
+        const lifecycle = runtime.sessionManager.ensureActiveSession(nowMs);
+        if (lifecycle.ended) {
+            this.enqueueRawEvent({
+                type: "session_ended",
+                occurredAtMs: nowMs,
+                payload: {
+                    sessionId: lifecycle.ended.sessionId,
+                    exitUrl: readCurrentLifecycleUrl(),
+                    durationMs: lifecycle.ended.durationMs,
+                },
+            }, true);
+        }
+        if (lifecycle.started) {
+            runtime.traceManager.reset();
+            this.currentViewId = generateViewId();
+            this.refreshSessionCaptureEligibility();
+            this.enqueueRawEvent({
+                type: "session_started",
+                occurredAtMs: nowMs,
+                payload: {
+                    entryUrl: readCurrentLifecycleUrl(),
+                },
+            }, true);
+        }
+    }
+    shouldCaptureEvent(event) {
+        const runtime = this.runtime;
+        if (!runtime) {
+            return false;
+        }
+        if (this.sessionCaptureEligible) {
+            return true;
+        }
+        if (event.type === "session_started" || event.type === "session_ended") {
+            return true;
+        }
+        runtime.internalMetrics.increment("sampling_dropped_count");
+        return false;
+    }
+    measureSerializedBytes(event) {
+        return new TextEncoder().encode(JSON.stringify(event)).byteLength;
+    }
+    updateActiveTraceSpan(event, eventId) {
+        const traceManager = this.runtime?.traceManager;
+        if (!traceManager ||
+            isOfficialCustomLifecycleEvent(event) ||
+            !TRACE_ROOT_EVENTS.has(event.type)) {
+            return;
+        }
+        traceManager.setActiveSpan(eventId);
+    }
+}
+function sanitizeContextTraits(traits, deniedKeys, excludedKeys = new Set(), summary, pathPrefix = "") {
+    const sanitized = sanitizeObject(traits, deniedKeys, summary, pathPrefix);
+    if (typeof sanitized !== "object" || sanitized === null || Array.isArray(sanitized)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(sanitized).filter(([key]) => !excludedKeys.has(key)));
+}

package/dist/provider/sdk-input-normalization.d.ts

@@ -0,0 +1,7 @@
+import type { CluebaseSubjectProfile, CluebaseSubjectTraits } from "./types.js";
+export declare const toStringOrNull: (value: unknown) => string | null;
+export declare const normalizePublicIdentityId: (value: unknown) => string | null;
+export declare const isValidPublicCustomEventName: (value: unknown) => value is string;
+export declare const stripQueryAndHashFromUrl: (value: unknown) => string | null;
+export declare const normalizeProfileAvatarUrl: (raw: unknown) => string | null;
+export declare const toSubjectProfile: (traits: CluebaseSubjectTraits) => CluebaseSubjectProfile | null;

package/dist/provider/sdk-input-normalization.js

@@ -0,0 +1,113 @@
+import { detectIdentityPII, hashIdentityValue } from "../exporter/sanitize.js";
+const PUBLIC_CUSTOM_EVENT_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+const SAFE_DATA_IMAGE_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/jpg",
+    "image/gif",
+    "image/webp",
+    "image/avif",
+]);
+export const toStringOrNull = (value) => {
+    return typeof value === "string" ? value : null;
+};
+export const normalizePublicIdentityId = (value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+};
+export const isValidPublicCustomEventName = (value) => {
+    return (typeof value === "string" && PUBLIC_CUSTOM_EVENT_NAME_PATTERN.test(value));
+};
+export const stripQueryAndHashFromUrl = (value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        parsed.search = "";
+        parsed.hash = "";
+        return parsed.toString();
+    }
+    catch {
+        const withoutHash = trimmed.split("#", 1)[0] ?? "";
+        const withoutQuery = withoutHash.split("?", 1)[0] ?? "";
+        return withoutQuery || null;
+    }
+};
+const isSafeDataImageUrl = (value) => {
+    const commaIndex = value.indexOf(",");
+    if (commaIndex <= "data:".length) {
+        return false;
+    }
+    const metadata = value.slice("data:".length, commaIndex).toLowerCase();
+    const mimeType = metadata.split(";", 1)[0] ?? "";
+    return SAFE_DATA_IMAGE_MIME_TYPES.has(mimeType);
+};
+export const normalizeProfileAvatarUrl = (raw) => {
+    const value = toStringOrNull(raw);
+    if (value === null) {
+        return null;
+    }
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+            if (!parsed.hostname || parsed.username || parsed.password) {
+                return null;
+            }
+            parsed.search = "";
+            parsed.hash = "";
+            return parsed.toString();
+        }
+        if (parsed.protocol === "data:" && isSafeDataImageUrl(value)) {
+            return value;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeEmailTrait = (raw) => {
+    const value = toStringOrNull(raw);
+    if (value === null) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return detectIdentityPII(normalized) === "email" ? normalized : null;
+};
+const emailDomain = (email) => {
+    if (email === null) {
+        return null;
+    }
+    const atIndex = email.lastIndexOf("@");
+    if (atIndex < 0 || atIndex === email.length - 1) {
+        return null;
+    }
+    return email.slice(atIndex + 1);
+};
+export const toSubjectProfile = (traits) => {
+    const displayName = toStringOrNull(traits.name ?? traits.displayName);
+    const avatarUrl = normalizeProfileAvatarUrl(traits.avatarUrl);
+    const contactEmail = normalizeEmailTrait(traits.email ?? traits.emailAddress);
+    const contactIdentityHash = contactEmail === null ? null : hashIdentityValue(contactEmail);
+    const contactDomain = emailDomain(contactEmail);
+    if (displayName === null &&
+        avatarUrl === null &&
+        contactIdentityHash === null &&
+        contactDomain === null) {
+        return null;
+    }
+    return {
+        display_name: displayName,
+        avatar_url: avatarUrl,
+        contact_identity_hash: contactIdentityHash,
+        contact_domain: contactDomain,
+    };
+};

package/dist/provider/sdk-otel-pipeline.d.ts

@@ -0,0 +1,14 @@
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import type { BatchTransport } from "../exporter/batch.js";
+import type { CluebaseContext, ResolvedCluebaseConfig } from "./types.js";
+export type CluebaseOtelProvider = WebTracerProvider;
+type CreateCluebaseOtelPipelineOptions = {
+    resolved: ResolvedCluebaseConfig;
+    getTransport: () => BatchTransport | null;
+    getContext: () => CluebaseContext;
+};
+export declare const createCluebaseOtelPipeline: ({ resolved, getTransport, getContext, }: CreateCluebaseOtelPipelineOptions) => CluebaseOtelProvider | null;
+export declare const shutdownCluebaseOtelProvider: (provider: CluebaseOtelProvider | null) => void;
+export declare const shutdownCluebaseOtelProviderAsync: (provider: CluebaseOtelProvider | null) => Promise<void>;
+export declare const forceFlushCluebaseOtelProvider: (provider: CluebaseOtelProvider | null, signal?: AbortSignal) => Promise<void>;
+export {};