@wgtechlabs/log-engine 1.2.1 → 2.0.0

package/dist/logger/core.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Core Logger class that handles log message output with configurable levels
+ * Supports DEBUG, INFO, WARN, ERROR, and LOG levels with intelligent filtering
+ * LOG level always outputs regardless of configuration
+ * Uses colorized console output with timestamps for better readability
+ * Includes automatic data redaction for sensitive information
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const types_1 = require("../types");
+const formatter_1 = require("../formatter");
+const redaction_1 = require("../redaction");
+const config_1 = require("./config");
+const filtering_1 = require("./filtering");
+/**
+ * Logger class responsible for managing log output and configuration
+ * Provides mode-based filtering and formatted console output
+ */
+class Logger {
+    /**
+     * Logger constructor - sets up environment-based auto-configuration
+     */
+    constructor() {
+        this.configManager = new config_1.LoggerConfigManager();
+    }
+    /**
+     * Updates logger configuration with new settings
+     * Also updates redaction configuration based on environment
+     * @param config - Partial configuration object to apply
+     */
+    configure(config) {
+        this.configManager.updateConfig(config);
+        // Update redaction configuration based on current environment
+        redaction_1.DataRedactor.updateConfig({
+            ...redaction_1.defaultRedactionConfig,
+            ...redaction_1.RedactionController.getEnvironmentConfig()
+        });
+    }
+    /**
+     * Get current logger configuration
+     * @returns Current logger configuration
+     */
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    /**
+     * Determines if a message should be logged based on current log mode
+     * @param level - The log level of the message to check
+     * @returns true if message should be logged, false otherwise
+     */
+    shouldLog(level) {
+        const currentConfig = this.configManager.getConfig();
+        const currentMode = currentConfig.mode !== undefined ? currentConfig.mode : types_1.LogMode.INFO;
+        return filtering_1.LogFilter.shouldLog(level, currentMode);
+    }
+    /**
+     * Log a debug message with DEBUG level formatting
+     * Uses console.log for output with purple/magenta coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The debug message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    debug(message, data) {
+        if (this.shouldLog(types_1.LogLevel.DEBUG)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.DEBUG, message, processedData);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log an informational message with INFO level formatting
+     * Uses console.log for output with blue coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The info message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    info(message, data) {
+        if (this.shouldLog(types_1.LogLevel.INFO)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.INFO, message, processedData);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log a warning message with WARN level formatting
+     * Uses console.warn for output with yellow coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The warning message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    warn(message, data) {
+        if (this.shouldLog(types_1.LogLevel.WARN)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.WARN, message, processedData);
+            console.warn(formatted);
+        }
+    }
+    /**
+     * Log an error message with ERROR level formatting
+     * Uses console.error for output with red coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The error message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    error(message, data) {
+        if (this.shouldLog(types_1.LogLevel.ERROR)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.ERROR, message, processedData);
+            console.error(formatted);
+        }
+    }
+    /**
+     * Log a message with LOG level formatting (always outputs unless mode is OFF)
+     * Uses console.log for output with green coloring
+     * LOG level bypasses normal filtering and always outputs (except when OFF is set)
+     * Automatically redacts sensitive data when provided
+     * @param message - The log message to output
+     * @param data - Optional data object to log (will be redacted)
+     */
+    log(message, data) {
+        if (this.shouldLog(types_1.LogLevel.LOG)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.LOG, message, processedData);
+            console.log(formatted);
+        }
+    }
+    // Raw logging methods (bypass redaction for debugging)
+    /**
+     * Log a debug message without data redaction
+     * @param message - The debug message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    debugRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.DEBUG)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.DEBUG, message, data);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log an info message without data redaction
+     * @param message - The info message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    infoRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.INFO)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.INFO, message, data);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log a warning message without data redaction
+     * @param message - The warning message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    warnRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.WARN)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.WARN, message, data);
+            console.warn(formatted);
+        }
+    }
+    /**
+     * Log an error message without data redaction
+     * @param message - The error message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    errorRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.ERROR)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.ERROR, message, data);
+            console.error(formatted);
+        }
+    }
+    /**
+     * Log a message without data redaction (always outputs unless mode is OFF)
+     * @param message - The log message to output
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    logRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.LOG)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.LOG, message, data);
+            console.log(formatted);
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/logger/environment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Environment detection utilities for logging configuration
+ * Handles automatic environment-based configuration
+ */
+import { LogMode } from '../types';
+/**
+ * Environment detection and configuration utilities
+ */
+export declare class EnvironmentDetector {
+    /**
+     * Get the normalized NODE_ENV value
+     * @returns Normalized NODE_ENV (trimmed and lowercase)
+     */
+    private static getNormalizedNodeEnv;
+    /**
+     * Determines the appropriate log mode based on NODE_ENV
+     * @returns LogMode appropriate for current environment
+     */
+    static getEnvironmentMode(): LogMode;
+    /**
+     * Check if we're in a test environment
+     * @returns true if NODE_ENV is 'test'
+     */
+    static isTestEnvironment(): boolean;
+    /**
+     * Check if we're in a development environment
+     * @returns true if NODE_ENV is 'development'
+     */
+    static isDevelopmentEnvironment(): boolean;
+    /**
+     * Check if we're in a production environment
+     * @returns true if NODE_ENV is 'production'
+     */
+    static isProductionEnvironment(): boolean;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/logger/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/logger/environment.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC;;GAEG;AACH,qBAAa,mBAAmB;IAC5B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,IAAI,OAAO;IAiBpC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAInC;;;OAGG;IACH,MAAM,CAAC,wBAAwB,IAAI,OAAO;IAI1C;;;OAGG;IACH,MAAM,CAAC,uBAAuB,IAAI,OAAO;CAG5C"}

package/dist/logger/environment.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Environment detection utilities for logging configuration
+ * Handles automatic environment-based configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDetector = void 0;
+const types_1 = require("../types");
+/**
+ * Environment detection and configuration utilities
+ */
+class EnvironmentDetector {
+    /**
+     * Get the normalized NODE_ENV value
+     * @returns Normalized NODE_ENV (trimmed and lowercase)
+     */
+    static getNormalizedNodeEnv() {
+        return (process.env.NODE_ENV || '').trim().toLowerCase();
+    }
+    /**
+     * Determines the appropriate log mode based on NODE_ENV
+     * @returns LogMode appropriate for current environment
+     */
+    static getEnvironmentMode() {
+        const nodeEnv = EnvironmentDetector.getNormalizedNodeEnv();
+        switch (nodeEnv) {
+            case 'development':
+                return types_1.LogMode.DEBUG; // Verbose logging for development
+            case 'production':
+                return types_1.LogMode.INFO; // Important info and above for production
+            case 'staging':
+                return types_1.LogMode.WARN; // Focused logging for staging
+            case 'test':
+                return types_1.LogMode.ERROR; // Minimal logging during tests
+            default:
+                return types_1.LogMode.INFO; // Default fallback for unknown environments
+        }
+    }
+    /**
+     * Check if we're in a test environment
+     * @returns true if NODE_ENV is 'test'
+     */
+    static isTestEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'test';
+    }
+    /**
+     * Check if we're in a development environment
+     * @returns true if NODE_ENV is 'development'
+     */
+    static isDevelopmentEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'development';
+    }
+    /**
+     * Check if we're in a production environment
+     * @returns true if NODE_ENV is 'production'
+     */
+    static isProductionEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'production';
+    }
+}
+exports.EnvironmentDetector = EnvironmentDetector;

