@ncoderz/log-m8 1.0.2 → 1.2.0

package/dist/index.d.ts

@@ -521,13 +521,14 @@ interface PluginFactory<C extends PluginConfig = PluginConfig, P extends Plugin
  * Logging.flushAppenders();
  * ```
  */
-declare class LogM8 {
+declare class LogM8$1 {
     private _initialized;
     private _pluginManager;
     private _loggers;
     private _appenders;
     private _filters;
-    private _defaultLevel;
+    private _globalLogLevel;
+    private _globalLogLevelNumber;
     private _logLevelValues;
     private _logLevelSet;
     private _logBuffer;
@@ -601,6 +602,13 @@ declare class LogM8 {
      * ```
      */
     getLogger(name: string | string[]): Log;
+    /**
+     * 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: LogLevelType, logger?: string): void;
     /**
      * Enables an appender to resume processing log events.
      *
@@ -1251,6 +1259,14 @@ declare class LogM8Utils {
      * }
      */
     static serializeError(error: unknown): SerializedError | null;
+    /**
+     * 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: string, extraFlags?: string[]): RegExp | undefined;
 }
 
 /**
@@ -1261,16 +1277,16 @@ declare class LogM8Utils {
  *
  * @example
  * ```typescript
- * import { Logging } from 'log-m8';
+ * import { LogM8 } from 'log-m8';
  *
  * // Initialize with default console output
- * Logging.init();
+ * LogM8.init();
  *
  * // Get a logger and start logging
- * const logger = Logging.getLogger('app');
+ * const logger = LogM8.getLogger('app');
  * logger.info('Application started');
  * ```
  */
-declare const Logging: LogM8;
+declare const LogM8: LogM8$1;
 
-export { type Appender, type AppenderConfig, type ConsoleAppenderConfig, type DefaultFormatterConfig, type FileAppenderConfig, type Filter, type FilterConfig, type Formatter, type FormatterConfig, type Log, type LogContext, LogLevel, type LogLevelType, LogM8Utils, Logging, type LoggingConfig, type MatchFilterConfig, type Plugin, type PluginConfig, type PluginFactory, PluginKind, type PluginKindType };
+export { type Appender, type AppenderConfig, type ConsoleAppenderConfig, type DefaultFormatterConfig, type FileAppenderConfig, type Filter, type FilterConfig, type Formatter, type FormatterConfig, type Log, type LogContext, LogLevel, type LogLevelType, LogM8, LogM8Utils, type LoggingConfig, type MatchFilterConfig, type Plugin, type PluginConfig, type PluginFactory, PluginKind, type PluginKindType };

package/dist/index.js

@@ -117,6 +117,7 @@ import { createWriteStream } from "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 {
@@ -512,6 +513,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
@@ -612,8 +638,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() {
@@ -631,13 +657,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;
@@ -645,6 +671,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;
@@ -675,6 +710,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() {
@@ -1000,16 +1049,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());
@@ -1046,10 +1106,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;
@@ -1146,7 +1206,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);
@@ -1159,10 +1219,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.
    *
@@ -1293,7 +1367,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,
@@ -1318,9 +1392,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;
@@ -1368,17 +1442,17 @@ 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();
 export {
   LogLevel,
+  LogM82 as LogM8,
   LogM8Utils,
-  Logging,
   PluginKind
 };
 //# sourceMappingURL=index.js.map