Add handler for new /duration endpoint to update logger level tempora… (#383)

* Add handler for new /duration endpoint to update logger level temporarily and update OpenAPI spec

* refactor: change the new endpoint name

* Refactor POST /logging-manager to support temporary log level via  query param with duration in body; updated OpenAPI specs and README

---------

Co-authored-by: João Araújo <joao.p.araujo@feedzai.com>

Author: joaomatosdev

README.md

@@ -17,12 +17,13 @@
 The **Quarkus Logging Manager** Extension provides you endpoints to visualize and manage the
 log level of your loggers.
 
-| Endpoint                                     | Http Method |                                             Description                                              |
-|----------------------------------------------|:-----------:|:----------------------------------------------------------------------------------------------------:|
-| `/q/logging-manager`                         |    `GET`    |      Returns the list of all loggers, with information about the configured and effective level      |
-| `/q/logging-manager?loggerName={loggerName}` |    `GET`    | Returns the logger specified by this name, with information about the configured and effective level |
-| `/q/logging-manager`                         |   `POST`    |                            Changes the log level of the specified logger                             |
-| `/q/logging-manager/levels`                  |    `GET`    |                                     Get all the available level                                      |
+| Endpoint                                     | Http Method |                                                                               Description                                                                               |
+|----------------------------------------------|:-----------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| `/q/logging-manager`                         |    `GET`    |                                       Returns the list of all loggers, with information about the configured and effective level                                        |
+| `/q/logging-manager?loggerName={loggerName}` |    `GET`    |                                  Returns the logger specified by this name, with information about the configured and effective level                                   |
+| `/q/logging-manager`                         |   `POST`    |                                                              Changes the log level of the specified logger                                                              |
+| `/q/logging-manager?temporary=true`          |   `POST`    |                         Temporarily changes the log level of the specified logger for a given duration, then restores it to the original level                          |
+| `/q/logging-manager/levels`                  |    `GET`    |                                                                             Get all the available level                                                                 |
 
 ## Security
 Security of endpoints is important, and we do not want to allow unknown people to know (or worse, change!) the log levels of

deployment/src/main/java/io/quarkiverse/loggingmanager/deployment/LoggingManagerOpenAPIFilter.java

@@ -106,10 +106,13 @@ private Operation createLoggerPostOperation() {
         Map<String, Schema> properties = new LinkedHashMap<>();
         properties.put("loggerName", OASFactory.createSchema().type(List.of(Schema.SchemaType.STRING)));
         properties.put("loggerLevel", OASFactory.createSchema().ref(REF_LOGGER_LEVEL));
+        properties.put("duration", OASFactory.createSchema()
+                .type(List.of(Schema.SchemaType.INTEGER))
+                .description("Duration in seconds, used only if temporary=true"));
         return OASFactory.createOperation()
                 .operationId("logging_manager_update")
                 .summary("Update log level")
-                .description("Update a log level for a certain logger")
+                .description("Update a log level for a certain logger. Use query param `temporary=true` for temporary level.")
                 .tags(Collections.singletonList(tag))
                 .requestBody(OASFactory.createRequestBody()
                         .content(OASFactory.createContent().addMediaType(
@@ -118,7 +121,10 @@ private Operation createLoggerPostOperation() {
                                         .type(List.of(Schema.SchemaType.OBJECT))
                                         .properties(properties)))))
                 .responses(OASFactory.createAPIResponses()
-                        .addAPIResponse("201", OASFactory.createAPIResponse().description("Created")));
+                        .addAPIResponse("201", OASFactory.createAPIResponse().description("Created"))
+                        .addAPIResponse("200", OASFactory.createAPIResponse().description("Log level already set"))
+                        .addAPIResponse("400", OASFactory.createAPIResponse().description("Invalid request"))
+                        .addAPIResponse("404", OASFactory.createAPIResponse().description("Logger not found")));
     }
 
     private PathItem createLevelsPathItem() {

runtime/src/main/java/io/quarkiverse/loggingmanager/LogController.java

@@ -107,6 +107,20 @@ public static String getEffectiveLogLevel(Logger logger) {
         return getEffectiveLogLevel(logger.getParent());
     }
 
+    public static boolean doesLoggerExist(String loggerName) {
+        LogContext logContext = LogContext.getLogContext();
+        Enumeration<String> loggerNames = logContext.getLoggerNames();
+
+        while (loggerNames.hasMoreElements()) {
+            String existingLoggerName = loggerNames.nextElement();
+            if (existingLoggerName.equals(loggerName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     public static final List<String> LEVELS = List.of(
             OFF.getName(),
             SEVERE.getName(),

runtime/src/main/java/io/quarkiverse/loggingmanager/LoggerHandler.java

@@ -4,6 +4,9 @@
 import static io.vertx.core.http.HttpMethod.POST;
 
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.jboss.logmanager.LogContext;
 
 import io.vertx.core.Handler;
 import io.vertx.core.http.HttpMethod;
@@ -18,6 +21,20 @@
 public class LoggerHandler implements Handler<RoutingContext> {
     private static final String LOGGER_NAME_PARAM = "loggerName";
     private static final String LOGGER_LEVEL_PARAM = "loggerLevel";
+    private static final String LOGGER_DURATION = "duration";
+    private static final String TEMPORARY_ENABLED = "temporary";
+
+    private final ConcurrentHashMap<String, TemporaryLogState> temporaryStates = new ConcurrentHashMap<>();
+
+    private static class TemporaryLogState {
+        final String originalLevel;
+        long timerId;
+
+        TemporaryLogState(String originalLevel, long timerId) {
+            this.originalLevel = originalLevel;
+            this.timerId = timerId;
+        }
+    }
 
     /**
      * Handles incoming HTTP requests by delegating to appropriate method handlers.
@@ -33,15 +50,15 @@ public void handle(RoutingContext routingContext) {
         if (GET == method) {
             handleGet(request, response);
         } else if (POST == method) {
-            handlePost(request, response);
+            handlePost(request, response, routingContext);
         } else {
             response.setStatusCode(405).end(); // Method not allowed
         }
     }
 
     /**
-     * Handles GET requests to retrieve logger information.
-     * Returns all loggers if no logger name is specified, or details for a specific logger.
+     * Handles GET requests to retrieve logger information. Returns all loggers if no logger name is specified, or
+     * details for a specific logger.
      *
      * @param request The HTTP request
      * @param response The HTTP response
@@ -58,13 +75,13 @@ private void handleGet(HttpServerRequest request, HttpServerResponse response) {
     }
 
     /**
-     * Handles POST requests to update logger levels.
-     * Updates the specified logger with the provided level or removes the level if none specified.
+     * Handles POST requests to update logger levels. Updates the specified logger with the provided level or removes
+     * the level if none specified.
      *
      * @param request The HTTP request
      * @param response The HTTP response
      */
-    private void handlePost(HttpServerRequest request, HttpServerResponse response) {
+    private void handlePost(HttpServerRequest request, HttpServerResponse response, RoutingContext routingContext) {
         String contentType = request.getHeader("Content-Type");
         if (!"application/x-www-form-urlencoded".equals(contentType)) {
             response.setStatusCode(415).end();
@@ -74,6 +91,14 @@ private void handlePost(HttpServerRequest request, HttpServerResponse response)
         String loggerName = request.getFormAttribute(LOGGER_NAME_PARAM);
         String loggerLevel = request.getFormAttribute(LOGGER_LEVEL_PARAM);
 
+        String temporaryEnabled = request.getParam(TEMPORARY_ENABLED);
+
+        if ("true".equalsIgnoreCase(temporaryEnabled)) {
+            String loggerDuration = request.getFormAttribute(LOGGER_DURATION);
+            handleTemporaryPost(loggerName, loggerLevel, loggerDuration, routingContext, response);
+            return;
+        }
+
         if (loggerLevel == null || loggerLevel.isEmpty()) {
             LogController.updateLogLevel(loggerName, null);
         } else {
@@ -82,4 +107,68 @@ private void handlePost(HttpServerRequest request, HttpServerResponse response)
 
         response.setStatusCode(201).end();
     }
-}
+
+    /**
+     * Handles POST requests to update logger levels temporarily. Updates the specified logger to the provided level
+     * for a given duration, then restores the original level automatically.
+     *
+     * @param loggerName The name of the logger to update
+     * @param loggerLevel The new temporary log level
+     * @param loggerDuration Duration in seconds for which the temporary level should apply
+     * @param routingContext The Vert.x routing context
+     * @param response The HTTP response
+     */
+    private void handleTemporaryPost(
+            String loggerName,
+            String loggerLevel,
+            String loggerDuration,
+            RoutingContext routingContext,
+            HttpServerResponse response) {
+
+        if (loggerLevel == null || !LogController.LEVELS.contains(loggerLevel.toUpperCase())) {
+            response.setStatusCode(400).end("{\"error\":\"Invalid logger level\"}");
+            return;
+        }
+
+        if (!LogController.doesLoggerExist(loggerName)) {
+            response.setStatusCode(404).end("{\"error\":\"Logger '" + loggerName + "' not found\"}");
+            return;
+        }
+
+        int durationSeconds;
+        try {
+            durationSeconds = Integer.parseInt(loggerDuration);
+            if (durationSeconds <= 0)
+                throw new NumberFormatException();
+        } catch (NumberFormatException e) {
+            response.setStatusCode(400).end("{\"error\":\"Duration must be a positive integer\"}");
+            return;
+        }
+
+        String currentLevel = LogController.getConfiguredLogLevel(LogContext.getLogContext().getLogger(loggerName));
+        TemporaryLogState previousState = temporaryStates.get(loggerName);
+
+        if (loggerLevel.equalsIgnoreCase(currentLevel) && previousState == null) {
+            response.setStatusCode(200).end("{\"message\":\"Log level already set to " + loggerLevel + "\"}");
+            return;
+        }
+
+        if (previousState != null) {
+            routingContext.vertx().cancelTimer(previousState.timerId);
+        }
+
+        String originalLevel = previousState != null ? previousState.originalLevel : currentLevel;
+
+        LogController.updateLogLevel(loggerName, loggerLevel);
+
+        long timerId = routingContext.vertx().setTimer(durationSeconds * 1000L, id -> {
+            LogController.updateLogLevel(loggerName, originalLevel);
+            temporaryStates.remove(loggerName);
+        });
+
+        temporaryStates.put(loggerName, new TemporaryLogState(originalLevel, timerId));
+
+        response.setStatusCode(201)
+                .end("{\"message\":\"Temporary log level '" + loggerLevel + "' set for " + durationSeconds + " seconds\"}");
+    }
+}