Merge pull request #1447 from daneshk/dynamic_log_config

Add dynamic log level change support

Author: daneshk

ballerina/Ballerina.toml

@@ -1,7 +1,7 @@
 [package]
 org = "ballerina"
 name = "log"
-version = "2.16.1"
+version = "2.17.0"
 authors = ["Ballerina"]
 keywords = ["level", "format"]
 repository = "https://github.com/ballerina-platform/module-ballerina-log"
@@ -15,18 +15,18 @@ graalvmCompatible = true
 [[platform.java21.dependency]]
 groupId = "io.ballerina.stdlib"
 artifactId = "log-native"
-version = "2.16.1"
-path = "../native/build/libs/log-native-2.16.1.jar"
+version = "2.17.0"
+path = "../native/build/libs/log-native-2.17.0-SNAPSHOT.jar"
 
 [[platform.java21.dependency]]
 groupId = "io.ballerina.stdlib"
 artifactId = "log-compiler-plugin"
-version = "2.16.1"
-path = "../compiler-plugin/build/libs/log-compiler-plugin-2.16.1.jar"
+version = "2.17.0"
+path = "../compiler-plugin/build/libs/log-compiler-plugin-2.17.0-SNAPSHOT.jar"
 
 [[platform.java21.dependency]]
 groupId = "io.ballerina.stdlib"
 artifactId = "log-test-utils"
-version = "2.16.1"
-path = "../test-utils/build/libs/log-test-utils-2.16.1.jar"
+version = "2.17.0"
+path = "../test-utils/build/libs/log-test-utils-2.17.0-SNAPSHOT.jar"
 scope = "testOnly"

ballerina/CompilerPlugin.toml

@@ -3,4 +3,4 @@ id = "log-compiler-plugin"
 class = "io.ballerina.stdlib.log.compiler.LogCompilerPlugin"
 
 [[dependency]]
-path = "../compiler-plugin/build/libs/log-compiler-plugin-2.16.1.jar"
+path = "../compiler-plugin/build/libs/log-compiler-plugin-2.17.0-SNAPSHOT.jar"

ballerina/Dependencies.toml

