avo-inspector 3.0.1 → 3.1.0-alpha.2

package/dist/AvoInspector.js

@@ -0,0 +1,474 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInspector = void 0;
+const AvoInspectorEnv_1 = require("./AvoInspectorEnv");
+const AvoSchemaParser_1 = require("./AvoSchemaParser");
+const AvoBatcher_1 = require("./AvoBatcher");
+const AvoNetworkCallsHandler_1 = require("./AvoNetworkCallsHandler");
+const AvoStorage_1 = require("./AvoStorage");
+const AvoDeduplicator_1 = require("./AvoDeduplicator");
+const AvoStreamId_1 = require("./AvoStreamId");
+const utils_1 = require("./utils");
+const version_1 = require("./version");
+const libVersion = version_1.LIB_VERSION;
+class AvoInspector {
+    static get batchSize() {
+        return this._batchSize;
+    }
+    static set batchSize(newSize) {
+        if (newSize < 1) {
+            this._batchSize = 1;
+        }
+        else {
+            this._batchSize = newSize;
+        }
+    }
+    static get batchFlushSeconds() {
+        return this._batchFlushSeconds;
+    }
+    static get shouldLog() {
+        return this._shouldLog;
+    }
+    static set shouldLog(enable) {
+        this._shouldLog = enable;
+    }
+    static get networkTimeout() {
+        return this._networkTimeout;
+    }
+    static set networkTimeout(timeout) {
+        this._networkTimeout = timeout;
+    }
+    constructor(options) {
+        this.currentBranchId = null;
+        // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
+        if ((0, utils_1.isValueEmpty)(options.env)) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
+        }
+        else if (!Object.values(AvoInspectorEnv_1.AvoInspectorEnv).includes(options.env)) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] Unsupported environment provided. Defaulting to dev. Supported environments - Dev, Staging, Prod.");
+        }
+        else {
+            this.environment = options.env;
+        }
+        if ((0, utils_1.isValueEmpty)(options.apiKey)) {
+            throw new Error("[Avo Inspector] No API key provided. Inspector can't operate without API key.");
+        }
+        else {
+            this.apiKey = options.apiKey;
+        }
+        if ((0, utils_1.isValueEmpty)(options.version)) {
+            throw new Error("[Avo Inspector] No version provided. Many features of Inspector rely on versioning. Please provide comparable string version, i.e. integer or semantic.");
+        }
+        else {
+            this.version = options.version;
+        }
+        if (this.environment === AvoInspectorEnv_1.AvoInspectorEnv.Dev) {
+            AvoInspector._batchSize = 1;
+            AvoInspector._shouldLog = true;
+        }
+        else {
+            AvoInspector._batchSize = 30;
+            AvoInspector._batchFlushSeconds = 30;
+            AvoInspector._shouldLog = false;
+        }
+        AvoInspector.avoStorage = new AvoStorage_1.AvoStorage(AvoInspector._shouldLog, options.suffix != null ? options.suffix : "");
+        this.publicEncryptionKey = options.publicEncryptionKey;
+        this.avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion, this.publicEncryptionKey);
+        this.avoBatcher = new AvoBatcher_1.AvoBatcher(this.avoNetworkCallsHandler);
+        this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
+        this.streamId = AvoStreamId_1.AvoStreamId.streamId;
+        // Enable event spec fetching if streamId is present (note: "unknown" is truthy and will trigger initEventSpecModules; see streamId edge case in spec)
+        if (this.streamId && this.environment !== AvoInspectorEnv_1.AvoInspectorEnv.Prod) {
+            this._eventSpecReady = this.initEventSpecModules();
+        }
+    }
+    async initEventSpecModules() {
+        // ORDERING CONSTRAINT: All instance field assignments (this.eventSpecCache,
+        // this.eventSpecFetcher, this._validateEvent) MUST occur inside the try block,
+        // before the finally block clears this._eventSpecReady. The finally block sets
+        // this._eventSpecReady = undefined to signal completion. Concurrent callers that
+        // await this._eventSpecReady (via ensureEventSpecReady) will resume after the
+        // finally block executes. If any field assignment were moved to or after the
+        // finally block, those concurrent callers would find fields unpopulated, creating
+        // a race condition where they incorrectly proceed as if no event spec is available.
+        try {
+            const [{ EventSpecCache }, { AvoEventSpecFetcher }, { validateEvent }] = await Promise.all([
+                Promise.resolve().then(() => require("./eventSpec/AvoEventSpecCache")),
+                Promise.resolve().then(() => require("./eventSpec/AvoEventSpecFetcher")),
+                Promise.resolve().then(() => require("./eventSpec/EventValidator"))
+            ]);
+            this.eventSpecCache = new EventSpecCache(AvoInspector._shouldLog);
+            this.eventSpecFetcher = new AvoEventSpecFetcher(AvoInspector._networkTimeout, AvoInspector._shouldLog, this.environment);
+            this._validateEvent = validateEvent;
+            if (AvoInspector._shouldLog) {
+                console.log("[Avo Inspector] Event spec fetching and validation enabled");
+                if (this.publicEncryptionKey) {
+                    console.log("[Avo Inspector] Property value encryption enabled");
+                }
+            }
+        }
+        catch (error) {
+            if (AvoInspector._shouldLog) {
+                console.error("[Avo Inspector] Failed to load event spec modules:", error);
+            }
+        }
+        finally {
+            this._eventSpecReady = undefined;
+        }
+    }
+    async ensureEventSpecReady() {
+        if (this.environment === AvoInspectorEnv_1.AvoInspectorEnv.Prod)
+            return null;
+        if (this._eventSpecReady)
+            await this._eventSpecReady;
+        if (!this.eventSpecCache || !this.eventSpecFetcher || !this.streamId || !this._validateEvent)
+            return null;
+        return {
+            cache: this.eventSpecCache,
+            fetcher: this.eventSpecFetcher,
+            validate: this._validateEvent,
+            streamId: this.streamId,
+        };
+    }
+    async trackSchemaFromEvent(eventName, eventProperties) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                const eventSchema = await this.extractSchema(eventProperties, false);
+                // Fetch and validate event spec (sync blocking)
+                const validationResult = await this.fetchAndValidateEvent(eventName, eventProperties);
+                if (validationResult) {
+                    // Spec available: merge validation results into schema and send immediately
+                    const schemaWithValidation = this.mergeValidationResults(eventSchema, validationResult);
+                    this.sendEventWithValidation(eventName, schemaWithValidation, null, null, validationResult);
+                }
+                else {
+                    // No spec: fall back to batched flow
+                    this.trackSchemaInternal(eventName, eventSchema, null, null);
+                }
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    }
+    async _avoFunctionTrackSchemaFromEvent(eventName, eventProperties, eventId, eventHash) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, true)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                const eventSchema = await this.extractSchema(eventProperties, false);
+                // Fetch and validate event spec (sync blocking)
+                const validationResult = await this.fetchAndValidateEvent(eventName, eventProperties);
+                if (validationResult) {
+                    // Spec available: merge validation results into schema and send immediately
+                    const schemaWithValidation = this.mergeValidationResults(eventSchema, validationResult);
+                    this.sendEventWithValidation(eventName, schemaWithValidation, eventId, eventHash, validationResult);
+                }
+                else {
+                    // No spec: fall back to batched flow
+                    this.trackSchemaInternal(eventName, eventSchema, eventId, eventHash);
+                }
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    }
+    async trackSchema(eventName, eventSchema) {
+        try {
+            if (await this.avoDeduplicator.shouldRegisterSchemaFromManually(eventName, eventSchema)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with schema " +
+                        JSON.stringify(eventSchema));
+                }
+                // For trackSchema we don't have raw properties, so we can't validate
+                // Just fetch/cache spec for future use and use batched flow
+                await this.fetchEventSpecIfNeeded(eventName);
+                this.trackSchemaInternal(eventName, eventSchema, null, null);
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    }
+    trackSchemaInternal(eventName, eventSchema, eventId, eventHash) {
+        try {
+            this.avoBatcher.handleTrackSchema(eventName, eventSchema, eventId, eventHash);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    }
+    enableLogging(enable) {
+        AvoInspector._shouldLog = enable;
+    }
+    async extractSchema(eventProperties, shouldLogIfEnabled = true) {
+        try {
+            if (this.avoDeduplicator.hasSeenEventParams(eventProperties, true)) {
+                if (shouldLogIfEnabled && AvoInspector.shouldLog) {
+                    console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your Avo Codegen. " +
+                        "This is an indicator of duplicate inspector reporting. " +
+                        "Please reach out to support@avo.app for advice if you are not sure how to handle this.");
+                }
+            }
+            if (AvoInspector.shouldLog) {
+                console.log("Avo Inspector: extracting schema from " +
+                    JSON.stringify(eventProperties));
+            }
+            return await AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventProperties, this.publicEncryptionKey, this.environment);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong in extractSchema. Please report to support@avo.app.", e);
+            return [];
+        }
+    }
+    setBatchSize(newBatchSize) {
+        AvoInspector._batchSize = newBatchSize;
+    }
+    setBatchFlushSeconds(newBatchFlushSeconds) {
+        AvoInspector._batchFlushSeconds = newBatchFlushSeconds;
+    }
+    /**
+     * Handles branch change detection and cache storage for a fetched event spec.
+     * This logic is shared between fetchEventSpecIfNeeded and fetchAndValidateEvent.
+     */
+    handleBranchChangeAndCache(specResponse, eventName) {
+        // Check for branch change
+        const newBranchId = specResponse.metadata.branchId;
+        if (this.currentBranchId !== null && this.currentBranchId !== newBranchId) {
+            if (AvoInspector.shouldLog) {
+                console.log(`[Avo Inspector] Branch changed from ${this.currentBranchId} to ${newBranchId}. Flushing cache.`);
+            }
+            this.eventSpecCache?.clear();
+        }
+        this.currentBranchId = newBranchId;
+        // Store in cache
+        if (this.eventSpecCache && this.streamId) {
+            this.eventSpecCache.set(this.apiKey, this.streamId, eventName, specResponse);
+        }
+    }
+    /**
+     * Fetches the event spec if spec fetching is enabled.
+     * Used by trackSchema when we don't have raw properties to validate.
+     *
+     * Note: EventSpec fetching only happens in dev/staging environments.
+     */
+    async fetchEventSpecIfNeeded(eventName) {
+        const spec = await this.ensureEventSpecReady();
+        if (!spec)
+            return;
+        try {
+            // Check cache first (includes cached empty responses)
+            if (spec.cache.contains(this.apiKey, spec.streamId, eventName)) {
+                const cached = spec.cache.get(this.apiKey, spec.streamId, eventName);
+                if (!cached) {
+                    // Cached empty response — no spec exists for this event
+                    if (AvoInspector.shouldLog) {
+                        console.log(`[Avo Inspector] Cache hit (empty) for event: ${eventName}. Sending without validation.`);
+                    }
+                }
+                return;
+            }
+            // Cache miss - fetch from API (blocking)
+            const specResponse = await spec.fetcher.fetch({
+                apiKey: this.apiKey,
+                streamId: spec.streamId,
+                eventName
+            });
+            if (specResponse) {
+                this.handleBranchChangeAndCache(specResponse, eventName);
+            }
+            else {
+                // Cache the empty response so we don't re-fetch
+                spec.cache.set(this.apiKey, spec.streamId, eventName, null);
+                if (AvoInspector.shouldLog) {
+                    console.log(`[Avo Inspector] Event spec fetch returned null for event: ${eventName}. Cached empty response.`);
+                }
+            }
+        }
+        catch (error) {
+            // Graceful degradation - log but don't fail
+            if (AvoInspector.shouldLog) {
+                console.error(`[Avo Inspector] Error fetching event spec for ${eventName}:`, error);
+            }
+        }
+    }
+    /**
+     * Fetches event spec and validates the event against it.
+     * Returns ValidationResult if spec is available, null otherwise.
+     *
+     * Note: EventSpec fetching and validation only happens in dev/staging environments.
+     */
+    async fetchAndValidateEvent(eventName, eventProperties) {
+        const spec = await this.ensureEventSpecReady();
+        if (!spec)
+            return null;
+        try {
+            // Check cache first (includes cached empty responses)
+            if (spec.cache.contains(this.apiKey, spec.streamId, eventName)) {
+                const cached = spec.cache.get(this.apiKey, spec.streamId, eventName);
+                if (cached) {
+                    if (AvoInspector.shouldLog) {
+                        console.log(`[Avo Inspector] Cache hit for event: ${eventName}`);
+                    }
+                    return spec.validate(eventProperties, cached);
+                }
+                else {
+                    // Cached empty response — no spec exists for this event
+                    if (AvoInspector.shouldLog) {
+                        console.log(`[Avo Inspector] Cache hit (empty) for event: ${eventName}. Sending without validation.`);
+                    }
+                    return null;
+                }
+            }
+            // Cache miss - fetch from API (blocking)
+            const specResponse = await spec.fetcher.fetch({
+                apiKey: this.apiKey,
+                streamId: spec.streamId,
+                eventName
+            });
+            if (specResponse) {
+                this.handleBranchChangeAndCache(specResponse, eventName);
+                return spec.validate(eventProperties, specResponse);
+            }
+            else {
+                // Cache the empty response so we don't re-fetch
+                spec.cache.set(this.apiKey, spec.streamId, eventName, null);
+                if (AvoInspector.shouldLog) {
+                    console.log(`[Avo Inspector] Event spec fetch returned null for event: ${eventName}. Cached empty response.`);
+                }
+                return null;
+            }
+        }
+        catch (error) {
+            // Graceful degradation - log but don't fail
+            if (AvoInspector.shouldLog) {
+                console.error(`[Avo Inspector] Error validating event ${eventName}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Merges validation results into the event schema.
+     * Adds failedEventIds or passedEventIds to each property based on validation.
+     * Recursively merges validation results for nested children.
+     */
+    mergeValidationResults(eventSchema, validationResult) {
+        return eventSchema.map((prop) => {
+            const propValidation = validationResult.propertyResults[prop.propertyName];
+            return this.mergePropertyValidation(prop, propValidation);
+        });
+    }
+    /**
+     * Merges validation result into a single property, recursively handling children.
+     */
+    mergePropertyValidation(prop, propValidation) {
+        const result = {
+            propertyName: prop.propertyName,
+            propertyType: prop.propertyType
+        };
+        if (prop.encryptedPropertyValue) {
+            result.encryptedPropertyValue = prop.encryptedPropertyValue;
+        }
+        // Recursively merge validation results into children
+        if (prop.children && Array.isArray(prop.children)) {
+            result.children = prop.children.map((child) => {
+                // Children can be strings (for array types) or objects (for nested properties)
+                if (typeof child === 'string') {
+                    return child;
+                }
+                if (child && typeof child === 'object' && child.propertyName) {
+                    // Get nested validation result for this child
+                    const childValidation = propValidation?.children?.[child.propertyName];
+                    return this.mergePropertyValidation(child, childValidation);
+                }
+                return child;
+            });
+        }
+        // Add validation result for this property
+        if (propValidation) {
+            if (propValidation.failedEventIds) {
+                result.failedEventIds = propValidation.failedEventIds;
+            }
+            if (propValidation.passedEventIds) {
+                result.passedEventIds = propValidation.passedEventIds;
+            }
+        }
+        return result;
+    }
+    /**
+     * Sends an event immediately with validation data (bypasses batching).
+     * Logs validation info if shouldLog is true.
+     */
+    sendEventWithValidation(eventName, eventSchema, eventId, eventHash, validationResult) {
+        // Log validation info if shouldLog is enabled
+        if (AvoInspector.shouldLog) {
+            const hasFailures = eventSchema.some((p) => p.failedEventIds && p.failedEventIds.length > 0);
+            if (hasFailures) {
+                console.log(`[Avo Inspector] Validation failures for event "${eventName}":`, eventSchema
+                    .filter((p) => p.failedEventIds && p.failedEventIds.length > 0)
+                    .map((p) => ({
+                    property: p.propertyName,
+                    failedEventIds: p.failedEventIds
+                })));
+            }
+        }
+        // Create the event body with validation data
+        const eventBody = this.avoNetworkCallsHandler.bodyForEventSchemaCall(eventName, eventSchema, eventId, eventHash, validationResult.metadata ?? undefined, validationResult.metadata?.branchId);
+        // Send immediately (bypass batching)
+        this.avoNetworkCallsHandler.callInspectorImmediately(eventBody, (error) => {
+            if (error) {
+                if (AvoInspector.shouldLog) {
+                    console.error(`[Avo Inspector] Failed to send event "${eventName}" with validation:`, error);
+                }
+                // Fallback: add to batch on failure (without validation data)
+                this.avoBatcher.handleTrackSchema(eventName, eventSchema, eventId, eventHash);
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log(`[Avo Inspector] Event "${eventName}" sent successfully with validation`);
+                }
+            }
+        });
+    }
+}
+exports.AvoInspector = AvoInspector;
+AvoInspector._batchSize = 30;
+AvoInspector._batchFlushSeconds = 30;
+AvoInspector._shouldLog = false;
+AvoInspector._networkTimeout = 2000;

package/{dist-native → dist}/AvoInspectorEnv.js

@@ -4,5 +4,5 @@ exports.AvoInspectorEnv = void 0;
 exports.AvoInspectorEnv = {
     Prod: "prod",
     Dev: "dev",
-    Staging: "staging",
+    Staging: "staging"
 };

package/dist/AvoNetworkCallsHandler.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoNetworkCallsHandler = void 0;
+const AvoGuid_1 = require("./AvoGuid");
+const AvoInspector_1 = require("./AvoInspector");
+const AvoStreamId_1 = require("./AvoStreamId");
+class AvoNetworkCallsHandler {
+    constructor(apiKey, envName, appName, appVersion, libVersion, publicEncryptionKey) {
+        this.samplingRate = 1.0;
+        this.sending = false;
+        this.apiKey = apiKey;
+        this.envName = envName;
+        this.appName = appName;
+        this.appVersion = appVersion;
+        this.libVersion = libVersion;
+        this.publicEncryptionKey = publicEncryptionKey;
+    }
+    callInspectorWithBatchBody(inEvents, onCompleted) {
+        if (this.sending) {
+            onCompleted(new Error("Batch sending cancelled because another batch sending is in progress. Your events will be sent with next batch."));
+            return;
+        }
+        const events = inEvents.filter((x) => x != null);
+        this.fixStreamIds(events);
+        if (events.length === 0) {
+            return;
+        }
+        if (this.shouldDropBySampling()) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.log("Avo Inspector: last event schema dropped due to sampling rate.");
+            }
+            return;
+        }
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: events", events);
+            events.forEach((event) => {
+                if (event.type === "sessionStarted") {
+                    console.log("Avo Inspector: sending session started event.");
+                }
+                else if (event.type === "event") {
+                    console.log("Avo Inspector: sending event " +
+                        event.eventName +
+                        " with schema " +
+                        JSON.stringify(event.eventProperties));
+                }
+            });
+        }
+        this.sending = true;
+        this.callInspectorApi(events, (error) => {
+            this.sending = false;
+            onCompleted(error);
+        });
+    }
+    fixStreamIds(events) {
+        let knownStreamId = null;
+        events.forEach(function (event) {
+            if (event.streamId !== null &&
+                event.streamId !== undefined &&
+                event.streamId !== "unknown") {
+                knownStreamId = event.streamId;
+            }
+        });
+        events.forEach(function (event) {
+            if (event.streamId === "unknown") {
+                if (knownStreamId != null) {
+                    event.streamId = knownStreamId;
+                }
+                else {
+                    event.streamId = AvoStreamId_1.AvoStreamId.streamId;
+                }
+            }
+        });
+    }
+    bodyForSessionStartedCall() {
+        const sessionBody = this.createBaseCallBody();
+        sessionBody.type = "sessionStarted";
+        return sessionBody;
+    }
+    bodyForEventSchemaCall(eventName, eventProperties, eventId, eventHash, eventSpecMetadata, validatedBranchId) {
+        const eventSchemaBody = this.createBaseCallBody();
+        eventSchemaBody.type = "event";
+        eventSchemaBody.eventName = eventName;
+        eventSchemaBody.eventProperties = eventProperties;
+        if (eventId != null) {
+            eventSchemaBody.avoFunction = true;
+            eventSchemaBody.eventId = eventId;
+            eventSchemaBody.eventHash = eventHash;
+        }
+        else {
+            eventSchemaBody.avoFunction = false;
+            eventSchemaBody.eventId = null;
+            eventSchemaBody.eventHash = null;
+        }
+        // Set metadata on base body if provided
+        if (eventSpecMetadata) {
+            eventSchemaBody.eventSpecMetadata = eventSpecMetadata;
+        }
+        // Set validated branch ID if value validation was performed
+        if (validatedBranchId) {
+            eventSchemaBody.validatedBranchId = validatedBranchId;
+        }
+        return eventSchemaBody;
+    }
+    createBaseCallBody() {
+        const body = {
+            apiKey: this.apiKey,
+            appName: this.appName,
+            appVersion: this.appVersion,
+            libVersion: this.libVersion,
+            env: this.envName,
+            libPlatform: "web",
+            messageId: AvoGuid_1.default.newGuid(),
+            trackingId: "",
+            createdAt: new Date().toISOString(),
+            sessionId: "",
+            streamId: AvoStreamId_1.AvoStreamId.streamId,
+            samplingRate: this.samplingRate
+        };
+        if (this.publicEncryptionKey) {
+            body.publicEncryptionKey = this.publicEncryptionKey;
+        }
+        return body;
+    }
+    /**
+     * Calls Inspector API immediately with a single event (bypasses batching).
+     * Used when event spec validation is available.
+     * Note: Does not drop due to sampling - validated events are always sent.
+     */
+    callInspectorImmediately(eventBody, onCompleted) {
+        // Fix stream ID if needed
+        if (eventBody.streamId === "unknown") {
+            eventBody.streamId = AvoStreamId_1.AvoStreamId.streamId;
+        }
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: calling inspector immediately (with validation)", eventBody.eventName);
+            console.log("Avo Inspector: event body", eventBody);
+        }
+        this.callInspectorApi([eventBody], onCompleted);
+    }
+    /**
+     * Check if event should be dropped based on sampling rate.
+     */
+    shouldDropBySampling() {
+        return Math.random() > this.samplingRate;
+    }
+    /**
+     * Core Inspector API call logic shared by batch and immediate calls.
+     */
+    callInspectorApi(events, onCompleted) {
+        const xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
+        xmlhttp.setRequestHeader("Content-Type", "text/plain");
+        xmlhttp.timeout = AvoInspector_1.AvoInspector.networkTimeout;
+        xmlhttp.send(JSON.stringify(events));
+        xmlhttp.onload = () => {
+            if (xmlhttp.status !== 200) {
+                onCompleted(new Error(`Error ${xmlhttp.status}: ${xmlhttp.statusText}`));
+            }
+            else {
+                let response;
+                try {
+                    response = JSON.parse(xmlhttp.response);
+                }
+                catch (e) {
+                    onCompleted(new Error(`Failed to parse response: ${e instanceof Error ? e.message : String(e)}`));
+                    return;
+                }
+                if (response != null &&
+                    typeof response.samplingRate === "number" &&
+                    !isNaN(response.samplingRate)) {
+                    this.samplingRate = response.samplingRate;
+                }
+                onCompleted(null);
+            }
+        };
+        xmlhttp.onerror = () => {
+            onCompleted(new Error("Request failed"));
+        };
+        xmlhttp.ontimeout = () => {
+            onCompleted(new Error("Request timed out"));
+        };
+    }
+}
+exports.AvoNetworkCallsHandler = AvoNetworkCallsHandler;
+AvoNetworkCallsHandler.trackingEndpoint = "https://api.avo.app/inspector/v1/track";