node-avo-inspector 2.0.0-beta.1 → 2.0.0

package/dist/AvoInspector.js

@@ -13,46 +13,237 @@ exports.AvoInspector = void 0;
 const AvoInspectorEnv_1 = require("./AvoInspectorEnv");
 const AvoSchemaParser_1 = require("./AvoSchemaParser");
 const AvoNetworkCallsHandler_1 = require("./AvoNetworkCallsHandler");
+const AvoBatchQueue_1 = require("./AvoBatchQueue");
 const AvoDeduplicator_1 = require("./AvoDeduplicator");
 const AvoStreamId_1 = require("./AvoStreamId");
 const AvoEventSpecFetcher_1 = require("./eventSpec/AvoEventSpecFetcher");
 const AvoEventSpecCache_1 = require("./eventSpec/AvoEventSpecCache");
 const EventValidator_1 = require("./eventSpec/EventValidator");
+const AvoInspectorVersion_1 = require("./AvoInspectorVersion");
+const AvoLog_1 = require("./AvoLog");
 const utils_1 = require("./utils");
-const libVersion = require("../package.json").version;
+const libVersion = AvoInspectorVersion_1.VERSION;
+const DEFAULT_BATCH_SIZE = 30;
+const DEFAULT_BATCH_FLUSH_SECONDS = 30;
+const DEFAULT_MAX_QUEUE_SIZE = 1000;
+const DEFAULT_FLUSH_TIMEOUT_MS = 10000;
+// The longest a track call can stay pending on its own work: a spec fetch (a socket wait
+// and the fetch, 10 s each), then, in dev, its send (10 s). A send that also waits for a
+// free slot can take longer; the call then resolves with its schema when the hold runs out.
+const AWAITED_TRACK_HOLD_MS = 30000;
+// A track call's promise that notices when someone awaits it. The SDK's sockets and
+// timers do not hold the process, so a script awaiting a track that waits on a spec fetch
+// or (in dev) on its send would otherwise look idle: "beforeExit" would fire mid-loop and
+// the exit drain could end the process before the loop resumes. Once the promise is
+// awaited (await, then, catch, finally, Promise.all all call then), a ref'd timer holds the
+// process until it settles, at most AWAITED_TRACK_HOLD_MS; a fire-and-forget call with
+// .catch() counts. A call whose promise nothing touches holds nothing. A call still pending
+// when its hold runs out resolves with `onHoldExpired()`, so the script resumes; its event
+// stays queued, and goes out with the exit drain or is reported as lost at exit.
+class AwaitedTrackPromise extends Promise {
+    constructor() {
+        super(...arguments);
+        this.onFirstAwait = null;
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    then(onFulfilled, onRejected) {
+        const onFirstAwait = this.onFirstAwait;
+        if (onFirstAwait !== null) {
+            this.onFirstAwait = null;
+            onFirstAwait();
+        }
+        return super.then(onFulfilled, onRejected);
+    }
+}
+const holdWhileAwaited = (work, onHoldExpired) => {
+    let settled = false;
+    let hold = null;
+    const done = () => {
+        settled = true;
+        if (hold !== null) {
+            clearTimeout(hold);
+            hold = null;
+        }
+    };
+    let release = () => { };
+    const tracked = new AwaitedTrackPromise((resolve, reject) => {
+        release = resolve;
+        work.then((value) => {
+            done();
+            resolve(value);
+        }, (reason) => {
+            done();
+            reject(reason);
+        });
+    });
+    tracked.onFirstAwait = () => {
+        if (!settled) {
+            hold = setTimeout(() => {
+                hold = null;
+                settled = true;
+                release(onHoldExpired());
+            }, AWAITED_TRACK_HOLD_MS);
+        }
+    };
+    return tracked;
+};
+// At an idle point with validations pending, how long the exit drain waits for them before
+// sending anything (once per exit deadline).
+const VALIDATION_GRACE_MS = 1000;
+// Events waiting for a spec fetch at once, across every instance. The fetches share one
+// 8-socket pool, so past this an event is sent without validation rather than queued.
+const MAX_WAITING_VALIDATIONS = 1000;
+// String() for a warning; a value with no string conversion (a null-prototype object)
+// falls back to its tag, e.g. "[object Object]", which String() gives a plain object.
+const valueToString = (value) => {
+    try {
+        return String(value);
+    }
+    catch (e) {
+        return Object.prototype.toString.call(value);
+    }
+};
+const NO_API_KEY_MESSAGE = "[Avo Inspector] No API key provided. Inspector can't operate without API key.";
+// The keys of InspectorEvent; any other key in a tracked event is warned about.
+const KNOWN_EVENT_KEYS = ["eventName", "eventProperties", "streamId", "outputReference", "originHint", "originAppVersion"];
 class AvoInspector {
-    trackPending(promise) {
-        this.pendingCount++;
-        if (this.keepAliveTimer === null) {
-            this.keepAliveTimer = setInterval(() => { }, 60000);
+    drainThisTurn() {
+        if (!this.drainScheduled) {
+            this.drainScheduled = true;
+            setImmediate(() => {
+                this.drainScheduled = false;
+                if (!this.destroyed) {
+                    this.batchQueue.drain();
+                }
+            });
+        }
+    }
+    // Mirrors `promise`, but resolves `onDestroy` instead if destroy() runs first.
+    untilDestroyed(promise, onDestroy) {
+        return new Promise((resolve, reject) => {
+            const cancel = () => resolve(onDestroy);
+            this.destroyWaiters.add(cancel);
+            promise.then((value) => {
+                this.destroyWaiters.delete(cancel);
+                resolve(value);
+            }, (reason) => {
+                this.destroyWaiters.delete(cancel);
+                reject(reason);
+            });
+        });
+    }
+    // Mirrors a validation, but resolves null (send unvalidated) if giveUpValidations() runs first.
+    untilGivenUp(validation) {
+        return new Promise((resolve, reject) => {
+            const giveUp = () => resolve(null);
+            this.giveUpWaiters.add(giveUp);
+            validation.then((value) => {
+                this.giveUpWaiters.delete(giveUp);
+                resolve(value);
+            }, (reason) => {
+                this.giveUpWaiters.delete(giveUp);
+                reject(reason);
+            });
+        });
+    }
+    /** The exit drain ran out of time for validations: their events are sent unvalidated. */
+    giveUpValidations() {
+        const waiters = Array.from(this.giveUpWaiters);
+        this.giveUpWaiters.clear();
+        if (waiters.length > 0 && AvoInspector.shouldLog) {
+            console.log("Avo Inspector: exiting; sending " + waiters.length + " event(s) without waiting for their event spec.");
         }
+        waiters.forEach((giveUp) => giveUp());
+    }
+    get pendingCount() {
+        return this.pending.size;
+    }
+    trackPending(promise) {
+        this.pending.add(promise);
+        this.updateExitDrain();
         const done = () => {
-            this.pendingCount--;
-            if (this.pendingCount === 0 && this.keepAliveTimer !== null) {
-                clearInterval(this.keepAliveTimer);
-                this.keepAliveTimer = null;
-            }
+            this.pending.delete(promise);
+            this.updateExitDrain();
         };
         promise.then(done, done);
+        return promise;
+    }
+    static armExitDrain() {
+        if (!AvoInspector.exitDrainArmed) {
+            process.once("beforeExit", AvoInspector.drainOnExit);
+            AvoInspector.exitDrainArmed = true;
+        }
+    }
+    static disarmExitDrain() {
+        if (AvoInspector.exitDrainArmed) {
+            process.removeListener("beforeExit", AvoInspector.drainOnExit);
+            AvoInspector.exitDrainArmed = false;
+        }
+    }
+    updateExitDrain() {
+        const hasWork = !this.destroyed && (this.batchQueue.length > 0 || this.pending.size > 0);
+        if (hasWork) {
+            AvoInspector.instancesWithWork.add(this);
+            AvoInspector.armExitDrain();
+            if (!AvoInspector.exitReportArmed) {
+                process.on("exit", AvoInspector.reportOnExit);
+                AvoInspector.exitReportArmed = true;
+            }
+        }
+        else {
+            AvoInspector.instancesWithWork.delete(this);
+            if (AvoInspector.instancesWithWork.size === 0) {
+                AvoInspector.disarmExitDrain();
+                process.removeListener("exit", AvoInspector.reportOnExit);
+                AvoInspector.exitReportArmed = false;
+                AvoInspector.exitDeadline = null;
+            }
+        }
     }
+    /** Whether the SDK writes its diagnostic log lines (shared by every instance). */
     static get shouldLog() {
         return this._shouldLog;
     }
     static set shouldLog(enable) {
         this._shouldLog = enable;
     }
+    /**
+     * Creates an Inspector instance. A missing or unsupported `env` falls back to dev.
+     *
+     * @throws if `apiKey` or `version` is blank, or `apiKey` contains a character that
+     * cannot be sent in an HTTP header.
+     */
     constructor(options) {
         this.eventSpecFetcher = null;
         this.eventSpecCache = null;
         this.eventValidator = null;
         this.generatedAnonymousId = "";
-        // Keep the Node process alive while there are pending inspector operations.
-        // Without this, short-lived processes (e.g. CLIs) can exit before async
-        // sends complete, since the caller typically doesn't await the inspector promise.
-        this.pendingCount = 0;
-        this.keepAliveTimer = null;
+        this.destroyed = false;
+        // Settles each track still waiting on a spec fetch or an immediate send when destroy()
+        // runs. Entries remove themselves once their wait settles, so none outlive their call.
+        this.destroyWaiters = new Set();
+        // In-flight work (spec fetches before enqueue, and batch sends) that flush() awaits.
+        // Nothing here keeps the process alive: callers flush() or await before exit.
+        this.pending = new Set();
+        // Pending entries that are event spec validations, keyed by their pending promise.
+        this.validations = new Map();
+        // One drain for every flush-marked validation that settles in the same event-loop turn.
+        this.drainScheduled = false;
+        // Frees this instance's places among them; destroy() runs whatever is left.
+        this.releaseWaiting = new Set();
+        // Validations not finished yet (their events are not queued), settled when they are.
+        this.validationOutcomes = new Set();
+        // Gives up each validation still pending (giveUpValidations).
+        this.giveUpWaiters = new Set();
         // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
-        if ((0, utils_1.isValueEmpty)(options.env)) {
+        if (options === null || typeof options !== "object") {
+            throw new Error(NO_API_KEY_MESSAGE);
+        }
+        // A non-string env is not "empty": it falls through to the unsupported-value check.
+        const env = options.env;
+        if (env === undefined || env === null || (typeof env === "string" && (0, utils_1.isValueEmpty)(env))) {
             this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
             console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
         }
@@ -63,13 +254,23 @@ class AvoInspector {
         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.");
+        if (typeof options.apiKey !== "string" || (0, utils_1.isValueEmpty)(options.apiKey)) {
+            throw new Error(NO_API_KEY_MESSAGE);
+        }
+        else if (/[\r\n\0]/.test(options.apiKey)) {
+            // The spec's exact message covers CR, LF and NUL.
+            throw new Error("[Avo Inspector] API key contains a control character. The API key is sent as a request header and cannot contain CR, LF, or NUL.");
+        }
+        else if ((0, utils_1.hasHeaderControlChar)(options.apiKey)) {
+            throw new Error("[Avo Inspector] apiKey must not contain control characters");
+        }
+        else if ((0, utils_1.hasNonLatin1Char)(options.apiKey)) {
+            throw new Error("[Avo Inspector] apiKey must only contain characters that can be sent in an HTTP header");
         }
         else {
             this.apiKey = options.apiKey;
         }
-        if ((0, utils_1.isValueEmpty)(options.version)) {
+        if (typeof options.version !== "string" || (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 {
@@ -94,28 +295,158 @@ class AvoInspector {
         }
         this.avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion, this.publicEncryptionKey);
         this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
+        const batchOptions = AvoInspector.resolveBatchOptions(options);
+        // dev sends every event immediately, whatever was configured.
+        this.batchSize =
+            this.environment === AvoInspectorEnv_1.AvoInspectorEnv.Dev ? 1 : batchOptions.batchSize;
+        // Not clamped: the conformance suite (batch-4) requires FIFO overflow in this case.
+        if (this.batchSize > batchOptions.maxQueueSize) {
+            console.warn("[Avo Inspector] batchSize " + this.batchSize + " is larger than maxQueueSize " +
+                batchOptions.maxQueueSize + ", so a batch never fills: events are sent only by the " +
+                "scheduled flush or flush(), and the oldest are dropped once " +
+                batchOptions.maxQueueSize + " are buffered. Set batchSize to at most maxQueueSize.");
+        }
+        this.batchQueue = new AvoBatchQueue_1.AvoBatchQueue(Object.assign(Object.assign({}, batchOptions), { batchSize: this.batchSize }), (batch) => this.sendBatch(batch), "failed", 
+        // A batch is in flight from the moment it is swapped out, even while it waits for a
+        // send slot, so flush() waits for it.
+        (outcome) => this.trackPending(outcome));
         // Initialize event spec validation for dev/staging only
         if (this.environment !== AvoInspectorEnv_1.AvoInspectorEnv.Prod) {
-            this.eventSpecFetcher = new AvoEventSpecFetcher_1.AvoEventSpecFetcher(this.apiKey);
+            // Spec fetches follow the track endpoint to a mock server, so validation runs there too.
+            this.eventSpecFetcher = new AvoEventSpecFetcher_1.AvoEventSpecFetcher(this.apiKey, this.avoNetworkCallsHandler.mockEndpoint);
             this.eventSpecCache = new AvoEventSpecCache_1.AvoEventSpecCache();
             this.eventValidator = new EventValidator_1.EventValidator();
         }
     }
-    trackSchemaFromEvent(eventName, eventProperties, streamId) {
+    static resolveBatchOptions(options) {
+        const pick = (name, value, fallback, isValid) => {
+            if (value === undefined || value === null) {
+                return fallback;
+            }
+            if (typeof value === "number" && isValid(value)) {
+                return value;
+            }
+            console.warn(
+            // valueToString: concatenation throws for a symbol or a null-prototype object.
+            "[Avo Inspector] Invalid " + name + " " + valueToString(value) + ". Using default " + fallback + ".");
+            return fallback;
+        };
+        const isPositiveInteger = (v) => Number.isInteger(v) && v >= 1;
+        return {
+            batchSize: pick("batchSize", options.batchSize, DEFAULT_BATCH_SIZE, isPositiveInteger),
+            batchFlushSeconds: pick("batchFlushSeconds", options.batchFlushSeconds, DEFAULT_BATCH_FLUSH_SECONDS, (v) => Number.isFinite(v) && v > 0),
+            maxQueueSize: pick("maxQueueSize", options.maxQueueSize, DEFAULT_MAX_QUEUE_SIZE, isPositiveInteger),
+            disableBatchTimer: options.disableBatchTimer === true,
+        };
+    }
+    /**
+     * Resolves the gateway options for one event. outputReference / originHint are
+     * omitted when blank; appVersion is the per-event override, null for a
+     * source-scoped event without one, else the instance version.
+     */
+    resolveGatewayFields(options) {
+        const opts = options !== null && typeof options === "object" ? options : {};
+        const outputReference = (0, utils_1.normalizeOption)(opts.outputReference);
+        const originHint = (0, utils_1.normalizeOption)(opts.originHint);
+        const originAppVersion = (0, utils_1.normalizeOption)(opts.originAppVersion);
+        const resolved = {
+            gatewayScoped: outputReference !== undefined ||
+                originHint !== undefined ||
+                originAppVersion !== undefined,
+            appVersion: originAppVersion !== undefined
+                ? originAppVersion
+                : originHint !== undefined
+                    ? null
+                    : this.version,
+        };
+        if (outputReference !== undefined) {
+            resolved.outputReference = outputReference;
+        }
+        if (originHint !== undefined) {
+            resolved.originHint = originHint;
+        }
+        return resolved;
+    }
+    // Warns (always on, rate-limited) when the event has keys other than InspectorEvent's,
+    // such as a typo; the known keys are still used and the event is still tracked.
+    // Never throws: listing a proxy's keys can.
+    static warnUnknownEventKeys(event) {
+        let unknown;
         try {
+            unknown = Object.keys(event).filter((key) => KNOWN_EVENT_KEYS.indexOf(key) < 0);
+        }
+        catch (e) {
+            return;
+        }
+        if (unknown.length > 0) {
+            AvoLog_1.AvoLog.unknownEventKeys(unknown, KNOWN_EVENT_KEYS);
+        }
+    }
+    /**
+     * Extracts the event schema and queues it for the Inspector API.
+     *
+     * Resolves with the schema once the event is queued. In dev (batch size 1) the send
+     * happens within the call and a non-200 response resolves `[]`; with batching the
+     * batch's HTTP outcome is not observable here. Buffered events are only delivered
+     * by a later size or time trigger, or by `flush()` — call `flush()` before exit.
+     *
+     * Anything but an object (such as a 1.x call `trackSchemaFromEvent(name, properties)`)
+     * sends nothing, prints an always-on error naming the fix, and resolves `[]`.
+     */
+    trackSchemaFromEvent(event) {
+        if (event === null || typeof event !== "object" || Array.isArray(event)) {
+            AvoLog_1.AvoLog.notAnInspectorEvent();
+            return Promise.resolve([]);
+        }
+        AvoInspector.warnUnknownEventKeys(event);
+        const call = { schema: [] };
+        let work;
+        try {
+            // Each field is read once, here: a getter on the event runs only once.
+            const { eventName, eventProperties, streamId, outputReference, originHint, originAppVersion } = event;
+            work = this.track(eventName, 
+            // Absent or null: no properties. Every step below handles both, as for a JS caller.
+            eventProperties, false, null, null, streamId, { outputReference, originHint, originAppVersion }, call);
+        }
+        catch (e) {
+            AvoLog_1.AvoLog.internal(e);
+            work = Promise.reject(AvoLog_1.INTERNAL_ERROR_MESSAGE);
+        }
+        return holdWhileAwaited(work, () => call.schema);
+    }
+    /**
+     * Codegen entry point: like `trackSchemaFromEvent`, and additionally records the
+     * Avo function's `eventId` / `eventHash` so the event is sent with `avoFunction: true`.
+     */
+    _avoFunctionTrackSchemaFromEvent(eventName, eventProperties, eventId, eventHash, streamId, options) {
+        const call = { schema: [] };
+        return holdWhileAwaited(this.track(eventName, eventProperties, true, eventId, eventHash, streamId, options, call), () => call.schema);
+    }
+    // Shared by the manual and Codegen entry points.
+    track(eventName, eventProperties, fromAvoFunction, eventId, eventHash, streamId, options, call) {
+        AvoInspector.lastTrackAt = (0, utils_1.monotonicNowMs)();
+        try {
+            if (this.destroyed) {
+                return Promise.resolve([]);
+            }
+            // A missing event name (null, undefined, non-string, empty or whitespace-only) is
+            // still reported to Inspector, under a placeholder name. A valid name is kept as is.
+            if (typeof eventName !== "string" || eventName.trim().length === 0) {
+                AvoLog_1.AvoLog.missingEventName();
+                eventName = AvoLog_1.MISSING_EVENT_NAME;
+            }
             const avoStreamId = new AvoStreamId_1.AvoStreamId(streamId);
             const anonymousId = avoStreamId.streamId || this.generatedAnonymousId;
-            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false, anonymousId)) {
+            const gatewayFields = this.resolveGatewayFields(options);
+            if (this.shouldRegisterEvent(eventName, eventProperties, fromAvoFunction, anonymousId, gatewayFields)) {
+                let eventSchema = this.extractSchema(eventProperties, false);
+                call.schema = eventSchema;
                 if (AvoInspector.shouldLog) {
-                    console.log("Avo Inspector: Supplied event " +
-                        eventName +
-                        " with params \n" +
-                        JSON.stringify(eventProperties));
+                    // The schema (names and types), never the values: the logging flag is shared by
+                    // every instance, so a prod instance can log once any dev instance turns it on.
+                    console.log("Avo Inspector: Supplied event " + eventName + " with schema " + JSON.stringify(eventSchema));
                 }
-                let eventSchema = this.extractSchema(eventProperties, false);
-                return this.sendEventWithOptionalValidation(eventName, eventSchema, null, null, anonymousId, eventProperties).then(() => {
-                    return eventSchema;
-                });
+                return this.sampleAndEnqueue(eventName, eventSchema, eventId, eventHash, anonymousId, eventProperties, gatewayFields);
             }
             else {
                 if (AvoInspector.shouldLog) {
@@ -125,102 +456,266 @@ class AvoInspector {
             }
         }
         catch (e) {
-            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
-            return Promise.reject("Avo Inspector: something went wrong. Please report to support@avo.app.");
+            AvoLog_1.AvoLog.internal(e);
+            return Promise.reject(AvoLog_1.INTERNAL_ERROR_MESSAGE);
         }
     }
-    _avoFunctionTrackSchemaFromEvent(eventName, eventProperties, eventId, eventHash, streamId) {
-        try {
-            const anonymousId = (streamId && streamId.length > 0) ? streamId : this.generatedAnonymousId;
-            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, true, anonymousId)) {
+    /**
+     * Codegen/manual deduplication applies only to plain calls. A call carrying gateway
+     * options is a distinct observation per gateway output and is always sent.
+     */
+    shouldRegisterEvent(eventName, eventProperties, fromAvoFunction, anonymousId, gatewayFields) {
+        if (gatewayFields.gatewayScoped) {
+            return true;
+        }
+        return this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, fromAvoFunction, anonymousId);
+    }
+    /**
+     * Samples the event, then queues it. When event spec validation is active the spec
+     * is fetched (or read from cache) first, so the event joins the queue once its
+     * validation results are merged in; flush() awaits that fetch before draining.
+     */
+    sampleAndEnqueue(eventName, eventSchema, eventId, eventHash, anonymousId, rawEventProperties, gatewayFields) {
+        const samplingRate = this.avoNetworkCallsHandler.getSamplingRate();
+        // Stamped at the call: with validation active the event may join the queue later.
+        const createdAt = new Date().toISOString();
+        if (Math.random() > samplingRate) {
+            if (AvoInspector.shouldLog) {
+                console.log("Avo Inspector: event " + eventName + " dropped due to sampling rate.");
+            }
+            return Promise.resolve(eventSchema);
+        }
+        // The rate that governed this event's sampling decision, not the one at send time.
+        const stamp = { createdAt, samplingRate };
+        const buildBody = (validationResult) => {
+            // The body gets its own copy: the call resolves with eventSchema, which the caller
+            // may change while the event still waits in the batch.
+            const bodySchema = JSON.parse(JSON.stringify(eventSchema));
+            let body;
+            if (validationResult) {
                 if (AvoInspector.shouldLog) {
-                    console.log("Avo Inspector: Supplied event " +
-                        eventName +
-                        " with params \n" +
-                        JSON.stringify(eventProperties));
+                    console.log("Avo Inspector: Sending validated event " + eventName);
                 }
-                let eventSchema = this.extractSchema(eventProperties, false);
-                return this.sendEventWithOptionalValidation(eventName, eventSchema, eventId, eventHash, anonymousId, eventProperties).then(() => {
-                    return eventSchema;
-                });
+                const eventProps = this.avoNetworkCallsHandler.buildEventProperties(bodySchema, rawEventProperties);
+                body = this.avoNetworkCallsHandler.bodyForValidatedEventSchemaCall(anonymousId, eventName, eventProps, eventId, eventHash, validationResult.metadata, validationResult.propertyResults, gatewayFields, stamp);
             }
             else {
-                if (AvoInspector.shouldLog) {
-                    console.log("Avo Inspector: Deduplicated event " + eventName);
+                body = this.avoNetworkCallsHandler.bodyForEventSchemaCall(anonymousId, eventName, bodySchema, eventId, eventHash, rawEventProperties, gatewayFields, stamp);
+            }
+            return body;
+        };
+        if (!this.isValidationActive()) {
+            return this.enqueue(buildBody(null), eventSchema).result;
+        }
+        // A flush() that starts while this validation is in progress sets flushRequested:
+        // the event then goes out once it is queued, in the drain shared by every validation
+        // that settles in the same event-loop turn, and flush() waits for that send.
+        const validation = { flushRequested: false };
+        const outcome = this.untilDestroyed(this.untilGivenUp(this.fetchAndValidate(eventName, eventSchema, anonymousId, rawEventProperties, gatewayFields)), null)
+            .catch((err) => {
+            if (AvoInspector.shouldLog) {
+                // Only the error's type: validation reads property values, which can end up in it.
+                console.warn("Avo Inspector: Event spec validation failed for event: " + eventName + ". Sending without validation. (" + AvoLog_1.AvoLog.errorType(err) + ")");
+            }
+            return null;
+        })
+            .then((validationResult) => {
+            if (this.destroyed) {
+                return { result: Promise.resolve([]), send: null };
+            }
+            try {
+                const enqueued = this.enqueue(buildBody(validationResult), eventSchema);
+                let send = enqueued.send;
+                if (send === null && validation.flushRequested) {
+                    // flush() waits for the batch that carries this event. Another drain (a size
+                    // trigger or the timer) may swap it out before the scheduled one runs, so the
+                    // wait follows the buffered batch, not this particular drain.
+                    send = this.batchQueue.bufferedBatchOutcome();
+                    this.drainThisTurn();
                 }
-                return Promise.resolve([]);
+                return { result: enqueued.result, send };
             }
+            catch (err) {
+                // Same outcome as a synchronous internal error on the unvalidated path (SPEC §4.2
+                // step 5): logged, and the call rejects with the internal error message.
+                AvoLog_1.AvoLog.internal(err);
+                return { result: null, send: null };
+            }
+        });
+        this.validationOutcomes.add(outcome);
+        const validated = () => {
+            this.validationOutcomes.delete(outcome);
+        };
+        outcome.then(validated, validated);
+        // In flight until the event is queued and, if that triggered a send, until it settles.
+        const inFlight = outcome.then(({ send }) => (send ? send.then(() => undefined) : undefined));
+        this.validations.set(inFlight, validation);
+        const forget = () => {
+            this.validations.delete(inFlight);
+        };
+        inFlight.then(forget, forget);
+        this.trackPending(inFlight);
+        return outcome.then(({ result }) => result || Promise.reject(AvoLog_1.INTERNAL_ERROR_MESSAGE));
+    }
+    enqueue(body, eventSchema) {
+        const send = this.batchQueue.enqueue(body);
+        this.updateExitDrain();
+        if (this.batchSize === 1 && send !== null) {
+            // Immediate send: the HTTP outcome is observable per call. An event whose send is
+            // abandoned by destroy() is not delivered, so it resolves [] like a non-200.
+            return {
+                result: this.untilDestroyed(send.then((outcome) => (outcome === "non200" || this.destroyed ? [] : eventSchema)), []),
+                send,
+            };
         }
-        catch (e) {
-            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
-            return Promise.reject("Avo Inspector: something went wrong. Please report to support@avo.app.");
+        if (this.batchQueue.waitingLength >= AvoBatchQueue_1.BACKPRESSURE_WAITING_EVENTS) {
+            // Backpressure: the event is queued, but the call resolves only once a send slot
+            // frees up enough room, so an awaited loop cannot outrun the sends and overflow the
+            // backlog. A call that is not awaited is unaffected. destroy() resolves it [].
+            return {
+                result: this.untilDestroyed(this.batchQueue.whenBelowBackpressure().then(() => (this.destroyed ? [] : eventSchema)), []),
+                send,
+            };
         }
+        return { result: Promise.resolve(eventSchema), send };
+    }
+    sendBatch(batch) {
+        if (this.destroyed) {
+            return Promise.resolve("failed");
+        }
+        const send = this.avoNetworkCallsHandler.callInspectorWithBatchBody(batch).then((status) => {
+            if (typeof status === "number" && status !== 200) {
+                // Not logged for a send abandoned by destroy().
+                if (!this.destroyed) {
+                    AvoLog_1.AvoLog.rejected(status);
+                }
+                return "non200";
+            }
+            if (AvoInspector.shouldLog) {
+                batch.forEach((event) => {
+                    console.log("Avo Inspector: Saved event " + event.eventName + " with schema " + (0, utils_1.formatSchema)(event.eventProperties));
+                });
+            }
+            return "ok";
+        }, (err) => {
+            // At-most-once: a failed batch is dropped, never re-queued or retried.
+            if (!this.destroyed) {
+                AvoLog_1.AvoLog.failed(err);
+            }
+            return "failed";
+        });
+        return send;
+    }
+    isValidationActive() {
+        return this.eventSpecFetcher !== null;
     }
     /**
-     * Try to fetch event spec and validate, then send a single event call.
-     * If validation succeeds, sends a validated event (with results merged in).
-     * If unavailable, sends a plain event.
-     *
-     * Uses trackPending() to keep the Node process alive until the work completes,
-     * so short-lived processes (CLIs) don't exit before the send finishes — even
-     * when the caller doesn't await the returned promise.
+     * Sends every buffered event, then waits until all in-flight sends (and spec fetches
+     * that will enqueue) have completed or `timeoutMs` (default 10000) has elapsed.
+     * Resolves `true` if, when it resolves, this instance has nothing buffered, waiting or in
+     * flight (always after destroy()), and `false` if the timeout won. Never rejects. Call it
+     * before process exit or before a serverless handler returns.
      */
-    sendEventWithOptionalValidation(eventName, eventSchema, eventId, eventHash, anonymousId, rawEventProperties) {
-        const work = this.doSendEventWithOptionalValidation(eventName, eventSchema, eventId, eventHash, anonymousId, rawEventProperties);
-        this.trackPending(work);
-        return work;
+    flush() {
+        return __awaiter(this, arguments, void 0, function* (timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) {
+            const budget = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs >= 0
+                ? Math.min(timeoutMs, AvoBatchQueue_1.MAX_TIMER_MS)
+                : DEFAULT_FLUSH_TIMEOUT_MS;
+            // While an explicit flush runs, the exit drain holds the process until its deadline too.
+            const token = {};
+            AvoInspector.explicitFlushDeadlines.set(token, (0, utils_1.monotonicNowMs)() + budget);
+            try {
+                yield this.flushWithin(budget);
+            }
+            finally {
+                AvoInspector.explicitFlushDeadlines.delete(token);
+            }
+            return this.hasDrained();
+        });
     }
-    doSendEventWithOptionalValidation(eventName, eventSchema, eventId, eventHash, anonymousId, rawEventProperties) {
+    // Nothing buffered, waiting for a send slot, or in flight (spec validations included).
+    hasDrained() {
+        return (this.destroyed ||
+            (this.pending.size === 0 && this.batchQueue.length === 0 && this.batchQueue.waitingLength === 0));
+    }
+    // The body of flush(): also used by the exit drain, whose own deadline is not an explicit one.
+    // Resolves whether everything it waited for settled within the budget (false if the
+    // budget ran out first).
+    flushWithin(budget) {
         return __awaiter(this, void 0, void 0, function* () {
-            const validationResult = yield this.fetchAndValidate(eventName, eventSchema, anonymousId, rawEventProperties, eventId);
             try {
-                let body;
-                if (validationResult) {
-                    if (AvoInspector.shouldLog) {
-                        console.log("Avo Inspector: Sending validated event " + eventName);
-                    }
-                    const eventProps = this.avoNetworkCallsHandler.buildEventProperties(eventSchema, rawEventProperties);
-                    body = this.avoNetworkCallsHandler.bodyForValidatedEventSchemaCall(anonymousId, eventName, eventProps, eventId, eventHash, validationResult.metadata, validationResult.propertyResults);
+                if (this.destroyed) {
+                    return true;
                 }
-                else {
-                    body = this.avoNetworkCallsHandler.bodyForEventSchemaCall(anonymousId, eventName, eventSchema, eventId, eventHash, rawEventProperties);
+                // Only work started before this call, plus the batch it drains, is awaited.
+                const waitFor = Array.from(this.pending);
+                waitFor.forEach((promise) => {
+                    const validation = this.validations.get(promise);
+                    if (validation) {
+                        validation.flushRequested = true;
+                    }
+                });
+                const drained = this.batchQueue.drain();
+                if (drained !== null) {
+                    waitFor.push(drained);
                 }
-                yield this.avoNetworkCallsHandler.callInspectorWithBatchBody([body]);
-                if (AvoInspector.shouldLog) {
-                    const schemaString = eventSchema.map(p => '\t"' + p.propertyName + '": "' + p.propertyType + '"').join(";\n");
-                    console.log("Avo Inspector: Saved event " + eventName + " with schema {\n" + schemaString + "\n}");
+                if (waitFor.length === 0) {
+                    return true;
                 }
+                let timer;
+                const completed = yield Promise.race([
+                    Promise.allSettled(waitFor).then(() => true),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve(false), budget);
+                        timer.unref();
+                    }),
+                ]);
+                clearTimeout(timer);
+                return completed;
             }
-            catch (err) {
-                console.error("Avo Inspector: schema sending failed: " + err + ".");
+            catch (e) {
+                // flush() is a completion guarantee and never rejects.
+                return false;
+            }
+            finally {
+                // Counts whose window has expired are printed now; a count still inside its window
+                // stays pending, so an app that flushes after every event keeps the 10 s limit.
+                AvoLog_1.AvoLog.flushPending(true);
             }
         });
     }
+    /** @internal Test-only hook for the conformance harness; not part of the public API. */
+    _setSamplingRateForTesting(samplingRate) {
+        this.avoNetworkCallsHandler._setSamplingRateForTesting(samplingRate);
+    }
+    /** Turns the SDK's diagnostic logging on or off for every instance. */
     enableLogging(enable) {
         AvoInspector._shouldLog = enable;
     }
+    /** Returns the schema of `eventProperties` without tracking or sending anything. */
     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 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.");
-                }
+            // The scan compares against every recent Codegen entry, so it runs only when its
+            // warning can print (never on the tracking path, which passes false).
+            if (shouldLogIfEnabled &&
+                AvoInspector.shouldLog &&
+                this.avoDeduplicator.hasSeenEventParams(eventProperties, true)) {
+                console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your 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));
+                // No property values in logs; the parsed schema is logged below.
+                console.log("Avo Inspector: extracting schema");
             }
             const schema = AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventProperties);
             if (AvoInspector.shouldLog) {
-                const schemaString = schema.map(p => '\t"' + p.propertyName + '": "' + p.propertyType + '"').join(";\n");
-                console.log("Avo Inspector: Parsed schema {\n" + schemaString + "\n}");
+                console.log("Avo Inspector: Parsed schema " + (0, utils_1.formatSchema)(schema));
             }
             return schema;
         }
         catch (e) {
-            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            AvoLog_1.AvoLog.internal(e);
             return [];
         }
     }
@@ -228,7 +723,7 @@ class AvoInspector {
      * Fetch event spec and validate. Returns validation results + metadata if
      * validation succeeds, or null if unavailable (prod, no spec, fetch error).
      */
-    fetchAndValidate(eventName, eventSchema, anonymousId, rawEventProperties, eventId) {
+    fetchAndValidate(eventName, eventSchema, anonymousId, rawEventProperties, gatewayFields) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.eventSpecFetcher || !this.eventSpecCache || !this.eventValidator) {
                 if (AvoInspector.shouldLog) {
@@ -239,7 +734,16 @@ class AvoInspector {
                 }
                 return null;
             }
-            const cacheKey = AvoEventSpecCache_1.AvoEventSpecCache.makeKey(this.apiKey, anonymousId, eventName);
+            // The same normalized coordinates as on the track body: a gateway key answers the spec
+            // of that checkpoint, and each checkpoint's spec has its own cache entry and fetch.
+            const coordinates = {};
+            if (gatewayFields && gatewayFields.originHint !== undefined) {
+                coordinates.originHint = gatewayFields.originHint;
+            }
+            if (gatewayFields && gatewayFields.outputReference !== undefined) {
+                coordinates.outputReference = gatewayFields.outputReference;
+            }
+            const cacheKey = AvoEventSpecCache_1.AvoEventSpecCache.makeKey(this.apiKey, anonymousId, eventName, coordinates);
             const cache = this.eventSpecCache;
             const validator = this.eventValidator;
             const doValidate = (specResponse) => {
@@ -249,52 +753,106 @@ class AvoInspector {
                     }
                     return null;
                 }
-                const eventProperties = eventSchema.map((prop) => (Object.assign({ propertyName: prop.propertyName, propertyType: prop.propertyType }, (rawEventProperties && rawEventProperties[prop.propertyName] !== undefined
-                    ? { propertyValue: String(rawEventProperties[prop.propertyName]) }
-                    : {}))));
+                const specEventCount = specResponse.eventSpec.events.length;
                 if (AvoInspector.shouldLog) {
                     console.log("Avo Inspector: Validating event: " + eventName
-                        + " with " + eventProperties.length + " properties"
-                        + " against " + specResponse.eventSpec.properties.length + " spec properties");
+                        + " with " + eventSchema.length + " properties"
+                        + " against " + specEventCount + " spec event" + (specEventCount === 1 ? "" : "s"));
                 }
-                const validationId = eventId || eventName;
-                const results = validator.validate(specResponse.eventSpec, eventProperties, validationId);
+                const results = validator.validate(specResponse.eventSpec, eventSchema, rawEventProperties);
                 if (AvoInspector.shouldLog) {
                     console.log("Avo Inspector: Validation complete for event: " + eventName
-                        + " with " + results.length + " property results");
+                        + " with " + results.length + " failed propert" + (results.length === 1 ? "y" : "ies"));
                 }
                 return { metadata: specResponse.metadata, propertyResults: results };
             };
             // Check cache first
             const cached = cache.get(cacheKey);
+            if (cached === null) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Event spec cache hit (empty) for event: " + eventName + ". Sending without validation.");
+                }
+                return null;
+            }
             if (cached !== undefined) {
                 if (AvoInspector.shouldLog) {
                     console.log("Avo Inspector: Event spec cache hit for event: " + eventName);
                 }
                 return doValidate(cached);
             }
-            // Cache miss — fetch spec (process stays alive via trackPending)
+            // Cache miss — fetch spec (flush() awaits it via trackPending)
             if (AvoInspector.shouldLog) {
                 console.log("Avo Inspector: Event spec cache miss for event: " + eventName + ". Fetching before sending.");
             }
+            if (AvoInspector.waitingValidations >= MAX_WAITING_VALIDATIONS) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: " + MAX_WAITING_VALIDATIONS + " events are already waiting for an event spec. Sending " + eventName + " without validation.");
+                }
+                return null;
+            }
+            AvoInspector.waitingValidations++;
+            let waiting = true;
+            const release = () => {
+                if (waiting) {
+                    waiting = false;
+                    AvoInspector.waitingValidations--;
+                    this.releaseWaiting.delete(release);
+                }
+            };
+            this.releaseWaiting.add(release);
             const fetcher = this.eventSpecFetcher;
-            return new Promise((resolve) => {
-                fetcher.fetch(eventName, anonymousId, (result) => {
+            return new Promise((resolve, reject) => {
+                const onSpec = (result, notFound) => {
+                    release();
                     if (result !== null) {
                         cache.set(cacheKey, result);
-                        resolve(doValidate(result));
+                        // A throw here would be swallowed by the fetcher and leave this promise pending;
+                        // reject instead, so a miss falls back to an unvalidated send like a hit does.
+                        try {
+                            resolve(doValidate(result));
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
                     }
                     else {
+                        // Cached so a failing fetch is not repeated for every event: a 404 (no spec, such
+                        // as a gateway key without originHint) for the spec TTL, any other failure briefly.
+                        cache.set(cacheKey, null, notFound === true ? undefined : AvoEventSpecCache_1.TRANSIENT_FAILURE_TTL_MS);
                         if (AvoInspector.shouldLog) {
                             console.log("Avo Inspector: Event spec fetch returned null for event: " + eventName + ". Cached empty response. Sending without validation.");
                         }
                         resolve(null);
                     }
-                });
+                };
+                try {
+                    fetcher.fetch(eventName, anonymousId, onSpec, coordinates);
+                }
+                catch (err) {
+                    // No callback will come: free the slot and fall back to an unvalidated send.
+                    release();
+                    reject(err);
+                }
             });
         });
     }
+    /**
+     * Cancels and cleans up: discards the pending batch unsent, abandons in-flight
+     * requests and stops the flush timer. Does not flush. After destroy() the instance
+     * is terminated and trackSchemaFromEvent resolves [] without sending; a call still
+     * waiting on a spec fetch or on its immediate send also resolves [].
+     */
     destroy() {
+        this.destroyed = true;
+        const waiters = Array.from(this.destroyWaiters);
+        this.destroyWaiters.clear();
+        waiters.forEach((settle) => settle());
+        this.batchQueue.clear();
+        this.pending.clear();
+        this.validations.clear();
+        Array.from(this.releaseWaiting).forEach((release) => release());
+        this.updateExitDrain();
+        this.avoNetworkCallsHandler.abortInFlight();
         if (this.eventSpecFetcher) {
             this.eventSpecFetcher.destroy();
             this.eventSpecFetcher = null;
@@ -304,12 +862,122 @@ class AvoInspector {
             this.eventSpecCache = null;
         }
         this.eventValidator = null;
-        if (this.keepAliveTimer !== null) {
-            clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = null;
-        }
-        this.pendingCount = 0;
+        // Destroy is final: report every pending count now.
+        AvoLog_1.AvoLog.flushPending();
     }
 }
 exports.AvoInspector = AvoInspector;
+// Best-effort delivery at exit: when the event loop empties ("beforeExit"), every
+// instance with buffered or in-flight events is flushed. One listener serves all
+// instances, and only instances with work are registered, so idle instances are not
+// retained. The listener schedules nothing when there is nothing to send, so it never
+// keeps the process alive on its own. "beforeExit" does not fire on process.exit() or
+// on signals; callers flush() there.
+AvoInspector.instancesWithWork = new Set();
+AvoInspector.exitDrainArmed = false;
+AvoInspector.exitReportArmed = false;
+// One deadline for the whole exit, however often "beforeExit" fires during it. Cleared
+// once every instance has drained, in case the process carries on.
+AvoInspector.exitDeadline = null;
+// Events waiting for a spec fetch, across every instance (at most MAX_WAITING_VALIDATIONS).
+AvoInspector.waitingValidations = 0;
+// When any instance last tracked an event (monotonic clock).
+AvoInspector.lastTrackAt = -Infinity;
+// The exit deadline whose validation grace has been used.
+AvoInspector.validationGraceUsedFor = null;
+// Deadlines of explicit flush() calls still running, by call.
+AvoInspector.explicitFlushDeadlines = new Map();
+AvoInspector.drainOnExit = () => {
+    AvoInspector.exitDrainArmed = false;
+    const instances = Array.from(AvoInspector.instancesWithWork);
+    if (instances.length === 0) {
+        return;
+    }
+    const now = (0, utils_1.monotonicNowMs)();
+    // One deadline per exit: "beforeExit" re-fires while the same exit continues (also when
+    // the app's own beforeExit work keeps the loop alive past the deadline), so a hung
+    // endpoint cannot stretch it. Only a track after the deadline passed shows the process
+    // carried on from that exit; the next one then gets a new deadline.
+    const deadlinePassed = AvoInspector.exitDeadline !== null && now > AvoInspector.exitDeadline;
+    if (AvoInspector.exitDeadline === null ||
+        (deadlinePassed && AvoInspector.lastTrackAt > AvoInspector.exitDeadline)) {
+        AvoInspector.exitDeadline = now + DEFAULT_FLUSH_TIMEOUT_MS;
+    }
+    // An explicit flush() still running gets its full deadline, even past the drain's own.
+    let deadline = AvoInspector.exitDeadline;
+    AvoInspector.explicitFlushDeadlines.forEach((flushDeadline) => {
+        deadline = Math.max(deadline, flushDeadline);
+    });
+    const remaining = deadline - now;
+    if (remaining <= 0) {
+        // Out of time: let the process exit; what is still unsent is reported at the exit.
+        return;
+    }
+    // Spec-fetch sockets are unref'd, so "beforeExit" also fires while a script awaits a
+    // track whose spec is being fetched. Once per deadline, give pending validations a short
+    // grace, sending nothing: with a working spec endpoint they settle well within it, the
+    // script carries on and its batches stay whole. Settled in time with no fetch given up
+    // counts as a completed idle point (the deadline is renewed); otherwise the grace is
+    // spent and the next "beforeExit" drains.
+    const validations = instances.reduce((all, inspector) => all.concat(Array.from(inspector.validationOutcomes)), []);
+    if (validations.length > 0 && AvoInspector.validationGraceUsedFor !== AvoInspector.exitDeadline) {
+        AvoInspector.validationGraceUsedFor = AvoInspector.exitDeadline;
+        const exitDeadline = AvoInspector.exitDeadline;
+        const timeoutsBefore = AvoEventSpecFetcher_1.AvoEventSpecFetcher.timeouts;
+        let grace;
+        const graceOver = new Promise((resolve) => {
+            grace = setTimeout(() => resolve(false), Math.min(VALIDATION_GRACE_MS, remaining));
+        });
+        Promise.race([Promise.allSettled(validations).then(() => true), graceOver]).then((settled) => {
+            clearTimeout(grace);
+            if (settled && (0, utils_1.monotonicNowMs)() < exitDeadline && AvoEventSpecFetcher_1.AvoEventSpecFetcher.timeouts === timeoutsBefore) {
+                AvoInspector.exitDeadline = null;
+            }
+        });
+        AvoInspector.armExitDrain();
+        return;
+    }
+    // Request sockets are unref'd, so this timer is what keeps the process alive while
+    // everything left is sent at once (within the in-flight cap). Every instance drains
+    // what is ready now; events still being validated follow as they are validated, and
+    // halfway through the budget the validations still pending are given up, so those
+    // events go out unvalidated within the rest of it.
+    const keepAlive = setTimeout(() => { }, remaining);
+    const giveUp = setTimeout(() => {
+        instances.forEach((inspector) => inspector.giveUpValidations());
+    }, remaining / 2);
+    giveUp.unref();
+    Promise.all(instances.map((inspector) => inspector.flushWithin(remaining))).then((completed) => {
+        clearTimeout(keepAlive);
+        clearTimeout(giveUp);
+        // Finished before the budget ran out: the next "beforeExit" starts a new exit with a
+        // fresh deadline. Decided by which won the race, not by reading the clock: under load
+        // a timer can fire while the monotonic clock still reads just short of the deadline,
+        // and a timed-out drain would then be renewed for another 10 s.
+        if (completed.every((done) => done)) {
+            AvoInspector.exitDeadline = null;
+        }
+    });
+    // Re-arm so work added during the drain is sent at the next "beforeExit".
+    AvoInspector.armExitDrain();
+};
+// At the real exit (natural, or process.exit(); signals do not emit it), reports what
+// every instance with work still holds, synchronously: events never sent (buffered,
+// waiting for a slot, or still being validated) and events in sends not yet completed.
+AvoInspector.reportOnExit = () => {
+    let unsent = 0;
+    let unconfirmed = 0;
+    AvoInspector.instancesWithWork.forEach((inspector) => {
+        unsent += inspector.batchQueue.length + inspector.batchQueue.waitingLength + inspector.validationOutcomes.size;
+        unconfirmed += inspector.batchQueue.inFlightEvents;
+    });
+    AvoLog_1.AvoLog.enterExit();
+    if (unsent > 0) {
+        AvoLog_1.AvoLog.dropped(unsent, "unsent at exit");
+    }
+    if (unconfirmed > 0) {
+        AvoLog_1.AvoLog.dropped(unconfirmed, "unconfirmed at exit");
+    }
+    AvoLog_1.AvoLog.flushPending();
+};
 AvoInspector._shouldLog = false;