@ncoderz/log-m8 1.0.2 → 1.2.0

package/dist/index.cjs

@@ -23,8 +23,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var index_exports = {};
 __export(index_exports, {
   LogLevel: () => LogLevel,
+  LogM8: () => LogM82,
   LogM8Utils: () => LogM8Utils,
-  Logging: () => Logging,
   PluginKind: () => PluginKind
 });
 module.exports = __toCommonJS(index_exports);
@@ -144,6 +144,7 @@ var import_fs = require("fs");
 
 // src/LogM8Utils.ts
 var TIMESTAMP_TOKEN_REGEX = /(yyyy|SSS|hh|mm|ss|SS|zz|z|yy|MM|dd|A|a|h|S)/g;
+var REGEX_MATCHER = /^\/(.+)\/([dgimsuvy]*)$/;
 var EXCLUDED_ERROR_KEYS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
 var COMMON_NON_ENUMERABLE_PROPS = ["code", "errno", "syscall", "path"];
 var LogM8Utils = class _LogM8Utils {
@@ -539,6 +540,31 @@ var LogM8Utils = class _LogM8Utils {
     };
     return serializeErrorInternal(error, /* @__PURE__ */ new WeakSet());
   }
+  /**
+   * Take a regex in the format /regex/flags and parse it into a RegExp object
+   *
+   * @param regex regex in the format /regex/flags
+   * @param extraFlags additional flags to apply to the regex
+   * @returns RegExp object or undefined if the regex is invalid
+   */
+  static parseRegexFromString(regex, extraFlags) {
+    try {
+      const match = regex.match(REGEX_MATCHER);
+      if (match == null) return void 0;
+      const [, pattern, flags] = match;
+      let finalFlags = flags;
+      if (Array.isArray(extraFlags)) {
+        for (const flag of extraFlags) {
+          if (!flags.includes(flag)) {
+            finalFlags += flag;
+          }
+        }
+      }
+      return new RegExp(pattern, finalFlags);
+    } catch (_e) {
+      return void 0;
+    }
+  }
 };
 
 // src/appenders/FileAppender.ts
