analogger 1.36.1 → 2.0.0

package/src/ana-logger.cjs

@@ -144,6 +144,7 @@ const symbolNames = {
     lock                      : "🔒",
     male_sign                 : "♂",
     minus_sign                : "➖",
+    money_bag                : "💰",
     no_entry                  : "⛔",
     old_key                   : "🗝️",
     partly_sunny              : "⛅",
@@ -397,6 +398,153 @@ function createTarGzArchiveSync(inputFile, archivePath, compressionLevel = 1) {
     }
 }
 
+function getInvocationLine()
+{
+    try
+    {
+        const error = new Error();
+        const stack = error.stack;
+        let anaLoggerPossibleFileName = "ana-logger";
+        let isMinified = false;
+        let result = null;
+        let strippedOutStackTrace;
+        let errorText = [];
+
+        if (stack) {
+            const lines = stack.split('\n');
+            let fileName = null;
+            if (lines.length >= 3) {
+                let index = 0;
+                // Look for the reference of this line
+                for (let i = 0, l = lines.length; i < l; i++) {
+                    const line = lines[i];
+
+                    // We can't use the name if it's minified
+                    const parts = line.split(':');
+                    if (parts.length < 3) {
+                        errorText.push(line);
+                        continue;
+                    }
+
+                    index = i;
+
+                    fileName = parts[parts.length - 3];
+
+                    if (line.indexOf(anaLoggerPossibleFileName)=== -1) {
+                        // We're sure we can use this stacktrace
+                        break;
+                    }
+
+                    if (line.indexOf("getInvocationLine")=== -1) {
+                        // The file is minified
+                        // We're only partially sure we can use this stacktrace
+                        isMinified = true;
+                        // We try to extract the file name
+                        anaLoggerPossibleFileName = fileName.split(/[\\/]/).pop();
+                        break;
+                    }
+
+                    // We have no idea if the stacktrace will help us, but we leave the search
+                    break;
+                }
+
+                // Look for when the call was done exactly
+                for (let i = index + 1, l = lines.length; i < l; i++) {
+                    const lineStr = lines[i];
+                    if (lineStr.indexOf(fileName) > -1) {
+                        continue;
+                    }
+
+                    const parts = lineStr.split(':');
+                    if (parts.length < 3) {
+                        continue;
+                    }
+
+                    strippedOutStackTrace = errorText.join("\n") + lines.slice(i).join('\n');
+
+                    const col = parseInt(parts.pop());
+                    const line = parseInt(parts.pop());
+                    const file = parts.pop();
+                    let infoStr = parts.pop();
+                    let infoArr = infoStr.split(" ");
+
+                    let method = null;
+                    for (let j = 0; j < infoArr.length; j++) {
+                        const element = infoArr[j];
+                        if (!element) {
+                            continue;
+                        }
+
+                        if (element.indexOf("at")===0) {
+                            continue;
+                        }
+
+                        method = element;
+                        break;
+                    }
+
+                    result = {
+                        file,
+                        line,
+                        col,
+                        method,
+                        isMinified,
+                        stack: strippedOutStackTrace
+                    }
+
+                    break;
+                }
+
+                return result;
+            }
+        }
+    }
+    catch(err)
+    {
+
+    }
+
+    return null;
+}
+
+function generateLid(maxChars = 8)
+{
+    try
+    {
+        const line = getInvocationLine();
+        if (!line) {
+            return `LID${Date.now()}`;
+        }
+        const fun = line.method.split(".");
+        const id = fun[0].toUpperCase().substring(0, 3);
+        if (id.length >= maxChars) {
+            return id.substring(0, maxChars);
+        }
+
+        let combined1 = `${id}:${line.line}`;
+        if (combined1.length >= maxChars) {
+            combined1 = combined1.replaceAll(":", "");
+            return combined1.substring(0, maxChars);
+        }
+
+        let combined2 = `${id}:${line.line}:${line.col}`;
+        if (combined2.length > maxChars) {
+            const combined3 = combined2.substring(0, maxChars);
+            if (combined3.endsWith(":")) {
+                return `${id}${line.line}:${line.col}`.substring(0, maxChars);
+            }
+
+            return combined2.substring(0, maxChars);
+        }
+
+        return `${id}${line.line}:${line.col}`.substring(0, maxChars);
+    }
+    catch (e) {
+        return `ERR_LID${Date.now()}`;
+    }
+}
+
+
 /**
  * https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
  * @returns {string}
@@ -514,6 +662,12 @@ class ____AnaLogger
 
     originalFormatFunction;
 
+    static lidTable = {};
+    static lidTableOn = false;
+
+    forceLidOn = false;
+    resolveLineCall = false;
+    resolveErrorLineCall = false;
 
     constructor({name = "default"} = {})
     {
@@ -567,6 +721,79 @@ class ____AnaLogger
         return this.instanceId;
     }
 
+    /**
+     * For the logger to generate a lid when none is specified
+     * @param lidOn
+     */
+    forceLid(lidOn = true)
+    {
+        this.forceLidOn = !!lidOn;
+    }
+
+    forceResolveLineCall(resolveLineCall = true)
+    {
+        this.resolveLineCall = !!resolveLineCall;
+    }
+
+    forceResolveErrorLineCall(resolveErrorLineCall = true)
+    {
+        this.resolveErrorLineCall = !!resolveErrorLineCall;
+    }
+
+    importLids(lids)
+    {
+        for (let lid in lids)
+        {
+            const lidObj = lids[lid] || {};
+            lidObj.lid = lid;
+            lidObj.callCount = 0;
+            lidObj.callTimes = [];
+            ____AnaLogger.lidTable[lid] = lidObj;
+        }
+        ____AnaLogger.lidTableOn = true;
+    }
+
+    loadLids(lids)
+    {
+        lids = lids || {};
+        this.importLids(lids);
+    }
+
+    convertTimestampToDate(timestamp)
+    {
+        const date = new Date(timestamp); // Create a Date object from the timestamp
+
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-indexed
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    }
+
+    getLids()
+    {
+        const clone = {...__AnaLogger.lidTable };
+        for (let lid in clone)
+        {
+            const lidObj = clone[lid] || {};
+            if (lidObj.callTimes.length)
+            {
+                lidObj.dates = [];
+                for (let j = 0; j < lidObj.callTimes.length; ++j)
+                {
+                    const callTime = lidObj.callTimes[j];
+                    const readableTime = this.convertTimestampToDate(callTime);
+                    lidObj.dates.push(readableTime);
+                }
+            }
+        }
+        return clone;
+    }
+
     keepLogHistory()
     {
         this.keepLog = true;
@@ -2006,18 +2233,74 @@ class ____AnaLogger
         }
     }
 
