@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/spec/mock-project/dist/src/FlinkLogFactory.js

@@ -0,0 +1,617 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlinkLogFactory = exports.ComponentLogger = void 0;
+var node_color_log_1 = __importDefault(require("node-color-log"));
+var LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+/**
+ * Component-specific logger with independent log level control
+ */
+var ComponentLogger = /** @class */ (function () {
+    function ComponentLogger(componentName) {
+        this.componentLevel = null;
+        this.componentName = componentName;
+        this.namedLogger = node_color_log_1.default.createNamedLogger(componentName);
+    }
+    /**
+     * Set log level for this specific component.
+     * Overrides the global log level.
+     */
+    ComponentLogger.prototype.setLevel = function (level) {
+        this.componentLevel = level;
+    };
+    /**
+     * Clear component-specific level and fall back to global level
+     */
+    ComponentLogger.prototype.clearLevel = function () {
+        this.componentLevel = null;
+    };
+    /**
+     * Check if a message should be logged based on component and global levels
+     */
+    ComponentLogger.prototype.shouldLog = function (messageLevel) {
+        var _a;
+        var effectiveLevel = (_a = this.componentLevel) !== null && _a !== void 0 ? _a : FlinkLogFactory.getGlobalLevel();
+        return LOG_LEVELS[messageLevel] >= LOG_LEVELS[effectiveLevel];
+    };
+    ComponentLogger.prototype.trace = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("trace")) {
+            // node-color-log doesn't support trace, use console.log for stdout
+            var timestamp = new Date().toISOString();
+            console.log.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [TRACE]")], args, false));
+        }
+    };
+    ComponentLogger.prototype.debug = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            (_a = this.namedLogger).debug.apply(_a, args);
+        }
+    };
+    ComponentLogger.prototype.info = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("info")) {
+            (_a = this.namedLogger).info.apply(_a, args);
+        }
+    };
+    ComponentLogger.prototype.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("warn")) {
+            // Use console.warn to write to stderr (Unix/POSIX best practice)
+            var timestamp = new Date().toISOString();
+            console.warn.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [WARN]")], args, false));
+        }
+    };
+    ComponentLogger.prototype.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("error")) {
+            // Use console.error to write to stderr (Unix/POSIX best practice)
+            var timestamp = new Date().toISOString();
+            console.error.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [ERROR]")], args, false));
+        }
+    };
+    ComponentLogger.prototype.json = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
+                var o = args_1[_a];
+                console.log(JSON.stringify(o, null, 2));
+            }
+        }
+    };
+    ComponentLogger.prototype.bgColorLog = function (color) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            (_a = this.namedLogger).bgColorLog.apply(_a, __spreadArray([color], args, false));
+        }
+    };
+    ComponentLogger.prototype.fontColorLog = function (color) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (this.shouldLog("info")) {
+            (_a = this.namedLogger).fontColorLog.apply(_a, __spreadArray([color], args, false));
+        }
+    };
+    return ComponentLogger;
+}());
+exports.ComponentLogger = ComponentLogger;
+/**
+ * Factory for creating component-specific loggers with hierarchical level control
+ */
+var FlinkLogFactory = /** @class */ (function () {
+    function FlinkLogFactory() {
+    }
+    /**
+     * Set the global log level (affects all loggers without component-specific levels)
+     */
+    FlinkLogFactory.setGlobalLevel = function (level) {
+        FlinkLogFactory.globalLevel = level;
+        // node-color-log doesn't support trace, so use debug as the effective level
+        var effectiveLevel = level === "trace" ? "debug" : level;
+        node_color_log_1.default.setLevel(effectiveLevel);
+    };
+    /**
+     * Get the current global log level
+     */
+    FlinkLogFactory.getGlobalLevel = function () {
+        return FlinkLogFactory.globalLevel;
+    };
+    /**
+     * Get all registered loggers (useful for debugging)
+     */
+    FlinkLogFactory.getLoggers = function () {
+        return FlinkLogFactory.loggers;
+    };
+    /**
+     * Clear all component-specific log levels (fall back to global)
+     */
+    FlinkLogFactory.resetComponentLevels = function () {
+        FlinkLogFactory.componentConfigs = {};
+        for (var _i = 0, _a = Array.from(FlinkLogFactory.loggers.values()); _i < _a.length; _i++) {
+            var logger = _a[_i];
+            logger.clearLevel();
+        }
+    };
+    /**
+     * Clear all hierarchical prefix configurations
+     */
+    FlinkLogFactory.resetHierarchicalLevels = function () {
+        FlinkLogFactory.hierarchicalConfigs = [];
+    };
+    /**
+     * Clear all wildcard pattern configurations
+     */
+    FlinkLogFactory.resetWildcardLevels = function () {
+        FlinkLogFactory.wildcardConfigs = [];
+    };
+    /**
+     * Set log level for a specific component by name (exact match)
+     */
+    FlinkLogFactory.setComponentLevel = function (componentName, level) {
+        var normalized = FlinkLogFactory.normalize(componentName);
+        if (level === null) {
+            // Remove exact match configuration
+            delete FlinkLogFactory.componentConfigs[normalized];
+            var logger = FlinkLogFactory.loggers.get(normalized);
+            if (logger) {
+                logger.clearLevel();
+            }
+        }
+        else {
+            // Set exact match configuration
+            FlinkLogFactory.componentConfigs[normalized] = level;
+            var logger = FlinkLogFactory.loggers.get(normalized);
+            if (logger) {
+                logger.setLevel(level);
+            }
+        }
+    };
+    /**
+     * Set hierarchical prefix-based log level (Java-style)
+     * @param prefix Logger name prefix (e.g., "flink.ai" matches all "flink.ai.*")
+     * @param level Log level to apply
+     *
+     * @example
+     * FlinkLogFactory.setHierarchicalLevel("flink.ai", "debug");
+     * // Now all loggers starting with "flink.ai." will use debug level
+     * // This includes the exact match "flink.ai" AND all children "flink.ai.*"
+     */
+    FlinkLogFactory.setHierarchicalLevel = function (prefix, level) {
+        var normalized = FlinkLogFactory.normalize(prefix);
+        // Ensure prefix ends with dot for consistent matching
+        var prefixWithDot = normalized.endsWith(".") ? normalized : normalized + ".";
+        var specificity = FlinkLogFactory.calculatePrefixSpecificity(normalized);
+        // Remove existing config for this prefix if it exists
+        FlinkLogFactory.hierarchicalConfigs = FlinkLogFactory.hierarchicalConfigs.filter(function (c) { return c.prefix !== prefixWithDot; });
+        // Add new config
+        FlinkLogFactory.hierarchicalConfigs.push({
+            prefix: prefixWithDot,
+            level: level,
+            specificity: specificity,
+        });
+        // Also set exact match for the prefix itself (without trailing dot)
+        // This ensures "flink.ai.openai" matches when using setHierarchicalLevel("flink.ai.openai", "debug")
+        FlinkLogFactory.componentConfigs[normalized] = level;
+        // Sort by specificity (most specific first) for efficient matching
+        FlinkLogFactory.hierarchicalConfigs.sort(function (a, b) { return b.specificity - a.specificity; });
+    };
+    /**
+     * Set wildcard pattern-based log level (advanced)
+     * @param pattern Wildcard pattern (e.g., "flink.ai.*" or "flink.ai.**")
+     * @param level Log level to apply
+     *
+     * @example
+     * FlinkLogFactory.setWildcardLevel("flink.ai.*", "debug");
+     * // Matches flink.ai.openai but NOT flink.ai.openai.v4
+     *
+     * FlinkLogFactory.setWildcardLevel("flink.ai.**", "trace");
+     * // Matches any depth under flink.ai.
+     */
+    FlinkLogFactory.setWildcardLevel = function (pattern, level) {
+        var normalized = FlinkLogFactory.normalize(pattern);
+        var specificity = FlinkLogFactory.calculateWildcardSpecificity(normalized);
+        // Remove existing config for this pattern if it exists
+        FlinkLogFactory.wildcardConfigs = FlinkLogFactory.wildcardConfigs.filter(function (c) { return c.pattern !== normalized; });
+        // Add new config
+        FlinkLogFactory.wildcardConfigs.push({
+            pattern: normalized,
+            level: level,
+            specificity: specificity,
+        });
+        // Sort by specificity (most specific first) for efficient matching
+        FlinkLogFactory.wildcardConfigs.sort(function (a, b) { return b.specificity - a.specificity; });
+    };
+    /**
+     * Get the effective log level for a component (resolved through hierarchy)
+     * @param componentName Component name to check
+     * @returns Resolved log level or null if only global level applies
+     */
+    FlinkLogFactory.getEffectiveLevel = function (componentName) {
+        return FlinkLogFactory.resolveComponentLevel(componentName);
+    };
+    /**
+     * Initialize logging from environment variables and/or configuration
+     *
+     * Supports multiple environment variable conventions:
+     * 1. LOG_LEVEL=debug - Set global level
+     * 2. DEBUG=flink.ai,flink.database - Enable debug for hierarchies (Java-style)
+     * 3. LOG_LEVEL_OPENAI=debug - Component-specific level (format: LOG_LEVEL_{COMPONENT})
+     * 4. LOG_LEVELS=flink.ai:debug,flink.database:warn - Hierarchical or exact matches (Java-style)
+     * 5. LOG_LEVELS=flink.ai.*:debug - Wildcard patterns (advanced)
+     *
+     * @param config Optional logging configuration (overrides environment)
+     *
+     * @example
+     * ```typescript
+     * // In FlinkApp constructor
+     * FlinkLogFactory.configure({
+     *   global: "info",
+     *   components: { "flink.ai.openai": "trace" },
+     *   hierarchical: [{ prefix: "flink.ai.", level: "debug", specificity: 2 }]
+     * });
+     * ```
+     */
+    FlinkLogFactory.configure = function (config) {
+        if (FlinkLogFactory.initialized) {
+            return; // Only initialize once
+        }
+        // 1. Parse environment variables first (lowest priority)
+        var envConfig = FlinkLogFactory.parseEnvironment();
+        // 2. Merge with provided config (higher priority)
+        var finalConfig = {
+            global: (config === null || config === void 0 ? void 0 : config.global) || envConfig.global || "info",
+            components: __assign(__assign({}, envConfig.components), config === null || config === void 0 ? void 0 : config.components),
+            hierarchical: __spreadArray(__spreadArray([], (envConfig.hierarchical || []), true), ((config === null || config === void 0 ? void 0 : config.hierarchical) || []), true),
+            wildcards: __spreadArray(__spreadArray([], (envConfig.wildcards || []), true), ((config === null || config === void 0 ? void 0 : config.wildcards) || []), true),
+        };
+        // 3. Apply global level
+        if (finalConfig.global) {
+            FlinkLogFactory.setGlobalLevel(finalConfig.global);
+        }
+        // 4. Store component configs for later (when loggers are created)
+        FlinkLogFactory.componentConfigs = finalConfig.components || {};
+        // 5. Store hierarchical configs (sorted by specificity)
+        FlinkLogFactory.hierarchicalConfigs = (finalConfig.hierarchical || []).sort(function (a, b) { return b.specificity - a.specificity; });
+        // 6. Store wildcard configs (sorted by specificity)
+        FlinkLogFactory.wildcardConfigs = (finalConfig.wildcards || []).sort(function (a, b) { return b.specificity - a.specificity; });
+        FlinkLogFactory.initialized = true;
+    };
+    /**
+     * Parse logging configuration from environment variables
+     */
+    FlinkLogFactory.parseEnvironment = function () {
+        var config = {
+            components: {},
+            hierarchical: [],
+            wildcards: [],
+        };
+        // 1. Global level: LOG_LEVEL=debug
+        if (process.env.LOG_LEVEL) {
+            var level = process.env.LOG_LEVEL.toLowerCase();
+            if (FlinkLogFactory.isValidLogLevel(level)) {
+                config.global = level;
+            }
+        }
+        // 2. Debug shorthand: DEBUG=flink.ai,flink.database (Java-style prefix matching)
+        if (process.env.DEBUG) {
+            var components = process.env.DEBUG.split(",").map(function (c) { return c.trim(); });
+            for (var _i = 0, components_1 = components; _i < components_1.length; _i++) {
+                var component = components_1[_i];
+                if (component && component !== "*") {
+                    var normalized = FlinkLogFactory.normalize(component);
+                    // Check if it's a hierarchical prefix (contains dots)
+                    if (normalized.includes(".")) {
+                        var prefixWithDot = normalized.endsWith(".") ? normalized : normalized + ".";
+                        config.hierarchical.push({
+                            prefix: prefixWithDot,
+                            level: "debug",
+                            specificity: FlinkLogFactory.calculatePrefixSpecificity(normalized),
+                        });
+                    }
+                    else {
+                        // Simple name without dots - treat as exact match
+                        config.components[normalized] = "debug";
+                    }
+                }
+                else if (component === "*") {
+                    config.global = "debug";
+                }
+            }
+        }
+        // 3. Component-specific: LOG_LEVEL_OPENAI=debug
+        for (var _a = 0, _b = Object.entries(process.env); _a < _b.length; _a++) {
+            var _c = _b[_a], key = _c[0], value = _c[1];
+            if (key.startsWith("LOG_LEVEL_") && value) {
+                var componentName = key.replace("LOG_LEVEL_", "");
+                var level = value.toLowerCase();
+                if (FlinkLogFactory.isValidLogLevel(level)) {
+                    // Convert to lowercase dot notation
+                    var normalizedName = FlinkLogFactory.normalize(componentName);
+                    config.components[normalizedName] = level;
+                }
+            }
+        }
+        // 4. Multiple components: LOG_LEVELS=flink.ai:debug,flink.database:warn (Java-style)
+        if (process.env.LOG_LEVELS) {
+            var pairs = process.env.LOG_LEVELS.split(",");
+            for (var _d = 0, pairs_1 = pairs; _d < pairs_1.length; _d++) {
+                var pair = pairs_1[_d];
+                var parts = pair.split(":");
+                if (parts.length !== 2)
+                    continue;
+                var componentOrPattern = parts[0].trim();
+                var level = parts[1].trim().toLowerCase();
+                if (!FlinkLogFactory.isValidLogLevel(level))
+                    continue;
+                var normalized = FlinkLogFactory.normalize(componentOrPattern);
+                if (normalized.includes("*")) {
+                    // Wildcard pattern (e.g., "flink.ai.*" or "flink.ai.**")
+                    config.wildcards.push({
+                        pattern: normalized,
+                        level: level,
+                        specificity: FlinkLogFactory.calculateWildcardSpecificity(normalized),
+                    });
+                }
+                else if (normalized.endsWith(".")) {
+                    // Explicit prefix (ends with dot)
+                    config.hierarchical.push({
+                        prefix: normalized,
+                        level: level,
+                        specificity: FlinkLogFactory.calculatePrefixSpecificity(normalized),
+                    });
+                }
+                else if (normalized.includes(".")) {
+                    // Ambiguous: could be exact or prefix
+                    // Strategy: Store BOTH exact and hierarchical
+                    // Exact match will be checked first, so if logger exists it wins
+                    // Otherwise hierarchical prefix will match child loggers
+                    config.components[normalized] = level;
+                    var prefixWithDot = normalized + ".";
+                    config.hierarchical.push({
+                        prefix: prefixWithDot,
+                        level: level,
+                        specificity: FlinkLogFactory.calculatePrefixSpecificity(normalized),
+                    });
+                }
+                else {
+                    // Simple name (no dots) - exact match only
+                    config.components[normalized] = level;
+                }
+            }
+        }
+        return config;
+    };
+    /**
+     * Normalize logger name to lowercase (Java-style convention)
+     * @param name Logger name or pattern
+     * @returns Normalized lowercase name
+     */
+    FlinkLogFactory.normalize = function (name) {
+        return name.toLowerCase();
+    };
+    /**
+     * Determine if a name should be treated as a hierarchical prefix
+     * @param name Normalized logger name
+     * @returns True if it should be treated as a prefix
+     */
+    FlinkLogFactory.shouldTreatAsPrefix = function (name) {
+        // Default: if name contains dots, treat as hierarchical prefix
+        // This covers the common case where "flink.ai" should match "flink.ai.*"
+        return name.includes(".");
+    };
+    /**
+     * Calculate specificity for prefix matching
+     * More specific prefixes (more segments) have higher specificity
+     * @param prefix Prefix string (may or may not end with dot)
+     * @returns Specificity score (number of segments)
+     */
+    FlinkLogFactory.calculatePrefixSpecificity = function (prefix) {
+        // Remove trailing dot if present
+        var normalized = prefix.endsWith(".") ? prefix.slice(0, -1) : prefix;
+        // Count dot-separated segments
+        return normalized.split(".").filter(function (s) { return s.length > 0; }).length;
+    };
+    /**
+     * Calculate specificity for wildcard patterns
+     * More specific patterns (more non-wildcard segments) have higher specificity
+     * For same segment count, * (single-level) is more specific than ** (multi-level)
+     * @param pattern Wildcard pattern
+     * @returns Specificity score (base + decimal for wildcard type)
+     */
+    FlinkLogFactory.calculateWildcardSpecificity = function (pattern) {
+        var segments = pattern.split(".");
+        var nonWildcardCount = segments.filter(function (seg) { return seg !== "*" && seg !== "**" && seg.length > 0; }).length;
+        // Base specificity: number of non-wildcard segments
+        var specificity = nonWildcardCount * 10;
+        // Add fractional specificity based on wildcard type
+        // * (single-level) = more specific than ** (multi-level)
+        if (pattern.includes("*")) {
+            if (pattern.includes("**")) {
+                specificity += 1; // ** is less specific
+            }
+            else {
+                specificity += 5; // * is more specific
+            }
+        }
+        return specificity;
+    };
+    /**
+     * Resolve component log level through hierarchical matching
+     * Order of precedence (highest to lowest):
+     * 1. Exact match
+     * 2. Most specific prefix match
+     * 3. Less specific prefix match
+     * 4. Wildcard pattern match
+     * 5. null (falls back to global level)
+     *
+     * @param componentName Component name to resolve
+     * @returns Resolved log level or null
+     */
+    FlinkLogFactory.resolveComponentLevel = function (componentName) {
+        var normalized = FlinkLogFactory.normalize(componentName);
+        // 1. Try exact match first (O(1) - fastest, highest priority)
+        if (FlinkLogFactory.componentConfigs[normalized]) {
+            return FlinkLogFactory.componentConfigs[normalized];
+        }
+        // 2. Try hierarchical prefix matches (O(n) where n = number of prefixes)
+        // Already sorted by specificity (most specific first)
+        for (var _i = 0, _a = FlinkLogFactory.hierarchicalConfigs; _i < _a.length; _i++) {
+            var config = _a[_i];
+            if (normalized.startsWith(config.prefix)) {
+                return config.level;
+            }
+        }
+        // 3. Try wildcard patterns (O(n) where n = number of patterns)
+        // Already sorted by specificity (most specific first)
+        for (var _b = 0, _c = FlinkLogFactory.wildcardConfigs; _b < _c.length; _b++) {
+            var config = _c[_b];
+            if (FlinkLogFactory.matchWildcard(normalized, config.pattern)) {
+                return config.level;
+            }
+        }
+        // 4. No match - fall back to global level
+        return null;
+    };
+    /**
+     * Simple wildcard matching for logger patterns
+     * Supports:
+     * - * matches single segment (flink.ai.* matches flink.ai.openai)
+     * - ** matches any depth (flink.ai.** matches flink.ai.openai.v4)
+     * - Partial segment match (flink.ai.open* matches flink.ai.openai)
+     *
+     * @param name Logger name to match
+     * @param pattern Wildcard pattern
+     * @returns True if pattern matches
+     */
+    FlinkLogFactory.matchWildcard = function (name, pattern) {
+        // Special handling for ** (multi-level wildcard)
+        // Need to process dots BEFORE replacing **
+        // Step 1: Escape dots first (before any other processing)
+        var regexPattern = pattern.replace(/\./g, "\\.");
+        // Step 2: Replace ** with placeholder (matches anything including dots)
+        regexPattern = regexPattern.replace(/\*\*/g, "___DOUBLE_STAR___");
+        // Step 3: Replace single * with single-segment match (non-dot chars)
+        regexPattern = regexPattern.replace(/\*/g, "[^\\.]+");
+        // Step 4: Replace ** placeholder with multi-segment match
+        regexPattern = regexPattern.replace(/___DOUBLE_STAR___/g, ".*");
+        var regex = new RegExp("^".concat(regexPattern, "$"));
+        return regex.test(name);
+    };
+    /**
+     * Check if a string is a valid log level
+     */
+    FlinkLogFactory.isValidLogLevel = function (level) {
+        return ["trace", "debug", "info", "warn", "error"].includes(level);
+    };
+    /**
+     * Create or retrieve a component-specific logger
+     * Automatically applies environment/config settings when logger is created
+     * Supports hierarchical prefix matching (Java-style)
+     *
+     * @param componentName Logger name (lowercase dot notation recommended, e.g., "flink.ai.openai")
+     * @returns ComponentLogger instance
+     *
+     * @example
+     * ```typescript
+     * // Java-style hierarchical naming (recommended)
+     * const log = FlinkLogFactory.createLogger("flink.ai.openai");
+     * const dbLog = FlinkLogFactory.createLogger("flink.database.mongodb");
+     *
+     * // Case insensitive - these create the same logger
+     * const log1 = FlinkLogFactory.createLogger("flink.ai.openai");
+     * const log2 = FlinkLogFactory.createLogger("Flink.AI.OpenAI");  // Same instance
+     * ```
+     */
+    FlinkLogFactory.createLogger = function (componentName) {
+        // Initialize from environment if not already done
+        if (!FlinkLogFactory.initialized) {
+            FlinkLogFactory.configure();
+        }
+        // Normalize to lowercase for consistent lookup
+        var normalized = FlinkLogFactory.normalize(componentName);
+        if (!FlinkLogFactory.loggers.has(normalized)) {
+            var logger = new ComponentLogger(normalized);
+            FlinkLogFactory.loggers.set(normalized, logger);
+            // Resolve level through hierarchical matching
+            var resolvedLevel = FlinkLogFactory.resolveComponentLevel(normalized);
+            if (resolvedLevel) {
+                logger.setLevel(resolvedLevel);
+            }
+        }
+        return FlinkLogFactory.loggers.get(normalized);
+    };
+    FlinkLogFactory.globalLevel = "info";
+    FlinkLogFactory.loggers = new Map();
+    FlinkLogFactory.initialized = false;
+    /**
+     * Store component configurations from environment/config for lazy application
+     */
+    FlinkLogFactory.componentConfigs = {};
+    /**
+     * Hierarchical prefix configurations (Java-style)
+     * Sorted by specificity (most specific first) for efficient matching
+     */
+    FlinkLogFactory.hierarchicalConfigs = [];
+    /**
+     * Wildcard pattern configurations (optional, advanced)
+     * Sorted by specificity (most specific first) for efficient matching
+     */
+    FlinkLogFactory.wildcardConfigs = [];
+    return FlinkLogFactory;
+}());
+exports.FlinkLogFactory = FlinkLogFactory;

package/spec/mock-project/dist/src/FlinkPlugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });