app-tracker 3.0.0 → 3.1.1

package/README.md

@@ -56,6 +56,7 @@ tracker.error("An error occurred", errorObj);
 - **Batching:** Logs are collected and sent after `maxLogsCount` or immediately for critical errors
 - **Explicit flush:** Call and await `tracker.flush()` before a controlled Node.js shutdown
 - **Environment Awareness:** Automatically adapts for browser/Node.js
+- **Browser correlation:** Generates one in-memory correlation ID per page lifetime and includes it in every browser log batch. Node.js payloads do not include it. Use `tracker.getCorrelationId()` to display the current ID when needed.
 - **Secure Sending:** API key required, retry mechanism on errors
 - **External Dependency:** Uses `cross-fetch` for HTTP requests
 

package/app-tracker.service.d.ts

@@ -11,14 +11,13 @@ export declare class AppTrackerService {
     private isSending;
     private activeSend?;
     private maxLogsCount;
-    private userAgent;
+    private clientInfo;
+    private correlationId?;
     private logLevel;
     private sendLogsByTypesImmediately;
     private isNode;
     private nodeProcess;
-    private os;
     private isRunningLocal;
-    private ident;
     private eventListenerAdded;
     private _boundBeforeUnloadHandler?;
     init(apiKey: string, config?: AppTrackerConfig): void;
@@ -27,6 +26,7 @@ export declare class AppTrackerService {
     private beforeunloadHandler;
     private setRunningSystem;
     getIdent(): string;
+    getCorrelationId(): string;
     debug(message?: string, ...optionalParams: any[]): void;
     info(message?: string, ...optionalParams: any[]): void;
     log(message?: string, ...optionalParams: any[]): void;
@@ -43,6 +43,8 @@ export declare class AppTrackerService {
     private sendLogsToServerCore;
     private getLogsEndpoint;
     private serializePayload;
-    private setUserAgentFromOs;
-    private createUUID;
+    private getBrowserClientInfo;
+    private getNodeClientInfo;
+    private majorVersion;
+    private createId;
 }

package/app-tracker.service.js

@@ -12,6 +12,7 @@ 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() {
@@ -25,12 +26,11 @@ class AppTrackerService {
         this.requestTimeoutMs = 10000;
         this.isSending = false;
         this.maxLogsCount = 10;
-        this.userAgent = '';
+        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.ident = '';
         this.eventListenerAdded = false;
     }
     init(apiKey, config) {
@@ -56,6 +56,9 @@ class AppTrackerService {
                 this.sendLogsByTypesImmediately = config.sendLogsByTypesImmediately;
         }
         this.setRunningSystem(config);
+        if (!this.isNode && !this.correlationId) {
+            this.correlationId = this.createId();
+        }
     }
     addEventListener(apiKey) {
         if (apiKey != '' && !this.isNode && !this.isRunningLocal && !this.eventListenerAdded) {
@@ -76,7 +79,7 @@ class AppTrackerService {
         if (this.logs.length === 0)
             return;
         const logsToSend = this.logs.splice(0);
-        const body = this.serializePayload(logsToSend, true);
+        const body = this.serializePayload(logsToSend, true, this.createId());
         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.
@@ -92,35 +95,24 @@ class AppTrackerService {
         this.logs.unshift(...logsToSend);
         void this.flush();
     }
-    setRunningSystem(config) {
+    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]';
-        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.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() {
-        try {
-            let ident = localStorage.getItem('App-Tracker.device-ident');
-            if (!ident) {
-                ident = this.createUUID();
-                localStorage.setItem('App-Tracker.device-ident', ident);
-            }
-            return ident;
-        }
-        catch (_) {
-            // Storage can be unavailable in sandboxed iframes or privacy modes.
-            return this.createUUID();
-        }
+        // 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);
@@ -155,22 +147,24 @@ class AppTrackerService {
     }
     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(message, ...optionalParams);
+                    console.debug(safeMessage, ...safeParams);
                     break;
                 case log_1.LogType.critical:
                 case log_1.LogType.error:
-                    console.error(message, ...optionalParams);
+                    console.error(safeMessage, ...safeParams);
                     break;
                 case log_1.LogType.info:
-                    console.info(message, ...optionalParams);
+                    console.info(safeMessage, ...safeParams);
                     break;
                 case log_1.LogType.log:
-                    console.log(message, ...optionalParams);
+                    console.log(safeMessage, ...safeParams);
                     break;
                 case log_1.LogType.warn:
-                    console.warn(message, ...optionalParams);
+                    console.warn(safeMessage, ...safeParams);
                     break;
                 default:
                     console.warn("Unkown LogType: ", type);
@@ -180,12 +174,18 @@ class AppTrackerService {
     }
     sendLogsToServer(type, message, ...optionalParams) {
         var _a, _b;
-        const log = { logType: type, message: message, optionalParams: [], createdAt: new Date(), ident: this.ident };
+        const log = {
+            eventId: this.createId(),
+            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(o));
+                op.forEach(o => log.optionalParams.push(log_privacy_1.sanitizeLogValue(o)));
             else
-                log.optionalParams.push(op);
+                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;
@@ -238,11 +238,12 @@ class AppTrackerService {
     sendLogsToServerCore(logsToSend) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const batchId = this.createId();
             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 body = this.serializePayload(logsToSend, false, batchId);
                     const response = yield safeFetch(this.getLogsEndpoint(), {
                         method: 'POST',
                         headers: {
@@ -260,7 +261,7 @@ class AppTrackerService {
                     return true;
                 }
                 catch (error) {
-                    console.error(`AppLogger: Could not send logs to server (attempt ${sendTry}/${this.maxSendTries})`, 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));
                 }
@@ -277,15 +278,17 @@ class AppTrackerService {
         const last = this.endpointUrl.charAt(this.endpointUrl.length - 1);
         return `${this.endpointUrl}${last === '/' ? 'logs/createLog' : '/logs/createLog'}`;
     }
-    serializePayload(logsToSend, includeApiKey = false) {
+    serializePayload(logsToSend, includeApiKey = false, batchId = this.createId()) {
         const seen = new WeakSet();
         const payload = {
-            ident: this.ident,
             logs: logsToSend,
+            batchId: batchId,
             osType: this.isNode ? 'node' : 'web',
             packageVersion: version_1.APP_TRACKER_VERSION,
-            userAgent: this.userAgent
+            clientInfo: this.clientInfo
         };
+        if (!this.isNode && this.correlationId)
+            payload.correlationId = this.correlationId;
         if (includeApiKey)
             payload.apiKey = this.apiKey;
         return JSON.stringify(payload, (_key, value) => {
@@ -307,26 +310,62 @@ class AppTrackerService {
             return value;
         });
     }
-    setUserAgentFromOs() {
+    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;
-        if (!this.os) {
-            return JSON.stringify({ platform: (_a = this.nodeProcess) === null || _a === void 0 ? void 0 : _a.platform, version: (_b = this.nodeProcess) === null || _b === void 0 ? void 0 : _b.version });
-        }
-        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()
+        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,
         };
-        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);
-        });
+    majorVersion(value) {
+        const match = typeof value === 'string' ? value.match(/\d+/) : null;
+        return match ? match[0] : '';
+    }
+    createId() {
+        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/log-privacy.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeLogText(value: string): string;
+export declare function sanitizeLogValue(value: any, depth?: number, seen?: WeakSet<object>): any;

package/log-privacy.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEYS = new Set(['authorization', 'cookie', 'password', 'passwd', 'secret', 'token', 'apikey', 'email', 'emailaddress', 'phone', 'mobile', 'firstname', 'lastname', 'fullname', 'address', 'street', 'postcode', 'postalcode', 'ip', 'ipaddress', 'hostname', 'ident', 'userid', 'customerid', 'paymentid', 'sessionid', 'refreshtoken', 'accesstoken', 'recipient', 'recipients', 'username', 'displayname', 'birthdate', 'dateofbirth', 'dob', 'iban', 'bic', 'accountnumber', 'creditcard', 'cardnumber', 'coordinates', 'latitude', 'longitude']);
+const SECRET_KEY_PARTS = ['authorization', 'cookie', 'password', 'passwd', 'secret', 'token', 'apikey', 'credential', 'privatekey'];
+function isSensitiveKey(key) {
+    const normalizedKey = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    return SENSITIVE_KEYS.has(normalizedKey) || SECRET_KEY_PARTS.some(part => normalizedKey.indexOf(part) >= 0);
+}
+function sanitizeLogUrl(value) {
+    let sanitizedUrl = '[REDACTED URL]';
+    try {
+        const url = new URL(value);
+        const identityRoutes = new Set(['users', 'customers', 'accounts', 'sessions', 'payments']);
+        const segments = url.pathname.split('/').map((segment, index, allSegments) => {
+            const followsIdentityRoute = index > 0 && identityRoutes.has(allSegments[index - 1].toLowerCase());
+            const isIdentifier = /^[0-9a-f]{24}$/i.test(segment) || /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(segment) || /^(?:cus|pi|pm|seti|sub|cs|price|in|ch)_[A-Za-z0-9_]+$/.test(segment) || /^\d{6,}$/.test(segment);
+            return followsIdentityRoute || isIdentifier ? ':id' : segment;
+        });
+        sanitizedUrl = `${url.protocol}//${url.host}${segments.join('/')}`;
+    }
+    catch (_error) {
+        // Keep the privacy-safe fallback.
+    }
+    return sanitizedUrl;
+}
+function sanitizeLogText(value) {
+    return value
+        .replace(/https?:\/\/[^\s"'<>]+/gi, (url) => sanitizeLogUrl(url))
+        .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, REDACTED)
+        .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, REDACTED)
+        .replace(/\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b/g, REDACTED)
+        .replace(/\+\d[\d\s().-]{7,}\d/g, REDACTED)
+        .replace(/[A-Z]:\\Users\\[^\\\s]+/gi, REDACTED)
+        .replace(/\/home\/[^/\s]+/g, REDACTED)
+        .replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+=*/gi, REDACTED)
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, REDACTED);
+}
+exports.sanitizeLogText = sanitizeLogText;
+function sanitizeLogValue(value, depth = 0, seen = new WeakSet()) {
+    if (typeof value === 'string')
+        return sanitizeLogText(value);
+    if (value === null || typeof value === 'undefined' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint')
+        return value;
+    if (depth >= 6)
+        return '[TRUNCATED]';
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Error)
+        return Object.assign({ name: sanitizeLogText(value.name), message: sanitizeLogText(value.message) }, (typeof value.stack === 'string' ? { stack: sanitizeLogText(value.stack) } : {}));
+    if (typeof value === 'object') {
+        if (seen.has(value))
+            return '[Circular]';
+        seen.add(value);
+        if (Array.isArray(value))
+            return value.map(item => sanitizeLogValue(item, depth + 1, seen));
+        const result = {};
+        Object.keys(value).forEach(key => result[key] = isSensitiveKey(key) ? REDACTED : sanitizeLogValue(value[key], depth + 1, seen));
+        return result;
+    }
+    return `[${typeof value}]`;
+}
+exports.sanitizeLogValue = sanitizeLogValue;

package/log.d.ts

@@ -12,19 +12,15 @@ export declare class AppTrackerConfig {
     /** Defines which log types should be sent to the server */
     logLevel?: LogType[];
     sendLogsByTypesImmediately?: LogType[];
-    /**
-     * Please pass:
-     * Web -> navigator.userAgent,
-     * Node -> os (from require('os'))
-     */
-    userAgentOrOs: any;
+    /** Used only to derive coarse browser/OS categories; raw values are not transmitted. */
+    userAgentOrOs?: any;
 }
 export declare class Log {
+    eventId: string;
     logType: LogType;
     message: any;
     optionalParams: any[];
     createdAt: Date;
-    ident: string;
 }
 export declare enum LogType {
     debug = 0,

package/log.js

@@ -13,10 +13,10 @@ class AppTrackerConfig {
 exports.AppTrackerConfig = AppTrackerConfig;
 class Log {
     constructor() {
+        this.eventId = '';
         this.logType = LogType.log;
         this.optionalParams = [];
         this.createdAt = new Date();
-        this.ident = '';
     }
 }
 exports.Log = Log;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "app-tracker",
-    "version": "3.0.0",
+    "version": "3.1.1",
     "description": "App Tracker for Web-Applications",
     "main": "index.js",
     "repository": {

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /** Replaced with the package.json version by the build script. */
-exports.APP_TRACKER_VERSION = '3.0.0';
+exports.APP_TRACKER_VERSION = '3.1.1';