@zoho_apptics/apptics-js-sdk 2.0.0-beta → 2.0.0-beta.2

package/dist/cjs/engagement/session.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var constants = require('../core/constants.js');
@@ -8,6 +8,7 @@ var utils = require('../core/utils.js');
 var storage = require('../core/storage.js');
 var env = require('../core/env.js');
 var consent = require('../core/consent.js');
+var locks = require('../core/locks.js');
 
 /** The most recently started item of `type` that is still open (endtime 0). */
 function latestOpen(type, items) {
@@ -58,16 +59,12 @@ function closeScreensOf(session, time) {
         }, Promise.resolve());
     });
 }
-/** `track_session: false`, Android's automaticSessionsTrackingStatus: no sessions are recorded. */
-function sessionsOff() {
-    return state.getConfig('track_session') === false; // no i18n
-}
 /**
  * Track the session.
  * @param sessionData A set of properties belonging to the session.
  */
 function trackSession(sessionData) {
-    if (!consent.canTrackEngagement('trackSession')) { // no i18n
+    if (!consent.canTrackEngagement('trackSession', constants.AP_CONSTANTS.SESSION)) { // no i18n
         return Promise.resolve();
     }
     if (sessionData && typeof sessionData !== 'object') { // no i18n
@@ -79,13 +76,16 @@ function trackSession(sessionData) {
     logger.Console.dir(sessionData);
     return written;
 }
-/** This tab's session when it has one, otherwise the newest open session in storage. */
+/**
+ * This tab's session while it is open, otherwise the newest open session in storage: the one the
+ * site's other tabs are on, which this tab joins rather than starting a second session beside it.
+ */
 function currentSession() {
     var mine = tabSessionId();
     return storage.engagement_transactions.all().then(function (items) {
         if (mine) {
             var ours = items.filter(function (item) {
-                return item.type == constants.AP_CONSTANTS.SESSION && item.id === mine;
+                return item.type == constants.AP_CONSTANTS.SESSION && item.id === mine && item.endtime === 0;
             })[0];
             if (ours) {
                 return ours;
@@ -94,6 +94,119 @@ function currentSession() {
         return latestOpen(constants.AP_CONSTANTS.SESSION, items);
     });
 }
+/**
+ * This page's own id, among the tabs sharing a session. New on every page load, so a reload or a
+ * duplicated tab counts as a tab of its own rather than as the one it came from. Made on first use,
+ * not when the module loads: getNewUUID reads `screen`, which a server-side render doesn't have.
+ */
+var tabIdValue = ''; // no i18n
+function tabId() {
+    if (tabIdValue === '') {
+        tabIdValue = utils.getNewUUID();
+    }
+    return tabIdValue;
+}
+/**
+ * The tabs of this site using a session. All of them share one session, which ends when the last
+ * of them closes (see endCurrentSession). Kept on the stored session, never sent: see
+ * sendEngagementData. A session stored by an older SDK has none, and counts as this tab's alone.
+ */
+function tabsOf(session) {
+    return Array.isArray(session.tabs) ? session.tabs.slice() : [];
+}
+function withThisTab(session) {
+    var tabs = tabsOf(session);
+    if (tabs.indexOf(tabId()) === -1) {
+        tabs.push(tabId());
+    }
+    return tabs;
+}
+/* ---------------- screen views left open by tabs that are gone ----------------
+ * A screen view is ended by the tab that opened it: by the next screen, or as the page hides or
+ * closes. A tab that reloads, closes or crashes before that write lands leaves its view open, and
+ * nothing ended it until the whole session did, which with tabs sharing one session can be hours.
+ *
+ * So each tab holds a Web Lock, `apptics-tab-<its id>`, for as long as it is open: the browser
+ * lets go of it the moment the tab is gone, however it went. A tab that starts, or comes back into
+ * view, ends every open view whose tab no longer holds its lock, at the time that tab was last seen
+ * active. Without the Web Locks API, views are left as before and end with their session. */
+const TAB_LOCK_PREFIX = 'apptics-tab-'; // no i18n
+/** A view this young may belong to a tab whose lock is not granted yet: left alone. */
+const YOUNG_VIEW_MS = 5000;
+function tabLocks() {
+    var locks = typeof navigator !== 'undefined' ? navigator.locks : undefined; // no i18n
+    return locks && typeof locks.request === 'function' && typeof locks.query === 'function' ? locks : undefined; // no i18n
+}
+var holdingTabLock = false;
+/** Takes this tab's lock, held until the page is gone. Once per page. */
+function holdTabLock() {
+    var locks = tabLocks();
+    if (!locks || holdingTabLock) {
+        return;
+    }
+    holdingTabLock = true;
+    locks.request(TAB_LOCK_PREFIX + tabId(), function () {
+        return new Promise(function () { });
+    }).catch(function () {
+        holdingTabLock = false;
+    });
+}
+/** Ends the open screen views of tabs that are gone. Resolves right away without Web Locks. */
+function closeScreensOfGoneTabs() {
+    var locks = tabLocks();
+    if (!locks) {
+        return Promise.resolve();
+    }
+    var mine = tabId();
+    return locks.query().then(function (state) {
+        var alive = {};
+        (state.held || []).concat(state.pending || []).forEach(function (lock) {
+            if (lock.name && lock.name.indexOf(TAB_LOCK_PREFIX) === 0) {
+                alive[lock.name.slice(TAB_LOCK_PREFIX.length)] = true;
+            }
+        });
+        var now = utils.nowMs();
+        return storage.engagement_transactions.all().then(function (items) {
+            var gone = items.filter(function (item) {
+                return item.type == constants.AP_CONSTANTS.SCREEN && item.endtime === 0 && typeof item.tab === 'string' // no i18n
+                    && item.tab !== mine && !alive[item.tab] && now - item.starttime > YOUNG_VIEW_MS;
+            });
+            if (gone.length) {
+                logger.Console.log('closeScreensOfGoneTabs: ending ' + gone.length + ' screen view(s) left open by a tab that is gone'); // no i18n
+            }
+            return gone.reduce(function (done, item) {
+                // when that tab was last seen with the view open, not now: the time since is not time spent
+                var end = Math.max(item.starttime, Number(item.lastseen) || item.starttime);
+                return done.then(function () {
+                    return storage.engagement_transactions.update(Object.assign({}, item, { endtime: end }));
+                });
+            }, Promise.resolve());
+        });
+    }).catch(function (err) {
+        logger.Console.log('closeScreensOfGoneTabs: ' + err); // no i18n
+    });
+}
+/** Notes on this tab's open view that the tab is still here, the end a gone tab's view is given. */
+function markScreenSeen(time) {
+    var current = state._ZAP._current_screen;
+    if (!current || !current.id || current.endtime) {
+        return Promise.resolve();
+    }
+    return storage.engagement_transactions.all().then(function (items) {
+        var open = items.filter(function (item) {
+            return item.type == constants.AP_CONSTANTS.SCREEN && item.id === current.id && item.endtime === 0;
+        })[0];
+        return open ? storage.engagement_transactions.update(Object.assign({}, open, { lastseen: time })) : undefined;
+    });
+}
+/**
+ * Every change to the session runs under a lock shared by the site's tabs: each one reads the
+ * stored session, changes it and writes it back, and two tabs doing that at once would each write
+ * over the other's change.
+ */
+function withSessionLock(run) {
+    return locks.withLock('session', run); // no i18n
+}
 /** The id of this tab's session. sessionStorage is per tab and survives a reload. */
 const TAB_KEY = 'apptics-session'; // no i18n
 function tabSessionId() {
@@ -112,9 +225,9 @@ function rememberTabSession(id) {
         // the session still works, it just can't be recognised after a reload
     }
 }
-/** True until the first session on this device has been recorded. */
+/** True until the first session on this device has been recorded: device_info's hadsession. */
 function isFirstEverSession() {
-    return utils.isEmpty(storage.user_defaults.item(HAD_SESSION_KEY));
+    return storage.getKeyFromDeviceInfo(HAD_SESSION_KEY) !== true;
 }
 const HAD_SESSION_KEY = 'hadsession'; // no i18n
 /**
@@ -151,7 +264,7 @@ function commitPendingSession() {
     // the flag is set here rather than at the start, so a dropped session does not consume it and
     // leave the next real session reporting firstsession false
     if (session.firstsession) {
-        storage.user_defaults.add(HAD_SESSION_KEY, true);
+        storage.setDeviceInfoKey(HAD_SESSION_KEY, true);
     }
     return trackSession(session);
 }
@@ -176,6 +289,7 @@ function startNewSession(time) {
         firstsession: isFirstEverSession(),
         networkstatus: env.getNetworkStatus(),
         lastactivetime: time,
+        tabs: [tabId()],
     };
     // ram is optional in sessionWebSDK but checked against ram_rom ('4 GB'), which an empty
     // string cannot match. navigator.deviceMemory is Chromium-only, so Firefox and Safari have
@@ -202,25 +316,126 @@ function startNewSession(time) {
 /** The un-deferred path, for a minimum of 0. */
 function commitNow(session) {
     if (session.firstsession) {
-        storage.user_defaults.add(HAD_SESSION_KEY, true);
+        storage.setDeviceInfoKey(HAD_SESSION_KEY, true);
     }
     return trackSession(session);
 }
+/** Whether this tab is inactive: hidden, minimised, or its window has lost focus. */
+var inactive = false;
+var inactivityTimer = null;
+/**
+ * The tab went inactive. That moment becomes the session's lastactivetime, the time it ends at if
+ * the user does not come back within inactiveduration. If they do not, the session is ended at it
+ * then, and `onEnded` sends it, rather than staying open until they return or the tab closes.
+ * Going inactive twice (a window blur, then the tab hidden) keeps the first moment.
+ */
+function markTabInactive(onEnded) {
+    var first = !inactive;
+    inactive = true;
+    if (inactivityTimer !== null) {
+        clearTimeout(inactivityTimer);
+    }
+    inactivityTimer = setTimeout(function () {
+        inactivityTimer = null;
+        endInactiveSession().then(function (ended) {
+            if (ended) {
+                onEnded();
+            }
+        });
+    }, state._ZAP.inactiveduration * 60 * 1000 + 1000);
+    return first ? updateLastActiveTimeOfSession() : Promise.resolve();
+}
+/**
+ * The tab is active again. The caller then settles the session (checkAndUpdateSession): back
+ * within inactiveduration it continues, later it has ended and a new one starts.
+ */
+function markTabActive() {
+    inactive = false;
+    if (inactivityTimer !== null) {
+        clearTimeout(inactivityTimer);
+        inactivityTimer = null;
+    }
+}
+/** reset(): no timer left running, and the tab counts as active. */
+function resetInactivity() {
+    markTabActive();
+}
+/**
+ * inactiveduration has passed with the tab inactive: the session ends at its lastactivetime, when
+ * the user left, so the time away is not counted. Resolves true when it ended one. While another
+ * tab of the site is still on the session, this tab only leaves it; one whose lastactivetime is
+ * recent is in use elsewhere and is left alone.
+ */
+function endInactiveSession() {
+    if (!state._ZAP._token || env.is_apptics_disabled()) {
+        return Promise.resolve(false);
+    }
+    var ended = false;
+    return withSessionLock(function () {
+        return currentSession().then(function (_currentSession) {
+            if (!_currentSession || _currentSession.endtime !== 0) {
+                return;
+            }
+            var lastActive = Number(_currentSession.lastactivetime) || utils.nowMs();
+            if (utils.nowMs() - lastActive < state._ZAP.inactiveduration * 60 * 1000) {
+                return;
+            }
+            var others = tabsOf(_currentSession).filter(function (tab) { return tab !== tabId(); });
+            if (others.length > 0) {
+                var left = Object.assign({}, _currentSession, { tabs: others });
+                state._ZAP._current_session = left;
+                return storage.engagement_transactions.update(left);
+            }
+            var endAt = Math.max(lastActive, Number(_currentSession.starttime) || lastActive);
+            var closed = Object.assign({}, _currentSession, { endtime: endAt, tabs: [] });
+            state._ZAP._current_session = closed;
+            ended = true;
+            logger.Console.log('session: inactive for ' + state._ZAP.inactiveduration + ' minutes, so it ends when the user left, ' + endAt); // no i18n
+            return storage.engagement_transactions.update(closed).then(function () {
+                return closeScreensOf(closed, endAt);
+            });
+        });
+    }).then(function () {
+        return ended;
+    });
+}
 /**
- * Closes this tab's session, so it can be sent: the tab is closing or the page is being replaced.
- * Nothing happens when the session is already closed.
+ * This tab is closing, or the page is being replaced. The session ends here when this is the last
+ * tab using it, so it can be sent; while another tab of the site is still on it, this tab only
+ * leaves it, and the last tab to close ends it. Nothing happens when it is already closed.
+ *
+ * A tab closed while inactive ends the session when the user left (its lastactivetime), not when
+ * the tab closed: the time it sat hidden or in the background is not session time.
  */
 function endCurrentSession() {
     var time = utils.nowMs();
+    var wasInactive = inactive;
+    markTabActive();
     // nothing was tracked and the minimum was never reached: this visit is not reported at all
     if (dropPendingSession()) {
         return Promise.resolve();
     }
+    return withSessionLock(function () {
+        return closeOrLeaveSession(time, wasInactive);
+    });
+}
+function closeOrLeaveSession(now, wasInactive) {
     return currentSession().then(function (_currentSession) {
         if (!_currentSession || _currentSession.endtime !== 0) {
             return;
         }
-        var closed = Object.assign({}, _currentSession, { endtime: time, lastactivetime: time });
+        var lastActive = Number(_currentSession.lastactivetime) || 0;
+        var time = wasInactive && lastActive > 0
+            ? Math.max(Math.min(lastActive, now), Number(_currentSession.starttime) || 0)
+            : now;
+        var others = tabsOf(_currentSession).filter(function (tab) { return tab !== tabId(); });
+        if (others.length > 0) {
+            var left = Object.assign({}, _currentSession, { tabs: others, lastactivetime: time });
+            state._ZAP._current_session = left;
+            logger.Console.log('endCurrentSession: ' + others.length + ' other tab(s) still on this session, so it stays open'); // no i18n
+            return storage.engagement_transactions.update(left);
+        }
+        var closed = Object.assign({}, _currentSession, { endtime: time, lastactivetime: time, tabs: [] });
         state._ZAP._current_session = closed;
         logger.Console.log('endCurrentSession: closing the session opened at ' + closed.starttime); // no i18n
         return storage.engagement_transactions.update(closed).then(function () {
@@ -257,18 +472,21 @@ function closeAbandonedSessions() {
 }
 function checkAndUpdateSession() {
     if (!state._ZAP._token) {
-        logger.logFailure(constants.AP_LOG_MODULE.SESSION, 'checkAndUpdateSession: You must call apptics.init() first'); // no i18n
+        logger.logFailure(constants.AP_LOG_MODULE.SESSION, 'checkAndUpdateSession: You must call Apptics.init() first'); // no i18n
         return Promise.resolve();
     }
     if (env.is_apptics_disabled()) {
         return Promise.resolve();
     }
-    if (sessionsOff()) {
-        return Promise.resolve();
-    }
     var time = utils.nowMs();
-    // a tab that was killed before it could close its session: close it so it gets sent
-    return closeAbandonedSessions().then(currentSession).then(function (_currentSession) {
+    return withSessionLock(function () {
+        return settleSession(time);
+    });
+}
+function settleSession(time) {
+    // a tab that was killed before it could close its session: close it so it gets sent; and the
+    // screen views left open by tabs that are gone, so they end now rather than with the session
+    return closeAbandonedSessions().then(closeScreensOfGoneTabs).then(currentSession).then(function (_currentSession) {
         // a closed session belongs to a tab that has gone: this tab starts its own
         if (!_currentSession || _currentSession.endtime !== 0) {
             return startNewSession(time);
@@ -289,13 +507,14 @@ function checkAndUpdateSession() {
             });
         }
         logger.Console.log('checkAndUpdateSession: User is back before ' + state._ZAP.inactiveduration + ' minutes so updating the lastactivitytime - ' + time); // no i18n
-        return updateLastActiveTimeOfSession();
+        return touchSession();
     });
 }
 function updateLastActiveTimeOfSession() {
-    if (sessionsOff()) {
-        return Promise.resolve();
-    }
+    return withSessionLock(touchSession);
+}
+/** Marks the session active now, with this tab among its tabs. Callers hold the session lock. */
+function touchSession() {
     var time = utils.nowMs();
     // a pending session is not in the store yet, so it is updated in place instead
     if (pendingSession) {
@@ -308,20 +527,28 @@ function updateLastActiveTimeOfSession() {
             return;
         }
         logger.Console.log('updateLastActiveTimeOfSession: Updating the lastactivitytime - ' + time); // no i18n
-        var _newSession = Object.assign({}, _currentSession, { lastactivetime: time });
+        var _newSession = Object.assign({}, _currentSession, { lastactivetime: time, tabs: withThisTab(_currentSession) });
         state._ZAP._current_session = _newSession;
         return storage.engagement_transactions.update(_newSession);
+    }).then(function () {
+        return markScreenSeen(time);
     });
 }
 
 exports.checkAndUpdateSession = checkAndUpdateSession;
 exports.closeAbandonedSessions = closeAbandonedSessions;
 exports.closeScreen = closeScreen;
+exports.closeScreensOfGoneTabs = closeScreensOfGoneTabs;
 exports.commitPendingSession = commitPendingSession;
 exports.currentSession = currentSession;
 exports.dropPendingSession = dropPendingSession;
 exports.endCurrentSession = endCurrentSession;
+exports.holdTabLock = holdTabLock;
+exports.markTabActive = markTabActive;
+exports.markTabInactive = markTabInactive;
+exports.resetInactivity = resetInactivity;
 exports.startNewSession = startNewSession;
+exports.tabId = tabId;
 exports.trackSession = trackSession;
 exports.updateLastActiveTimeOfSession = updateLastActiveTimeOfSession;
 exports.updateScreenWithEndtime = updateScreenWithEndtime;

package/dist/cjs/engagement/track.d.ts

@@ -1,12 +1,12 @@
 import type { Dict, Properties } from '../types.js';
 import { type DefinedEvent } from './defined-events.js';
 /**
- * Records an event: `trackEvent(name, group?, properties?)`, or a defined event with
+ * Records an event: `trackEvent(name, group, properties?)`, or a defined event with
  * `trackEvent(DefinedEvents.AP_USER_LOGIN, properties?)`, which brings its own group.
  *
- * As on Android, an invalid name or group is not logged. A group left out is `default`, so the
- * one-argument form keeps working; a group given but invalid is a mistake worth being told about,
- * not one to file quietly under `default`.
+ * The group is required. An event without one, or with an invalid name or group, is not logged,
+ * and the console says why (debug or not): filing it under a group the app never named would hide
+ * the mistake.
  */
 export declare function trackEvent(eventName: string | DefinedEvent, groupName?: string | Properties, jsonObj?: Properties): void;
 /** The app's own screen view. Automatic screen tracking calls recordScreen() instead. */

package/dist/cjs/engagement/track.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var constants = require('../core/constants.js');
@@ -16,16 +16,30 @@ var apiRules = require('./api-rules.js');
 var definedEvents = require('./defined-events.js');
 var autoScreen = require('./auto-screen.js');
 
+/** Messages already printed, so a name refused in a loop says so once. */
+var refusedSaid = {};
 /**
- * Records an event: `trackEvent(name, group?, properties?)`, or a defined event with
+ * A call the SDK refused because of what the app passed it (an invalid event, group or screen
+ * name): reported as every failure is, and said in the console too, debug or not, once per
+ * message. Nothing else tells an integrator why the event or screen never shows up.
+ */
+function refused(module, message) {
+    logger.logFailure(module, message);
+    if (!refusedSaid[message]) {
+        refusedSaid[message] = true;
+        logger.warnAlways(message);
+    }
+}
+/**
+ * Records an event: `trackEvent(name, group, properties?)`, or a defined event with
  * `trackEvent(DefinedEvents.AP_USER_LOGIN, properties?)`, which brings its own group.
  *
- * As on Android, an invalid name or group is not logged. A group left out is `default`, so the
- * one-argument form keeps working; a group given but invalid is a mistake worth being told about,
- * not one to file quietly under `default`.
+ * The group is required. An event without one, or with an invalid name or group, is not logged,
+ * and the console says why (debug or not): filing it under a group the app never named would hide
+ * the mistake.
  */
 function trackEvent(eventName, groupName, jsonObj) {
-    if (!consent.canTrackEngagement('trackEvent')) { // no i18n
+    if (!consent.canTrackEngagement('trackEvent', constants.AP_CONSTANTS.EVENT)) { // no i18n
         return;
     }
     var defined = definedEvents.asDefinedEvent(eventName);
@@ -37,14 +51,17 @@ function trackEvent(eventName, groupName, jsonObj) {
     }
     else {
         if (typeof eventName !== 'string' || !validate.validateEventOrGroup(eventName)) { // no i18n
-            logger.logFailure(constants.AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid eventName: ' + String(eventName)); // no i18n
+            refused(constants.AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: Invalid eventName: ' + String(eventName)); // no i18n
             return;
         }
-        if (groupName === undefined || groupName === null || groupName === '') { // no i18n
-            groupName = constants.AP_CONFIG.default_group_name;
+        // the group is required: an event without one (or with its properties in the group's
+        // place) is not logged, and the console says why
+        if (groupName === undefined || groupName === null || groupName === '' || typeof groupName === 'object') { // no i18n
+            refused(constants.AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: groupName is required for "' + eventName + '": addEvent(eventName, groupName, properties?)'); // no i18n
+            return;
         }
-        else if (typeof groupName !== 'string' || !validate.validateEventOrGroup(groupName)) { // no i18n
-            logger.logFailure(constants.AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
+        if (typeof groupName !== 'string' || !validate.validateEventOrGroup(groupName)) { // no i18n
+            refused(constants.AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
             return;
         }
     }
@@ -70,7 +87,7 @@ function trackEvent(eventName, groupName, jsonObj) {
     session.commitPendingSession();
     debug.noteDebugActivity();
     storage.engagement_transactions.add(eventData);
-    logger.Console.log('AppticsEvents.addEvent(\'' + eventName + '\',\'' + groupName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    logger.Console.log('AppticsEvent.addEvent(\'' + eventName + '\',' + '\'' + groupName + '\'' + ',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     logger.Console.dir(eventData);
 }
 /**
@@ -80,7 +97,7 @@ function trackEvent(eventName, groupName, jsonObj) {
  */
 function inScreenAt(screenName, jsonObj, id, startedAt) {
     if (!validate.validateScreenName(screenName)) {
-        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        refused(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreen.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
         return;
     }
     // the app named this screen itself: the automatic view of the same navigation gives way to it
@@ -90,7 +107,7 @@ function inScreenAt(screenName, jsonObj, id, startedAt) {
 /** Ends the screen view inScreen() began, as Android's AppticsScreenTracker.outScreen(id). */
 function outScreenAt(id, endedAt) {
     if (utils.isEmpty(id)) {
-        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.outScreen: no screen id given'); // no i18n
+        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreen.outScreen: no screen id given'); // no i18n
         return;
     }
     session.closeScreen(id, endedAt);
@@ -103,11 +120,11 @@ function outScreenAt(id, endedAt) {
  * An open view is not sent until it is closed, as an open session is not.
  */
 function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
-    if (!consent.canTrackEngagement('inScreen')) { // no i18n
+    if (!consent.canTrackEngagement('inScreen', constants.AP_CONSTANTS.SCREEN)) { // no i18n
         return;
     }
     if (!validate.validateScreenName(screenName)) {
-        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        refused(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreen.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
         return;
     }
     jsonObj = jsonObj || {};
@@ -124,7 +141,10 @@ function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
         networkstatus: env.getNetworkStatus(),
         orientation: env.getOrientation(),
         sessionstarttime: state._ZAP._current_session.starttime || time,
-        customproperties: _jsonObj
+        customproperties: _jsonObj,
+        // the tab showing it, so a tab that is gone can have its view ended (closeScreensOfGoneTabs).
+        // SDK bookkeeping, removed before sending, as lastseen is
+        tab: session.tabId(),
     };
     // the screen being left ends where this one starts
     var previous = state._ZAP._current_screen && state._ZAP._current_screen.id;
@@ -137,7 +157,7 @@ function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
     // `implicit`: a view recorded only so a heatmap record has one to belong to. Kept on the
     // in-memory copy alone, never on the stored item, which goes to the server as it is
     state._ZAP._current_screen = implicit ? Object.assign({}, screenData, { implicit: true }) : screenData;
-    logger.Console.log('AppticsScreenTracker.inScreen(\'' + screenName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    logger.Console.log('AppticsScreen.inScreen(\'' + screenName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     logger.Console.dir(screenData);
 }
 /**
@@ -196,7 +216,7 @@ function withoutQueryForLog(path) {
     return String(path || '').split(/[?#]/)[0]; // no i18n
 }
 function trackApi(jsonObj) {
-    if (!consent.canTrackEngagement('trackApi')) { // no i18n
+    if (!consent.canTrackEngagement('trackApi', constants.AP_CONSTANTS.API)) { // no i18n
         return;
     }
     jsonObj = jsonObj || {};
@@ -226,16 +246,19 @@ function trackApi(jsonObj) {
     var hostname = jsonObj.hostname || '';
     var port = (typeof jsonObj.port === 'number') ? jsonObj.port : 0;
     var path = jsonObj.path || '';
+    // a call reported by its parts, a hostname and a path with no url: its scheme and port are its
+    // own (https and 443 unless given), not the page's, which belong to another host
+    var partsOnly = utils.isEmpty(jsonObj.url) && !utils.isEmpty(jsonObj.hostname);
     if (!utils.isEmpty(rawUrl)) {
         try {
             var urlObj = new URL(rawUrl, window.location.origin);
-            if (utils.isEmpty(scheme)) {
+            if (utils.isEmpty(scheme) && !partsOnly) {
                 scheme = urlObj.protocol.replace(':', ''); // "https:"
             }
             if (utils.isEmpty(hostname)) {
                 hostname = urlObj.hostname;
             }
-            if (!port) {
+            if (!port && !partsOnly) {
                 if (urlObj.port) {
                     port = parseInt(urlObj.port, 10);
                 }
@@ -256,22 +279,27 @@ function trackApi(jsonObj) {
     }
     // only http and https exist as far as the proxy's api_scheme is concerned
     scheme = (scheme === 'https' || scheme === 'http') ? scheme : 'https'; // no i18n
+    if (!port) {
+        port = scheme === 'https' ? 443 : 80; // no i18n
+    }
     // a hostname the proxy refuses cannot be repaired without inventing one, so the call is
     // dropped here and said out loud. localhost and bare IPs land here: api_hostname wants at
     // least one dot and an alphabetic suffix, which is worth knowing when nothing shows up locally
     if (!API_HOSTNAME.test(hostname)) {
-        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApiTracker: hostname not accepted by the server: ' + String(hostname)); // no i18n
+        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApi: hostname not accepted by the server: ' + String(hostname)); // no i18n
         return;
     }
-    // configureApiTracking: the app's rules decide whether this call is recorded at all
-    if (!apiRules.hostAllowed(hostname) || apiRules.endpointIgnored(path)) {
-        logger.Console.log('AppticsApiTracker: ' + hostname + withoutQueryForLog(path) + ' is left out by configureApiTracking'); // no i18n
+    // configureApiTracking: the app's rules decide whether this call is recorded at all, tried on
+    // the URL as it was called, without its query
+    var defaultPort = (scheme === 'https' && port === 443) || (scheme === 'http' && port === 80); // no i18n
+    var calledUrl = scheme + '://' + hostname + (port && !defaultPort ? ':' + port : '') + (String(path).charAt(0) === '/' ? '' : '/') + path; // no i18n
+    if (!apiRules.urlTracked(calledUrl)) {
+        logger.Console.log('AppticsApi: ' + hostname + withoutQueryForLog(path) + ' is left out by configureApiTracking'); // no i18n
         return;
     }
-    // and the name it is recorded under: ids become *, regional hosts one group, so the console
-    // groups calls by endpoint rather than by every id that went through it
+    // and the name it is recorded under: ids become *, so the console groups calls by endpoint
+    // rather than by every id that went through it
     path = sanitizeApiPath(apiRules.normalizeApiPath(path));
-    hostname = apiRules.groupedHost(hostname);
     var sessionStart = state._ZAP._current_session.starttime || starttime;
     // no customproperties: apiWebSDK does not declare the key, unlike the screen and event
     // templates, so anything extra the caller passes is context for the log line only
@@ -296,7 +324,7 @@ function trackApi(jsonObj) {
     session.commitPendingSession();
     debug.noteDebugActivity();
     storage.engagement_transactions.add(apiData);
-    logger.Console.log('AppticsApiTracker(\'' + method + ' ' + scheme + '://' + hostname + path + '\')'); // no i18n
+    logger.Console.log('AppticsApi(\'' + method + ' ' + scheme + '://' + hostname + path + '\')'); // no i18n
     logger.Console.dir(apiData);
 }
 /** Begun calls by id. Bounded, so an app that starts calls it never ends can't grow it forever. */
@@ -324,7 +352,7 @@ function startTrackApi(url, method) {
 function endTrackApiAt(id, responseCode, responseMessage, endedAt) {
     var open = openCalls[id];
     if (!open) {
-        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApiTracker.endTrackApi: no call started with id ' + String(id)); // no i18n
+        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApi.endTrackApi: no call started with id ' + String(id)); // no i18n
         return;
     }
     delete openCalls[id];

package/dist/cjs/errors/send.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var state = require('../core/state.js');
@@ -14,7 +14,7 @@ var transport = require('../core/transport.js');
  * Sends pending errors to the Apptics API.
  */
 function sendErrorData(forget) {
-    // errortracking off (getupdates): queued errors stay until tracking is back on or they expire
+    // js_error off (getsdkconfig): queued errors stay until tracking is back on or they expire
     if (env.is_apptics_disabled() || !consent.shouldTrackOrSendData() || !state._ZAP._errorTracking) {
         return Promise.resolve();
     }

package/dist/cjs/errors/track.d.ts

@@ -1,4 +1,5 @@
 import type { Properties } from '../types.js';
 export declare function trackError(errorEvent: any, jsonObj?: Properties): void;
-export declare function enableGlobalErrorHandler(status?: boolean): void;
+/** AppticsError.setErrorTracking: uncaught errors on or off, as the `track_error` config sets it. */
+export declare function setErrorTracking(status?: boolean): void;
 export declare function extractMethodNameFromStackTrace(stackTrace: string): string;