@dash0/sdk-web 0.6.2

package/dist/modules/api/session.js

@@ -0,0 +1,88 @@
+import { isSupported, getItem, setItem, removeItem, SESSION_ID_BYTES } from "../utils";
+import { debug, generateUniqueId, now } from "../utils";
+import { info, warn } from "../utils";
+const SESSION_STORAGE_KEY = "d0_session";
+const STORAGE_SEPARATOR_KEY = "#";
+const DEFAULT_SESSION_INACTIVITY_TIMEOUT_MILLIS = 1000 * 60 * 60 * 3;
+const DEFAULT_SESSION_TERMINATION_TIMEOUT_MILLIS = 1000 * 60 * 60 * 6;
+const MAX_ALLOWED_SESSION_TIMEOUT_MILLIS = 1000 * 60 * 60 * 24;
+export let sessionId = null;
+export function trackSessions(sessionInactivityTimeoutMillis, sessionTerminationTimeoutMillis) {
+    if (!isSupported) {
+        debug("Storage API is not available and session tracking is therefore not supported.");
+        return;
+    }
+    if (!sessionInactivityTimeoutMillis) {
+        sessionInactivityTimeoutMillis = DEFAULT_SESSION_INACTIVITY_TIMEOUT_MILLIS;
+    }
+    if (!sessionTerminationTimeoutMillis) {
+        sessionTerminationTimeoutMillis = DEFAULT_SESSION_TERMINATION_TIMEOUT_MILLIS;
+    }
+    sessionInactivityTimeoutMillis = Math.min(sessionInactivityTimeoutMillis, MAX_ALLOWED_SESSION_TIMEOUT_MILLIS);
+    sessionTerminationTimeoutMillis = Math.min(sessionTerminationTimeoutMillis, MAX_ALLOWED_SESSION_TIMEOUT_MILLIS);
+    try {
+        const storedValue = getItem(SESSION_STORAGE_KEY);
+        let session = parseSession(storedValue);
+        if (session && !isSessionValid(session, sessionInactivityTimeoutMillis, sessionTerminationTimeoutMillis)) {
+            session = null;
+        }
+        if (session) {
+            session.lastActivityTime = now();
+        }
+        else {
+            session = {
+                id: generateUniqueId(SESSION_ID_BYTES),
+                startTime: now(),
+                lastActivityTime: now(),
+            };
+        }
+        setItem(SESSION_STORAGE_KEY, serializeSession(session));
+        sessionId = session.id;
+    }
+    catch (e) {
+        warn("Failed to record session information", e);
+    }
+}
+export function terminateSession() {
+    sessionId = null;
+    if (!isSupported) {
+        return;
+    }
+    try {
+        removeItem(SESSION_STORAGE_KEY);
+    }
+    catch (e) {
+        info("Failed to terminate session", e);
+    }
+}
+function parseSession(storedValue) {
+    if (!storedValue) {
+        return null;
+    }
+    const values = storedValue.split(STORAGE_SEPARATOR_KEY);
+    if (values.length < 3) {
+        return null;
+    }
+    const id = values[0];
+    const startTime = parseInt(values[1], 10);
+    const lastActivityTime = parseInt(values[2], 10);
+    if (!id || isNaN(startTime) || isNaN(lastActivityTime)) {
+        return null;
+    }
+    return {
+        id,
+        startTime,
+        lastActivityTime,
+    };
+}
+function serializeSession(session) {
+    return session.id + STORAGE_SEPARATOR_KEY + session.startTime + STORAGE_SEPARATOR_KEY + session.lastActivityTime;
+}
+function isSessionValid(session, sessionInactivityTimeoutMillis, sessionTerminationTimeoutMillis) {
+    const minAllowedLastActivityTime = now() - sessionInactivityTimeoutMillis;
+    if (session.lastActivityTime < minAllowedLastActivityTime) {
+        return false;
+    }
+    const minAllowedStartTime = now() - sessionTerminationTimeoutMillis;
+    return session.startTime >= minAllowedStartTime;
+}

package/dist/modules/attributes/common.js

