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

package/dist/esm/engagement/session.js

@@ -1,11 +1,12 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
-import { AP_LOG_MODULE, AP_CONSTANTS } from '../core/constants.js';
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { AP_CONSTANTS, AP_LOG_MODULE } from '../core/constants.js';
 import { _ZAP, getConfig } from '../core/state.js';
 import { logFailure, Console } from '../core/logger.js';
-import { nowMs, isEmpty, getNewUUID } from '../core/utils.js';
-import { engagement_transactions, user_defaults } from '../core/storage.js';
+import { isEmpty, getNewUUID, nowMs } from '../core/utils.js';
+import { engagement_transactions, getKeyFromDeviceInfo, setDeviceInfoKey } from '../core/storage.js';
 import { is_apptics_disabled, getNetworkStatus, getOrientation, getConnectionType, getRam } from '../core/env.js';
 import { canTrackEngagement } from '../core/consent.js';
+import { withLock } from '../core/locks.js';
 
 /** The most recently started item of `type` that is still open (endtime 0). */
 function latestOpen(type, items) {
@@ -56,16 +57,12 @@ function closeScreensOf(session, time) {
         }, Promise.resolve());
     });
 }
-/** `track_session: false`, Android's automaticSessionsTrackingStatus: no sessions are recorded. */
-function sessionsOff() {
-    return getConfig('track_session') === false; // no i18n
-}
 /**
  * Track the session.
  * @param sessionData A set of properties belonging to the session.
  */
 function trackSession(sessionData) {
-    if (!canTrackEngagement('trackSession')) { // no i18n
+    if (!canTrackEngagement('trackSession', AP_CONSTANTS.SESSION)) { // no i18n
         return Promise.resolve();
     }
     if (sessionData && typeof sessionData !== 'object') { // no i18n
@@ -77,13 +74,16 @@ function trackSession(sessionData) {
     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 engagement_transactions.all().then(function (items) {
         if (mine) {
             var ours = items.filter(function (item) {
-                return item.type == AP_CONSTANTS.SESSION && item.id === mine;
+                return item.type == AP_CONSTANTS.SESSION && item.id === mine && item.endtime === 0;
             })[0];
             if (ours) {
                 return ours;
@@ -92,6 +92,119 @@ function currentSession() {
         return latestOpen(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 = 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 = nowMs();
+        return engagement_transactions.all().then(function (items) {
+            var gone = items.filter(function (item) {
+                return item.type == 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) {
+                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 engagement_transactions.update(Object.assign({}, item, { endtime: end }));
+                });
+            }, Promise.resolve());
+        });
+    }).catch(function (err) {
+        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 = _ZAP._current_screen;
+    if (!current || !current.id || current.endtime) {
+        return Promise.resolve();
+    }
+    return engagement_transactions.all().then(function (items) {
+        var open = items.filter(function (item) {
+            return item.type == AP_CONSTANTS.SCREEN && item.id === current.id && item.endtime === 0;
+        })[0];
+        return open ? 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 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() {
@@ -110,9 +223,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 isEmpty(user_defaults.item(HAD_SESSION_KEY));
+    return getKeyFromDeviceInfo(HAD_SESSION_KEY) !== true;
 }
 const HAD_SESSION_KEY = 'hadsession'; // no i18n
 /**
@@ -149,7 +262,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) {
-        user_defaults.add(HAD_SESSION_KEY, true);
+        setDeviceInfoKey(HAD_SESSION_KEY, true);
     }
     return trackSession(session);
 }
@@ -174,6 +287,7 @@ function startNewSession(time) {
         firstsession: isFirstEverSession(),
         networkstatus: 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
@@ -200,25 +314,126 @@ function startNewSession(time) {
 /** The un-deferred path, for a minimum of 0. */
 function commitNow(session) {
     if (session.firstsession) {
-        user_defaults.add(HAD_SESSION_KEY, true);
+        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();
+            }
+        });
+    }, _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 (!_ZAP._token || 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) || nowMs();
+            if (nowMs() - lastActive < _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 });
+                _ZAP._current_session = left;
+                return engagement_transactions.update(left);
+            }
+            var endAt = Math.max(lastActive, Number(_currentSession.starttime) || lastActive);
+            var closed = Object.assign({}, _currentSession, { endtime: endAt, tabs: [] });
+            _ZAP._current_session = closed;
+            ended = true;
+            Console.log('session: inactive for ' + _ZAP.inactiveduration + ' minutes, so it ends when the user left, ' + endAt); // no i18n
+            return 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 = 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 });
+            _ZAP._current_session = left;
+            Console.log('endCurrentSession: ' + others.length + ' other tab(s) still on this session, so it stays open'); // no i18n
+            return engagement_transactions.update(left);
+        }
+        var closed = Object.assign({}, _currentSession, { endtime: time, lastactivetime: time, tabs: [] });
         _ZAP._current_session = closed;
         Console.log('endCurrentSession: closing the session opened at ' + closed.starttime); // no i18n
         return engagement_transactions.update(closed).then(function () {
@@ -255,18 +470,21 @@ function closeAbandonedSessions() {
 }
 function checkAndUpdateSession() {
     if (!_ZAP._token) {
-        logFailure(AP_LOG_MODULE.SESSION, 'checkAndUpdateSession: You must call apptics.init() first'); // no i18n
+        logFailure(AP_LOG_MODULE.SESSION, 'checkAndUpdateSession: You must call Apptics.init() first'); // no i18n
         return Promise.resolve();
     }
     if (is_apptics_disabled()) {
         return Promise.resolve();
     }
-    if (sessionsOff()) {
-        return Promise.resolve();
-    }
     var time = 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);
@@ -287,13 +505,14 @@ function checkAndUpdateSession() {
             });
         }
         Console.log('checkAndUpdateSession: User is back before ' + _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 = nowMs();
     // a pending session is not in the store yet, so it is updated in place instead
     if (pendingSession) {
@@ -306,10 +525,12 @@ function updateLastActiveTimeOfSession() {
             return;
         }
         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) });
         _ZAP._current_session = _newSession;
         return engagement_transactions.update(_newSession);
+    }).then(function () {
+        return markScreenSeen(time);
     });
 }
 