+    isContextMessagePattern(str) {
+        return /\{\{[^}]+}}/.test(str);
+    }
+
+    transformContextMessage(template, data)
+    {
+        let result = template;
+        for (const key in data)
+        {
+            const placeholder = `{{${key}}}`;
+            const value = data[key];
+            // Replace all occurrences of the placeholder with the value
+            result = result.replaceAll(placeholder, value);
+        }
+        return result;
+    }
+
     /**
      * Display log following template
      * @param context
+     * @param argsWithoutContext
      */
-    processOutput(context = {})
+    processOutput(context = {}, ...argsWithoutContext)
     {
         try
         {
             let message = "";
+
+            if (____AnaLogger.lidTableOn && context.lid) {
+                const lidObj = ____AnaLogger.lidTable[context.lid];
+
+                // If the lid is already in the table, we set the message if not existing
+                if (lidObj)
+                {
+                    context.message = context.message || lidObj.message;
+                    lidObj.callCount = lidObj.callCount || 0;
+                    ++lidObj.callCount;
+                    lidObj.callTimes.push(Date.now());
+                }
+                // If the lid is not already in the table, we register it
+                else {
+                    ____AnaLogger.lidTable[context.lid] = {
+                        ...context,
+                        message: argsWithoutContext[0],
+                        lid: context.lid,
+                        callCount: 1,
+                        callTimes: [Date.now()]
+                    }
+                }
+            }
+
+            if (context.message) {
+                // If the context message is a template
+                if (this.isContextMessagePattern(context.message)) {
+                    // The context message second parameter should be an object that we will use to perform the replacement
+                    if (argsWithoutContext.length >= 1 && typeof argsWithoutContext[0] === "object") {
+                        context.message = this.transformContextMessage(context.message, argsWithoutContext[0]);
+                        // We remove the second parameter from the arguments
+                        argsWithoutContext.shift();
+                    }
+                }
+
+                // We add the context message as an arguments
+                argsWithoutContext.unshift(context.message);
+            }
             this.applySymbolByName(context);
 
-            this.checkOnLogging(context, context, arguments, "onContext");
+            this.checkOnLogging(context, context, argsWithoutContext, "onContext");
             if (!this.isTargetAllowed(context.target))
             {
                 return;
@@ -2033,12 +2316,12 @@ class ____AnaLogger
                 return;
             }
 
-            // Clone arguments without the context (= the first argument passed) to generate the message
-            const newMessages = this.checkOnLogging(context, arguments && arguments.length > 1? arguments[1] : arguments, arguments,"onMessage");
+            const newMessages = this.checkOnLogging(context, argsWithoutContext[0], arguments,"onMessage");
             if (newMessages !== undefined) {
                 arguments[1] = newMessages;
             }
-            let args = Array.prototype.slice.call(arguments, 1 /* => Ignore arguments[0] = context */);
+
+            let args = argsWithoutContext;
 
             message = this.convertArgumentsToText(args);
 
@@ -2145,6 +2428,12 @@ class ____AnaLogger
             options.hasOwnProperty("lid");
     }
 
+    /**
+     * Convert a string to an object by parsing the string
+     * and identifying key-value pairs
+     * @param str
+     * @returns {{}|null}
+     */
     stringToObject(str) {
         try {
             str = str.trim();
@@ -2209,39 +2498,39 @@ class ____AnaLogger
     /**
      * Convert a string into a Context object if possible
      * TODO: To implement in next version
-     * @param str
      * @returns {string}
+     * @param input
      */
-    extractContextFromInput(str)
+    extractContextFromInput(input)
     {
-        if (typeof str === "string" || str instanceof String)
+        if (typeof input === "string" || input instanceof String)
         {
-            if (str.toLowerCase().indexOf("lid:") !== 0)
+            if (input.toLowerCase().indexOf("lid:") !== 0)
             {
-                return str;
+                return input;
             }
 
-            const obj = this.stringToObject(str);
+            const obj = this.stringToObject(input);
             if (obj) {
-                str = obj;
+                input = obj;
             }
         }
 
-        if (typeof str==="object" && !Array.isArray(str) && str!==null) {
-            if (this.isExtendedOptionsPassed(str)) {
-                if (str.contextName) {
-                    const obj = this.#contexts[str.contextName];
+        if (typeof input==="object" && !Array.isArray(input) && input!==null) {
+            if (this.isExtendedOptionsPassed(input)) {
+                if (input.contextName) {
+                    const obj = this.#contexts[input.contextName];
                     if (obj) {
-                        str = Object.assign({}, obj, str);
+                        input = Object.assign({}, obj, input);
                     }
                 }
-                if (!str.target) {
-                    str.target = this.getActiveTarget();
+                if (!input.target) {
+                    input.target = this.getActiveTarget();
                 }
             }
         }
 
-        return str;
+        return input;
     }
 
     listSymbols()
@@ -2303,13 +2592,25 @@ class ____AnaLogger
     log(options, ...args)
     {
         options = this.extractContextFromInput(options);
+
         // If the first parameter is not of context format,
         // We use the default context
         if (!this.isExtendedOptionsPassed(options))
         {
-            const defaultContext = this.generateDefaultContext();
-            this.processOutput.apply(this, [defaultContext, options, ...args]);
-            return;
+            if (!this.forceLidOn)
+            {
+                const defaultContext = this.generateDefaultContext();
+                this.processOutput.apply(this, [defaultContext, options, ...args]);
+                return;
+            }
+
+            if (!args || !args.length)
+            {
+                args = [options];
+            }
+
+            const newLid = generateLid(this.options.lidLenMax);
+            options = {lid: newLid};
         }
 
         const someContext = this.generateDefaultContext();
@@ -2321,6 +2622,14 @@ class ____AnaLogger
             return;
         }
 
+        if (this.resolveLineCall)
+        {
+            // If this.resolveErrorLineCall, the stack has already been set
+            if (!this.resolveErrorLineCall)
+            {
+                context.stack = getInvocationLine();
+            }
+        }
         this.processOutput.apply(this, [context, ...args]);
     }
 
@@ -2337,16 +2646,25 @@ class ____AnaLogger
         // We use the error context and display
         if (!this.isExtendedOptionsPassed(options))
         {
-            const defaultContext = this.generateErrorContext();
-            this.processOutput.apply(this, [defaultContext, options, ...args]);
-            return;
+            if (!this.forceLidOn)
+            {
+                const defaultContext = this.generateErrorContext();
+                this.processOutput.apply(this, [defaultContext, options, ...args]);
+                return;
+            }
+
+            const newLid = generateLid(this.options.lidLenMax);
+            options = {lid: newLid};
         }
 
         const errorContext = this.generateErrorContext();
         let context = this.convertToContext(options, errorContext);
 
-        let args0 = Array.prototype.slice.call(arguments, 1);
-        this.log(context, ...args0);
+        if (this.resolveErrorLineCall)
+        {
+            context.stack = getInvocationLine();
+        }
+        this.log(context, ...args);
     }
 
     overrideError()