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

package/dist/cjs/core/attempts.js

@@ -0,0 +1,113 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./constants.js');
+var storage = require('./storage.js');
+var utils = require('./utils.js');
+
+/**
+ * Retry bookkeeping: `attempt`, `firstattempttime` and `lst`.
+ *
+ * Every url that carries data declares all three; app/addversion and getsdkconfig declare none,
+ * because they are start-up calls whose answers the SDK needs rather than payloads it is pushing.
+ *
+ * What they are for is the case this SDK cannot see on its own. A send goes out, the server
+ * stores it, and the answer is lost on the way back — a closed tab, a dropped connection, a
+ * proxy that times out. The SDK has no way to tell that from a send that never arrived, so it
+ * sends again. `attempt` and `firstattempttime` are what let the server recognise the second
+ * copy as the same payload rather than storing it twice. Without them, every retry is a
+ * duplicate session.
+ *
+ * `attempt` is declared `regex="[1-5]"`, so five is not a policy choice here — it is the largest
+ * number the proxy will accept. A batch that has not landed in five passes is dropped, because
+ * the sixth would be refused for the param rather than for the payload, which would look like a
+ * different fault entirely.
+ *
+ * State is per path and survives a reload, which is the point: the tab that was closed mid-send
+ * is exactly the one that needs to say "attempt 2" when it comes back.
+ */
+/** The largest value `attempt` may carry, from its own regex. */
+const MAX_ATTEMPTS = 5;
+const STORE_KEY = 'sendstate'; // no i18n
+function allState() {
+    var saved = storage.user_defaults.item(STORE_KEY);
+    return saved && typeof saved === 'object' ? saved : {};
+}
+function stateOf(path) {
+    var state = allState()[path];
+    return state && typeof state === 'object'
+        ? { attempt: Number(state.attempt) || 1, firstattempttime: Number(state.firstattempttime) || 0, lst: Number(state.lst) || 0 }
+        : { attempt: 1, firstattempttime: 0, lst: 0 };
+}
+function save(path, state) {
+    var all = allState();
+    all[path] = state;
+    storage.user_defaults.add(STORE_KEY, all);
+}
+/**
+ * Whether this path has already used its five attempts, so the batch should be dropped rather
+ * than sent a sixth time with a param the proxy will refuse.
+ */
+function attemptsExhausted(path) {
+    return stateOf(path).attempt > MAX_ATTEMPTS;
+}
+/**
+ * Records that a send is going out, and returns the params to put on it.
+ *
+ * Call it once per request, immediately before sending: it is what moves the attempt counter on,
+ * so calling it twice for one request would skip a number and reach five early.
+ */
+function beginAttempt(path) {
+    if (!constants.RETRY_CAPABLE_PATHS[path]) {
+        return {};
+    }
+    var state = stateOf(path);
+    var at = utils.nowMs();
+    if (state.attempt <= 1 || state.firstattempttime === 0) {
+        state.attempt = 1;
+        state.firstattempttime = at;
+    }
+    var params = {
+        attempt: String(Math.min(state.attempt, MAX_ATTEMPTS)),
+        firstattempttime: state.firstattempttime,
+    };
+    // lst is the last send this path had accepted. There is none before the first one lands, and
+    // an optional param is better absent than present and meaningless
+    if (state.lst > 0) {
+        params.lst = state.lst; // no i18n
+    }
+    // the next send for this path is the next attempt, unless this one is confirmed first
+    save(path, { attempt: state.attempt + 1, firstattempttime: state.firstattempttime, lst: state.lst });
+    return params;
+}
+/**
+ * Records that a send was accepted: the counter goes back to 1 and `lst` moves to now.
+ *
+ * For a page-close send the confirmation arrives after the caller has moved on, which is fine —
+ * nothing waits for this, it only decides what the *next* send says about itself.
+ */
+function attemptSucceeded(path) {
+    if (!constants.RETRY_CAPABLE_PATHS[path]) {
+        return;
+    }
+    save(path, { attempt: 1, firstattempttime: 0, lst: utils.nowMs() });
+}
+/** Gives up on the current run of attempts, so the next send starts again at 1. */
+function resetAttempts(path) {
+    if (!constants.RETRY_CAPABLE_PATHS[path]) {
+        return;
+    }
+    var state = stateOf(path);
+    save(path, { attempt: 1, firstattempttime: 0, lst: state.lst });
+}
+/** Forgets every path's bookkeeping. reset() calls it. */
+function clearAttempts() {
+    storage.user_defaults.add(STORE_KEY, undefined);
+}
+
+exports.MAX_ATTEMPTS = MAX_ATTEMPTS;
+exports.attemptSucceeded = attemptSucceeded;
+exports.attemptsExhausted = attemptsExhausted;
+exports.beginAttempt = beginAttempt;
+exports.clearAttempts = clearAttempts;
+exports.resetAttempts = resetAttempts;

package/dist/cjs/core/batch.d.ts

@@ -0,0 +1,32 @@
+import { type Queue } from './storage.js';
+import { type ApiPath } from './transport.js';
+import type { Dict, QueueItem, ServerResult } from '../types.js';
+/** Retries `send` in 500 ms, replacing any retry already scheduled. */
+export declare function defer(send: () => Promise<void>): void;
+export declare function clearDefer(): void;
+/** Only one tab sends a queue at a time. Without the Web Locks API, runs directly (1.x behaviour). */
+export declare function withSendLock(name: string, run: () => Promise<void>): Promise<void>;
+/**
+ * The batch to send: closed items within batch_request_timeout days.
+ * Expired items are removed from the queue without being sent.
+ */
+export declare function freshItems(queue: Queue, isClosed: (item: QueueItem) => boolean, timeOf: (item: QueueItem) => number): Promise<QueueItem[]>;
+/**
+ * Sends one batch of queued items. Resolves only when the server has accepted it, so the caller
+ * removes the items then and not before: a batch that fails stays queued and goes again on the
+ * next pass, as attempt 2, which `attempt` and `firstattempttime` let the server recognise as a
+ * copy rather than store twice.
+ *
+ * With `forget` (the page is closing) it goes by keepalive, and the promise settles if the answer
+ * arrives before the page is gone. See postKeepalive.
+ *
+ * Five attempts is the cap, because `attempt` is declared regex="[1-5]" and a sixth would be
+ * refused for the param rather than for the payload.
+ */
+export declare function sendBatch(path: ApiPath, label: string, _payload: Dict, forget?: boolean): Promise<ServerResult>;
+/**
+ * Hands a send's outcome back to a sender. Normally the sender waits for it. While the page
+ * closes it does not: the request is already out, and waiting would hold the next queue's send
+ * until after the page has gone. The outcome is still handled whenever it arrives.
+ */
+export declare function awaitUnlessClosing(landed: Promise<unknown>, forget: boolean | undefined, label: string): Promise<void> | undefined;

package/dist/cjs/core/batch.js