@@ -88,7 +88,7 @@ modules = [
 [[package]]
 org = "ballerina"
 name = "log"
-version = "2.16.1"
+version = "2.17.0"
 dependencies = [
 	{org = "ballerina", name = "io"},
 	{org = "ballerina", name = "jballerina.java"},

ballerina/README.md

@@ -151,6 +151,41 @@ The log module supports contextual logging, allowing you to create loggers with
 
 For more details and advanced usage, see the module specification and API documentation.
 
+### Runtime Log Level Modification
+
+The log module supports modifying log levels at runtime without restarting the application. All loggers created via `fromConfig` are registered in a logger registry with a unique ID and can be discovered and updated at runtime.
+
+```ballerina
+// Create a logger with an explicit ID
+log:Logger paymentLogger = check log:fromConfig(id = "payment-service", level = log:INFO);
+
+// Change the level at runtime
+check paymentLogger.setLevel(log:DEBUG);
+log:Level current = paymentLogger.getLevel(); // DEBUG
+```
+
+The logger registry provides a way to discover and manage all registered loggers:
+
+```ballerina
+log:LoggerRegistry registry = log:getLoggerRegistry();
+
+// List all registered logger IDs
+string[] ids = registry.getIds();
+// e.g., ["root", "myorg/payment:payment-service", "myorg/payment:init"]
+
+// Look up a logger by ID and update its level
+log:Logger? logger = registry.getById("myorg/payment:payment-service");
+if logger is log:Logger {
+    check logger.setLevel(log:DEBUG);
+}
+```
+
+The registry contains:
+- `"root"` — the global root logger
+- All loggers created via `fromConfig` (module-prefixed user IDs or auto-generated IDs)
+
+> **Note:** Per-module log levels configured via `[[ballerina.log.modules]]` in `Config.toml` are static — they apply at startup and cannot be changed at runtime through the registry. Child loggers (created via `withContext`) are also not registered and always inherit their level from the parent.
+
 ### Sensitive Data Masking
 
 The log module provides capabilities to mask sensitive data in log messages to maintain data privacy and security when dealing with personally identifiable information (PII) or other sensitive data.

ballerina/init.bal

@@ -21,6 +21,18 @@ function init() returns error? {
     rootLogger = new RootLogger();
     check validateDestinations(destinations);
     setModule();
+
+    // Register the global root logger in the registry
+    lock {
+        loggerRegistry["root"] = rootLogger;
+    }
+
+    // Populate the Java-side ConcurrentHashMap with per-module level overrides so that
+    // RootLogger.print() can do a lock-free level lookup on the hot logging path.
+    // Module loggers are intentionally NOT registered in the Ballerina-side LoggerRegistry.
+    foreach Module mod in modules {
+        setModuleLevelNative(mod.name, mod.level);
+    }
 }
 
 isolated function validateDestinations(OutputDestination[] destinations) returns Error? {

ballerina/logger.bal

@@ -53,4 +53,20 @@ public type Logger isolated object {
    # + keyValues - The key-value pairs to be added to the logger context
    # + return - A new Logger instance with the given key-values added to its context
    public isolated function withContext(*KeyValues keyValues) returns Logger|error;
+
+   # Returns the effective log level of this logger.
+   # For root and custom loggers, returns the explicitly set level.
+   # For child loggers (created via `withContext`), returns the inherited level from the parent logger.
+   #
+   # + return - The effective log level
+   public isolated function getLevel() returns Level;
+
+   # Sets the log level of this logger at runtime.
+   # This is supported on root loggers, module loggers, and loggers created via `fromConfig`.
+   # Child loggers (created via `withContext`) do not support this operation and will return an error.
+   # To change a child logger's effective level, set the level on its parent logger instead.
+   #
+   # + level - The new log level to set
+   # + return - An error if the operation is not supported, nil on success
+   public isolated function setLevel(Level level) returns error?;
 };

ballerina/natives.bal

@@ -468,14 +468,17 @@ isolated function replaceString(handle receiver, handle target, handle replaceme
     paramTypes: ["java.lang.CharSequence", "java.lang.CharSequence"]
 } external;
 
-isolated function isLogLevelEnabled(string loggerLogLevel, string logLevel, string moduleName) returns boolean {
-    string moduleLogLevel = loggerLogLevel;
-    if modules.length() > 0 {
-        if modules.hasKey(moduleName) {
-            moduleLogLevel = modules.get(moduleName).level;
-        }
-    }
-    return logLevelWeight.get(logLevel) >= logLevelWeight.get(moduleLogLevel);
+final readonly & map<int> LOG_LEVEL_WEIGHT = {
+    "ERROR": 1000,
+    "WARN": 900,
+    "INFO": 800,
+    "DEBUG": 700
+};
+
+isolated function isLevelEnabled(string effectiveLevel, string logLevel) returns boolean {
+    int requestedWeight = LOG_LEVEL_WEIGHT[logLevel] ?: 0;
+    int effectiveWeight = LOG_LEVEL_WEIGHT[effectiveLevel] ?: 800;
+    return requestedWeight >= effectiveWeight;
 }
 
 isolated function getModuleName(KeyValues keyValues, int offset = 2) returns string {
@@ -492,3 +495,20 @@ isolated function getCurrentFileSize(string filePath) returns int = @java:Method
 isolated function getTimeSinceLastRotation(string filePath, string policy, int maxFileSize, int maxAgeInMillis, int maxBackupFiles) returns int = @java:Method {'class: "io.ballerina.stdlib.log.Utils"} external;
 
 isolated function rotateLog(string filePath, string policy, int maxFileSize, int maxAgeInMillis, int maxBackupFiles) returns error? = @java:Method {'class: "io.ballerina.stdlib.log.Utils"} external;
+
+// ========== Internal native function declarations for runtime log configuration ==========
+
+isolated function generateLoggerIdNative(int stackOffset) returns string = @java:Method {
+    'class: "io.ballerina.stdlib.log.LogConfigManager",
+    name: "generateLoggerId"
+} external;
+
+isolated function getModuleLevelNative(string moduleName) returns Level? = @java:Method {
+    'class: "io.ballerina.stdlib.log.LogConfigManager",
+    name: "getModuleLevel"
+} external;
+
+isolated function setModuleLevelNative(string moduleName, Level level) = @java:Method {
+    'class: "io.ballerina.stdlib.log.LogConfigManager",
+    name: "setModuleLevel"
+} external;