-export { checkAndUpdateSession, closeAbandonedSessions, closeScreen, commitPendingSession, currentSession, dropPendingSession, endCurrentSession, startNewSession, trackSession, updateLastActiveTimeOfSession, updateScreenWithEndtime };
+export { checkAndUpdateSession, closeAbandonedSessions, closeScreen, closeScreensOfGoneTabs, commitPendingSession, currentSession, dropPendingSession, endCurrentSession, holdTabLock, markTabActive, markTabInactive, resetInactivity, startNewSession, tabId, trackSession, updateLastActiveTimeOfSession, updateScreenWithEndtime };

package/dist/esm/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/esm/engagement/track.js

@@ -1,29 +1,43 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
-import { AP_LOG_MODULE, AP_CONFIG, AP_CONSTANTS } from '../core/constants.js';
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { AP_LOG_MODULE, AP_CONSTANTS } from '../core/constants.js';
 import { _ZAP } from '../core/state.js';
-import { logFailure, Console } from '../core/logger.js';
-import { getNewUUID, nowMs, isEmpty } from '../core/utils.js';
+import { logFailure, Console, warnAlways } from '../core/logger.js';
+import { isEmpty, nowMs, getNewUUID } from '../core/utils.js';
 import { engagement_transactions } from '../core/storage.js';
-import { commitPendingSession, closeScreen } from './session.js';
-import { getConnectionType, getNetworkStatus, getOrientation } from '../core/env.js';
+import { closeScreen, commitPendingSession, tabId } from './session.js';
+import { getConnectionType, getOrientation, getNetworkStatus } from '../core/env.js';
 import { canTrackEngagement } from '../core/consent.js';
-import { validateEventOrGroup, validateJSON, validateScreenName } from '../core/validate.js';
+import { validateScreenName, validateEventOrGroup, validateJSON } from '../core/validate.js';
 import { noteDebugActivity } from '../core/debug.js';
 import { hooks } from '../core/hooks.js';
-import { hostAllowed, endpointIgnored, normalizeApiPath, groupedHost } from './api-rules.js';
+import { urlTracked, normalizeApiPath } from './api-rules.js';
 import { asDefinedEvent } from './defined-events.js';
 import { automaticScreenName } from './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) {
