@genn-inc/cluebase-frontend-sdk 0.0.6 → 0.0.8

package/dist/exporter/source-event.d.ts

@@ -1,6 +1,7 @@
 import type { CanonicalJsonValue, CluebasePrivacySummary, CluebaseSubjectProfile, SdkCollectionMode } from "../provider/types.js";
 export declare const SDK_SOURCE_SIGNAL_EVENT_NAME = "sdk_source_signal_observed";
 export declare const SDK_SOURCE_SIGNAL_EVENT_TYPE = "sdk_source_signal";
+export declare const SOURCE_SCHEMA_VERSION = 1;
 export type BrowserSdkSignalContext = {
     producer_id: string | null;
     anonymous_id: string | null;
@@ -99,4 +100,5 @@ export type BrowserSourceSignalEvent = {
     sdk_signal: BrowserSdkSignal;
 };
 export type BrowserSourceEvent = BrowserSourceSignalEvent;
+export declare const withSourceEvidence: (event: BrowserSourceEvent) => BrowserSourceEvent;
 export declare function isBrowserSourceSignalEvent(event: unknown): event is BrowserSourceSignalEvent;

package/dist/exporter/source-event.js

@@ -1,5 +1,22 @@
+import { DEFAULT_FRONTEND_SOURCE_IDENTIFIER } from "../provider/constants.js";
 export const SDK_SOURCE_SIGNAL_EVENT_NAME = "sdk_source_signal_observed";
 export const SDK_SOURCE_SIGNAL_EVENT_TYPE = "sdk_source_signal";
+export const SOURCE_SCHEMA_VERSION = 1;
+export const withSourceEvidence = (event) => ({
+    ...event,
+    source_event_id: event.source_event_id ?? event.event_id,
+    source_schema_version: String(SOURCE_SCHEMA_VERSION),
+    source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+    source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+    event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
+    event_category: "context",
+    producer_id: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+    service_name: event.service_name ?? DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+    privacy_state: event.privacy_state ?? "masked",
+    privacy_level: event.privacy_level ?? "default_masked",
+    masking_state: event.masking_state ?? "masked",
+    allowed_value_keys: event.allowed_value_keys ?? [],
+});
 const isReadableObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 export function isBrowserSourceSignalEvent(event) {
     if (!isReadableObject(event)) {

package/dist/exporter/span-to-source-signal.d.ts

@@ -1,6 +1,6 @@
 import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import type { CluebaseContext } from "../provider/types.js";
-import { type BrowserSourceSignalEvent } from "./source-event.js";
+import type { BrowserSourceSignalEvent } from "./source-event.js";
 export interface SpanToSourceSignalOptions {
     context: CluebaseContext;
     deniedKeys?: readonly string[];

package/dist/exporter/span-to-source-signal.js

@@ -1,55 +1,6 @@
-import { CLUEBASE_CORRELATION_ATTRIBUTE_KEYS } from "../_generated/correlation-attribute-keys.js";
-import { nanosToIso, parentSpanId } from "../_generated/otel-span-conversion.js";
-import { ALWAYS_DENIED_KEYS, EVENT_SOURCE, EVENT_VERSION, SOURCE_SCHEMA_VERSION, } from "../provider/constants.js";
-import { generateEventId } from "./event-id.js";
-import { isDeniedKey } from "./sanitize.js";
-import { initSdkCoreWasm, isSdkCoreWasmReady, spanToSdkSignalJson, } from "./sdk-core-wasm.js";
-import { SDK_SOURCE_SIGNAL_EVENT_NAME, SDK_SOURCE_SIGNAL_EVENT_TYPE, } from "./source-event.js";
-function withCoreMasking(summary, masking) {
-    const maskedValueCount = masking?.masked_value_count ?? 0;
-    const maskedFields = masking?.masked_fields ?? [];
-    if (!summary) {
-        if (maskedValueCount === 0 && maskedFields.length === 0)
-            return undefined;
-        return {
-            level: "masked",
-            masked_value_count: maskedValueCount,
-            dropped_field_count: 0,
-            masked_fields: [...maskedFields].sort(),
-            rule_set_version: null,
-        };
-    }
-    return {
-        ...summary,
-        masked_value_count: summary.masked_value_count + maskedValueCount,
-        masked_fields: [
-            ...new Set([...summary.masked_fields, ...maskedFields]),
-        ].sort(),
-    };
-}
-function rawAttrString(attributes, key) {
-    const value = attributes?.[key];
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : null;
-}
-function preFilterDeniedAttributes(attributes, deniedKeys) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(attributes ?? {})) {
-        if (!CLUEBASE_CORRELATION_ATTRIBUTE_KEYS.has(key) &&
-            isDeniedKey(key, deniedKeys)) {
-            continue;
-        }
-        filtered[key] = value;
-    }
-    return filtered;
-}
-function seedFallbackAttribute(attributesForCore, attributeKey, candidateKeys, fallback) {
-    const alreadyPresent = candidateKeys.some((candidateKey) => rawAttrString(attributesForCore, candidateKey) !== null);
-    if (alreadyPresent || !fallback)
-        return;
-    attributesForCore[attributeKey] = fallback;
-}
+import { parentSpanId } from "../_generated/otel-span-conversion.js";
+import { EVENT_SOURCE } from "../provider/constants.js";
+import { initSdkCoreWasm, isSdkCoreWasmReady, spanToObservationSourceEventJson, } from "./sdk-core-wasm.js";
 function resourceAttributesInput(resource) {
     const input = resource;
     try {
@@ -59,19 +10,13 @@ function resourceAttributesInput(resource) {
         return {};
     }
 }
-const FIXED_CORE_DENIED_KEYS = Object.freeze([...new Set(ALWAYS_DENIED_KEYS)].sort());
-function coreDeniedKeys(deniedKeys) {
-    if (deniedKeys.length === 0)
-        return FIXED_CORE_DENIED_KEYS;
-    return [...new Set([...FIXED_CORE_DENIED_KEYS, ...deniedKeys])].sort();
-}
 function instrumentationScopeName(span) {
     const instrumentation = span;
     return (instrumentation.instrumentationScope?.name ??
         instrumentation.instrumentationLibrary?.name ??
         null);
 }
-function contextRecord(context, overrides) {
+function contextRecord(context) {
     return {
         producer_id: context.producer_id,
         anonymous_id: context.anonymous_id,
@@ -80,11 +25,11 @@ function contextRecord(context, overrides) {
         user_profile: context.user_profile,
         session_id: context.session_id,
         tab_id: context.tab_id,
-        trace_id: overrides.trace_id,
-        request_id: overrides.request_id,
-        request_span_id: overrides.request_span_id,
-        action_id: overrides.action_id,
-        interaction_id: overrides.interaction_id,
+        trace_id: context.trace_id,
+        request_id: context.request_id,
+        request_span_id: context.request_span_id,
+        action_id: context.action_id,
+        interaction_id: context.interaction_id,
         correlation_id: context.correlation_id,
         sdk_collection_mode: context.sdk_collection_mode,
         frontend_release: context.frontend_release,
@@ -119,100 +64,35 @@ export async function spanToSourceSignalEvent(span, options) {
         await initSdkCoreWasm();
     }
     const context = options.context;
-    const deniedKeys = options.deniedKeys ?? [];
     const spanContext = span.spanContext();
-    const spanId = spanContext.spanId || null;
-    const parentId = parentSpanId(span, span.attributes);
-    const traceId = rawAttrString(span.attributes, "cluebase.trace_id") ??
-        spanContext.traceId ??
-        undefined;
-    const attributesForCore = preFilterDeniedAttributes(span.attributes, deniedKeys);
-    seedFallbackAttribute(attributesForCore, "cluebase.request_span_id", ["cluebase.request_span_id"], spanId ?? context.request_span_id);
-    seedFallbackAttribute(attributesForCore, "cluebase.request_id", ["cluebase.request.id", "cluebase.request_id"], context.request_id);
-    seedFallbackAttribute(attributesForCore, "cluebase.action_id", ["cluebase.action.id", "cluebase.action_id"], context.action_id ?? undefined);
-    seedFallbackAttribute(attributesForCore, "cluebase.interaction_id", ["cluebase.interaction.id", "cluebase.interaction_id"], context.interaction_id);
     const corePayload = {
         name: span.name,
         kind: typeof span.kind === "number" ? span.kind : undefined,
-        trace_id: traceId,
-        span_id: spanId ?? undefined,
-        parent_span_id: parentId ?? undefined,
+        trace_id: spanContext.traceId,
+        span_id: spanContext.spanId,
+        parent_span_id: parentSpanId(span, span.attributes),
         start_time: span.startTime,
         end_time: span.endTime,
         status: span.status
             ? { code: span.status.code ?? undefined, message: span.status.message }
             : undefined,
-        attributes: attributesForCore,
+        attributes: span.attributes,
         events: (span.events ?? []).map((event) => ({
             name: event.name,
-            attributes: preFilterDeniedAttributes(event.attributes, deniedKeys),
+            attributes: event.attributes ?? {},
         })),
         resource_attributes: resourceAttributesInput(span.resource),
-        instrumentation_scope_name: instrumentationScopeName(span) ?? undefined,
+        instrumentation_scope_name: instrumentationScopeName(span),
     };
     const coreOptions = {
-        denied_keys: coreDeniedKeys(deniedKeys),
+        denied_keys: options.deniedKeys ?? [],
         surface: "frontend",
-    };
-    const core = JSON.parse(spanToSdkSignalJson(JSON.stringify(corePayload), JSON.stringify(coreOptions)));
-    const resolvedTraceId = core.trace_id ?? traceId ?? "";
-    const eventId = generateEventId();
-    return {
-        event_id: eventId,
-        source_event_id: eventId,
-        source_schema_version: SOURCE_SCHEMA_VERSION,
-        source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
-        source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+        sdk_collection_mode: context.sdk_collection_mode,
         producer_id: context.producer_id,
         service_name: EVENT_SOURCE,
-        event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
-        event_category: "context",
-        event_source: EVENT_SOURCE,
-        event_version: EVENT_VERSION,
-        occurred_at: nanosToIso(core.start_time_unix_nano),
-        ingested_at: new Date().toISOString(),
-        status: "observed",
-        sdk_collection_mode: context.sdk_collection_mode,
-        privacy_state: "masked",
-        privacy_level: "default_masked",
-        masking_state: "masked",
-        allowed_value_keys: [],
-        privacy_summary: withCoreMasking(context.privacy_summary, core.privacy_masking),
-        trace_id: resolvedTraceId,
-        span_id: core.span_id,
-        parent_span_id: core.parent_span_id,
-        request_id: core.request_id,
-        request_span_id: core.request_span_id,
-        action_id: core.action_id,
-        interaction_id: core.interaction_id,
         frontend_release: context.frontend_release,
-        backend_release: null,
-        properties: {},
-        metrics: {},
-        sdk_signal: {
-            surface: "frontend",
-            kind: "span",
-            name: span.name,
-            span_kind: core.span_kind,
-            trace_id: resolvedTraceId,
-            span_id: core.span_id,
-            parent_span_id: core.parent_span_id,
-            start_time_unix_nano: core.start_time_unix_nano,
-            end_time_unix_nano: core.end_time_unix_nano,
-            status_code: core.status_code ?? null,
-            status_message: core.status_message,
-            instrumentation_scope_name: core.instrumentation_scope_name,
-            attributes: core.attributes,
-            events: core.events,
-            resource: core.resource,
-            raw_resource: core.raw_resource,
-            context: contextRecord(context, {
-                trace_id: resolvedTraceId,
-                request_id: core.request_id,
-                request_span_id: core.request_span_id,
-                action_id: core.action_id,
-                interaction_id: core.interaction_id,
-            }),
-        },
+        context: contextRecord(context),
+        context_privacy_summaries: [context.privacy_summary],
     };
+    return JSON.parse(spanToObservationSourceEventJson(JSON.stringify(corePayload), JSON.stringify(coreOptions)));
 }

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import type { InternalMetricsSnapshot } from "./internal/metrics.js";
-import type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties } from "./provider/types.js";
+import type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseLinkInput, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties } from "./provider/types.js";
 declare const cluebase: {
     init(options: CluebaseInitOptions): void;
     identify(userId: string, traits?: CluebaseSubjectTraits): void;
     group(groupType: CluebaseGroupType, groupKey: string, traits?: CluebaseGroupTraits): void;
+    link(input: CluebaseLinkInput): void;
     linkExternalAccount(namespace: string, externalId: string): void;
-    logout(): void;
     reset(): void;
     track(eventName: string, properties?: CluebaseTrackProperties, metrics?: CluebaseTrackMetrics): void;
     setConsent(consent: CluebaseConsentState): void;
@@ -18,5 +18,5 @@ declare const cluebase: {
 export { EXPORT_RESULT_FAILED, EXPORT_RESULT_SUCCESS, ObservationSourceEventExporter, type ObservationSourceEventExporterOptions, } from "./exporter/observation-source-event-exporter.js";
 export { attachNextRouterIntegration } from "./integrations/next-router.js";
 export { attachReactRouterIntegration } from "./integrations/react-router.js";
-export type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties, InternalMetricsSnapshot, };
+export type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseLinkInput, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties, InternalMetricsSnapshot, };
 export default cluebase;

package/dist/index.js

@@ -97,14 +97,16 @@ const cluebase = {
             internalSdk.setOrganization(groupKey, traits);
         });
     },
+    link(input) {
+        safeCall("link", () => {
+            internalSdk.link(input);
+        });
+    },
     linkExternalAccount(namespace, externalId) {
         safeCall("linkExternalAccount", () => {
             internalSdk.linkExternalAccount(namespace, externalId);
         });
     },
-    logout() {
-        safeCall("logout", () => internalSdk.logout());
-    },
     reset() {
         safeCall("reset", () => internalSdk.reset());
     },

package/dist/instrumentation/network.d.ts

@@ -9,7 +9,7 @@ export declare const createCluebaseNetworkPropagator: () => TextMapPropagator;
 export declare const startNetworkCapture: (context: CaptureModuleContext, options?: {
     tracerProvider?: TracerProvider;
     deniedKeys?: readonly string[];
-    ignoreUrlPrefixes?: string[];
+    ignoreUrlPrefixes?: readonly string[];
     tracePropagationOrigins?: string[];
     createRequestTraceContext?: (input?: RequestTraceContextInput) => RequestTraceContext;
 }) => CaptureStopHandle;

package/dist/instrumentation/network.js

@@ -497,6 +497,23 @@ export const startNetworkCapture = (context, options = {}) => {
         flush: async () => {
             await waitForFetchSpanEnd();
         },
+        refreshIgnoreUrlPrefixes: () => {
+            if (activeCapture !== capture)
+                return;
+            const ignoreUrls = urlPrefixPatterns(capture.ignoreUrlPrefixes);
+            if (fetchInstrumentation) {
+                fetchInstrumentation.setConfig({
+                    ...fetchInstrumentation.getConfig(),
+                    ignoreUrls,
+                });
+            }
+            if (xhrInstrumentation) {
+                xhrInstrumentation.setConfig({
+                    ...xhrInstrumentation.getConfig(),
+                    ignoreUrls,
+                });
+            }
+        },
         stop: () => {
             if (activeCapture !== capture)
                 return;

package/dist/provider/_version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION: "0.0.6";
+export declare const SDK_VERSION: "0.0.8";

package/dist/provider/_version.js

@@ -1,3 +1,3 @@
 // This file is generated by scripts/generate-version-module.mjs.
 // Do NOT edit by hand. The source of truth is `package.json` `version`.
-export const SDK_VERSION = "0.0.6";
+export const SDK_VERSION = "0.0.8";

package/dist/provider/config.js

@@ -1,3 +1,4 @@
+import { CANONICAL_BROWSER_INGEST_PATH, CLUEBASE_API_V1_PREFIX, } from "../_generated/ingest-routes.js";
 import { ALWAYS_DENIED_KEYS, DEFAULT_API_BASE_URL, DEFAULT_CONFIG, DEFAULT_FRONTEND_SOURCE_IDENTIFIER, MAX_DIAGNOSTIC_TTL_MS, } from "./constants.js";
 import { SDK_COLLECTION_MODE } from "./contracts.js";
 const normalizeKeyList = (keys) => {
@@ -74,6 +75,12 @@ export const parseSendableUrl = (value) => {
         return null;
     }
 };
+const isExtendableIngestPath = (pathname) => {
+    const path = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+    return (path === "" ||
+        path.endsWith(CLUEBASE_API_V1_PREFIX) ||
+        path.endsWith(CANONICAL_BROWSER_INGEST_PATH));
+};
 const normalizeConfiguredEndpoint = (value) => parseSendableUrl(value)?.toString() ?? "";
 const normalizeTracePropagationOrigin = (value) => {
     const trimmed = value.trim();
@@ -101,7 +108,6 @@ export const resolveConfig = (options) => {
     return {
         endpoint: originalEndpoint,
         originalEndpoint,
-        localSetupCheckEndpoint: null,
         projectKey: options.projectKey?.trim() ?? "",
         producerId: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
         autocapture: options.autocapture ?? DEFAULT_CONFIG.autocapture,
@@ -138,8 +144,15 @@ export const resolveConfig = (options) => {
 };
 export const validateConfig = (config) => {
     const issues = [];
-    if (!config.endpoint) {
-        issues.push("endpoint is required");
+    const endpoint = parseSendableUrl(config.endpoint);
+    if (!endpoint) {
+        issues.push("endpoint must be an absolute http(s) url with a host, such as https://api.cluebase.io");
+    }
+    else if (endpoint.search || endpoint.hash) {
+        issues.push("endpoint must not carry a query string or fragment; pass the api base url only");
+    }
+    else if (!isExtendableIngestPath(endpoint.pathname)) {
+        issues.push(`endpoint path cannot be extended to ${CANONICAL_BROWSER_INGEST_PATH}; pass the api base url, the ${CLUEBASE_API_V1_PREFIX} base, or the canonical ingest path`);
     }
     if (!config.projectKey) {
         issues.push("projectKey is required");

package/dist/provider/constants.js

@@ -41,7 +41,6 @@ export const MAX_SANITIZE_DEPTH = 20;
 export const DEFAULT_CONFIG = {
     endpoint: "",
     originalEndpoint: "",
-    localSetupCheckEndpoint: null,
     projectKey: "",
     producerId: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
     autocapture: true,

package/dist/provider/lifecycle-event-dedup.d.ts

@@ -0,0 +1,7 @@
+import type { CanonicalJsonValue } from "./types.js";
+export type LifecycleEventIdentity = Readonly<Record<string, CanonicalJsonValue>>;
+export declare class LifecycleEventDedup {
+    private readonly seenAtMs;
+    shouldEmit(identity: LifecycleEventIdentity): boolean;
+    clear(): void;
+}

package/dist/provider/lifecycle-event-dedup.js

@@ -0,0 +1,31 @@
+import { canonicalize } from "json-canonicalize";
+const LIFECYCLE_DEDUPE_TTL_MS = 300000;
+const LIFECYCLE_DEDUPE_MAX_ENTRIES = 4096;
+export class LifecycleEventDedup {
+    constructor() {
+        this.seenAtMs = new Map();
+    }
+    shouldEmit(identity) {
+        const key = canonicalize(identity);
+        const now = Date.now();
+        for (const [seenKey, seenAt] of this.seenAtMs) {
+            if (now - seenAt > LIFECYCLE_DEDUPE_TTL_MS) {
+                this.seenAtMs.delete(seenKey);
+            }
+        }
+        if (this.seenAtMs.has(key)) {
+            this.seenAtMs.set(key, now);
+            return false;
+        }
+        if (this.seenAtMs.size >= LIFECYCLE_DEDUPE_MAX_ENTRIES) {
+            const oldest = [...this.seenAtMs.entries()].sort((left, right) => left[1] - right[1])[0]?.[0];
+            if (oldest !== undefined)
+                this.seenAtMs.delete(oldest);
+        }
+        this.seenAtMs.set(key, now);
+        return true;
+    }
+    clear() {
+        this.seenAtMs.clear();
+    }
+}

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

@@ -6,7 +6,7 @@ import type { TabManager } from "../context/tab.js";
 import { TraceManager } from "../context/trace.js";
 import type { BatchTransport } from "../exporter/batch.js";
 import type { InternalMetricsStore } from "../internal/metrics.js";
-import type { CluebaseConsentState, CluebaseContext, CluebaseInternalLogger, IngestUsageGovernorFeedback, RawCapturedEvent, ResolvedCluebaseConfig } from "./types.js";
+import type { CluebaseConsentState, CluebaseContext, CluebaseInternalLogger, RawCapturedEvent, ResolvedCluebaseConfig } from "./types.js";
 export declare const OFFICIAL_CUSTOM_EVENT_NAME: {
     readonly identityIdentified: "identity_identified";
     readonly identityReset: "identity_reset";
@@ -33,7 +33,6 @@ export declare const getSessionCaptureEligibility: (transport: BatchTransport) =
 export declare class ProviderEventPipeline {
     private runtime;
     private currentViewId;
-    private usageGovernorFeedback;
     private sessionCaptureEligible;
     private unregisterSessionCaptureEligibility;
     configure(runtime: ProviderEventPipelineRuntime): void;
@@ -48,7 +47,6 @@ export declare class ProviderEventPipeline {
         tabId: string | null;
     };
     enqueueRawEvent(event: RawCapturedEvent, skipSessionTouch?: boolean): void;
-    applyUsageGovernorFeedback(feedback: IngestUsageGovernorFeedback | null | undefined): void;
     refreshSessionCaptureEligibility(): void;
     buildContext(event?: RawCapturedEvent): CluebaseContext;
     private attachInteractionContext;

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

@@ -6,7 +6,6 @@ import { sanitizeObject, } from "../exporter/sanitize.js";
 import { FRONTEND_EVENT_NAME } from "./contracts.js";
 import { shouldSampleSession } from "./sampling.js";
 import { stripQueryAndHashFromUrl, toStringOrNull, toSubjectProfile, } from "./sdk-input-normalization.js";
-import { DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK, hasUsageGovernorFeedbackChanged, isCostCapabilityDisabled, normalizeIngestUsageGovernorFeedback, } from "./usage-governor.js";
 const TRACE_ROOT_EVENTS = new Set([
     "page_view",
     "route_change",
@@ -76,7 +75,6 @@ export class ProviderEventPipeline {
     constructor() {
         this.runtime = null;
         this.currentViewId = null;
-        this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
         this.sessionCaptureEligible = true;
         this.unregisterSessionCaptureEligibility = null;
     }
@@ -86,14 +84,12 @@ export class ProviderEventPipeline {
         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() {
@@ -150,10 +146,6 @@ export class ProviderEventPipeline {
                     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),
@@ -188,13 +180,6 @@ export class ProviderEventPipeline {
             });
         }
     }
-    applyUsageGovernorFeedback(feedback) {
-        const nextFeedback = normalizeIngestUsageGovernorFeedback(feedback);
-        if (!hasUsageGovernorFeedbackChanged(this.usageGovernorFeedback, nextFeedback)) {
-            return;
-        }
-        this.usageGovernorFeedback = nextFeedback;
-    }
     refreshSessionCaptureEligibility() {
         const config = this.runtime?.config;
         if (!config) {

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

@@ -6,8 +6,9 @@ type CreateCluebaseOtelPipelineOptions = {
     resolved: ResolvedCluebaseConfig;
     getTransport: () => BatchTransport | null;
     getContext: () => CluebaseContext;
+    ignoreUrlPrefixes: readonly string[];
 };
-export declare const createCluebaseOtelPipeline: ({ resolved, getTransport, getContext, }: CreateCluebaseOtelPipelineOptions) => CluebaseOtelProvider | null;
+export declare const createCluebaseOtelPipeline: ({ resolved, getTransport, getContext, ignoreUrlPrefixes, }: 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>;

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

@@ -2,7 +2,6 @@ import { context, propagation, trace } from "@opentelemetry/api";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
-import { resolveBrowserTokenEndpoint, resolveCanonicalIngestEndpoint, } from "../exporter/client.js";
 import { createFrontendResourceAttributes } from "../exporter/frontend-resource.js";
 import { ObservationSourceEventExporter } from "../exporter/observation-source-event-exporter.js";
 import { createCluebaseNetworkPropagator } from "../instrumentation/network.js";
@@ -16,7 +15,7 @@ const getTracerDelegate = (provider) => {
     const candidate = provider;
     return candidate.getDelegate?.();
 };
-export const createCluebaseOtelPipeline = ({ resolved, getTransport, getContext, }) => {
+export const createCluebaseOtelPipeline = ({ resolved, getTransport, getContext, ignoreUrlPrefixes, }) => {
     if (!getTransport()) {
         return null;
     }
@@ -58,15 +57,7 @@ export const createCluebaseOtelPipeline = ({ resolved, getTransport, getContext,
         },
         getContext,
         deniedKeys: resolved.privacy?.deniedKeys ?? [],
-        ignoreUrlPrefixes: [
-            resolveCanonicalIngestEndpoint(resolved.endpoint),
-            resolveCanonicalIngestEndpoint(resolved.originalEndpoint),
-            resolveBrowserTokenEndpoint(resolved.endpoint),
-            resolveBrowserTokenEndpoint(resolved.originalEndpoint),
-            ...(resolved.localSetupCheckEndpoint
-                ? [resolved.localSetupCheckEndpoint]
-                : []),
-        ].filter((url) => typeof url === "string" && url.length > 0),
+        ignoreUrlPrefixes,
     });
     const provider = new WebTracerProvider({
         resource,

package/dist/provider/sdk-runtime-surfaces.d.ts

@@ -1,6 +1,6 @@
 import { TraceManager } from "../context/trace.js";
 import type { BatchTransport } from "../exporter/batch.js";
-import { type IngestClient } from "../exporter/client.js";
+import type { IngestClient } from "../exporter/client.js";
 import type { InternalMetricsStore } from "../internal/metrics.js";
 import { type CluebaseOtelProvider } from "./sdk-otel-pipeline.js";
 import type { CaptureModuleContext, CluebaseConsentState, CluebaseInternalLogger, RawCapturedEvent, ResolvedCluebaseConfig } from "./types.js";
@@ -41,7 +41,8 @@ export declare class ProviderRuntimeSurfaces {
     constructor(options: ProviderRuntimeSurfacesOptions);
     buildCaptureContext(): CaptureModuleContext;
     warmupBrowserToken(client: IngestClient): void;
-    startCaptureModules(config: ResolvedCluebaseConfig): void;
+    refreshIgnoreUrlPrefixes(): void;
+    startCaptureModules(config: ResolvedCluebaseConfig, ignoreUrlPrefixes: readonly string[]): void;
     stopCaptureModules(): void;
     abortBrowserTokenWarmup(): void;
     flushCaptureSummaries(reason: string): Promise<void>;

package/dist/provider/sdk-runtime-surfaces.js

@@ -1,5 +1,4 @@
 import { TraceManager } from "../context/trace.js";
-import { resolveBrowserTokenEndpoint, resolveCanonicalIngestEndpoint, } from "../exporter/client.js";
 import { startActionCapture } from "../instrumentation/action.js";
 import { startDragCapture } from "../instrumentation/drag.js";
 import { startErrorCapture } from "../instrumentation/error.js";
@@ -88,7 +87,12 @@ export class ProviderRuntimeSurfaces {
             }
         });
     }
-    startCaptureModules(config) {
+    refreshIgnoreUrlPrefixes() {
+        for (const handle of this.captureHandles) {
+            handle.refreshIgnoreUrlPrefixes?.();
+        }
+    }
+    startCaptureModules(config, ignoreUrlPrefixes) {
         const captureContext = this.buildCaptureContext();
         const handles = [];
         handles.push(startInputCapture(captureContext));
@@ -101,10 +105,7 @@ export class ProviderRuntimeSurfaces {
             handles.push(startNetworkCapture(captureContext, {
                 tracerProvider: this.getTracerProvider() ?? undefined,
                 deniedKeys: config.privacy.deniedKeys,
-                ignoreUrlPrefixes: [
-                    resolveCanonicalIngestEndpoint(config.endpoint),
-                    resolveBrowserTokenEndpoint(config.endpoint),
-                ],
+                ignoreUrlPrefixes,
                 tracePropagationOrigins: config.network.tracePropagationOrigins,
                 createRequestTraceContext: (input) => {
                     const traceManager = this.getTraceManager();