Add configurable agent logging backend

Signed-off-by: Arnab Nandy <arnab_nandy7@yahoo.com>

Author: arnabnandy7

collector/src/main/java/io/prometheus/jmx/logger/JulLoggerBackend.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) The Prometheus jmx_exporter Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.prometheus.jmx.logger;
+
+import java.util.logging.Formatter;
+import java.util.logging.Handler;
+import java.util.logging.SimpleFormatter;
+
+/** Logging backend that delegates to Java Util Logging (JUL). */
+final class JulLoggerBackend implements LoggerBackend {
+
+    private static final String ROOT_LOGGER = "";
+
+    private final java.util.logging.Logger logger;
+
+    static {
+        configureSimpleFormatters(java.util.logging.Logger.getLogger(ROOT_LOGGER));
+    }
+
+    /**
+     * Constructs a JUL backend for the specified logger name.
+     *
+     * @param loggerName logger name
+     */
+    JulLoggerBackend(String loggerName) {
+        logger = java.util.logging.Logger.getLogger(loggerName);
+        configureSimpleFormatters(logger);
+    }
+
+    private static void configureSimpleFormatters(java.util.logging.Logger logger) {
+        for (Handler handler : logger.getHandlers()) {
+            Formatter formatter = handler.getFormatter();
+            if (formatter != null && formatter.getClass().getName().endsWith(SimpleFormatter.class.getName())) {
+                handler.setFormatter(new LoggerFormatter());
+            }
+        }
+    }
+
+    @Override
+    public boolean isEnabled(Level level) {
+        return logger.isLoggable(toJulLevel(level));
+    }
+
+    @Override
+    public void log(Level level, String message) {
+        logger.log(toJulLevel(level), message);
+    }
+
+    static java.util.logging.Level toJulLevel(Level level) {
+        switch (level) {
+            case TRACE:
+                return java.util.logging.Level.FINEST;
+            case INFO:
+                return java.util.logging.Level.INFO;
+            case WARN:
+                return java.util.logging.Level.WARNING;
+            case ERROR:
+                return java.util.logging.Level.SEVERE;
+            default:
+                throw new IllegalArgumentException("Unknown logging level: " + level);
+        }
+    }
+}

collector/src/main/java/io/prometheus/jmx/logger/Level.java

@@ -28,38 +28,23 @@ public enum Level {
      * Trace level logging. This is the most verbose level and is used for detailed debugging
      * information.
      */
-    TRACE(java.util.logging.Level.FINEST),
+    TRACE,
 
     /**
      * Info level logging. This level is used for informational messages that highlight the progress
      * of the application.
      */
-    INFO(java.util.logging.Level.INFO),
+    INFO,
 
     /**
      * Warn level logging. This level is used for potentially harmful situations that should be
      * looked at.
      */
-    WARN(java.util.logging.Level.WARNING),
+    WARN,
 
     /**
      * Error level logging. This level is used for error events that might still allow the
      * application to continue running.
      */
-    ERROR(java.util.logging.Level.SEVERE);
-
-    private final java.util.logging.Level julLevel;
-
-    Level(java.util.logging.Level julLevel) {
-        this.julLevel = julLevel;
-    }
-
-    /**
-     * Returns the corresponding {@link java.util.logging.Level} for this level.
-     *
-     * @return the java.util.logging.Level
-     */
-    public java.util.logging.Level julLevel() {
-        return julLevel;
-    }
+    ERROR
 }

collector/src/main/java/io/prometheus/jmx/logger/Logger.java

