@wgtechlabs/log-engine 1.2.0 → 1.3.0

package/dist/redaction/redactor.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Core data redaction engine
+ * Handles automatic detection and redaction of sensitive information in log data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRedactor = void 0;
+const config_1 = require("./config");
+/**
+ * DataRedactor class - Core redaction logic for processing log data
+ * Automatically detects and redacts sensitive information while preserving structure
+ */
+class DataRedactor {
+    /**
+     * Update the redaction configuration with new settings
+     * Merges provided config with existing settings and reloads environment variables
+     * @param newConfig - Partial configuration to merge with current settings
+     */
+    static updateConfig(newConfig) {
+        // Reload environment configuration to pick up any changes
+        const envConfig = config_1.RedactionController.getEnvironmentConfig();
+        this.config = {
+            ...config_1.defaultRedactionConfig,
+            ...envConfig,
+            ...newConfig
+        };
+    }
+    /**
+     * Get the current redaction configuration
+     * @returns Deep copy of current redaction configuration
+     */
+    static getConfig() {
+        return {
+            ...this.config,
+            sensitiveFields: [...this.config.sensitiveFields],
+            contentFields: [...this.config.contentFields],
+            customPatterns: this.config.customPatterns ? [...this.config.customPatterns] : undefined
+        };
+    }
+    /**
+     * Refresh configuration from environment variables
+     * Useful for picking up runtime environment changes
+     */
+    static refreshConfig() {
+        const envConfig = config_1.RedactionController.getEnvironmentConfig();
+        this.config = {
+            ...config_1.defaultRedactionConfig,
+            ...envConfig
+        };
+    }
+    /**
+     * Add custom regex patterns for advanced field detection
+     * @param patterns - Array of regex patterns to add
+     */
+    static addCustomPatterns(patterns) {
+        const currentPatterns = this.config.customPatterns || [];
+        this.config = {
+            ...this.config,
+            customPatterns: [...currentPatterns, ...patterns]
+        };
+    }
+    /**
+     * Clear all custom regex patterns
+     */
+    static clearCustomPatterns() {
+        this.config = {
+            ...this.config,
+            customPatterns: []
+        };
+    }
+    /**
+     * Add custom sensitive field names to the existing list
+     * @param fields - Array of field names to add
+     */
+    static addSensitiveFields(fields) {
+        this.config = {
+            ...this.config,
+            sensitiveFields: [...this.config.sensitiveFields, ...fields]
+        };
+    }
+    /**
+     * Test if a field name would be redacted with current configuration
+     * @param fieldName - Field name to test
+     * @returns true if field would be redacted, false otherwise
+     */
+    static testFieldRedaction(fieldName) {
+        const testObj = { [fieldName]: 'test-value' };
+        const result = this.redactData(testObj);
+        return result[fieldName] !== 'test-value';
+    }
+    /**
+     * Main entry point for data redaction
+     * Processes any type of data and returns a redacted version
+     * @param data - Data to be processed for redaction
+     * @returns Redacted version of the data
+     */
+    static redactData(data) {
+        // Skip processing if redaction is disabled or data is null/undefined
+        if (!this.config.enabled || data === null || data === undefined) {
+            return data;
+        }
+        return this.processValue(data, new WeakSet(), 0);
+    }
+    /**
+     * Process a value of any type (primitive, object, array)
+     * Recursively handles nested structures when deepRedaction is enabled
+     * Includes circular reference protection and recursion depth limiting
+     * @param value - Value to process
+     * @param visited - Set to track visited objects (prevents circular references)
+     * @param depth - Current recursion depth (prevents stack overflow)
+     * @returns Processed value with redaction applied
+     */
+    static processValue(value, visited = new WeakSet(), depth = 0) {
+        // Check recursion depth limit to prevent stack overflow
+        if (depth >= this.MAX_RECURSION_DEPTH) {
+            return '[Max Depth Exceeded]';
+        }
+        // Handle null and undefined
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Handle arrays - process each element
+        if (Array.isArray(value)) {
+            // Check for circular reference
+            if (visited.has(value)) {
+                return '[Circular Array]';
+            }
+            visited.add(value);
+            const result = value.map(item => this.processValue(item, visited, depth + 1));
+            // Keep value in visited set to detect circular references across branches
+            return result;
+        }
+        // Handle objects - process each property
+        if (typeof value === 'object') {
+            // Check for circular reference
+            if (visited.has(value)) {
+                return '[Circular Object]';
+            }
+            visited.add(value);
+            const result = this.redactObject(value, visited, depth + 1);
+            // Keep value in visited set to detect circular references across branches
+            return result;
+        }
+        // Handle primitives (string, number, boolean) - return as-is
+        return value;
+    }
+    /**
+     * Process an object and redact sensitive fields
+     * Handles field-level redaction and content truncation
+     * @param obj - Object to process
+     * @param visited - Set to track visited objects (prevents circular references)
+     * @param depth - Current recursion depth (prevents stack overflow)
+     * @returns Object with sensitive fields redacted
+     */
+    static redactObject(obj, visited = new WeakSet(), depth = 0) {
+        // Check recursion depth limit to prevent stack overflow
+        if (depth >= this.MAX_REDACT_OBJECT_DEPTH) {
+            return { '[Max Depth Exceeded]': '[Max Depth Exceeded]' };
+        }
+        const redacted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // Check if this field should be completely redacted
+            if (this.isSensitiveField(key)) {
+                redacted[key] = this.config.redactionText;
+            }
+            // Check if this field should be truncated (for large content)
+            else if (this.isContentField(key) && typeof value === 'string') {
+                redacted[key] = this.truncateContent(value);
+            }
+            // Recursively process nested objects/arrays if deep redaction is enabled
+            else if (this.config.deepRedaction && (typeof value === 'object' && value !== null)) {
+                redacted[key] = this.processValue(value, visited, depth + 1);
+            }
+            // Keep the value unchanged
+            else {
+                redacted[key] = value;
+            }
+        }
+        return redacted;
+    }
+    /**
+     * Check if a field name indicates sensitive information
+     * Uses case-insensitive matching with exact and partial matches
+     * Includes smart filtering to avoid false positives and custom patterns
+     * @param fieldName - Field name to check
+     * @returns true if field should be redacted, false otherwise
+     */
+    static isSensitiveField(fieldName) {
+        const lowerField = fieldName.toLowerCase();
+        // Check custom regex patterns first (highest priority)
+        if (this.config.customPatterns && this.config.customPatterns.length > 0) {
+            for (const pattern of this.config.customPatterns) {
+                if (pattern.test(fieldName)) {
+                    return true;
+                }
+            }
+        }
+        return this.config.sensitiveFields.some(sensitive => {
+            const lowerSensitive = sensitive.toLowerCase();
+            // Exact match (highest confidence)
+            if (lowerField === lowerSensitive) {
+                return true;
+            }
+            // Field ends with sensitive term (e.g., "userPassword" ends with "password")
+            if (lowerField.endsWith(lowerSensitive)) {
+                return true;
+            }
+            // Field starts with sensitive term (e.g., "passwordHash" starts with "password")
+            if (lowerField.startsWith(lowerSensitive)) {
+                return true;
+            }
+            // Whitelist of short sensitive terms that should always trigger substring matching
+            const shortSensitiveWhitelist = ['pin', 'cvv', 'cvc', 'ssn', 'pwd', 'key', 'jwt', 'dob', 'pii', 'auth', 'csrf'];
+            // Field contains sensitive term - either from whitelist or length >= 5 to avoid false positives
+            if ((shortSensitiveWhitelist.includes(lowerSensitive) || lowerSensitive.length >= 5) &&
+                lowerField.includes(lowerSensitive)) {
+                return true;
+            }
+            // Handle compound words with underscores or camelCase
+            if (lowerField.includes('_' + lowerSensitive) || lowerField.includes(lowerSensitive + '_')) {
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Check if a field name indicates content that should be truncated
+     * Uses exact case-insensitive matching for content fields
+     * @param fieldName - Field name to check
+     * @returns true if field is a content field, false otherwise
+     */
+    static isContentField(fieldName) {
+        const lowerField = fieldName.toLowerCase();
+        return this.config.contentFields.some(content => content.toLowerCase() === lowerField);
+    }
+    /**
+     * Truncate content that exceeds the maximum length
+     * Preserves readability while preventing log bloat
+     * @param content - Content string to potentially truncate
+     * @returns Original content or truncated version with indicator
+     */
+    static truncateContent(content) {
+        if (content.length <= this.config.maxContentLength) {
+            return content;
+        }
+        return content.substring(0, this.config.maxContentLength) + this.config.truncationText;
+    }
+}
+exports.DataRedactor = DataRedactor;
+DataRedactor.config = {
+    ...config_1.defaultRedactionConfig,
+    ...config_1.RedactionController.getEnvironmentConfig()
+};
+// Maximum recursion depth to prevent stack overflow attacks
+DataRedactor.MAX_RECURSION_DEPTH = 100;
+// Slightly lower limit for redactObject to ensure it can be reached
+DataRedactor.MAX_REDACT_OBJECT_DEPTH = 99;

package/dist/types/index.d.ts

@@ -61,4 +61,168 @@ export interface LoggerConfig {
     /** Optional environment identifier for context (e.g., 'production', 'staging') */
     environment?: string;
 }
+/**
+ * Configuration options for automatic data redaction
+ * Controls how sensitive information is processed in log messages
+ */
+export interface RedactionConfig {
+    /** Whether redaction is enabled globally */
+    enabled: boolean;
+    /** List of field names that should be redacted (case-insensitive partial matching) */
+    sensitiveFields: string[];
+    /** List of field names that should be truncated if they exceed maxContentLength */
+    contentFields: string[];
+    /** Maximum length for content fields before truncation occurs */
+    maxContentLength: number;
+    /** Text to replace sensitive field values with */
+    redactionText: string;
+    /** Text to append when content is truncated */
+    truncationText: string;
+    /** Whether to recursively scan nested objects and arrays */
+    deepRedaction: boolean;
+    /** Optional custom regex patterns for advanced field detection */
+    customPatterns?: RegExp[];
+}
+/**
+ * Interface for the LogEngine singleton object
+ * Provides all logging methods with comprehensive TypeScript support
+ */
+export interface ILogEngine {
+    /** Configure the logger with new settings */
+    configure(config: Partial<LoggerConfig>): void;
+    /** Log a debug message with automatic data redaction */
+    debug(message: string, data?: any): void;
+    /** Log an info message with automatic data redaction */
+    info(message: string, data?: any): void;
+    /** Log a warn message with automatic data redaction */
+    warn(message: string, data?: any): void;
+    /** Log an error message with automatic data redaction */
+    error(message: string, data?: any): void;
+    /** Log a message with automatic data redaction */
+    log(message: string, data?: any): void;
+    /** Log a debug message without redaction */
+    debugRaw(message: string, data?: any): void;
+    /** Log an info message without redaction */
+    infoRaw(message: string, data?: any): void;
+    /** Log a warn message without redaction */
+    warnRaw(message: string, data?: any): void;
+    /** Log an error message without redaction */
+    errorRaw(message: string, data?: any): void;
+    /** Log a message without redaction */
+    logRaw(message: string, data?: any): void;
+    /** Configure redaction settings */
+    configureRedaction(config: Partial<RedactionConfig>): void;
+    /** Reset redaction configuration to defaults */
+    resetRedactionConfig(): void;
+    /** Refresh redaction configuration from environment variables */
+    refreshRedactionConfig(): void;
+    /** Get current redaction configuration */
+    getRedactionConfig(): RedactionConfig;
+    /** Add custom regex patterns for advanced field detection */
+    addCustomRedactionPatterns(patterns: RegExp[]): void;
+    /** Clear all custom redaction patterns */
+    clearCustomRedactionPatterns(): void;
+    /** Add custom sensitive field names to the existing list */
+    addSensitiveFields(fields: string[]): void;
+    /** Test if a field name would be redacted with current configuration */
+    testFieldRedaction(fieldName: string): boolean;
+    /** Temporarily disable redaction for a specific logging call */
+    withoutRedaction(): ILogEngineWithoutRedaction;
+}
+/**
+ * Interface for LogEngine methods without redaction
+ * Returned by withoutRedaction() method
+ */
+export interface ILogEngineWithoutRedaction {
+    /** Log a debug message without redaction */
+    debug(message: string, data?: any): void;
+    /** Log an info message without redaction */
+    info(message: string, data?: any): void;
+    /** Log a warn message without redaction */
+    warn(message: string, data?: any): void;
+    /** Log an error message without redaction */
+    error(message: string, data?: any): void;
+    /** Log a message without redaction */
+    log(message: string, data?: any): void;
+}
+/**
+ * Interface for the DataRedactor static class methods
+ * Provides type safety for all redaction operations
+ */
+export interface IDataRedactor {
+    /** Update redaction configuration */
+    updateConfig(newConfig: Partial<RedactionConfig>): void;
+    /** Get current redaction configuration */
+    getConfig(): RedactionConfig;
+    /** Refresh configuration from environment variables */
+    refreshConfig(): void;
+    /** Add custom regex patterns for field detection */
+    addCustomPatterns(patterns: RegExp[]): void;
+    /** Clear all custom regex patterns */
+    clearCustomPatterns(): void;
+    /** Add sensitive field names to the existing list */
+    addSensitiveFields(fields: string[]): void;
+    /** Test if a field name would be redacted */
+    testFieldRedaction(fieldName: string): boolean;
+    /** Redact sensitive data from any value */
+    redactData(data: any): any;
+}
+/**
+ * Interface for the RedactionController methods
+ * Provides environment-based configuration management
+ */
+export interface IRedactionController {
+    /** Load configuration from environment variables */
+    loadFromEnvironment(): RedactionConfig;
+    /** Reset configuration to default values */
+    resetToDefaults(): RedactionConfig;
+    /** Get currently active configuration */
+    getCurrentConfig(): RedactionConfig;
+}
+/**
+ * Options for configuring redaction behavior
+ * Used for advanced redaction scenarios
+ */
+export interface RedactionOptions {
+    /** Whether to enable deep scanning of nested objects */
+    deep?: boolean;
+    /** Custom patterns to use for this operation */
+    customPatterns?: RegExp[];
+    /** Additional sensitive fields for this operation */
+    additionalSensitiveFields?: string[];
+    /** Override default redaction text */
+    redactionText?: string;
+}
+/**
+ * Result type for field redaction testing
+ * Provides detailed information about redaction decisions
+ */
+export interface FieldRedactionResult {
+    /** Whether the field would be redacted */
+    wouldRedact: boolean;
+    /** Reason for the redaction decision */
+    reason: 'sensitive_field' | 'custom_pattern' | 'not_sensitive';
+    /** Pattern that matched (if applicable) */
+    matchedPattern?: RegExp;
+}
+/**
+ * Environment variable configuration mapping
+ * Documents all supported environment variables
+ */
+export interface EnvironmentConfig {
+    /** LOG_REDACTION_DISABLED - Disable all redaction */
+    LOG_REDACTION_DISABLED?: string;
+    /** LOG_REDACTION_TEXT - Custom redaction text */
+    LOG_REDACTION_TEXT?: string;
+    /** LOG_REDACTION_SENSITIVE_FIELDS - Comma-separated sensitive field names */
+    LOG_REDACTION_SENSITIVE_FIELDS?: string;
+    /** LOG_REDACTION_CONTENT_FIELDS - Comma-separated content field names */
+    LOG_REDACTION_CONTENT_FIELDS?: string;
+    /** LOG_REDACTION_MAX_CONTENT_LENGTH - Maximum length for content fields */
+    LOG_REDACTION_MAX_CONTENT_LENGTH?: string;
+    /** LOG_REDACTION_TRUNCATION_TEXT - Text for truncated content */
+    LOG_REDACTION_TRUNCATION_TEXT?: string;
+    /** LOG_REDACTION_DEEP - Enable deep redaction */
+    LOG_REDACTION_DEEP?: string;
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,oBAAY,QAAQ;IAChB,qFAAqF;IACrF,KAAK,IAAI;IACT,2DAA2D;IAC3D,IAAI,IAAI;IACR,kEAAkE;IAClE,IAAI,IAAI;IACR,sEAAsE;IACtE,KAAK,IAAI;IACT,kGAAkG;IAClG,GAAG,KAAK;CACX;AAED;;;GAGG;AACH,oBAAY,OAAO;IACf,kEAAkE;IAClE,KAAK,IAAI;IACT,uDAAuD;IACvD,IAAI,IAAI;IACR,gDAAgD;IAChD,IAAI,IAAI;IACR,0CAA0C;IAC1C,KAAK,IAAI;IACT,8CAA8C;IAC9C,MAAM,IAAI;IACV,kDAAkD;IAClD,GAAG,IAAI;CACV;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACrB,qCAAqC;IACrC,SAAS,EAAE,IAAI,CAAC;IAChB,2CAA2C;IAC3C,KAAK,EAAE,QAAQ,CAAC;IAChB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB,qDAAqD;IACrD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;0EACsE;IACtE,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@wgtechlabs/log-engine",
-  "version": "1.2.0",
-  "description": "A lightweight and efficient logging utility designed specifically for bot applications running on Node.js.",
+  "version": "1.3.0",
+  "description": "A lightweight, security-first logging utility with automatic data redaction for Node.js applications - the first logging library with built-in PII protection.",
   "keywords": [
     "logging",
+    "security",
+    "redaction",
+    "pii-protection",
+    "data-redaction",
+    "typescript",
+    "nodejs",
     "bot",
     "discord",
     "telegram",
-    "nodejs",
-    "typescript"
+    "privacy",
+    "gdpr",
+    "compliance"
   ],
   "license": "AGPL-3.0",
   "author": "WG Tech Labs <opensource@wgtechlabs.com> (https://wgtechlabs.com)",