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

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.1 | (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,10 +57,6 @@ 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.
@@ -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,13 +314,14 @@ 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);
 }
 /**
- * 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.
  */
 function endCurrentSession() {
     var time = nowMs();
@@ -214,11 +329,23 @@ function endCurrentSession() {
     if (dropPendingSession()) {
         return Promise.resolve();
     }
+    return withSessionLock(function () {
+        return closeOrLeaveSession(time);
+    });
+}
+function closeOrLeaveSession(time) {
     return currentSession().then(function (_currentSession) {
         if (!_currentSession || _currentSession.endtime !== 0) {
             return;
         }
-        var closed = Object.assign({}, _currentSession, { endtime: time, lastactivetime: time });
+        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 +382,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 +417,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 +437,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, startNewSession, tabId, trackSession, updateLastActiveTimeOfSession, updateScreenWithEndtime };

package/dist/esm/engagement/track.js

@@ -1,19 +1,33 @@
-/*! @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.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { AP_LOG_MODULE, AP_CONSTANTS, AP_CONFIG } 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 = {};
+/**
+ * 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.
@@ -35,14 +49,14 @@ 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;
         }
         else if (typeof groupName !== 'string' || !validateEventOrGroup(groupName)) { // no i18n
-            logFailure(AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
+            refused(AP_LOG_MODULE.EVENT, 'AppticsEvent.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
             return;
         }
     }
@@ -68,7 +82,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 +92,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 +102,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);
@@ -105,7 +119,7 @@ function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
         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 +136,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 +152,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);
 }
 /**
@@ -224,16 +241,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 +274,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 +319,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 +347,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.1 | (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';

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

@@ -1,4 +1,4 @@
 import type { Properties } from '../types.js';
 export declare function trackError(errorEvent: any, jsonObj?: Properties): void;
-export declare function enableGlobalErrorHandler(status?: boolean): void;
+export declare function trackGlobalErrorHandler(status?: boolean): void;
 export declare function extractMethodNameFromStackTrace(stackTrace: string): string;

package/dist/esm/errors/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.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { AP_CONSTANTS } from '../core/constants.js';
 import { _ZAP } from '../core/state.js';
 import { Console } from '../core/logger.js';
@@ -36,19 +36,59 @@ function stackOf(errorEvent) {
 }
 /** Said in place of a stack when there is none, so `message` is never sent empty. */
 const NO_STACK = 'no stack available'; // no i18n
+/** The element an event came from, as `<script src="…">`, so a failed load says what failed. */
+function describeTarget(target) {
+    var el = target;
+    if (!el || typeof el.tagName !== 'string') { // no i18n
+        return ''; // no i18n
+    }
+    var tag = el.tagName.toLowerCase();
+    var url = el.currentSrc || el.src || el.href || ''; // no i18n
+    return ' on <' + tag + (url ? (el.href && !el.src ? ' href="' : ' src="') + url + '"' : '') + '>'; // no i18n
+}
+/**
+ * What was thrown or rejected, as text an issue can be named by. An Error reads as itself. A
+ * promise rejected with an Event - what a failed script or image load hands over - used to be
+ * recorded as "[object Event]"; it is named by its type and where it came from instead. Anything
+ * else that is an object is shown as its JSON, cut short.
+ */
+function describeThrown(thrown) {
+    if (thrown === null || thrown === undefined) {
+        return ''; // no i18n
+    }
+    if (typeof thrown !== 'object') { // no i18n
+        return String(thrown);
+    }
+    if (thrown instanceof Error || typeof thrown.message === 'string' && typeof thrown.name === 'string') { // no i18n
+        return String(thrown);
+    }
+    if (typeof Event !== 'undefined' && thrown instanceof Event) { // no i18n
+        return 'Event "' + thrown.type + '"' + describeTarget(thrown.target); // no i18n
+    }
+    var text = String(thrown);
+    if (text !== '[object Object]') { // no i18n
+        return text;
+    }
+    try {
+        return JSON.stringify(thrown).slice(0, 300);
+    }
+    catch (err) {
+        return text;
+    }
+}
 function trackError(errorEvent, jsonObj) {
     if (!canTrackErrors('trackError')) { // no i18n
         return;
     }
     if (isEmpty(errorEvent)) {
-        Console.warn('AppticsTrackError: Invalid error'); // no i18n
+        Console.warn('AppticsError.trackError: Invalid error'); // no i18n
         return;
     }
     var _jsonObj = validateJSON(jsonObj);
     var stack = stackOf(errorEvent);
     var methodName = extractMethodNameFromStackTrace(stack) || "";
     var issuetype = errorEvent.type || "";
-    var thrown = errorEvent.reason || errorEvent.error || errorEvent.message || "";
+    var thrown = describeThrown(errorEvent.reason || errorEvent.error || errorEvent.message || "");
     // "Error: x at handler", or just "Error: x" when the stack names no method. issuename is
     // required too, so something that carried no message at all is still named rather than blank
     var described = !isEmpty(String(thrown)) ? String(thrown) : (!isEmpty(issuetype) ? String(issuetype) : 'Unknown error'); // no i18n
@@ -74,10 +114,10 @@ function trackError(errorEvent, jsonObj) {
     commitPendingSession();
     noteDebugActivity();
     error_transactions.add(errorData);
-    Console.log('AppticsTrackError(\'' + issuetype + '\',\'' + message + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    Console.log('AppticsError.trackError(\'' + issuetype + '\',\'' + message + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     Console.dir(errorData);
 }
-function enableGlobalErrorHandler(status) {
+function trackGlobalErrorHandler(status) {
     _ZAP._isGlobalErrorTracking = typeof status === "boolean" ? status : true; // no i18n
 }
 function extractMethodNameFromStackTrace(stackTrace) {
@@ -120,4 +160,4 @@ function extractMethodNameFromStackTrace(stackTrace) {
     return methodName;
 }
 
-export { enableGlobalErrorHandler, extractMethodNameFromStackTrace, trackError };
+export { extractMethodNameFromStackTrace, trackError, trackGlobalErrorHandler };

package/dist/esm/feedback/controls.d.ts

@@ -12,6 +12,12 @@ export declare const logChoice: {
     includeLog?: boolean;
     includeDyninfo?: boolean;
 };
+/**
+ * Who a sendFeedback() report, made without the form, is attributed to: nobody when `anonymous`,
+ * else the user AppticsUser.setUser set (or the active registered one, status 1). Returns a function
+ * that puts back the choice that was there, so a form left open keeps its own.
+ */
+export declare function chooseUserForSend(anonymous: boolean): () => void;
 /**
  * The "User" dropdown above the description. It lists Anonymous plus every registered user, and
  * starts on the active one (status 1) unless the caller asked for anonymous.

package/dist/esm/feedback/controls.js

@@ -1,8 +1,9 @@
-/*! @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.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { Console } from '../core/logger.js';
 import { hooks } from '../core/hooks.js';
 import { user_defaults } from '../core/storage.js';
 import { isEmpty } from '../core/utils.js';
+import { _ZAP } from '../core/state.js';
 import { hasLogLines, hasDiagnostics, logText, diagnosticsText } from './logs.js';
 
 /**
@@ -23,6 +24,34 @@ function resetUserChoice() {
     userChoice.userid = ''; // no i18n
     userChoice.groupid = ''; // no i18n
 }
+/**
+ * Who a sendFeedback() report, made without the form, is attributed to: nobody when `anonymous`,
+ * else the user AppticsUser.setUser set (or the active registered one, status 1). Returns a function
+ * that puts back the choice that was there, so a form left open keeps its own.
+ */
+function chooseUserForSend(anonymous) {
+    var before = { anonymous: userChoice.anonymous, userid: userChoice.userid, groupid: userChoice.groupid };
+    resetUserChoice();
+    if (!anonymous) {
+        // the user setUser set on this page, else the active one of those registered before
+        var active = !isEmpty(_ZAP._user_info.userid) ? _ZAP._user_info : null;
+        storedUsers().forEach(function (user) {
+            if (!active && user && user.status == 1 && !isEmpty(user.userid)) {
+                active = user;
+            }
+        });
+        if (active) {
+            userChoice.anonymous = false;
+            userChoice.userid = String(active.userid);
+            userChoice.groupid = String(active.groupid || ''); // no i18n
+        }
+    }
+    return function restore() {
+        userChoice.anonymous = before.anonymous;
+        userChoice.userid = before.userid;
+        userChoice.groupid = before.groupid;
+    };
+}
 /** Every distinct registered user, by the address the picker shows. */
 function storedUsers() {
     var users = user_defaults.item('users'); // no i18n
@@ -277,4 +306,4 @@ hooks.feedbackUser = function () {
     return userChoice.anonymous || isEmpty(userChoice.userid) ? null : userChoice;
 };
 
-export { logChoice, userChoice, wireDrag, wireLogControls, wireUserPicker };
+export { chooseUserForSend, logChoice, userChoice, wireDrag, wireLogControls, wireUserPicker };