feat: Implement label filtering

Author: FoxxMD

README.md

@@ -178,6 +178,43 @@ logger.debug({labels: ['MyLabel']}, 'My log message');
 
 **NOTE:** If a label *function* throws an error then the label will be the error's message. Make sure your labels don't throw!
 
+#### Filtering By Label
+
+Logs can be filtered by labels similar to how [debug-js](https://github.com/debug-js/debug) works.
+
+By default *no* filtering is done. Your child loggers follow the Pino Child Logger behavior of inherting parent log level.
+
+Using either `LOG_FILTER_ENABLE` or `LOG_FILTER_DISABLE` you can enable or disable a child logger and it's children.
+
+```ts
+
+/*
+ * process.env.LOG_FILTER_ENABLE = 'Third:Fourth,Second:*:Foo,Bar'
+ */
+
+import {loggerApp, childLogger} from '@foxxmd/logging';
+
+logger = loggerApp();
+logger.debug('Test');
+// [2024-03-07 11:27:41.944 -0500] DEBUG: Test
+
+const nestedChild1 = childLogger(logger, 'First');
+nestedChild1.debug('I am nested one level');
+// [2024-03-07 11:27:41.945 -0500] DEBUG: [First] I am nested one level
+
+const nestedChild2 = childLogger(nestedChild1, ['Second', 'Third'], { level: 'silent' });
+nestedChild2.info('I do not log because of set level and not enabled by filter');
+
+const nestedChild3 = childLogger(nestedChild2, ['Fourth']);
+nestedChild3.info('I do log because of filter Third:Fourth');
+
+const nestedChild4 = childLogger(nestedChild3, ['Foo']);
+nestedChild4.info('I do log because of filter Second:*:Foo');
+
+const nestedChild5 = childLogger(nestedChild4, ['Bar']);
+nestedChild5.info('I do log because of filter Bar');
+```
+
 ### Serializing Objects and Errors
 
 Passing an object or array as the first argument to the logger will cause the object to be JSONified and pretty printed below the log message

src/funcs.ts

@@ -1,8 +1,10 @@
 import process from "process";
 import {
+    ChildLabel,
     FileLogOptions,
     FileLogOptionsParsed,
     FileLogPathOptions,
+    FilterLabelsFunc,
     LOG_LEVEL_NAMES,
     LogLevel,
     LogOptions,
@@ -111,3 +113,54 @@ export const getLogPath = (path?: string, options: FileLogPathOptions = {}) => {
 
     return resolve(baseDir, pathVal);
 }
+
+export const labelsStrBuilder = (labels: ChildLabel[]) => {
+    return labels.map(x => typeof x === 'function' ? 'dynamicfunc' : x.toLocaleLowerCase().trim()).reverse().join(':');
+}
+export const labelFilterToRegex = (filter: string) => {
+    const reverseCleaned = filter.split(':').map(x => x.trim().toLocaleLowerCase().replace('*','.+')).reverse().join(':');
+    return new RegExp(`^${reverseCleaned}`);
+}
+
+export const labelFiltersFromStr = (str?: string): RegExp[] | undefined => {
+    if(str === undefined || str.trim() === '') {
+        return undefined;
+    }
+    return str.split(',').map(x => labelFilterToRegex(x.trim()));
+}
+
+export const labelFiltersFromEnvSingleton = (envName: string): FilterLabelsFunc => {
+    let envFilterRes: false | RegExp[];
+    return (labels: ChildLabel[]) => {
+        if(envFilterRes === undefined) {
+            envFilterRes = labelFiltersFromStr(process.env[envName]);
+            if(envFilterRes === undefined) {
+                envFilterRes = false;
+            }
+        }
+        if(envFilterRes === false) {
+            return false;
+        }
+
+        const labelStr = labelsStrBuilder(labels);
+        return envFilterRes.some(x => x.test(labelStr));
+    }
+}
+
+
+export const labelsEnableFromEnvSingleton = labelFiltersFromEnvSingleton('LOG_FILTER_ENABLE');
+export const labelsDisableFromEnvSingleton = labelFiltersFromEnvSingleton('LOG_FILTER_DISABLE');
+
+export const labelsFilterFromEnv = (envName: string): FilterLabelsFunc => {
+    return (labels: ChildLabel[]) => {
+        const envFilterRes = labelFiltersFromStr(process.env[envName]);
+        if(envFilterRes === undefined) {
+            return false;
+        }
+        const labelStr = labelsStrBuilder(labels);
+        return envFilterRes.some(x => x.test(labelStr));
+    }
+}
+
+export const labelsEnableFromEnv = labelsFilterFromEnv('LOG_FILTER_ENABLE');
+export const labelsDisableFromEnv = labelsFilterFromEnv('LOG_FILTER_DISABLE');

src/index.ts

@@ -8,12 +8,21 @@ import {
     LogLevel,
     LOG_LEVEL_NAMES,
     LoggerAppExtras,
-    PrettyOptionsExtra
+    PrettyOptionsExtra,
+    ChildLoggerOptions
 } from './types.js'
 
 import {
     isLogOptions,
     parseLogOptions,
+    labelsStrBuilder,
+    labelFiltersFromStr,
+    labelFiltersFromEnvSingleton,
+    labelsEnableFromEnvSingleton,
+    labelsDisableFromEnvSingleton,
+    labelsFilterFromEnv,
+    labelsEnableFromEnv,
+    labelsDisableFromEnv
 } from './funcs.js'
 
 import {childLogger, loggerApp, loggerDebug, loggerTest, loggerTrace, loggerAppRolling} from './loggers.js';
@@ -27,7 +36,8 @@ export type {
     LogDataPretty,
     LogLevel,
     LoggerAppExtras,
-    PrettyOptionsExtra
+    PrettyOptionsExtra,
+    ChildLoggerOptions
 }
 
 export {
@@ -39,5 +49,13 @@ export {
     LOG_LEVEL_NAMES,
     childLogger,
     parseLogOptions,
-    isLogOptions
+    isLogOptions,
+    labelsStrBuilder,
+    labelFiltersFromStr,
+    labelFiltersFromEnvSingleton,
+    labelsEnableFromEnvSingleton,
+    labelsDisableFromEnvSingleton,
+    labelsFilterFromEnv,
+    labelsEnableFromEnv,
+    labelsDisableFromEnv
 }

src/loggers.ts

@@ -1,12 +1,13 @@
-import {parseLogOptions} from "./funcs.js";
+import {labelsDisableFromEnv, labelsDisableFromEnvSingleton, labelsEnableFromEnv, labelsEnableFromEnvSingleton, parseLogOptions} from "./funcs.js";
 import {
     PinoLoggerOptions,
     CUSTOM_LEVELS,
     Logger,
     LoggerAppExtras,
     LogLevel,
     LogLevelStreamEntry,
-    LogOptions
+    LogOptions,
+    ChildLoggerOptions
 } from "./types.js";
 import {buildDestinationFile, buildDestinationRollingFile, buildDestinationStdout} from "./destinations.js";
 import {pino, levels, stdSerializers} from "pino";
@@ -45,7 +46,7 @@ export const buildLogger = (defaultLevel: LogLevel, streams: LogLevelStreamEntry
         },
         mixinMergeStrategy(mergeObject: Record<any, any>, mixinObject: Record<any, any>) {
             if(mergeObject.labels === undefined || mixinObject.labels === undefined || mixinObject.labels.length === 0) {
-                return Object.assign(mergeObject, mixinObject)
+                return Object.assign(mergeObject, mixinObject);
             }
             const runtimeLabels = Array.isArray(mergeObject.labels) ? mergeObject.labels : [mergeObject.labels];
             const finalObj = Object.assign(mergeObject, mixinObject);
@@ -91,10 +92,18 @@ export const buildLogger = (defaultLevel: LogLevel, streams: LogLevelStreamEntry
  * @param parent Logger Parent logger to inherit from
  * @param labelsVal (any | any[]) Labels to always apply to logs from this logger
  * @param context object Additional properties to always apply to logs from this logger
- * @param options object
+ * @param options ChildLoggerOptions
  * */
-export const childLogger = (parent: Logger, labelsVal: any | any[] = [], context: object = {}, options = {}): Logger => {
-    const newChild = parent.child(context, options) as Logger;
+export const childLogger = (parent: Logger, labelsVal: any | any[] = [], context: object = {}, options: ChildLoggerOptions = {}): Logger => {
+    const {
+        labelEnable = labelsEnableFromEnvSingleton,
+        labelEnableLevel = parent.level,
+        labelDisable = labelsDisableFromEnvSingleton,
+        labelDisableLevel = 'silent',
+        ...rest
+    } = options;
+
+    const newChild = parent.child(context, rest) as Logger;
     const labels = Array.isArray(labelsVal) ? labelsVal : [labelsVal];
     newChild.labels = [...[...(parent.labels ?? [])], ...labels];
     newChild.addLabel = function (value) {
@@ -103,6 +112,12 @@ export const childLogger = (parent: Logger, labelsVal: any | any[] = [], context
         }
         this.labels.push(value);
     }
+
+    if(newChild.level !== labelEnableLevel && labelEnable !== undefined && labelEnable(newChild.labels)) {
+         newChild.level = labelEnableLevel;
+    } else if (newChild.level !== labelDisableLevel && labelDisable !== undefined && labelDisable(newChild.labels)) {
+        newChild.level = labelDisableLevel;
+    }
     return newChild
 }
 /**

src/types.ts

@@ -51,6 +51,18 @@ const CUSTOM_LEVEL_NAMES = Object.keys(CUSTOM_LEVELS);
 
 export const LOG_LEVEL_NAMES= ['silent', 'fatal', 'error', 'warn', 'info', 'log', 'verbose', 'debug', 'trace'] as const;
 
+export type ChildLabel = (string | CallableFunction);
+
+export type FilterLabelsFunc = (labels: ChildLabel[]) => boolean;
+
+export interface ChildLoggerOptions {
+    labelEnable?: (labels: ChildLabel[]) => boolean,
+    labelEnableLevel?: LogLevel,
+    labelDisable?: (labels: ChildLabel[]) => boolean,
+    labelDisableLevel?: LogLevel
+    [key: string]: any
+}
+
 /**
  * Configure log levels and file options for an AppLogger.
  *