analogger 1.35.0 → 1.36.0

package/README.md

@@ -690,8 +690,9 @@ anaLogger.setDefaultContext({
 
 #### Targets
 
-Targets allow defining some log categories. For example, they can be developers, roles, etc.
-setActiveTarget() allows hiding logs from other devs or roles.
+Targets allow filtering logs by targets. 
+For example, they can be developers, testers, roles, etc.
+and setActiveTarget() will ignore logs for non-targeted users.
 
 ##### Examples
 
@@ -712,21 +713,31 @@ anaLogger.setTargets("GROUP1", "GROUP2", "TOM", "TIM"/*, "ALL", "USER"*/);
 // Assign an active target
 anaLogger.setActiveTarget("TOM");                          // <- You are "TOM"
 
-// Seen as TOM
+// Seen because you're TOM
 anaLogger.log({target: "TOM"}, `Testing log 1`);           // You will see this
 
 // Not seen (only for TIM)
-anaLogger.log({target: "TOM"}, `Testing log 2`);           // You will not see this
+anaLogger.log({target: "MATT"}, `Testing log 2`);           // You will not see this
 
+// Here we set the allowed targets
+anaLogger.setTargets({TOM: "TOM", GROUP1: "GROUP1", GROUP2: "GROUP2"});
+anaLogger.setActiveTargets(["TOM", "GROUP1"]);
+anaLogger.log({target: "TOM"}, `You will see this`);
+anaLogger.log({target: "TIM"}, `You will not see this`);
+anaLogger.log({target: "GROUP1"}, `You will see this`);
 
-anaLogger.setActiveTarget(["TOM", "GROUP1"]);
-anaLogger.log({target: "TOM"}, `Testing log 3`);           // You will see this
-anaLogger.log({target: "TIM"}, `Testing log 4`);           // You will not see this
-anaLogger.log({target: "GROUP1"}, `Testing log 5`);        // You will see this
+// To work, we should have called `anaLogger.setTargets(["NonDefinedTarget"])`
+anaLogger.setActiveTarget("NonDefinedTarget");
+anaLogger.log({lid: "WEB35388"}, `You will not see this`);
+anaLogger.log({lid: "WEB35388", target: "NonDefinedTarget"}, `You will not see this`);
 
-// No target defined. Everybody sees this
+// Clear the active target, so we can see everything
+anaLogger.setActiveTarget(null);
+anaLogger.log({lid: "WEB35388"}, `You will see this`);
+
+// No target defined the active target will see this
 anaLogger.log({context: null}, `Testing log 6`);           // You will see this    
-anaLogger.log(`Testing log 4`);                            // You will see this. No context = "ALL"
+anaLogger.log(`Testing log 4`);                            // You will see this
 
 
 ```
@@ -740,6 +751,7 @@ Examples:
 
 ```javascript
 anaLogger.setTargets({DEV1: "192.168.12.45", DEV: "192.168.12.46"});
+// or anaLogger.setTargets("192.168.12.45", "192.168.12.46")
 anaLogger.setActiveTarget(require('ip').address());   
 ```
 <br/>
@@ -749,6 +761,7 @@ anaLogger.setActiveTarget(require('ip').address());
 ```javascript
 // Example 2: File  
 anaLogger.setTargets({DEV1: "fg890234ru20u93r2303092pkid0293"});
+// or anaLogger.setTargets("fg890234ru20u93r2303092pkid0293")
 anaLogger.setActiveTarget(require('./something.json').key);
 ```
 

package/ana-logger.d.cts

@@ -43,7 +43,7 @@ declare class ____AnaLogger {
     instanceName: string;
     logIndex: number;
     logCounter: number;
-    activeTargets: any[];
+    activeTargets: string[][];
     indexColor: number;
     format: string;
     keepLog: boolean;
@@ -181,13 +181,18 @@ declare class ____AnaLogger {
     getContexts(): readonly any[];
     setTargets(targetTable?: {}): void;
     addTargets(targets: any): void;
-    getTargets(): Readonly<{}>;
+    getTargets(): Readonly<{
+        ALL: string;
+        USER: string;
+        NONE: string;
+    }>;
     /**
      * Set one or more active targets
      * @param targets
      */
     setActiveTargets(targets?: any): void;
-    getActiveTarget(): any[];
+    getActiveTargets(): string[][];
+    getActiveTarget(): string | string[];
     /**
      * Set only one active target
      * NOTE: Kept for backward compatibility.

package/browser/ana-logger.mjs

@@ -37,7 +37,8 @@ const DEFAULT = {
 
 export const DEFAULT_LOG_TARGETS  = {
     ALL : "ALL",
-    USER: "USER"
+    USER: "USER",
+    NONE: "NONE"
 };
 
 export const DEFAULT_LOG_LEVELS  = {
@@ -473,10 +474,10 @@ class ____AnaLogger
     logCounter = 0;
 
     #contexts = [];
-    #targets = {};
+    #targets = {...DEFAULT_LOG_TARGETS};
     #levels = {};
 
-    activeTargets = [];
+    activeTargets = [Object.values(DEFAULT_LOG_TARGETS)];
 
     indexColor = 0;
 
@@ -1301,6 +1302,16 @@ class ____AnaLogger
      */
     setActiveTargets(targets = null)
     {
+        if (targets === undefined || targets === null) {
+            this.activeTargets = [DEFAULT_LOG_TARGETS.ALL];
+            return;
+        }
+
+        // If targets is a function, call it to get the actual targets
+        if (typeof targets === "function") {
+            targets = targets.call(this);
+        }
+
         if (targets === null)
         {
             this.activeTargets = [DEFAULT_LOG_TARGETS.ALL];
@@ -1310,24 +1321,43 @@ class ____AnaLogger
         {
             targets = targets.split(",");
         }
-        else if (typeof targets === "object" || typeof targets === "function")
+        else if (typeof targets === "function")
         {
-            return;
+            // If targets is a closure, call it to get the actual targets
+            targets = targets.call(this);
+        }
+        else if (typeof targets === "object")
+        {
+            targets = Object.values(targets);
+        }
+        else if (!Array.isArray(targets))
+        {
+            return ;
         }
 
+        const filteredTargets = [];
         for (let i = 0; i < targets.length; ++i)
         {
-            targets[i] = targets[i].trim();
+            const target = targets[i].trim();
+            if (Object.values(this.#targets).includes(target)) {
+                filteredTargets.push(target);
+            }
         }
 
-        this.activeTargets = targets;
+        this.activeTargets = filteredTargets;
     }
 
-    getActiveTarget()
+    getActiveTargets()
     {
         return this.activeTargets;
     }
 
+    getActiveTarget()
+    {
+        const activeTargets = this.getActiveTargets() || [];
+        return activeTargets[0] || DEFAULT_LOG_TARGETS.NONE;
+    }
+
     /**
      * Set only one active target
      * NOTE: Kept for backward compatibility.
@@ -1339,7 +1369,8 @@ class ____AnaLogger
         this.activeTargets = [];
         this.setActiveTargets(target);
         // In case of strings
-        this.activeTargets = [this.activeTargets[0]];
+        const activeTarget = this.activeTargets[0] || DEFAULT_LOG_TARGETS.NONE;
+        this.activeTargets = [activeTarget];
     }
 
     setLogLevel(name, level)
@@ -1364,10 +1395,9 @@ class ____AnaLogger
 
     isTargetAllowed(target)
     {
-        // If target or activeTargets undefined, allow everything
-        if (!target || !this.activeTargets || !this.activeTargets.length)
+        if (target === DEFAULT_LOG_TARGETS.NONE)
         {
-            return true;
+            return false;
         }
 
         if (target === DEFAULT_LOG_TARGETS.ALL)
@@ -1375,12 +1405,12 @@ class ____AnaLogger
             return true;
         }
 
-        if (this.activeTargets.includes(DEFAULT_LOG_TARGETS.ALL))
+        if (this.getActiveTarget() === DEFAULT_LOG_TARGETS.ALL)
         {
             return true;
         }
 
-        return this.activeTargets.includes(target);
+         return this.activeTargets.includes(target);
     }
 
 
@@ -2196,11 +2226,16 @@ class ____AnaLogger
             }
         }
 
-        if (typeof str === 'object' && !Array.isArray(str) && str !== null) {
-            if (str.contextName) {
-                const obj =  this.#contexts[str.contextName];
-                if (obj) {
-                    str = Object.assign({}, obj, str);
+        if (typeof str==="object" && !Array.isArray(str) && str!==null) {
+            if (this.isExtendedOptionsPassed(str)) {
+                if (str.contextName) {
+                    const obj = this.#contexts[str.contextName];
+                    if (obj) {
+                        str = Object.assign({}, obj, str);
+                    }
+                }
+                if (!str.target) {
+                    str.target = this.getActiveTarget();
                 }
             }
         }
@@ -2268,7 +2303,7 @@ class ____AnaLogger
     {
         options = this.extractContextFromInput(options);
         // If the first parameter is not of context format,
-        // We use the default context and display
+        // We use the default context
         if (!this.isExtendedOptionsPassed(options))
         {
             const defaultContext = this.generateDefaultContext();

package/demo.cjs

@@ -16,6 +16,10 @@ anaLogger.log({lid: "WEB35382", color: "yellow"}, `Log with target`);
 anaLogger.log({contextName: "TEST"}, `Test Log example TEST`);
 anaLogger.log({contextName: "TEST"}, `Test Log example TEST 2`);
 
+anaLogger.log({lid: "WEB35380", color: "yellow"}, {MY: "TEST"}, `Log with target`);
+anaLogger.log({lid: "WEB35380", color: "yellow"}, {MY: "TEST"}, {MY: "TEST2"}, `Log with target`);
+anaLogger.log({MY: "TEST"}, {MY: "TEST2"}, `Log with target`);
+
 anaLogger.setDefaultContext({
     "contextName": "DEFAULT",
     "target": "USER",
@@ -35,18 +39,45 @@ anaLogger.setDefaultContext({
         return `${logCounter}: ${formattedMessage}`;
     }
 });
-anaLogger.log({lid: "WEB35382", color: "yellow", target: "DEFAULT"}, `Log with target 1`);
-anaLogger.log({lid: "WEB35384", color: "yellow", target: "USER"}, `Log with non-existent target 2`);
-anaLogger.log({lid: "WEB35386", color: "yellow", target: undefined}, `Log with undefined target 3`);
-anaLogger.log({lid: "WEB35388", color: "yellow"}, `Log without target 3`);
 
+anaLogger.setTargets({DEV1: "Me", DEV2: "You"});
+anaLogger.setActiveTarget("Me");
+anaLogger.log({lid: "WEB35382", color: "yellow"}, `You should see this`);
+
+anaLogger.log({lid: "WEB35384", color: "yellow", target: "DEFAULT"}, `You should not see this`);
+anaLogger.log({lid: "WEB35386", color: "yellow", target: "USER"}, `You should not see this`);
+anaLogger.log({lid: "WEB35388", color: "yellow", target: undefined}, `You should see this`);
+anaLogger.log({lid: "WEB35390", color: "yellow"}, `You should see this`);
+anaLogger.log({lid: "WEB35392", color: "yellow", target: "You"}, `You should not see this`);
+anaLogger.log({lid: "WEB35394", color: "yellow", target: "Me"}, `You should see this`);
+
+// To work, we should have called `anaLogger.setTargets(["NonDefinedTarget"])`
+anaLogger.setActiveTarget("NonDefinedTarget");
+anaLogger.log({lid: "WEB35396"}, `You cannot see this`);
+anaLogger.log({lid: "WEB35398", target: "NonDefinedTarget"}, `You cannot see this`);
+
+anaLogger.setTargets({DEV1: "NonDefinedTarget"});
+anaLogger.setActiveTarget("NonDefinedTarget");
+anaLogger.log({lid: "WEB35400", target: "NonDefinedTarget"}, `You should see this`);
+
+// Here we set the allowed targets
+anaLogger.setTargets({TOM: "TOM", GROUP1: "GROUP1", GROUP2: "GROUP2"});
+anaLogger.setActiveTargets(["TOM", "GROUP1"]);
+anaLogger.log({target: "TOM"}, `TOM can see this`);
+anaLogger.log({target: "TIM"}, `TIM shouldn't see this`);
+anaLogger.log({target: "GROUP1"}, `GROUP1 can see this`);
+
+// setActiveTargets here will work even if we set the targets before
 anaLogger.setActiveTargets("localhost, api");
+anaLogger.log({lid: "WEB35382", color: "yellow"}, `Log without target`);
 anaLogger.log({lid: "WEB35382", target: "localhost", color: "yellow"}, `Log with target`);
-anaLogger.log({lid: "WEB35382", target: "localhost"}, `Log with target`);
+anaLogger.log({lid: "WEB35382", target: "api"}, `Log with target`);
 anaLogger.log({lid: "WEB35382", color: "green", target: "localhost"}, `Log without target`);
 
+anaLogger.setTargets(["localhost", "api"]);
+anaLogger.setActiveTargets("localhost, api");
 anaLogger.log({contextName: "TEST", target: "localhost"}, `Test Log example TEST`);
-anaLogger.log({contextName: "TEST", target: "localhost"}, `Test Log example TEST 2`);
+anaLogger.log({contextName: "TEST", target: "api"}, `Test Log example TEST 2`);
 
 // Check archive
 for (let i = 1; i < 10; ++i) {