+    logFailure(module, message);
+    if (!refusedSaid[message]) {
+        refusedSaid[message] = true;
+        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 (!canTrackEngagement('trackEvent')) { // no i18n
+    if (!canTrackEngagement('trackEvent', AP_CONSTANTS.EVENT)) { // no i18n
         return;
     }
     var defined = asDefinedEvent(eventName);
@@ -35,14 +49,17 @@ function trackEvent(eventName, groupName, jsonObj) {
     }
     else {
         if (typeof eventName !== 'string' || !validateEventOrGroup(eventName)) { // no i18n
-            logFailure(AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid eventName: ' + String(eventName)); // no i18n
+            refused(AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: Invalid eventName: ' + String(eventName)); // no i18n
             return;
         }
-        if (groupName === undefined || groupName === null || groupName === '') { // no i18n
-            groupName = 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(AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: groupName is required for "' + eventName + '": addEvent(eventName, groupName, properties?)'); // no i18n
+            return;
         }
-        else if (typeof groupName !== 'string' || !validateEventOrGroup(groupName)) { // no i18n
-            logFailure(AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
+        if (typeof groupName !== 'string' || !validateEventOrGroup(groupName)) { // no i18n
+            refused(AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
             return;
         }
     }
@@ -68,7 +85,7 @@ function trackEvent(eventName, groupName, jsonObj) {
     commitPendingSession();
     noteDebugActivity();
     engagement_transactions.add(eventData);
-    Console.log('AppticsEvents.addEvent(\'' + eventName + '\',\'' + groupName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    Console.log('AppticsEvent.addEvent(\'' + eventName + '\',' + '\'' + groupName + '\'' + ',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     Console.dir(eventData);
 }
 /**
@@ -78,7 +95,7 @@ function trackEvent(eventName, groupName, jsonObj) {
  */
 function inScreenAt(screenName, jsonObj, id, startedAt) {
     if (!validateScreenName(screenName)) {
-        logFailure(AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        refused(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
@@ -88,7 +105,7 @@ function inScreenAt(screenName, jsonObj, id, startedAt) {
 /** Ends the screen view inScreen() began, as Android's AppticsScreenTracker.outScreen(id). */
 function outScreenAt(id, endedAt) {
     if (isEmpty(id)) {
-        logFailure(AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.outScreen: no screen id given'); // no i18n
+        logFailure(AP_LOG_MODULE.SCREEN, 'AppticsScreen.outScreen: no screen id given'); // no i18n
         return;
     }
     closeScreen(id, endedAt);
@@ -101,11 +118,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 (!canTrackEngagement('inScreen')) { // no i18n
+    if (!canTrackEngagement('inScreen', AP_CONSTANTS.SCREEN)) { // no i18n
         return;
     }
     if (!validateScreenName(screenName)) {
-        logFailure(AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        refused(AP_LOG_MODULE.SCREEN, 'AppticsScreen.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
         return;
     }
     jsonObj = jsonObj || {};
@@ -122,7 +139,10 @@ function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
         networkstatus: getNetworkStatus(),
         orientation: getOrientation(),
         sessionstarttime: _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: tabId(),
     };
     // the screen being left ends where this one starts
     var previous = _ZAP._current_screen && _ZAP._current_screen.id;
@@ -135,7 +155,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
     _ZAP._current_screen = implicit ? Object.assign({}, screenData, { implicit: true }) : screenData;
-    Console.log('AppticsScreenTracker.inScreen(\'' + screenName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    Console.log('AppticsScreen.inScreen(\'' + screenName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     Console.dir(screenData);
 }
 /**
@@ -194,7 +214,7 @@ function withoutQueryForLog(path) {
     return String(path || '').split(/[?#]/)[0]; // no i18n
 }
 function trackApi(jsonObj) {
-    if (!canTrackEngagement('trackApi')) { // no i18n
+    if (!canTrackEngagement('trackApi', AP_CONSTANTS.API)) { // no i18n
         return;
     }
     jsonObj = jsonObj || {};
@@ -224,16 +244,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 = isEmpty(jsonObj.url) && !isEmpty(jsonObj.hostname);
     if (!isEmpty(rawUrl)) {
         try {
             var urlObj = new URL(rawUrl, window.location.origin);
-            if (isEmpty(scheme)) {
+            if (isEmpty(scheme) && !partsOnly) {
                 scheme = urlObj.protocol.replace(':', ''); // "https:"
             }
             if (isEmpty(hostname)) {
                 hostname = urlObj.hostname;
             }
-            if (!port) {
+            if (!port && !partsOnly) {
                 if (urlObj.port) {
                     port = parseInt(urlObj.port, 10);
                 }
@@ -254,22 +277,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)) {
-        logFailure(AP_LOG_MODULE.API, 'AppticsApiTracker: hostname not accepted by the server: ' + String(hostname)); // no i18n
+        logFailure(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 (!hostAllowed(hostname) || endpointIgnored(path)) {
-        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 (!urlTracked(calledUrl)) {
+        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(normalizeApiPath(path));
-    hostname = groupedHost(hostname);
     var sessionStart = _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
@@ -294,7 +322,7 @@ function trackApi(jsonObj) {
     commitPendingSession();
     noteDebugActivity();
     engagement_transactions.add(apiData);
-    Console.log('AppticsApiTracker(\'' + method + ' ' + scheme + '://' + hostname + path + '\')'); // no i18n
+    Console.log('AppticsApi(\'' + method + ' ' + scheme + '://' + hostname + path + '\')'); // no i18n
     Console.dir(apiData);
 }
 /** Begun calls by id. Bounded, so an app that starts calls it never ends can't grow it forever. */
@@ -322,7 +350,7 @@ function startTrackApi(url, method) {
 function endTrackApiAt(id, responseCode, responseMessage, endedAt) {
     var open = openCalls[id];
     if (!open) {
-        logFailure(AP_LOG_MODULE.API, 'AppticsApiTracker.endTrackApi: no call started with id ' + String(id)); // no i18n
+        logFailure(AP_LOG_MODULE.API, 'AppticsApi.endTrackApi: no call started with id ' + String(id)); // no i18n
         return;
     }
     delete openCalls[id];

package/dist/esm/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 */
 import { _ZAP } from '../core/state.js';
 import { Console, warnAlways } from '../core/logger.js';
 import { cloneObject } from '../core/utils.js';
@@ -12,7 +12,7 @@ import { isPermanentRefusal } from '../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 (is_apptics_disabled() || !shouldTrackOrSendData() || !_ZAP._errorTracking) {
         return Promise.resolve();
     }