package/dist/logger/filtering.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Log level and mode filtering logic
+ * Handles the decision logic for whether messages should be logged
+ */
+import { LogLevel, LogMode } from '../types';
+/**
+ * Filtering logic for log messages based on levels and modes
+ * Determines whether a message should be output based on current configuration
+ */
+export declare class LogFilter {
+    private static readonly SEVERITY_RANKS;
+    private static readonly MODE_THRESHOLDS;
+    /**
+     * Determines if a message should be logged based on current log mode
+     * Messages are shown only if their level is appropriate for the configured mode
+     * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
+     * OFF mode disables all logging including LOG level messages
+     * @param level - The log level of the message to check
+     * @param currentMode - The current logging mode
+     * @returns true if message should be logged, false otherwise
+     */
+    static shouldLog(level: LogLevel, currentMode: LogMode): boolean;
+    /**
+     * Get the severity rank for a log level
+     * @param level - The log level to get rank for
+     * @returns Numeric severity rank
+     */
+    static getSeverityRank(level: LogLevel): number;
+    /**
+     * Get the threshold for a log mode
+     * @param mode - The log mode to get threshold for
+     * @returns Numeric threshold value
+     */
+    static getModeThreshold(mode: LogMode): number;
+}
+//# sourceMappingURL=filtering.d.ts.map

package/dist/logger/filtering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../src/logger/filtering.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE7C;;;GAGG;AACH,qBAAa,SAAS;IAElB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAMpC;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO;IAWhE;;;;OAIG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAI/C;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;CAGjD"}