@@ -0,0 +1,116 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var state = require('./state.js');
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+require('./constants.js');
+require('./db.js');
+var consent = require('./consent.js');
+var attempts = require('./attempts.js');
+var transport = require('./transport.js');
+
+/** Retries `send` in 500 ms, replacing any retry already scheduled. */
+function defer(send) {
+    if (state._ZAP._deferSendTimer) {
+        clearTimeout(state._ZAP._deferSendTimer);
+    }
+    state._ZAP._deferSendTimer = setTimeout(send, 500);
+}
+function clearDefer() {
+    if (state._ZAP._deferSendTimer) {
+        clearTimeout(state._ZAP._deferSendTimer);
+        state._ZAP._deferSendTimer = null;
+    }
+}
+/** Only one tab sends a queue at a time. Without the Web Locks API, runs directly (1.x behaviour). */
+function withSendLock(name, run) {
+    var locks = typeof navigator !== 'undefined' ? navigator.locks : undefined; // no i18n
+    if (!locks || typeof locks.request !== 'function') { // no i18n
+        return run();
+    }
+    return locks.request('apptics-send-' + name, { ifAvailable: true }, function (lock) {
+        return lock ? run() : undefined;
+    }).then(function () { return undefined; });
+}
+/**
+ * The batch to send: closed items within batch_request_timeout days.
+ * Expired items are removed from the queue without being sent.
+ */
+function freshItems(queue, isClosed, timeOf) {
+    return queue.payload().then(function (items) {
+        var fresh = [];
+        var expired = [];
+        items.forEach(function (item) {
+            if (!isClosed(item)) {
+                return;
+            }
+            (state.isExpired(timeOf(item)) ? expired : fresh).push(item);
+        });
+        return expired.length ? queue.remove(expired).then(function () { return fresh; }) : fresh;
+    });
+}
+/**
+ * Sends one batch of queued items. Resolves only when the server has accepted it, so the caller
+ * removes the items then and not before: a batch that fails stays queued and goes again on the
+ * next pass, as attempt 2, which `attempt` and `firstattempttime` let the server recognise as a
+ * copy rather than store twice.
+ *
+ * With `forget` (the page is closing) it goes by keepalive, and the promise settles if the answer
+ * arrives before the page is gone. See postKeepalive.
+ *
+ * Five attempts is the cap, because `attempt` is declared regex="[1-5]" and a sixth would be
+ * refused for the param rather than for the payload.
+ */
+function sendBatch(path, label, _payload, forget) {
+    var blocked = transport.rejectIfDisabled(label);
+    if (blocked) {
+        return blocked;
+    }
+    if (!consent.shouldTrackOrSendData()) {
+        return Promise.reject(label + ': tracking is off'); // no i18n
+    }
+    if (utils.isEmptyObj(_payload)) {
+        return Promise.reject(label + ': nothing to send'); // no i18n
+    }
+    var missing = transport.rejectIfNoDeviceIds(label);
+    if (missing) {
+        return missing;
+    }
+    if (!_payload.hasOwnProperty('meta')) { // no i18n
+        _payload.meta = transport.getMetaObj();
+    }
+    if (attempts.attemptsExhausted(path)) {
+        // five passes without a confirmed landing. Keeping it would block every later batch
+        // behind a payload the proxy will now refuse for its attempt number alone
+        logger.warnAlways('apptics: dropping a ' + label + ' batch after ' + attempts.MAX_ATTEMPTS + ' attempts'); // no i18n
+        attempts.resetAttempts(path);
+        return Promise.resolve({ result: 'success' }); // no i18n
+    }
+    logger.Console.log(label + ': Payload size : ' + (utils.sizeof(_payload) / 1024)); // no i18n
+    var body = JSON.stringify(_payload);
+    return forget
+        ? transport.postKeepalive(path, body, transport.apiHeaders(), label)
+        : transport.postToApptics(path, body, transport.apiHeaders(), label);
+}
+/**
+ * Hands a send's outcome back to a sender. Normally the sender waits for it. While the page
+ * closes it does not: the request is already out, and waiting would hold the next queue's send
+ * until after the page has gone. The outcome is still handled whenever it arrives.
+ */
+function awaitUnlessClosing(landed, forget, label) {
+    if (!forget) {
+        return landed.then(function () { return undefined; });
+    }
+    landed.catch(function (err) {
+        logger.Console.log(label + ': not confirmed before the page closed, kept for the next send: ' + String(err)); // no i18n
+    });
+    return undefined;
+}
+
+exports.awaitUnlessClosing = awaitUnlessClosing;
+exports.clearDefer = clearDefer;
+exports.defer = defer;
+exports.freshItems = freshItems;
+exports.sendBatch = sendBatch;
+exports.withSendLock = withSendLock;

package/dist/cjs/core/callsite.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ *
+ * There is no caller introspection in a browser, so the only way to answer "which line was this"
+ * is to throw an Error nobody catches and read its stack. That is cheap enough for a channel that
+ * only carries the SDK's own failures, but it is never on the app's path: everything here is
+ * wrapped so a stack we cannot parse costs a line its call site and nothing more.
+ */
+export interface CallSite {
+    /** The script's basename, not its url: logSDK caps filename at 100 characters. */
+    filename: string;
+    /** 0 when the stack gave us nothing — see entryFor() for why it is still sent. */
+    linenumber: number;
+    /** The calling function's name, when the frame has one. Anonymous callers have none. */
+    fn?: string;
+}
+export declare const NO_CALL_SITE: CallSite;
+/**
+ * A call typed in the browser's developer console: there is no file, line or function to report,
+ * only the console's own placeholder for its input, so the line says plainly that it came from
+ * nowhere in the app. file_name and the function field both accept `-`.
+ */
+export declare const CONSOLE_CALL_SITE: CallSite;
+/**
+ * The frame `skip` frames down a stack, counting only the ones that name a file — V8 heads its
+ * stacks with an `Error` line and Firefox does not, so counting raw lines would read a different
+ * frame in each browser.
+ */
+export declare function callSiteFromStack(stack: string | undefined, skip: number): CallSite;
+/**
+ * Where the caller `skip` levels above this call sits. `skip` is 0 for this function's own
+ * caller; each wrapper between that caller and the place worth reporting adds one.
+ */
+export declare function callSite(skip: number): CallSite;

package/dist/cjs/core/callsite.js

@@ -0,0 +1,115 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+/**
+ * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ *
+ * There is no caller introspection in a browser, so the only way to answer "which line was this"
+ * is to throw an Error nobody catches and read its stack. That is cheap enough for a channel that
+ * only carries the SDK's own failures, but it is never on the app's path: everything here is
+ * wrapped so a stack we cannot parse costs a line its call site and nothing more.
+ */
+const NO_CALL_SITE = { filename: '', linenumber: 0, fn: '' };
+/**
+ * A call typed in the browser's developer console: there is no file, line or function to report,
+ * only the console's own placeholder for its input, so the line says plainly that it came from
+ * nowhere in the app. file_name and the function field both accept `-`.
+ */
+const CONSOLE_CALL_SITE = { filename: '-', linenumber: 0, fn: '-' };
+/**
+ * The frame of code run from the developer console, in each browser:
+ *   V8 (Chrome, Edge):  `    at <anonymous>:1:15`        (the file is <anonymous>)
+ *   Firefox:            `@debugger eval code:1:15`
+ *   Safari:             `global code` or `eval code`, with no location at all
+ * V8 names a string run through eval or new Function <anonymous> too; it is no file either.
+ */
+const CONSOLE_FILE_V8 = '<anonymous>'; // no i18n
+const CONSOLE_FIREFOX = /debugger eval code/; // no i18n
+const CONSOLE_SAFARI = /^(global|eval) code(@|$)/; // no i18n
+/** logSDK declares max-len="100" on filename. */
+const FILENAME_MAX = 100;
+/**
+ * The file and line out of one stack frame, in either shape a browser produces:
+ *   V8:              `    at doThing (https://host/app.js:12:34)`
+ *   Firefox/Safari:  `doThing@https://host/app.js:12:34`
+ * Both end in `:line:column`, which is the only part that is the same everywhere, so the match is
+ * anchored there and the column is read only so that it can be thrown away — without it the
+ * pattern would take the column for the line.
+ */
+const FRAME = /([^\s(@]+):(\d+):(\d+)\)?$/;
+/** `https://host/path/app.js?v=2` -> `app.js`. The url would not fit in 100 characters. */
+function basename(url) {
+    var path = url.split(/[?#]/)[0] || url;
+    var parts = path.split('/');
+    return (parts[parts.length - 1] || path).slice(0, FILENAME_MAX);
+}
+/**
+ * The function a frame names, in either shape:
+ *   V8:              `at doThing (` — or `at async doThing (`
+ *   Firefox/Safari:  `doThing@`
+ * A frame without one (`at https://…` or `@https://…`) is an anonymous caller, and gets ''.
+ */
+const FRAME_FN_V8 = /^at\s+(?:async\s+)?(.+?)\s+\(/;
+const FRAME_FN_OTHER = /^([^@\s]+)@/;
+function frameFunction(frame) {
+    var match = FRAME_FN_V8.exec(frame) || FRAME_FN_OTHER.exec(frame);
+    return match ? (match[1] || '') : ''; // no i18n
+}
+function parseFrame(line) {
+    var trimmed = line.trim();
+    var match = FRAME.exec(trimmed);
+    if (match === null) {
+        return null;
+    }
+    var line_no = Number(match[2]);
+    if (!isFinite(line_no)) {
+        return null;
+    }
+    return { filename: basename(match[1] || ''), linenumber: line_no, fn: frameFunction(trimmed) };
+}
+/**
+ * The frame `skip` frames down a stack, counting only the ones that name a file — V8 heads its
+ * stacks with an `Error` line and Firefox does not, so counting raw lines would read a different
+ * frame in each browser.
+ */
+function callSiteFromStack(stack, skip) {
+    if (!stack) {
+        return NO_CALL_SITE;
+    }
+    var lines = stack.split('\n');
+    var seen = 0;
+    for (var i = 0; i < lines.length; i++) {
+        var raw = (lines[i] || '').trim(); // no i18n
+        var frame = parseFrame(raw);
+        if (frame === null) {
+            // Safari's console frame has no location, so it is never a frame parseFrame reads
+            if (seen === skip && CONSOLE_SAFARI.test(raw)) {
+                return CONSOLE_CALL_SITE;
+            }
+            continue;
+        }
+        if (seen++ < skip) {
+            continue;
+        }
+        return frame.filename === CONSOLE_FILE_V8 || CONSOLE_FIREFOX.test(raw) ? CONSOLE_CALL_SITE : frame;
+    }
+    return NO_CALL_SITE;
+}
+/**
+ * Where the caller `skip` levels above this call sits. `skip` is 0 for this function's own
+ * caller; each wrapper between that caller and the place worth reporting adds one.
+ */
+function callSite(skip) {
+    try {
+        // +1 for this function's own frame, which is never the answer
+        return callSiteFromStack(new Error().stack, skip + 1);
+    }
+    catch (err) {
+        return NO_CALL_SITE;
+    }
+}
+
+exports.CONSOLE_CALL_SITE = CONSOLE_CALL_SITE;
+exports.NO_CALL_SITE = NO_CALL_SITE;
+exports.callSite = callSite;
+exports.callSiteFromStack = callSiteFromStack;

package/dist/cjs/core/consent.d.ts

@@ -0,0 +1,27 @@
+import type { TrackingStatus } from '../types.js';
+/**
+ * DNT counts only when not ignored; while it counts, tracking is NO_TRACKING (opt_in_status).
+ * Decided on every visit and never stored: storing it made one visit with DNT on look like the
+ * visitor's own choice, so tracking stayed off after DNT was turned off or ignore_do_not_track set.
+ */
+export declare function hasDoNotTrackEnabled(): boolean;
+export declare function opt_in_status(): TrackingStatus;
+export declare function shouldTrackOrSendData(): boolean;
+/**
+ * The guard every tracking call starts with: init() has run, the client isn't a crawler,
+ * and consent / server flags allow tracking.
+ */
+export declare function canTrack(caller: string): boolean;
+/** canTrack plus the server's `engagementtracking` flag from getupdates (events, screens, sessions, api calls). */
+export declare function canTrackEngagement(caller: string): boolean;
+/**
+ * canTrack plus the server's heatmap flag (getsdkconfig module 18).
+ *
+ * Heatmap rode the engagement flag until v2 gave it one of its own, which matters: an app may
+ * well want events while declining to have every click's coordinates recorded.
+ */
+export declare function canTrackHeatmap(caller: string): boolean;
+/** canTrack plus the server's `errortracking` flag from getupdates. */
+export declare function canTrackErrors(caller: string): boolean;
+export declare function setTrackingStatus(trackingState: TrackingStatus): void;
+export declare function getTrackingStatus(): TrackingStatus;

package/dist/cjs/core/consent.js

@@ -0,0 +1,132 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./constants.js');
+var state = require('./state.js');
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+var storage = require('./storage.js');
+var env = require('./env.js');
+var hooks = require('./hooks.js');
+
+/**
+ * DNT counts only when not ignored; while it counts, tracking is NO_TRACKING (opt_in_status).
+ * Decided on every visit and never stored: storing it made one visit with DNT on look like the
+ * visitor's own choice, so tracking stayed off after DNT was turned off or ignore_do_not_track set.
+ */
+function hasDoNotTrackEnabled() {
+    if (state._ZAP._ignoreDnt) {
+        return false;
+    }
+    if (env.isDntOn()) {
+        logger.Console.warn('hasDoNotTrackEnabled: DoNotTrack is enabled, so nothing is tracked'); // no i18n
+        return true;
+    }
+    return false;
+}
+function opt_in_status() {
+    if (hasDoNotTrackEnabled()) {
+        logger.Console.warn('opt_in_status: It seems "Do Not Track" is enabled in this browser. Please enable tracking in the browser settings to continue tracking.'); // no i18n
+        return constants.AP_TRACKING_STATUS.NO_TRACKING;
+    }
+    var status = storage.tracking_preference.opt_in_status();
+    if (status == -1) {
+        logger.Console.warn('opt_in_status: You are opted out of Apptics tracking. This will prevent the our SDK from sending no data to our server.'); // no i18n
+    }
+    return status;
+}
+function shouldTrackOrSendData() {
+    var optInStatus = opt_in_status();
+    return optInStatus > -1 && state._ZAP._shouldTrack;
+}
+/**
+ * The guard every tracking call starts with: init() has run, the client isn't a crawler,
+ * and consent / server flags allow tracking.
+ */
+function canTrack(caller) {
+    if (!state._ZAP._token) {
+        logger.Console.warn('apptics.' + caller + ': You must call Apptics.init() first'); // no i18n
+        return false;
+    }
+    if (env.is_apptics_disabled()) {
+        return false;
+    }
+    return shouldTrackOrSendData();
+}
+/** canTrack plus the server's `engagementtracking` flag from getupdates (events, screens, sessions, api calls). */
+function canTrackEngagement(caller) {
+    if (!canTrack(caller)) {
+        return false;
+    }
+    if (!state._ZAP._engagementTracking) {
+        logger.Console.log('apptics.' + caller + ': engagement tracking is turned off by the server'); // no i18n
+        return false;
+    }
+    return true;
+}
+/**
+ * canTrack plus the server's heatmap flag (getsdkconfig module 18).
+ *
+ * Heatmap rode the engagement flag until v2 gave it one of its own, which matters: an app may
+ * well want events while declining to have every click's coordinates recorded.
+ */
+function canTrackHeatmap(caller) {
+    if (!canTrack(caller)) {
+        return false;
+    }
+    if (!state._ZAP._heatmapTracking) {
+        logger.Console.log('apptics.' + caller + ': heatmap tracking is turned off by the server'); // no i18n
+        return false;
+    }
+    return true;
+}
+/** canTrack plus the server's `errortracking` flag from getupdates. */
+function canTrackErrors(caller) {
+    if (!canTrack(caller)) {
+        return false;
+    }
+    if (!state._ZAP._errorTracking) {
+        logger.Console.log('apptics.' + caller + ': error tracking is turned off by the server'); // no i18n
+        return false;
+    }
+    return true;
+}
+function setTrackingStatus(trackingState) {
+    if (utils.isEmpty(trackingState)) {
+        logger.Console.warn('setTrackingStatus: trackingStatus is Empty'); // no i18n
+        return;
+    }
+    if (storage.tracking_preference.opt_in_status() == trackingState) {
+        return;
+    }
+    storage.tracking_preference.update_status(trackingState);
+    state._ZAP._devicestatus = storage.tracking_preference.opt_in_status();
+    state._ZAP._isanonrequired = storage.tracking_preference.opt_in_status() == constants.AP_TRACKING_STATUS.USAGE_TRACKING_WITH_PII ? false : state._ZAP._isanonrequired;
+    if (storage.tracking_preference.opt_in_status() != constants.AP_TRACKING_STATUS.NO_TRACKING) {
+        logger.Console.log('setTrackingStatus: Updating device info with new tracking status'); // no i18n
+        hooks.hooks.updateDevice(state._ZAP._device_info).then(function (result) {
+            if (utils.isSuccess(result)) {
+                logger.Console.log('setTrackingStatus: Device info updated with new tracking status' + JSON.stringify(result.data)); // no i18n
+                logger.Console.dir(result.data);
+            }
+            else {
+                logger.Console.log('setTrackingStatus: Error updating device info with new tracking status: ' + JSON.stringify(result)); // no i18n
+            }
+        }).catch(function (err) {
+            logger.Console.warn('setTrackingStatus: Error updating device info with new tracking status: ' + JSON.stringify(err)); // no i18n
+        });
+    }
+}
+function getTrackingStatus() {
+    return opt_in_status();
+}
+
+exports.canTrack = canTrack;
+exports.canTrackEngagement = canTrackEngagement;
+exports.canTrackErrors = canTrackErrors;
+exports.canTrackHeatmap = canTrackHeatmap;
+exports.getTrackingStatus = getTrackingStatus;
+exports.hasDoNotTrackEnabled = hasDoNotTrackEnabled;
+exports.opt_in_status = opt_in_status;
+exports.setTrackingStatus = setTrackingStatus;
+exports.shouldTrackOrSendData = shouldTrackOrSendData;