app-tracker 2.2.2 → 3.1.0

package/app-tracker.service.js

@@ -1,247 +1,363 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const log_1 = require("./log");
-const cross_fetch_1 = require("cross-fetch");
-const safeFetch = typeof window !== 'undefined' ? cross_fetch_1.default.bind(window) : cross_fetch_1.default;
-class AppTrackerService {
-    constructor() {
-        this.sendLogsInDevelopment = false;
-        this.logInConsole = false;
-        this.endpointUrl = 'https://app-tracker-api.azurewebsites.net/';
-        this.apiKey = '';
-        this.logs = [];
-        this.sendTries = 0;
-        this.maxSendTries = 5;
-        this.isSending = false;
-        this.maxLogsCount = 10;
-        this.userAgent = '';
-        this.logLevel = [log_1.LogType.error];
-        this.sendLogsByTypesImmediately = [log_1.LogType.error, log_1.LogType.critical];
-        this.isNode = false;
-        this.isRunningLocal = true;
-        this.ident = '';
-        this.eventListenerAdded = false;
-    }
-    init(apiKey, config) {
-        this.apiKey = apiKey;
-        if (config) {
-            if (typeof config.endpointUrl !== 'undefined')
-                this.endpointUrl = config.endpointUrl;
-            if (typeof config.maxLogsCount !== 'undefined')
-                this.maxLogsCount = config.maxLogsCount;
-            if (typeof config.maxSendTries !== 'undefined')
-                this.maxSendTries = config.maxSendTries;
-            if (typeof config.sendLogsInDevelopment !== 'undefined')
-                this.sendLogsInDevelopment = config.sendLogsInDevelopment;
-            if (typeof config.logInConsole !== 'undefined')
-                this.logInConsole = config.logInConsole;
-            if (typeof config.logLevel !== 'undefined')
-                this.logLevel = config.logLevel;
-            if (typeof config.sendLogsByTypesImmediately !== 'undefined')
-                this.sendLogsByTypesImmediately = config.sendLogsByTypesImmediately;
-        }
-        this.setRunningSystem(config);
-    }
-    addEventListener(apiKey) {
-        if (apiKey != '' && !this.isNode && !this.isRunningLocal && !this.eventListenerAdded) {
-            this._boundBeforeUnloadHandler = this._boundBeforeUnloadHandler || ((e) => this.beforeunloadHandler(e));
-            window.addEventListener('beforeunload', this._boundBeforeUnloadHandler, true);
-            this.eventListenerAdded = true;
-        }
-    }
-    removeEventListener(apiKey) {
-        if (apiKey != '' && !this.isNode && !this.isRunningLocal && this.eventListenerAdded) {
-            if (this._boundBeforeUnloadHandler) {
-                window.removeEventListener('beforeunload', this._boundBeforeUnloadHandler, true);
-            }
-            this.eventListenerAdded = false;
-        }
-    }
-    beforeunloadHandler(event) {
-        event.preventDefault();
-        event.returnValue = '';
-        if (!this.isSending) {
-            const logsToSend = this.logs;
-            this.isSending = true;
-            this.logs = [];
-            this.sendLogsToServerCore(logsToSend);
-        }
-    }
-    setRunningSystem(config) {
-        var _a, _b, _c;
-        this.isNode = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-        if (!this.isNode) {
-            this.userAgent = (_a = config) === null || _a === void 0 ? void 0 : _a.userAgentOrOs;
-            this.ident = this.getIdent();
-        }
-        else {
-            this.os = (_b = config) === null || _b === void 0 ? void 0 : _b.userAgentOrOs;
-            this.userAgent = this.setUserAgentFromOs();
-        }
-        this.isRunningLocal = this.isNode ? (_c = process.env.NODE_ENV, (_c !== null && _c !== void 0 ? _c : '')).indexOf("development") > -1 : window.location.href.indexOf('localhost') > -1;
-    }
-    getIdent() {
-        var _a;
-        let ident = (_a = localStorage) === null || _a === void 0 ? void 0 : _a.getItem('App-Tracker.device-ident');
-        if (!ident) {
-            ident = this.createUUID();
-            localStorage.setItem('App-Tracker.device-ident', ident);
-        }
-        return ident;
-    }
-    debug(message, ...optionalParams) {
-        this.addLog(log_1.LogType.debug, message, ...optionalParams);
-    }
-    info(message, ...optionalParams) {
-        this.addLog(log_1.LogType.info, message, ...optionalParams);
-    }
-    log(message, ...optionalParams) {
-        this.addLog(log_1.LogType.log, message, ...optionalParams);
-    }
-    warn(message, ...optionalParams) {
-        this.addLog(log_1.LogType.warn, message, ...optionalParams);
-    }
-    error(message, ...optionalParams) {
-        this.addLog(log_1.LogType.error, message, ...optionalParams);
-    }
-    critical(message, ...optionalParams) {
-        this.addLog(log_1.LogType.critical, message, ...optionalParams);
-    }
-    addLog(type, message, ...optionalParams) {
-        if (this.checkLogType(type)) {
-            if (this.isRunningLocal && !this.sendLogsInDevelopment) {
-                this.logToConsole(type, message, ...optionalParams);
-            }
-            else {
-                this.sendLogsToServer(type, message, ...optionalParams);
-            }
-        }
-        else {
-            this.logToConsole(type, message, ...optionalParams);
-        }
-    }
-    logToConsole(type, message, ...optionalParams) {
-        if (this.logInConsole) {
-            switch (type) {
-                case log_1.LogType.debug:
-                    console.debug(message, ...optionalParams);
-                    break;
-                case log_1.LogType.critical:
-                case log_1.LogType.error:
-                    console.error(message, ...optionalParams);
-                    break;
-                case log_1.LogType.info:
-                    console.info(message, ...optionalParams);
-                    break;
-                case log_1.LogType.log:
-                    console.log(message, ...optionalParams);
-                    break;
-                case log_1.LogType.warn:
-                    console.warn(message, ...optionalParams);
-                    break;
-                default:
-                    console.warn("Unkown LogType: ", type);
-                    break;
-            }
-        }
-    }
-    sendLogsToServer(type, message, ...optionalParams) {
-        var _a, _b;
-        const log = { logType: type, message: message, optionalParams: [], createdAt: new Date(), ident: this.ident };
-        optionalParams.forEach((op) => {
-            if (Array.isArray(op))
-                op.forEach(o => log.optionalParams.push(o));
-            else
-                log.optionalParams.push(op);
-        });
-        this.logs.push(log);
-        if ((this.logs.length >= this.maxLogsCount && !this.isSending) ||
-            ((((_a = this.sendLogsByTypesImmediately) === null || _a === void 0 ? void 0 : _a.find(l => l == type)) || type == log_1.LogType.critical) != null && !this.isSending)) {
-            const logsToSend = this.logs;
-            this.logs = [];
-            this.isSending = true;
-            this.sendLogsToServerCore(logsToSend);
-            this.removeEventListener(this.apiKey);
-        }
-        if (((_b = this.logs) === null || _b === void 0 ? void 0 : _b.length) > 0 && !this.eventListenerAdded) {
-            this.addEventListener(this.apiKey);
-        }
-    }
-    checkLogType(type) {
-        if (this.logLevel.find(l => l === type) != null || type === log_1.LogType.critical) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    sendLogsToServerCore(logsToSend) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.sendTries < this.maxSendTries) {
-                try {
-                    const last = this.endpointUrl.charAt(this.endpointUrl.length - 1);
-                    const response = yield safeFetch(`${this.endpointUrl}${last === '/' ? 'logs/createLog' : '/logs/createLog'}`, {
-                        method: 'POST',
-                        headers: {
-                            'Accept': 'application/json',
-                            'Content-Type': 'application/json',
-                            'X-Auth-Key': this.apiKey
-                        },
-                        body: JSON.stringify({ logs: logsToSend, userAgent: this.userAgent }, (key, value) => {
-                            if (value instanceof Error) {
-                                let error = {};
-                                Object.getOwnPropertyNames(value).forEach(function (key) {
-                                    error[key] = value[key];
-                                });
-                                return error;
-                            }
-                            return value;
-                        })
-                    });
-                    logsToSend = [];
-                    this.isSending = false;
-                    this.sendTries = 0; // Reset sendTries after successful send
-                }
-                catch (error) {
-                    console.error(`AppLogger: Could not send Logs to Server try ${this.sendTries}`, error);
-                    this.sendTries++;
-                    // Warten, bevor der nächste asynchrone Versuch gestartet wird
-                    yield new Promise(resolve => setTimeout(resolve, 10000));
-                    yield this.sendLogsToServerCore(logsToSend);
-                }
-            }
-            else {
-                this.sendTries = 0;
-                this.isSending = false;
-                console.error('AppLogger: Could not send Logs to Server finally');
-            }
-        });
-    }
-    setUserAgentFromOs() {
-        const osInfo = {
-            arch: this.os.arch(),
-            platform: this.os.platform(),
-            release: this.os.release(),
-            type: this.os.type(),
-            version: this.os.version(),
-            hostname: this.os.hostname()
-        };
-        return JSON.stringify(osInfo);
-    }
-    createUUID() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-}
-exports.AppTrackerService = AppTrackerService;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("./log");
+const cross_fetch_1 = require("cross-fetch");
+const version_1 = require("./version");
+const log_privacy_1 = require("./log-privacy");
+const safeFetch = typeof window !== 'undefined' ? cross_fetch_1.default.bind(window) : cross_fetch_1.default;
+class AppTrackerService {
+    constructor() {
+        this.sendLogsInDevelopment = false;
+        this.logInConsole = false;
+        this.endpointUrl = 'https://app-tracker-api.azurewebsites.net/';
+        this.apiKey = '';
+        this.logs = [];
+        this.maxSendTries = 5;
+        this.retryDelayMs = 10000;
+        this.requestTimeoutMs = 10000;
+        this.isSending = false;
+        this.maxLogsCount = 10;
+        this.clientInfo = null;
+        this.logLevel = [log_1.LogType.error];
+        this.sendLogsByTypesImmediately = [log_1.LogType.error, log_1.LogType.critical];
+        this.isNode = false;
+        this.isRunningLocal = true;
+        this.eventListenerAdded = false;
+    }
+    init(apiKey, config) {
+        this.apiKey = apiKey;
+        if (config) {
+            if (typeof config.endpointUrl !== 'undefined')
+                this.endpointUrl = config.endpointUrl;
+            if (typeof config.maxLogsCount !== 'undefined')
+                this.maxLogsCount = config.maxLogsCount;
+            if (typeof config.maxSendTries !== 'undefined')
+                this.maxSendTries = Math.max(1, config.maxSendTries);
+            if (typeof config.retryDelayMs !== 'undefined')
+                this.retryDelayMs = Math.max(0, config.retryDelayMs);
+            if (typeof config.requestTimeoutMs !== 'undefined')
+                this.requestTimeoutMs = Math.max(1, config.requestTimeoutMs);
+            if (typeof config.sendLogsInDevelopment !== 'undefined')
+                this.sendLogsInDevelopment = config.sendLogsInDevelopment;
+            if (typeof config.logInConsole !== 'undefined')
+                this.logInConsole = config.logInConsole;
+            if (typeof config.logLevel !== 'undefined')
+                this.logLevel = config.logLevel;
+            if (typeof config.sendLogsByTypesImmediately !== 'undefined')
+                this.sendLogsByTypesImmediately = config.sendLogsByTypesImmediately;
+        }
+        this.setRunningSystem(config);
+        if (!this.isNode && !this.correlationId) {
+            this.correlationId = this.createCorrelationId();
+        }
+    }
+    addEventListener(apiKey) {
+        if (apiKey != '' && !this.isNode && !this.isRunningLocal && !this.eventListenerAdded) {
+            this._boundBeforeUnloadHandler = this._boundBeforeUnloadHandler || ((e) => this.beforeunloadHandler(e));
+            window.addEventListener('beforeunload', this._boundBeforeUnloadHandler, true);
+            this.eventListenerAdded = true;
+        }
+    }
+    removeEventListener(apiKey) {
+        if (apiKey != '' && !this.isNode && !this.isRunningLocal && this.eventListenerAdded) {
+            if (this._boundBeforeUnloadHandler) {
+                window.removeEventListener('beforeunload', this._boundBeforeUnloadHandler, true);
+            }
+            this.eventListenerAdded = false;
+        }
+    }
+    beforeunloadHandler(_event) {
+        if (this.logs.length === 0)
+            return;
+        const logsToSend = this.logs.splice(0);
+        const body = this.serializePayload(logsToSend, true);
+        const url = this.getLogsEndpoint();
+        // sendBeacon is specifically designed to survive page termination. The API
+        // key is also accepted in the request body by the server's ApiKeyGuard.
+        // text/plain keeps a cross-origin beacon CORS-safelisted; the API explicitly
+        // enables JSON parsing for this content type.
+        if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+            const accepted = navigator.sendBeacon(url, new Blob([body], { type: 'text/plain;charset=UTF-8' }));
+            if (accepted)
+                return;
+        }
+        // Keep the logs queued if the browser could not schedule the beacon. A
+        // keepalive fetch is the best available fallback during page termination.
+        this.logs.unshift(...logsToSend);
+        void this.flush();
+    }
+    setRunningSystem(_config) {
+        var _a, _b, _c, _d, _e;
+        this.nodeProcess = typeof globalThis !== 'undefined' ? globalThis.process : undefined;
+        this.isNode = Object.prototype.toString.call(this.nodeProcess || 0) === '[object process]';
+        this.clientInfo = this.isNode
+            ? this.getNodeClientInfo((_a = _config) === null || _a === void 0 ? void 0 : _a.userAgentOrOs)
+            : this.getBrowserClientInfo((_b = _config) === null || _b === void 0 ? void 0 : _b.userAgentOrOs);
+        this.isRunningLocal = this.isNode
+            ? (_e = (_d = (_c = this.nodeProcess) === null || _c === void 0 ? void 0 : _c.env) === null || _d === void 0 ? void 0 : _d.NODE_ENV, (_e !== null && _e !== void 0 ? _e : '')).indexOf("development") > -1
+            : window.location.href.indexOf('localhost') > -1;
+    }
+    getIdent() {
+        // Kept for API compatibility. Stable device identifiers are deliberately
+        // no longer created or stored because they allow cross-session tracking.
+        return '';
+    }
+    getCorrelationId() {
+        return this.isNode ? '' : this.correlationId || '';
+    }
+    debug(message, ...optionalParams) {
+        this.addLog(log_1.LogType.debug, message, ...optionalParams);
+    }
+    info(message, ...optionalParams) {
+        this.addLog(log_1.LogType.info, message, ...optionalParams);
+    }
+    log(message, ...optionalParams) {
+        this.addLog(log_1.LogType.log, message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this.addLog(log_1.LogType.warn, message, ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        this.addLog(log_1.LogType.error, message, ...optionalParams);
+    }
+    critical(message, ...optionalParams) {
+        this.addLog(log_1.LogType.critical, message, ...optionalParams);
+    }
+    addLog(type, message, ...optionalParams) {
+        if (this.checkLogType(type)) {
+            if (this.isRunningLocal && !this.sendLogsInDevelopment) {
+                this.logToConsole(type, message, ...optionalParams);
+            }
+            else {
+                this.sendLogsToServer(type, message, ...optionalParams);
+            }
+        }
+        else {
+            this.logToConsole(type, message, ...optionalParams);
+        }
+    }
+    logToConsole(type, message, ...optionalParams) {
+        if (this.logInConsole) {
+            const safeMessage = typeof message === 'string' ? log_privacy_1.sanitizeLogText(message) : message;
+            const safeParams = optionalParams.map(param => log_privacy_1.sanitizeLogValue(param));
+            switch (type) {
+                case log_1.LogType.debug:
+                    console.debug(safeMessage, ...safeParams);
+                    break;
+                case log_1.LogType.critical:
+                case log_1.LogType.error:
+                    console.error(safeMessage, ...safeParams);
+                    break;
+                case log_1.LogType.info:
+                    console.info(safeMessage, ...safeParams);
+                    break;
+                case log_1.LogType.log:
+                    console.log(safeMessage, ...safeParams);
+                    break;
+                case log_1.LogType.warn:
+                    console.warn(safeMessage, ...safeParams);
+                    break;
+                default:
+                    console.warn("Unkown LogType: ", type);
+                    break;
+            }
+        }
+    }
+    sendLogsToServer(type, message, ...optionalParams) {
+        var _a, _b;
+        const log = { logType: type, message: typeof message === 'string' ? log_privacy_1.sanitizeLogText(message) : message, optionalParams: [], createdAt: new Date() };
+        optionalParams.forEach((op) => {
+            if (Array.isArray(op))
+                op.forEach(o => log.optionalParams.push(log_privacy_1.sanitizeLogValue(o)));
+            else
+                log.optionalParams.push(log_privacy_1.sanitizeLogValue(op));
+        });
+        this.logs.push(log);
+        const sendImmediately = type === log_1.LogType.critical || ((_a = this.sendLogsByTypesImmediately) === null || _a === void 0 ? void 0 : _a.includes(type)) === true;
+        if (this.logs.length >= this.maxLogsCount || sendImmediately)
+            void this.flush();
+        if (((_b = this.logs) === null || _b === void 0 ? void 0 : _b.length) > 0 && !this.eventListenerAdded) {
+            this.addEventListener(this.apiKey);
+        }
+    }
+    checkLogType(type) {
+        if (this.logLevel.find(l => l === type) != null || type === log_1.LogType.critical) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /** Sends all currently queued logs and any logs added while sending. */
+    flush() {
+        if (this.activeSend)
+            return this.activeSend;
+        if (this.logs.length === 0)
+            return Promise.resolve();
+        this.isSending = true;
+        this.removeEventListener(this.apiKey);
+        this.activeSend = this.runSendLoop();
+        return this.activeSend;
+    }
+    runSendLoop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                while (this.logs.length > 0) {
+                    const logsToSend = this.logs.splice(0);
+                    const sent = yield this.sendLogsToServerCore(logsToSend);
+                    if (!sent) {
+                        // Preserve the failed batch for a later explicit flush or log event.
+                        this.logs.unshift(...logsToSend);
+                        return;
+                    }
+                }
+            }
+            finally {
+                this.isSending = false;
+                this.activeSend = undefined;
+                if (this.logs.length > 0)
+                    this.addEventListener(this.apiKey);
+            }
+        });
+    }
+    sendLogsToServerCore(logsToSend) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let sendTry = 1; sendTry <= this.maxSendTries; sendTry++) {
+                const abortController = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+                const timeout = abortController ? setTimeout(() => abortController.abort(), this.requestTimeoutMs) : undefined;
+                try {
+                    const body = this.serializePayload(logsToSend);
+                    const response = yield safeFetch(this.getLogsEndpoint(), {
+                        method: 'POST',
+                        headers: {
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                            'X-Auth-Key': this.apiKey
+                        },
+                        body,
+                        signal: (_a = abortController) === null || _a === void 0 ? void 0 : _a.signal,
+                        // Browsers impose a small quota on keepalive requests.
+                        keepalive: body.length <= 60000
+                    });
+                    if (!response.ok)
+                        throw new Error(`HTTP ${response.status} ${response.statusText}`);
+                    return true;
+                }
+                catch (error) {
+                    console.error(`AppLogger: Could not send logs to server (attempt ${sendTry}/${this.maxSendTries})`);
+                    if (sendTry < this.maxSendTries)
+                        yield new Promise(resolve => setTimeout(resolve, this.retryDelayMs));
+                }
+                finally {
+                    if (timeout !== undefined)
+                        clearTimeout(timeout);
+                }
+            }
+            console.error('AppLogger: Could not send logs to server finally; batch remains queued');
+            return false;
+        });
+    }
+    getLogsEndpoint() {
+        const last = this.endpointUrl.charAt(this.endpointUrl.length - 1);
+        return `${this.endpointUrl}${last === '/' ? 'logs/createLog' : '/logs/createLog'}`;
+    }
+    serializePayload(logsToSend, includeApiKey = false) {
+        const seen = new WeakSet();
+        const payload = {
+            logs: logsToSend,
+            osType: this.isNode ? 'node' : 'web',
+            packageVersion: version_1.APP_TRACKER_VERSION,
+            clientInfo: this.clientInfo
+        };
+        if (!this.isNode && this.correlationId)
+            payload.correlationId = this.correlationId;
+        if (includeApiKey)
+            payload.apiKey = this.apiKey;
+        return JSON.stringify(payload, (_key, value) => {
+            if (value instanceof Error) {
+                if (seen.has(value))
+                    return '[Circular]';
+                seen.add(value);
+                const serializedError = {};
+                Object.getOwnPropertyNames(value).forEach(key => serializedError[key] = value[key]);
+                return serializedError;
+            }
+            if (typeof value === 'bigint')
+                return value.toString();
+            if (value && typeof value === 'object') {
+                if (seen.has(value))
+                    return '[Circular]';
+                seen.add(value);
+            }
+            return value;
+        });
+    }
+    getBrowserClientInfo(userAgentOrOs) {
+        const userAgent = typeof userAgentOrOs === 'string' ? userAgentOrOs : '';
+        const browserPatterns = [
+            { name: 'Edge', expression: /Edg\/([0-9]+)/ },
+            { name: 'Firefox', expression: /Firefox\/([0-9]+)/ },
+            { name: 'Chrome', expression: /(?:Chrome|CriOS)\/([0-9]+)/ },
+            { name: 'Safari', expression: /Version\/([0-9]+).*Safari/ },
+        ];
+        const browser = browserPatterns
+            .map(item => ({ item, match: userAgent.match(item.expression) }))
+            .find(item => item.match !== null);
+        const android = userAgent.match(/Android\s+([0-9]+)/i);
+        const ios = userAgent.match(/(?:iPhone|iPad).*OS\s+([0-9]+)/i);
+        const windows = userAgent.match(/Windows NT\s+([0-9]+)/i);
+        const macOs = userAgent.match(/Mac OS X\s+([0-9]+)/i);
+        const os = android ? { name: 'Android', version: android[1], platform: '' }
+            : ios ? { name: 'iOS', version: ios[1], platform: '' }
+                : windows ? { name: 'Windows', version: windows[1], platform: '' }
+                    : macOs ? { name: 'macOS', version: macOs[1], platform: '' }
+                        : /Linux/i.test(userAgent) ? { name: 'Linux', version: '', platform: '' } : null;
+        return {
+            client: browser ? { type: 'browser', name: browser.item.name, version: browser.match[1] } : null,
+            os,
+            device: { type: /iPad|Tablet/i.test(userAgent) ? 'tablet' : /Mobile|Android|iPhone/i.test(userAgent) ? 'smartphone' : 'desktop' },
+        };
+    }
+    getNodeClientInfo(os) {
+        var _a, _b;
+        const call = (name) => os && typeof os[name] === 'function' ? String(os[name]()) : '';
+        return {
+            client: { type: 'library', name: 'Node.js', version: this.majorVersion((_a = this.nodeProcess) === null || _a === void 0 ? void 0 : _a.version) },
+            os: { name: call('platform') || ((_b = this.nodeProcess) === null || _b === void 0 ? void 0 : _b.platform) || '', version: this.majorVersion(call('release')), platform: call('arch') },
+            device: null,
+        };
+    }
+    majorVersion(value) {
+        const match = typeof value === 'string' ? value.match(/\d+/) : null;
+        return match ? match[0] : '';
+    }
+    createCorrelationId() {
+        var _a, _b;
+        const browserCrypto = typeof globalThis !== 'undefined' ? globalThis.crypto : undefined;
+        if (typeof ((_a = browserCrypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === 'function')
+            return browserCrypto.randomUUID();
+        const bytes = new Uint8Array(16);
+        if (typeof ((_b = browserCrypto) === null || _b === void 0 ? void 0 : _b.getRandomValues) === 'function') {
+            browserCrypto.getRandomValues(bytes);
+        }
+        else {
+            for (let index = 0; index < bytes.length; index++)
+                bytes[index] = Math.floor(Math.random() * 256);
+        }
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes).map(value => (`0${value.toString(16)}`).slice(-2)).join('');
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+}
+exports.AppTrackerService = AppTrackerService;

package/index.d.ts

@@ -1,3 +1,4 @@
-export * from './main';
-export * from './app-tracker.service';
-export * from './log';
+export * from './main';
+export * from './app-tracker.service';
+export * from './log';
+export * from './version';