@@ -0,0 +1,26 @@
+import { nav, NO_VALUE_FALLBACK, win } from "../utils";
+import { BROWSER_TAB_ID, NETWORK_CONNECTION_TYPE, SESSION_ID, WINDOW_HEIGHT, WINDOW_WIDTH, } from "../semantic-conventions";
+import { sessionId } from "../api/session";
+import { vars } from "../vars";
+import { addAttribute } from "../utils/otel";
+import { addUrlAttributes } from "./url";
+import { tabId } from "../utils/tab-id";
+export function addCommonAttributes(attributes, options) {
+    for (let i = 0; i < vars.signalAttributes.length; i++) {
+        attributes.push(vars.signalAttributes[i]);
+    }
+    addUrlAttributes(attributes, options?.url ?? win?.location.href ?? NO_VALUE_FALLBACK);
+    if (sessionId) {
+        addAttribute(attributes, SESSION_ID, sessionId);
+    }
+    if (tabId) {
+        addAttribute(attributes, BROWSER_TAB_ID, tabId);
+    }
+    addAttribute(attributes, WINDOW_WIDTH, win?.innerWidth ?? NO_VALUE_FALLBACK);
+    addAttribute(attributes, WINDOW_HEIGHT, win?.innerHeight ?? NO_VALUE_FALLBACK);
+    // @ts-expect-error -- TypeScript is not aware of navigator.connection.effectiveType
+    const connectionType = nav?.connection?.effectiveType;
+    if (connectionType) {
+        addAttribute(attributes, NETWORK_CONNECTION_TYPE, connectionType);
+    }
+}

package/dist/modules/attributes/index.js

@@ -0,0 +1,2 @@
+export * from "./common";
+export * from "./url";

package/dist/modules/attributes/url.js

@@ -0,0 +1,25 @@
+import { addAttribute } from "../utils/otel";
+import { URL_DOMAIN, URL_FRAGMENT, URL_FULL, URL_PATH, URL_QUERY, URL_SCHEME } from "../semantic-conventions";
+import { parseUrl } from "../utils/url";
+export function addUrlAttributes(attributes, url) {
+    try {
+        const parsed = parseUrl(url);
+        if (parsed.username)
+            parsed.username = "REDACTED";
+        if (parsed.password)
+            parsed.password = "REDACTED";
+        addAttribute(attributes, URL_FULL, parsed.href);
+        addAttribute(attributes, URL_PATH, parsed.pathname);
+        addAttribute(attributes, URL_DOMAIN, parsed.hostname);
+        addAttribute(attributes, URL_SCHEME, parsed.protocol.replace(":", ""));
+        if (parsed.hash) {
+            addAttribute(attributes, URL_FRAGMENT, parsed.hash.replace("#", ""));
+        }
+        if (parsed.search) {
+            addAttribute(attributes, URL_QUERY, parsed.search.replace("?", ""));
+        }
+    }
+    catch (_e) {
+        addAttribute(attributes, URL_FULL, String(url));
+    }
+}

package/dist/modules/entrypoint/npm-package.js

@@ -0,0 +1,12 @@
+import { debug, INIT_MESSAGE } from "../utils";
+import { init as initApi } from "../api/init";
+export * from "../api/identify";
+export * from "../api/debug";
+export * from "../api/attributes";
+export * from "../api/events";
+export { terminateSession } from "../api/session";
+export { reportError } from "../api/report-error";
+export function init(opts) {
+    debug(`${INIT_MESSAGE} (via package)`);
+    initApi(opts);
+}

package/dist/modules/entrypoint/script.js

@@ -0,0 +1,60 @@
+import { win, debug, warn, INIT_MESSAGE } from "../utils";
+import { reportError } from "../api/report-error";
+import { identify } from "../api/identify";
+import { debug as debugApi } from "../api/debug";
+import { init as initApi } from "../api/init";
+import { terminateSession } from "../api/session";
+import { addSignalAttribute, removeSignalAttribute } from "../api/attributes";
+import { sendEvent } from "../api/events";
+/**
+ * All the APIs exposed through the script tag via `dash0('{{api name}}')`
+ */
+const scriptApis = {
+    init: initApi,
+    debug: debugApi,
+    identify,
+    terminateSession,
+    reportError,
+    addSignalAttribute,
+    removeSignalAttribute,
+    sendEvent,
+};
+init();
+function init() {
+    debug(`${INIT_MESSAGE} (via Script)`);
+    const globalObject = win["dash0"];
+    if (!globalObject) {
+        warn("global 'dash0' not found. Did you use the correct Dash0 Web SDK initializer?");
+        return;
+    }
+    if (!globalObject["_q"]) {
+        warn("Dash0 Web SDK command queue not defined. Did you add the script tag multiple times to your website?");
+        return;
+    }
+    processQueuedApiCalls(globalObject["_q"]);
+    addApiCallAfterInitializationSupport();
+}
+function processQueuedApiCalls(apiCalls) {
+    for (let i = 0, len = apiCalls.length; i < len; i++) {
+        processQueuedApiCall(apiCalls[i]);
+    }
+}
+function processQueuedApiCall(apiCall) {
+    const apiName = apiCall[0];
+    // @ts-expect-error the APIs are dynamic
+    const apiFn = scriptApis[apiName];
+    if (!apiFn) {
+        warn("Unsupported Dash0 Web SDK api: ", apiCall[0]);
+        return;
+    }
+    const args = [];
+    for (let i = 1; i < apiCall.length; i++) {
+        args.push(apiCall[i]);
+    }
+    apiFn.apply(null, args);
+}
+function addApiCallAfterInitializationSupport() {
+    win["dash0"] = function () {
+        return processQueuedApiCall(arguments);
+    };
+}

package/dist/modules/instrumentations/errors/async-function-wrapping.js

@@ -0,0 +1,105 @@
+const WRAPPED_EVENT_HANDLERS_ORIGINAL_FUNCTION_STORAGE_KEY = "__dash0OriginalFunctions";
+// Asynchronous function wrapping: The process of wrapping a listener which goes into one function, e.g.
+//
+//  - EventTarget#addEventListener
+//  - EventEmitter#on
+//
+// and is removed via another function, e.g.
+//
+//  - EventTarget#removeEventListener
+//  - EventEmitter#off
+//
+// What is complicated about this, is that these methods identify registered listeners by function reference.
+// When we wrap a function, we naturally change the reference. We must therefore keep track of which
+// original function belongs to what wrapped function.
+//
+// This file provides helpers that help in the typical cases. It is removed from all browser specific APIs
+// in order to allow simple unit test execution.
+//
+// Note that this file follows the behavior outlined in DOM specification. Among others, this means that it is not
+// possible to register the same listener twice.
+// http://dom.spec.whatwg.org
+export function addWrappedFunction(storageTarget, wrappedFunction, valuesForEqualityCheck) {
+    if (!storageTarget)
+        return wrappedFunction;
+    const storage = (storageTarget[WRAPPED_EVENT_HANDLERS_ORIGINAL_FUNCTION_STORAGE_KEY] =
+        storageTarget[WRAPPED_EVENT_HANDLERS_ORIGINAL_FUNCTION_STORAGE_KEY] || []);
+    const index = findInStorage(storageTarget, valuesForEqualityCheck);
+    if (index !== -1) {
+        // already registered. Do not allow re-registration
+        return storage[index].wrappedFunction;
+    }
+    storage.push({
+        wrappedFunction,
+        valuesForEqualityCheck,
+    });
+    return wrappedFunction;
+}
+function findInStorage(storageTarget, valuesForEqualityCheck) {
+    const storage = storageTarget[WRAPPED_EVENT_HANDLERS_ORIGINAL_FUNCTION_STORAGE_KEY];
+    for (let i = 0; i < storage.length; i++) {
+        const storageItem = storage[i];
+        if (matchesEqualityCheck(storageItem.valuesForEqualityCheck, valuesForEqualityCheck)) {
+            return i;
+        }
+    }
+    return -1;
+}
+export function popWrappedFunction(storageTarget, valuesForEqualityCheck, fallback) {
+    const storage = storageTarget?.[WRAPPED_EVENT_HANDLERS_ORIGINAL_FUNCTION_STORAGE_KEY];
+    if (storage == null) {
+        return fallback;
+    }
+    const index = findInStorage(storageTarget, valuesForEqualityCheck);
+    if (index === -1) {
+        return fallback;
+    }
+    const storageItem = storage[index];
+    storage.splice(index, 1);
+    return storageItem.wrappedFunction;
+}
+function matchesEqualityCheck(valuesForEqualityCheckA, valuesForEqualityCheckB) {
+    if (valuesForEqualityCheckA.length !== valuesForEqualityCheckB.length) {
+        return false;
+    }
+    for (let i = 0; i < valuesForEqualityCheckA.length; i++) {
+        if (valuesForEqualityCheckA[i] !== valuesForEqualityCheckB[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function addWrappedDomEventListener(storageTarget, wrappedFunction, eventName, eventListener, optionsOrCapture) {
+    return addWrappedFunction(storageTarget, wrappedFunction, getDomEventListenerValuesForEqualityCheck(eventName, eventListener, optionsOrCapture));
+}
+function getDomEventListenerValuesForEqualityCheck(eventName, eventListener, optionsOrCapture) {
+    return [eventName, eventListener, getDomEventListenerCaptureValue(optionsOrCapture)];
+}
+export function getDomEventListenerCaptureValue(optionsOrCapture) {
+    // > Let capture, passive, and once be the result of flattening more options.
+    // https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
+    //
+    // > To flatten more options, run these steps:
+    // > 1. Let capture be the result of flattening options.
+    // https://dom.spec.whatwg.org/#event-flatten-more
+    //
+    // > To flatten options, run these steps:
+    // > 1. If options is a boolean, then return options.
+    // > 2. Return options’s capture.
+    // https://dom.spec.whatwg.org/#concept-flatten-options
+    //
+    // > dictionary EventListenerOptions {
+    // >   boolean capture = false;
+    // > };
+    // https://dom.spec.whatwg.org/#dom-eventlisteneroptions-capture
+    if (optionsOrCapture == null) {
+        return false;
+    }
+    else if (typeof optionsOrCapture === "object") {
+        return Boolean(optionsOrCapture.capture);
+    }
+    return Boolean(optionsOrCapture);
+}
+export function popWrappedDomEventListener(storageTarget, eventName, eventListener, optionsOrCapture, fallback) {
+    return popWrappedFunction(storageTarget, getDomEventListenerValuesForEqualityCheck(eventName, eventListener, optionsOrCapture), fallback);
+}

package/dist/modules/instrumentations/errors/event-handlers.js

@@ -0,0 +1,52 @@
+import { vars } from "../../vars";
+import { win } from "../../utils";
+import { addWrappedDomEventListener, popWrappedDomEventListener, } from "./async-function-wrapping";
+import { ignoreNextOnErrorEvent } from "./unhandled-error";
+export function startEventHandlerInstrumentation() {
+    if (vars.wrapEventHandlers) {
+        wrapEventTarget(win?.EventTarget);
+    }
+}
+function wrapEventTarget(EventTarget) {
+    if (!EventTarget ||
+        typeof EventTarget.prototype.addEventListener !== "function" ||
+        typeof EventTarget.prototype.removeEventListener !== "function") {
+        return;
+    }
+    const originalAddEventListener = EventTarget.prototype.addEventListener;
+    const originalRemoveEventListener = EventTarget.prototype.removeEventListener;
+    EventTarget.prototype.addEventListener = function wrappedAddEventListener(eventName, fn, optionsOrCapture) {
+        if (typeof fn !== "function") {
+            return originalAddEventListener.apply(this, arguments);
+        }
+        // non-deopt arguments copy
+        const args = new Array(arguments.length);
+        for (let i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+        }
+        args[1] = function wrappedEventListener() {
+            try {
+                return fn.apply(this, arguments);
+            }
+            catch (e) {
+                reportError(e);
+                ignoreNextOnErrorEvent();
+                throw e;
+            }
+        };
+        args[1] = addWrappedDomEventListener(this, args[1], eventName, fn, optionsOrCapture);
+        return originalAddEventListener.apply(this, args);
+    };
+    EventTarget.prototype.removeEventListener = function wrappedRemoveEventListener(eventName, fn, optionsOrCapture) {
+        if (typeof fn !== "function") {
+            return originalRemoveEventListener.apply(this, arguments);
+        }
+        // non-deopt arguments copy
+        const args = new Array(arguments.length);
+        for (let i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+        }
+        args[1] = popWrappedDomEventListener(this, eventName, fn, optionsOrCapture, fn);
+        return originalRemoveEventListener.apply(this, args);
+    };
+}

package/dist/modules/instrumentations/errors/index.js

@@ -0,0 +1,10 @@
+import { startOnErrorInstrumentation } from "./unhandled-error";
+import { startUnhandledRejectionInstrumentation } from "./unhandled-promise-rejection";
+import { startEventHandlerInstrumentation } from "./event-handlers";
+import { startTimerInstrumentation } from "./timers";
+export function startErrorInstrumentation() {
+    startOnErrorInstrumentation();
+    startUnhandledRejectionInstrumentation();
+    startEventHandlerInstrumentation();
+    startTimerInstrumentation();
+}

package/dist/modules/instrumentations/errors/timers.js

@@ -0,0 +1,46 @@
+import { vars } from "../../vars";
+import { isRunningZoneJs } from "../../utils/timers";
+import { warn, win } from "../../utils";
+import { ignoreNextOnErrorEvent } from "./unhandled-error";
+export function startTimerInstrumentation() {
+    if (vars.wrapTimers) {
+        if (isRunningZoneJs) {
+            warn("We discovered a usage of Zone.js. In order to avoid any incompatibility issues timer wrapping is not going to be enabled.");
+            return;
+        }
+        wrapTimer("setTimeout");
+        wrapTimer("setInterval");
+    }
+}
+function wrapTimer(name) {
+    const original = win?.[name];
+    if (typeof original !== "function") {
+        // cannot wrap because fn is not a function – should actually never happen
+        return;
+    }
+    win[name] = function wrappedTimerSetter(fn) {
+        // non-deopt arguments copy
+        const args = new Array(arguments.length);
+        for (let i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+        }
+        args[0] = wrap(fn);
+        return original.apply(this, args);
+    };
+}
+function wrap(fn) {
+    if (typeof fn !== "function") {
+        // cannot wrap because fn is not a function
+        return fn;
+    }
+    return function wrappedTimerHandler() {
+        try {
+            return fn.apply(this, arguments);
+        }
+        catch (e) {
+            reportError(e);
+            ignoreNextOnErrorEvent();
+            throw e;
+        }
+    };
+}

package/dist/modules/instrumentations/errors/unhandled-error.js

@@ -0,0 +1,137 @@
+import { hasOwnProperty, nowNanos, win } from "../../utils";
+import { isErrorMessageIgnored } from "../../utils/ignore-rules";
+import { sendLog } from "../../transport";
+import { EVENT_NAME, EVENT_NAMES, EXCEPTION_COMPONENT_STACK, EXCEPTION_MESSAGE, EXCEPTION_STACKTRACE, EXCEPTION_TYPE, LOG_SEVERITIES, } from "../../semantic-conventions";
+import { addAttribute } from "../../utils/otel";
+import { addCommonAttributes } from "../../attributes";
+const MAX_ERRORS_TO_REPORT = 100;
+const MAX_STACK_SIZE = 30;
+const MAX_NUMBER_OF_TRACKED_ERRORS = 20;
+let reportedErrors = 0;
+let numberOfDifferentErrorsSeen = 0;
+let seenErrors = {};
+let scheduledTransmissionTimeoutHandle;
+// We are wrapping global listeners. In these, we are catching and rethrowing errors.
+// In older browsers, rethrowing errors actually manipulates the error objects. As a
+// result, it is not possible to just mark an error as reported. The simplest way to
+// avoid double reporting is to temporarily disable the global onError handler…
+let ignoreNextOnError = false;
+export function ignoreNextOnErrorEvent() {
+    ignoreNextOnError = true;
+}
+export function startOnErrorInstrumentation() {
+    if (!win)
+        return;
+    const globalOnError = win.onerror;
+    win.onerror = function (message, fileName, lineNumber, columnNumber, error) {
+        if (ignoreNextOnError) {
+            ignoreNextOnError = false;
+            if (typeof globalOnError === "function") {
+                return globalOnError.apply(this, arguments);
+            }
+            return;
+        }
+        let stack = error && error.stack;
+        if (!stack) {
+            stack = "at " + fileName + " " + lineNumber;
+            if (columnNumber != null) {
+                stack += ":" + columnNumber;
+            }
+        }
+        onUnhandledError({ message: String(message), stack });
+        if (typeof globalOnError === "function") {
+            return globalOnError.apply(this, arguments);
+        }
+    };
+}
+export function reportError(error, opts) {
+    if (!error) {
+        return;
+    }
+    if (typeof error === "string") {
+        onUnhandledError({ message: error, opts });
+    }
+    else {
+        onUnhandledError({ message: error.message, type: error.name, stack: error.stack, opts });
+    }
+}
+function onUnhandledError({ message, type, stack, opts }) {
+    if (!message || reportedErrors > MAX_ERRORS_TO_REPORT) {
+        return;
+    }
+    if (isErrorMessageIgnored(message)) {
+        return;
+    }
+    if (numberOfDifferentErrorsSeen >= MAX_NUMBER_OF_TRACKED_ERRORS) {
+        seenErrors = {};
+        numberOfDifferentErrorsSeen = 0;
+    }
+    message = String(message).substring(0, 300);
+    stack = shortenStackTrace(stack);
+    const location = win?.location.href;
+    const key = message + stack + location;
+    let trackedError = seenErrors[key];
+    if (trackedError) {
+        trackedError.seenCount++;
+    }
+    else {
+        const attributes = [];
+        addAttribute(attributes, EVENT_NAME, EVENT_NAMES.ERROR);
+        addAttribute(attributes, EXCEPTION_MESSAGE, message);
+        if (type) {
+            addAttribute(attributes, EXCEPTION_TYPE, type);
+        }
+        if (stack) {
+            addAttribute(attributes, EXCEPTION_STACKTRACE, stack);
+        }
+        if (opts?.componentStack) {
+            addAttribute(attributes, EXCEPTION_COMPONENT_STACK, opts?.componentStack.substring(0, 2048));
+        }
+        addCommonAttributes(attributes);
+        trackedError = {
+            seenCount: 1,
+            transmittedCount: 0,
+            log: {
+                timeUnixNano: nowNanos(),
+                attributes: attributes,
+                severityNumber: LOG_SEVERITIES.ERROR,
+                severityText: "ERROR",
+                body: {
+                    stringValue: message,
+                },
+            },
+        };
+        seenErrors[key] = trackedError;
+        numberOfDifferentErrorsSeen++;
+    }
+    scheduleTransmission();
+}
+export function shortenStackTrace(stack) {
+    return String(stack || "")
+        .split("\n")
+        .slice(0, MAX_STACK_SIZE)
+        .join("\n");
+}
+function scheduleTransmission() {
+    if (scheduledTransmissionTimeoutHandle) {
+        return;
+    }
+    scheduledTransmissionTimeoutHandle = setTimeout(send, 1000);
+}
+function send() {
+    if (scheduledTransmissionTimeoutHandle) {
+        clearTimeout(scheduledTransmissionTimeoutHandle);
+        scheduledTransmissionTimeoutHandle = null;
+    }
+    for (const key in seenErrors) {
+        if (hasOwnProperty(seenErrors, key)) {
+            const seenError = seenErrors[key];
+            if (seenError.seenCount > seenError.transmittedCount) {
+                sendLog(seenError.log);
+                reportedErrors++;
+            }
+        }
+    }
+    seenErrors = {};
+    numberOfDifferentErrorsSeen = 0;
+}

package/dist/modules/instrumentations/errors/unhandled-promise-rejection.js

@@ -0,0 +1,29 @@
+import { win } from "../../utils";
+import { reportError } from "./unhandled-error";
+const MESSAGE_PREFIX = "Unhandled promise rejection: ";
+const STACK_UNAVAILABLE_MESSAGE = "<unavailable because Promise wasn't rejected with an Error object>";
+export function startUnhandledRejectionInstrumentation() {
+    if (typeof win?.addEventListener === "function") {
+        win.addEventListener("unhandledrejection", onUnhandledRejection);
+    }
+}
+export function onUnhandledRejection(event) {
+    if (event.reason == null) {
+        reportError({
+            message: MESSAGE_PREFIX + "<no reason defined>",
+            stack: STACK_UNAVAILABLE_MESSAGE,
+        });
+    }
+    else if (typeof event.reason.message === "string") {
+        reportError({
+            message: MESSAGE_PREFIX + event.reason.message,
+            stack: typeof event.reason.stack === "string" ? event.reason.stack : STACK_UNAVAILABLE_MESSAGE,
+        });
+    }
+    else if (typeof event.reason !== "object") {
+        reportError({
+            message: MESSAGE_PREFIX + event.reason,
+            stack: STACK_UNAVAILABLE_MESSAGE,
+        });
+    }
+}