@pendo/agent 2.350.1 → 2.350.2

package/dist/dom.esm.js

@@ -7592,7 +7592,7 @@ function applyMatrix2dRect(matrix2d, rect) {
     return transformedRect;
 }
 
-var VERSION = '2.350.1_';
+var VERSION = '2.350.2_';
 
 var decodeURIComponent = _.isFunction(globalScope.decodeURIComponent) ? globalScope.decodeURIComponent : _.identity;
 

package/dist/pendo.module.js

@@ -4175,8 +4175,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.350.1_';
-let PACKAGE_VERSION = '2.350.1';
+let VERSION = '2.350.2_';
+let PACKAGE_VERSION = '2.350.2';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -12686,6 +12686,139 @@ var getURL = function () {
     return pendoDotUrl.get();
 };
 
+const UNSENT_EVENTS_KEY = 'unsentEvents';
+const UNSENT_EVENTS_MAX_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days
+function mergeEvents(target, source) {
+    _.each(source, (requests, key) => {
+        target[key] = (target[key] || []).concat(requests);
+    });
+    return target;
+}
+function migrateLegacyCookieEvents(events) {
+    const cookieValue = get_pendo_cookie(UNSENT_EVENTS_KEY);
+    if (cookieValue) {
+        try {
+            mergeEvents(events, JSON.parse(cookieValue));
+        }
+        catch (e) { }
+        clearCookie(getPendoCookieKey(UNSENT_EVENTS_KEY));
+    }
+}
+// the quota error doesn't say how much space is left, so halving keeps the
+// number of retries during pagehide small
+function dropOldestHalf(events) {
+    const entries = [];
+    _.each(events, (requests, key) => {
+        _.each(requests, (request) => {
+            entries.push({ key, request });
+        });
+    });
+    const newest = _.sortBy(entries, (entry) => entry.request.ts).slice(Math.ceil(entries.length / 2));
+    const remaining = {};
+    _.each(newest, (entry) => {
+        remaining[entry.key] = remaining[entry.key] || [];
+        remaining[entry.key].push(entry.request);
+    });
+    return remaining;
+}
+class LocalStorageEventBuffer {
+    constructor() {
+        this.events = {};
+        this.saved = [];
+    }
+    send(key, queue) {
+        const data = this.events[key];
+        if (!data)
+            return;
+        let request = data.shift();
+        while (request) {
+            queue.push(request);
+            request = data.shift();
+        }
+        delete this.events[key];
+    }
+    save(key, sendQueue) {
+        const previous = _.find(this.saved, (entry) => entry.sendQueue === sendQueue);
+        if (!previous && sendQueue.queue.length === 0)
+            return;
+        this.saved = _.without(this.saved, previous);
+        if (sendQueue.queue.length > 0) {
+            this.saved.push({ key, sendQueue, requests: sendQueue.queue.slice() });
+        }
+        this.dirty = true;
+    }
+    writeIfDirty() {
+        if (this.dirty) {
+            this.write();
+        }
+    }
+    remove(sendQueue, request) {
+        const entry = _.find(this.saved, (candidate) => candidate.sendQueue === sendQueue);
+        if (!entry)
+            return;
+        const index = _.indexOf(entry.requests, request);
+        if (index < 0)
+            return;
+        entry.requests.splice(index, 1);
+        if (entry.requests.length === 0) {
+            this.saved = _.without(this.saved, entry);
+        }
+        // rewriting the whole copy after every send is quadratic while a long backlog drains, so leave
+        // it for the next flushNow
+        this.dirty = true;
+    }
+    read(storage) {
+        /**
+        * If enabled, Pendo will write pending events to localStorage before unloading the page
+        * rather than attempting to send them. The events will be sent the next time the page is loaded.
+        *
+        * @name _pendo_unsentEvents
+        * @category Cookies/localStorage
+        * @access public
+        * @label UNSENT_EVENTS_KEY
+        */
+        storage.registry.addLocal(UNSENT_EVENTS_KEY, {
+            localStorageOnly: true,
+            duration: UNSENT_EVENTS_MAX_AGE
+        });
+        try {
+            this.events = JSON.parse(storage.read(UNSENT_EVENTS_KEY) || '{}');
+        }
+        catch (e) {
+            this.events = {};
+        }
+        migrateLegacyCookieEvents(this.events);
+        storage.clear(UNSENT_EVENTS_KEY);
+        this.storage = storage;
+        this.saved = [];
+        this.dirty = false;
+    }
+    // requests still in flight at teardown can finish afterwards, and a flushNow after that would
+    // write the saved copy under a key built from the now-cleared apiKey
+    teardown() {
+        this.storage = undefined;
+        this.saved = [];
+        this.dirty = false;
+    }
+    write(storage = this.storage) {
+        if (!storage)
+            return;
+        this.dirty = false;
+        let events = mergeEvents({}, this.events);
+        _.each(this.saved, (entry) => {
+            mergeEvents(events, { [entry.key]: entry.requests });
+        });
+        while (_.size(events) > 0) {
+            if (storage.write(UNSENT_EVENTS_KEY, JSON.stringify(events), UNSENT_EVENTS_MAX_AGE)) {
+                return;
+            }
+            events = dropOldestHalf(events);
+        }
+        storage.clear(UNSENT_EVENTS_KEY);
+    }
+}
+var localStorageEventBuffer = new LocalStorageEventBuffer();
+
 var buffers = {
     /* : events: Event[] */
     /* : silos: Silo[] */
@@ -12749,7 +12882,7 @@ function callLater(callback, n) {
  * @access public
  * @category Events
  * @param {Object} [options] - Options passed through to each queue's flush method
- * @param {boolean} [options.unload] - signals the page is unloading; drains the send queue using sendBeacon or sync XHR for reliable last-chance delivery
+ * @param {boolean} [options.unload] - signals the page is unloading; drains the send queue using sendBeacon or sync XHR for reliable last-chance delivery. With `analytics.localStorageUnload` enabled, unsent events are saved to localStorage instead and sent on the next page load, or on the next flush if the page doesn't unload
  * @param {boolean} [options.hidden] - signals the page is being hidden; drains the send queue immediately rather than waiting for the next timer tick
  * @returns {void}
  * @example
@@ -12762,6 +12895,7 @@ function flushNow(options) {
                 queue.flush(options);
             }
         });