@@ -20,19 +20,17 @@
 
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.logging.Formatter;
-import java.util.logging.Handler;
-import java.util.logging.SimpleFormatter;
 
 /**
  * Logger wrapper providing simple logging with TRACE, INFO, WARN, and ERROR levels.
  *
- * <p>This class wraps {@link java.util.logging.Logger} and provides:
+ * <p>This class delegates to the configured logging backend and provides:
  *
  * <ul>
  *   <li>Simple logging interface with format strings
+ *   <li>Native logging that does not initialize Java Util Logging (JUL)
+ *   <li>Optional JUL integration
  *   <li>Developer debug mode for additional console output
- *   <li>Custom formatter for consistent log message format
  * </ul>
  *
  * <p>Developer debug mode can be enabled via:
@@ -42,15 +40,15 @@
  *   <li>System property: {@code -Djmx.prometheus.exporter.developer.debug=true}
  * </ul>
  *
- * <p>Thread-safety: This class is thread-safe. The underlying logger is thread-safe, and
- * date formatting uses a thread-safe {@link DateTimeFormatter}.
+ * <p>Thread-safety: This class is thread-safe. Logging backends are responsible for serializing
+ * writes where required, and date formatting uses a thread-safe {@link DateTimeFormatter}.
  */
 public class Logger {
 
     /**
-     * The underlying Java util logger.
+     * The configured logging backend.
      */
-    private final java.util.logging.Logger LOGGER;
+    private final LoggerBackend backend;
 
     /**
      * Cached logger name for developer debug output.
@@ -60,15 +58,15 @@ public class Logger {
     /**
      * Flag indicating if developer debug mode is enabled.
      *
-     * <p>When enabled, logs are also written to stdout in addition to the normal logging
-     * destination. Evaluated once at class load time.
+     * <p>When enabled, logs are also written to stdout in addition to the configured logging
+     * backend. Evaluated once at class load time.
      */
     private static volatile boolean DEVELOPER_DEBUG =
             "true".equals(System.getenv("JMX_PROMETHEUS_EXPORTER_DEVELOPER_DEBUG"))
                     || "true".equals(System.getProperty("jmx.prometheus.exporter.developer.debug"));
 
     /**
-     * Thread-safe date formatter for log timestamps.
+     * Thread-safe date formatter for developer debug timestamps.
      */
     private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
 
@@ -78,16 +76,8 @@ public class Logger {
      * @param clazz the class for which to create a logger, must not be {@code null}
      */
     Logger(Class<?> clazz) {
-        LOGGER = java.util.logging.Logger.getLogger(clazz.getName());
-        loggerName = LOGGER.getName();
-
-        // Override the default formatter for the logger if it is SimpleFormatter
-        for (Handler handler : LOGGER.getHandlers()) {
-            Formatter formatter = handler.getFormatter();
-            if (null != formatter && formatter.getClass().getName().endsWith(SimpleFormatter.class.getName())) {
-                handler.setFormatter(new LoggerFormatter());
-            }
-        }
+        loggerName = clazz.getName();
+        backend = LoggerFactory.createBackend(loggerName);
     }
 
     /**
@@ -96,7 +86,7 @@ public class Logger {
      * @return {@code true} if TRACE logging is enabled, {@code false} otherwise
      */
     public boolean isTraceEnabled() {
-        return LOGGER.isLoggable(Level.TRACE.julLevel());
+        return backend.isEnabled(Level.TRACE);
     }
 
     /**
@@ -105,7 +95,7 @@ public boolean isTraceEnabled() {
      * @return {@code true} if INFO logging is enabled, {@code false} otherwise
      */
     public boolean isInfoEnabled() {
-        return LOGGER.isLoggable(Level.INFO.julLevel());
+        return backend.isEnabled(Level.INFO);
     }
 
     /**
@@ -114,7 +104,7 @@ public boolean isInfoEnabled() {
      * @return {@code true} if WARN logging is enabled, {@code false} otherwise
      */
     public boolean isWarnEnabled() {
-        return LOGGER.isLoggable(Level.WARN.julLevel());
+        return backend.isEnabled(Level.WARN);
     }
 
     /**
@@ -123,7 +113,7 @@ public boolean isWarnEnabled() {
      * @return {@code true} if ERROR logging is enabled, {@code false} otherwise
      */
     public boolean isErrorEnabled() {
-        return LOGGER.isLoggable(Level.ERROR.julLevel());
+        return backend.isEnabled(Level.ERROR);
     }
 
     /**
@@ -237,15 +227,14 @@ public void error(String format, Object... objects) {
      *
      * <p>Skips {@link String#format} since the message is already a plain string.
      *
-     * @param level   the level
+     * @param level the level
      * @param message the pre-formatted message
      */
     private void log(Level level, String message) {
-        java.util.logging.Level julLevel = level.julLevel();
-        boolean loggable = LOGGER.isLoggable(julLevel);
+        boolean loggable = backend.isEnabled(level);
         boolean debug = DEVELOPER_DEBUG;
         if (loggable) {
-            LOGGER.log(julLevel, message);
+            backend.log(level, message);
         }
         if (debug) {
             developerDebug(level, message);
@@ -255,18 +244,17 @@ private void log(Level level, String message) {
     /**
      * Logs a formatted message at the given level.
      *
-     * @param level   the level
-     * @param format  the format string
+     * @param level the level
+     * @param format the format string
      * @param objects the objects to format
      */
     private void log(Level level, String format, Object... objects) {
-        java.util.logging.Level julLevel = level.julLevel();
-        boolean loggable = LOGGER.isLoggable(julLevel);
+        boolean loggable = backend.isEnabled(level);
         boolean debug = DEVELOPER_DEBUG;
         if (loggable || debug) {
             String message = format(format, objects);
             if (loggable) {
-                LOGGER.log(julLevel, message);
+                backend.log(level, message);
             }
             if (debug) {
                 developerDebug(level, message);
@@ -275,7 +263,7 @@ private void log(Level level, String format, Object... objects) {
     }
 
     /**
-     * Writes a log message to stdout with timestamp, thread, level, and logger name.
+     * Writes a developer debug message to stdout with timestamp, thread, level, and logger name.
      */
     private void developerDebug(Level level, String message) {
         String timestamp = DATE_TIME_FORMATTER.format(LocalDateTime.now());

collector/src/main/java/io/prometheus/jmx/logger/LoggerBackend.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) The Prometheus jmx_exporter Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.prometheus.jmx.logger;
+
+/** Internal logging backend used by the Logger facade. */
+interface LoggerBackend {
+
+    /**
+     * Returns whether a logging level is enabled.
+     *
+     * @param level logging level
+     * @return {@code true} when the level is enabled
+     */
+    boolean isEnabled(Level level);
+
+    /**
+     * Logs a pre-formatted message.
+     *
+     * @param level logging level
+     * @param message message to log
+     */
+    void log(Level level, String message);
+}