@@ -639,8 +665,8 @@ var MatchFilter = class {
    */
   init(config) {
     const cfg = config ?? {};
-    this._allow = cfg.allow ?? void 0;
-    this._deny = cfg.deny ?? void 0;
+    this._allow = this._prepareRules(cfg.allow);
+    this._deny = this._prepareRules(cfg.deny);
     this.enabled = cfg.enabled !== false;
   }
   dispose() {
@@ -658,13 +684,13 @@ var MatchFilter = class {
       if (this._allow && Object.keys(this._allow).length > 0) {
         for (const [path, expected] of Object.entries(this._allow)) {
           const actual = LogM8Utils.getPropertyByPath(logEvent, path);
-          if (!this._isEqual(actual, expected)) return false;
+          if (!this._matches(actual, expected)) return false;
         }
       }
       if (this._deny && Object.keys(this._deny).length > 0) {
         for (const [path, expected] of Object.entries(this._deny)) {
           const actual = LogM8Utils.getPropertyByPath(logEvent, path);
-          if (this._isEqual(actual, expected)) return false;
+          if (this._matches(actual, expected)) return false;
         }
       }
       return true;
@@ -672,6 +698,15 @@ var MatchFilter = class {
       return false;
     }
   }
+  // Matches actual against expected, supporting RegExp; otherwise deep equality.
+  _matches(actual, expected) {
+    if (expected instanceof RegExp) {
+      if (actual === void 0 || actual === null) return false;
+      const asString = typeof actual === "string" ? actual : String(actual);
+      return expected.test(asString);
+    }
+    return this._isEqual(actual, expected);
+  }
   // Simple deep equality for primitives, arrays, plain objects, dates
   _isEqual(a, b) {
     if (a === b) return true;
@@ -702,6 +737,20 @@ var MatchFilter = class {
   _isPlainObject(val) {
     return typeof val === "object" && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
   }
+  // Convert rule map values: regex-like strings -> RegExp; leave others as-is.
+  _prepareRules(map) {
+    if (!map || Object.keys(map).length === 0) return void 0;
+    const prepared = {};
+    for (const [path, val] of Object.entries(map)) {
+      if (typeof val === "string") {
+        const rx = LogM8Utils.parseRegexFromString(val);
+        prepared[path] = rx ?? val;
+      } else {
+        prepared[path] = val;
+      }
+    }
+    return prepared;
+  }
 };
 var MatchFilterFactory = class {
   constructor() {
@@ -1027,16 +1076,27 @@ var DEFAULT_APPENDERS = [
 ];
 var LogM8 = class {
   constructor() {
-    __publicField(this, "_initialized", false);
-    __publicField(this, "_pluginManager", new PluginManager());
-    __publicField(this, "_loggers", /* @__PURE__ */ new Map());
-    __publicField(this, "_appenders", []);
+    __publicField(this, "_initialized");
+    __publicField(this, "_pluginManager");
+    __publicField(this, "_loggers");
+    __publicField(this, "_appenders");
     __publicField(this, "_filters", []);
-    __publicField(this, "_defaultLevel", LogLevel.info);
-    __publicField(this, "_logLevelValues", Object.values(LogLevel));
-    __publicField(this, "_logLevelSet", new Set(this._logLevelValues));
+    __publicField(this, "_globalLogLevel");
+    __publicField(this, "_globalLogLevelNumber");
+    __publicField(this, "_logLevelValues");
+    __publicField(this, "_logLevelSet");
     // Buffer for log events before the system is initialized
-    __publicField(this, "_logBuffer", []);
+    __publicField(this, "_logBuffer");
+    this._initialized = false;
+    this._pluginManager = new PluginManager();
+    this._loggers = /* @__PURE__ */ new Map();
+    this._appenders = [];
+    this._filters = [];
+    this._logLevelValues = Object.values(LogLevel);
+    this._logLevelSet = new Set(this._logLevelValues);
+    this._globalLogLevel = LogLevel.info;
+    this._globalLogLevelNumber = this._logLevelValues.indexOf(LogLevel.info);
+    this._logBuffer = [];
     this._pluginManager.registerPluginFactory(new ConsoleAppenderFactory());
     this._pluginManager.registerPluginFactory(new FileAppenderFactory());
     this._pluginManager.registerPluginFactory(new DefaultFormatterFactory());
@@ -1073,10 +1133,10 @@ var LogM8 = class {
   init(config) {
     config = Object.assign({}, config);
     this._reset();
-    this._defaultLevel = this._logLevelSet.has(config.level) ? config.level : LogLevel.info;
+    this._globalLogLevel = this._logLevelSet.has(config.level) ? config.level : LogLevel.info;
     for (const [name, level] of Object.entries(config.loggers ?? {})) {
       const logger = this.getLogger(name);
-      const l = this._logLevelSet.has(level) ? level : this._defaultLevel;
+      const l = this._logLevelSet.has(level) ? level : this._globalLogLevel;
       logger.setLevel(l);
     }
     const appenderConfigs = config.appenders ?? DEFAULT_APPENDERS;
@@ -1173,7 +1233,7 @@ var LogM8 = class {
     if (existingLogger) return existingLogger;
     const logger = {
       name: nameStr,
-      level: this._defaultLevel,
+      level: this._globalLogLevel,
       context: {}
     };
     logger.fatal = this._log.bind(this, logger, LogLevel.fatal);
@@ -1186,10 +1246,24 @@ var LogM8 = class {
     logger.setLevel = this._setLevel.bind(this, logger);
     logger.setContext = this._setContext.bind(this, logger);
     logger.getLogger = (name2) => this.getLogger([logger.name, name2]);
-    this._setLevel(logger, this._defaultLevel);
+    this._setLevel(logger, this._globalLogLevel);
     this._loggers.set(logger.name, logger);
     return logger;
   }
+  /**
+   * Sets the global logging level or a specific logger's level.
+   *
+   * @param level - New logging level name (e.g., 'info', 'debug', 'off')
+   * @param logger - Optional logger name to set level for a specific logger
+   */
+  setLevel(level, logger) {
+    if (logger) {
+      this.getLogger(logger).setLevel(level);
+    } else {
+      this._globalLogLevel = this._logLevelSet.has(level) ? level : this._globalLogLevel;
+      this._globalLogLevelNumber = this._logLevelValues.indexOf(this._globalLogLevel);
+    }
+  }
   /**
    * Enables an appender to resume processing log events.
    *
@@ -1320,7 +1394,7 @@ var LogM8 = class {
   }
   _log(logger, level, message, ...data) {
     const levelNumber = this._logLevelValues.indexOf(level);
-    if (levelNumber > logger._levelNumber) return;
+    if (levelNumber > logger._levelNumber || levelNumber > this._globalLogLevelNumber) return;
     const logEvent = {
       logger: logger.name,
       level,
@@ -1345,9 +1419,9 @@ var LogM8 = class {
     }
   }
   _setLevel(logger, level) {
-    logger.level = level;
+    logger.level = this._logLevelSet.has(level) ? level : logger.level;
     logger._levelNumber = this._logLevelValues.indexOf(level);
-    logger.isEnabled = level !== LogLevel.off;
+    logger.isEnabled = logger.level !== LogLevel.off;
     const levelNumber = logger._levelNumber;
     logger.isFatal = this._logLevelValues.indexOf(LogLevel.fatal) <= levelNumber;
     logger.isError = this._logLevelValues.indexOf(LogLevel.error) <= levelNumber;
@@ -1395,18 +1469,18 @@ var LogM8 = class {
     this.flushAppenders();
     this._appenders = [];
     this._loggers.clear();
-    this._defaultLevel = LogLevel.info;
+    this._globalLogLevel = LogLevel.info;
     this._pluginManager.disposePlugins();
   }
 };
 
 // src/index.ts
-var Logging = new LogM8();
+var LogM82 = new LogM8();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LogLevel,
+  LogM8,
   LogM8Utils,
-  Logging,
   PluginKind
 });
 //# sourceMappingURL=index.cjs.map