package/dist/logger/filtering.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Log level and mode filtering logic
+ * Handles the decision logic for whether messages should be logged
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFilter = void 0;
+const types_1 = require("../types");
+/**
+ * Filtering logic for log messages based on levels and modes
+ * Determines whether a message should be output based on current configuration
+ */
+class LogFilter {
+    /**
+     * Determines if a message should be logged based on current log mode
+     * Messages are shown only if their level is appropriate for the configured mode
+     * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
+     * OFF mode disables all logging including LOG level messages
+     * @param level - The log level of the message to check
+     * @param currentMode - The current logging mode
+     * @returns true if message should be logged, false otherwise
+     */
+    static shouldLog(level, currentMode) {
+        // Get the severity rank for the message level
+        const messageSeverity = this.SEVERITY_RANKS[level];
+        // Get the minimum severity threshold for the current mode
+        const modeThreshold = this.MODE_THRESHOLDS[currentMode];
+        // Allow the message if its severity meets or exceeds the mode threshold
+        return messageSeverity >= modeThreshold;
+    }
+    /**
+     * Get the severity rank for a log level
+     * @param level - The log level to get rank for
+     * @returns Numeric severity rank
+     */
+    static getSeverityRank(level) {
+        return this.SEVERITY_RANKS[level];
+    }
+    /**
+     * Get the threshold for a log mode
+     * @param mode - The log mode to get threshold for
+     * @returns Numeric threshold value
+     */
+    static getModeThreshold(mode) {
+        return this.MODE_THRESHOLDS[mode];
+    }
+}
+exports.LogFilter = LogFilter;
+// Maps LogLevel values to severity ranks for consistent comparison
+LogFilter.SEVERITY_RANKS = {
+    [types_1.LogLevel.DEBUG]: 0,
+    [types_1.LogLevel.INFO]: 1,
+    [types_1.LogLevel.WARN]: 2,
+    [types_1.LogLevel.ERROR]: 3,
+    [types_1.LogLevel.LOG]: 99 // Special case - always outputs (except when OFF)
+};
+// Maps LogMode values to minimum severity rank required for output
+LogFilter.MODE_THRESHOLDS = {
+    [types_1.LogMode.DEBUG]: 0, // Shows DEBUG and above
+    [types_1.LogMode.INFO]: 1, // Shows INFO and above
+    [types_1.LogMode.WARN]: 2, // Shows WARN and above
+    [types_1.LogMode.ERROR]: 3, // Shows ERROR and above
+    [types_1.LogMode.SILENT]: 99, // Only shows LOG messages
+    [types_1.LogMode.OFF]: 100 // Shows nothing
+};