+        localStorageEventBuffer.writeIfDirty();
     }
     catch (e) {
         log.critical('unhandled error while flushing event cache', { error: e });
@@ -12927,9 +13061,12 @@ class SendQueue {
         this.stopped = false;
     }
     push(...payload) {
-        this.queue.push(...payload);
+        this.enqueue(...payload);
         this.next();
     }
+    enqueue(...payload) {
+        this.queue.push(...payload);
+    }
     next() {
         if (this.queue.length && this.pending.size < 1) {
             const nextPayload = this.queue[0];
@@ -12953,6 +13090,9 @@ class SendQueue {
         if (index >= 0) {
             this.queue.splice(index, 1);
         }
+        if (this.onPass) {
+            this.onPass(payload);
+        }
         if (!this.stopped && dequeue) {
             this.next();
         }
@@ -13015,97 +13155,6 @@ class SendQueue {
     }
 }
 
-const UNSENT_EVENTS_KEY = 'unsentEvents';
-const UNSENT_EVENTS_MAX_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days
-function mergeEvents(target, source) {
-    _.each(source, (requests, key) => {
-        target[key] = (target[key] || []).concat(requests);
-    });
-    return target;
-}
-function migrateLegacyCookieEvents(events) {
-    const cookieValue = get_pendo_cookie(UNSENT_EVENTS_KEY);
-    if (cookieValue) {
-        try {
-            mergeEvents(events, JSON.parse(cookieValue));
-        }
-        catch (e) { }
-        clearCookie(getPendoCookieKey(UNSENT_EVENTS_KEY));
-    }
-}
-// the quota error doesn't say how much space is left, so halving keeps the
-// number of retries during pagehide small
-function dropOldestHalf(events) {
-    const entries = [];
-    _.each(events, (requests, key) => {
-        _.each(requests, (request) => {
-            entries.push({ key, request });
-        });
-    });
-    const newest = _.sortBy(entries, (entry) => entry.request.ts).slice(Math.ceil(entries.length / 2));
-    const remaining = {};
-    _.each(newest, (entry) => {
-        remaining[entry.key] = remaining[entry.key] || [];
-        remaining[entry.key].push(entry.request);
-    });
-    return remaining;
-}
-class LocalStorageEventBuffer {
-    constructor() {
-        this.events = {};
-    }
-    send(key, queue) {
-        const data = this.events[key];
-        if (!data)
-            return;
-        let request = data.shift();
-        while (request) {
-            queue.push(request);
-            request = data.shift();
-        }
-        delete this.events[key];
-    }
-    push(key, obj) {
-        const data = this.events[key] || [];
-        data.push(obj);
-        this.events[key] = data;
-    }
-    read(storage) {
-        /**
-        * If enabled, Pendo will write pending events to localStorage before unloading the page
-        * rather than attempting to send them. The events will be sent the next time the page is loaded.
-        *
-        * @name _pendo_unsentEvents
-        * @category Cookies/localStorage
-        * @access public
-        * @label UNSENT_EVENTS_KEY
-        */
-        storage.registry.addLocal(UNSENT_EVENTS_KEY, {
-            localStorageOnly: true,
-            duration: UNSENT_EVENTS_MAX_AGE
-        });
-        try {
-            this.events = JSON.parse(storage.read(UNSENT_EVENTS_KEY) || '{}');
-        }
-        catch (e) {
-            this.events = {};
-        }
-        migrateLegacyCookieEvents(this.events);
-        storage.clear(UNSENT_EVENTS_KEY);
-    }
-    write(storage) {
-        let events = this.events;
-        while (_.size(events) > 0) {
-            if (storage.write(UNSENT_EVENTS_KEY, JSON.stringify(events), UNSENT_EVENTS_MAX_AGE)) {
-                return;
-            }
-            events = dropOldestHalf(events);
-        }
-        storage.clear(UNSENT_EVENTS_KEY);
-    }
-}
-var localStorageEventBuffer = new LocalStorageEventBuffer();
-
 /*
  * These implementations are meant to help keep the agent's metrics usage aligned with
  * the expectations for the backend's open telemetry.
@@ -13807,6 +13856,10 @@ class SendQueueSplitter {
         const args = _.toArray(arguments);
         _.each(this.queues, (queue) => queue.push.apply(queue, args));
     }
+    enqueue() {
+        const args = _.toArray(arguments);
+        _.each(this.queues, (queue) => queue.enqueue.apply(queue, args));
+    }
     drain() {
         const args = _.toArray(arguments);
         return q.all(_.map(this.queues, (queue) => queue.drain.apply(queue, args)));
@@ -13826,12 +13879,6 @@ function createSendQueue(options, send, guaranteedSend) {
                     rt: failureCount
                 });
             }
-            if (options.localStorageUnload && isUnload) {
-                if (i === 0) {
-                    localStorageEventBuffer.push(options.beacon, request);
-                }
-                return q.resolve();
-            }
             if (isUnload && queue.failed()) {
                 return q.reject();
             }
@@ -13845,6 +13892,11 @@ function createSendQueue(options, send, guaranteedSend) {
         queue.onTimeout = function () {
             performanceMonitor.count(BEACON_GIF_FAILURES[options.beacon]);
         };
+        if (options.localStorageUnload && i === 0) {
+            queue.onPass = function (request) {
+                localStorageEventBuffer.remove(queue, request);
+            };
+        }
         queue.allowDrainWhileFailed = true;
         queue.retryPending = true;
         return queue;
@@ -13876,6 +13928,8 @@ class EventQueue {
         this.silos = options.silos || [];
         this.packageSilos = options.packageSilos;
         this.processSilos = options.processSilos;
+        this.beacon = options.beacon;
+        this.localStorageUnload = options.localStorageUnload;
         this.sendQueue = createSendQueue(options);
     }
     // silent skips the ptm lifecycle events, for a queue paused alongside the main one so they fire once.
@@ -13911,6 +13965,9 @@ class EventQueue {
     }
     flush({ unload = false, hidden = false } = {}) {
         const { cache, silos } = this;
+        if (!unload && !hidden) {
+            this.savedOnUnload = false;
+        }
         if (cache.length === 0 && silos.length === 0 && this.sendQueue.isEmpty())
             return;
         const leavingPage = unload || hidden;
@@ -13926,7 +13983,15 @@ class EventQueue {
                 requests.push(silo);
             });
         }, this);
-        if (unload || hidden) {
+        // queued but not sent: if the page stays alive the next flush sends them, and each one that goes out is
+        // removed from the saved copy. a real unload is followed by a hidden flush (unload/pagehide fire before
+        // visibilitychange), which has to save as well rather than send everything that was just saved
+        if (this.localStorageUnload && (unload || (hidden && this.savedOnUnload))) {
+            this.savedOnUnload = true;
+            this.sendQueue.enqueue(...requests);
+            localStorageEventBuffer.save(this.beacon, this.sendQueue.queues[0]);
+        }
+        else if (unload || hidden) {
             this.sendQueue.drain(requests, unload);
         }
         else {
@@ -31341,6 +31406,7 @@ function initialize(options) {
         }
         const localStorageUnloadEnabled = ConfigReader.get('analytics.localStorageUnload');
         localStorageEventBuffer.read(agentStorage);
+        teardownFns.push(() => localStorageEventBuffer.teardown());
         teardownFns.push(initializeEventBuffer({
             localStorageUnload: localStorageUnloadEnabled
         }));
@@ -31410,9 +31476,6 @@ function initialize(options) {
         teardownFns.push(() => Events.appHidden.off(flushOnAppHidden));
         const flushOnAppUnloaded = () => {
             flushNow({ unload: true });
-            if (localStorageUnloadEnabled) {
-                localStorageEventBuffer.write(agentStorage);
-            }
         };
         Events.appUnloaded.on(flushOnAppUnloaded);
         teardownFns.push(() => Events.appUnloaded.off(flushOnAppUnloaded));