package/dist/logger/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logger module exports
+ * Provides centralized access to all logging functionality
+ */
+export { Logger } from './core';
+export { LoggerConfigManager } from './config';
+export { LogFilter } from './filtering';
+export { EnvironmentDetector } from './environment';
+export { Logger as CoreLogger } from './core';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logger/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/dist/logger/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Logger module exports
+ * Provides centralized access to all logging functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreLogger = exports.EnvironmentDetector = exports.LogFilter = exports.LoggerConfigManager = exports.Logger = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return core_1.Logger; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "LoggerConfigManager", { enumerable: true, get: function () { return config_1.LoggerConfigManager; } });
+var filtering_1 = require("./filtering");
+Object.defineProperty(exports, "LogFilter", { enumerable: true, get: function () { return filtering_1.LogFilter; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "EnvironmentDetector", { enumerable: true, get: function () { return environment_1.EnvironmentDetector; } });
+// Backward compatibility - maintain the original Logger class interface
+var core_2 = require("./core");
+Object.defineProperty(exports, "CoreLogger", { enumerable: true, get: function () { return core_2.Logger; } });

package/dist/redaction/config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Default configuration and constants for data redaction
+ * Provides comprehensive coverage of common sensitive field patterns
+ */
+import { RedactionConfig } from '../types';
+/**
+ * Default redaction configuration with comprehensive sensitive field detection
+ * Covers authentication, personal information, financial data, and internal systems
+ */
+export declare const defaultRedactionConfig: RedactionConfig;
+/**
+ * Environment-based redaction controller
+ * Determines when redaction should be disabled based on environment variables
+ */
+export declare class RedactionController {
+    /**
+     * Check if redaction should be disabled based on environment variables
+     * Development mode and explicit flags can disable redaction for debugging
+     * @returns true if redaction should be disabled, false otherwise
+     */
+    static isRedactionDisabled(): boolean;
+    /**
+     * Get environment-specific configuration overrides
+     * Allows customization through environment variables
+     * @returns Partial redaction config with environment-based overrides
+     */
+    static getEnvironmentConfig(): Partial<RedactionConfig>;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/redaction/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/redaction/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAyCpC,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAmB;IAC5B;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,IAAI,OAAO;IAUrC;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,eAAe,CAAC;CA4B1D"}

package/dist/redaction/config.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Default configuration and constants for data redaction
+ * Provides comprehensive coverage of common sensitive field patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedactionController = exports.defaultRedactionConfig = void 0;
+/**
+ * Default redaction configuration with comprehensive sensitive field detection
+ * Covers authentication, personal information, financial data, and internal systems
+ */
+exports.defaultRedactionConfig = {
+    enabled: true,
+    deepRedaction: true,
+    maxContentLength: 100,
+    redactionText: '[REDACTED]',
+    truncationText: '... [TRUNCATED]',
+    // Comprehensive list of sensitive field patterns (case-insensitive)
+    sensitiveFields: [
+        // Authentication & Security
+        'password', 'pwd', 'pass', 'passphrase',
+        'token', 'accessToken', 'refreshToken', 'bearerToken',
+        'apiKey', 'api_key', 'secret', 'secretKey', 'privateKey',
+        'auth', 'authorization', 'authToken',
+        'jwt', 'sessionId', 'session_id',
+        'cookie', 'cookies', 'csrf', 'csrfToken',
+        // Personal Information (PII)
+        'email', 'emailAddress', 'email_address',
+        'phone', 'phoneNumber', 'phone_number', 'mobile',
+        'ssn', 'socialSecurityNumber', 'social_security_number',
+        'address', 'homeAddress', 'workAddress',
+        'firstName', 'lastName', 'fullName', 'realName', 'displayName',
+        'dateOfBirth', 'dob', 'birthDate',
+        // Financial Information
+        'creditCard', 'credit_card', 'cardNumber', 'card_number',
+        'cvv', 'cvc', 'pin', 'expiryDate', 'expiry_date',
+        'bankAccount', 'bank_account', 'routingNumber',
+        // Internal/System Information
+        'internalId', 'userId', 'customerId',
+        'personalInfo', 'pii', 'sensitive',
+        'clientSecret', 'webhookSecret'
+    ],
+    // Fields that should be truncated rather than redacted
+    contentFields: [
+        'content', 'text', 'message', 'body', 'data',
+        'payload', 'response', 'request', 'description'
+    ]
+};
+/**
+ * Environment-based redaction controller
+ * Determines when redaction should be disabled based on environment variables
+ */
+class RedactionController {
+    /**
+     * Check if redaction should be disabled based on environment variables
+     * Development mode and explicit flags can disable redaction for debugging
+     * @returns true if redaction should be disabled, false otherwise
+     */
+    static isRedactionDisabled() {
+        return (process.env.NODE_ENV === 'development' ||
+            process.env.LOG_REDACTION_DISABLED === 'true' ||
+            process.env.DEBUG_FULL_PAYLOADS === 'true' ||
+            process.env.LOG_LEVEL === 'debug' ||
+            process.env.LOG_REDACTION_ENABLED === 'false');
+    }
+    /**
+     * Get environment-specific configuration overrides
+     * Allows customization through environment variables
+     * @returns Partial redaction config with environment-based overrides
+     */
+    static getEnvironmentConfig() {
+        const envConfig = {
+            enabled: !this.isRedactionDisabled()
+        };
+        // Apply environment variable overrides if they exist
+        if (process.env.LOG_MAX_CONTENT_LENGTH) {
+            const parsedLength = parseInt(process.env.LOG_MAX_CONTENT_LENGTH, 10);
+            if (!isNaN(parsedLength) && parsedLength > 0) {
+                envConfig.maxContentLength = parsedLength;
+            }
+        }
+        if (process.env.LOG_REDACTION_TEXT) {
+            envConfig.redactionText = process.env.LOG_REDACTION_TEXT;
+        }
+        if (process.env.LOG_TRUNCATION_TEXT) {
+            envConfig.truncationText = process.env.LOG_TRUNCATION_TEXT;
+        }
+        if (process.env.LOG_SENSITIVE_FIELDS) {
+            const customFields = process.env.LOG_SENSITIVE_FIELDS.split(',').map(f => f.trim());
+            envConfig.sensitiveFields = [...exports.defaultRedactionConfig.sensitiveFields, ...customFields];
+        }
+        return envConfig;
+    }
+}
+exports.RedactionController = RedactionController;

package/dist/redaction/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Redaction module exports
+ * Provides centralized access to all redaction functionality
+ */
+export { DataRedactor } from './redactor';
+export { defaultRedactionConfig, RedactionController } from './config';
+export type { RedactionConfig } from '../types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/redaction/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACvE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/dist/redaction/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Redaction module exports
+ * Provides centralized access to all redaction functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedactionController = exports.defaultRedactionConfig = exports.DataRedactor = void 0;
+var redactor_1 = require("./redactor");
+Object.defineProperty(exports, "DataRedactor", { enumerable: true, get: function () { return redactor_1.DataRedactor; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "defaultRedactionConfig", { enumerable: true, get: function () { return config_1.defaultRedactionConfig; } });
+Object.defineProperty(exports, "RedactionController", { enumerable: true, get: function () { return config_1.RedactionController; } });