如何无需重启Vert.x应用即可在运行时修改日志级别？

Great question! You're right that modifying the vertx-default-jul-logging.properties file requires a restart since it's loaded on application startup. But there are a few practical ways to adjust log levels dynamically without restarting your Vert.x app, similar to how JBoss CLI works. Here are the most reliable approaches:

1. Build a custom endpoint to tweak JUL log levels via code #

Since Vert.x uses Java Util Logging (JUL) by default, you can directly interact with JUL's Logger API to update levels at runtime. A common pattern is to expose an HTTP endpoint in your app that accepts a logger name and desired level, then applies the change on the fly.

Here's a straightforward implementation example:

Router router = Router.router(vertx);

// Endpoint to update log levels
router.post("/api/log-level").handler(ctx -> {
    String loggerName = ctx.request().getParam("logger");
    String levelStr = ctx.request().getParam("level");
    
    if (loggerName == null || levelStr == null) {
        ctx.response().setStatusCode(400).end("Missing required parameters: 'logger' and 'level'");
        return;
    }
    
    try {
        Level targetLevel = Level.parse(levelStr.toUpperCase());
        Logger logger = Logger.getLogger(loggerName);
        
        // Update the logger's own level
        logger.setLevel(targetLevel);
        
        // Sync attached handlers to the new level (optional but recommended)
        for (Handler handler : logger.getHandlers()) {
            handler.setLevel(targetLevel);
        }
        
        ctx.response().end(String.format("Successfully updated %s log level to %s", loggerName, levelStr));
    } catch (IllegalArgumentException e) {
        ctx.response().setStatusCode(400).end("Invalid log level. Valid options: SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST");
    }
});

// Start the server to expose the endpoint
vertx.createHttpServer().requestHandler(router).listen(8080, res -> {
    if (res.succeeded()) {
        System.out.println("Log level adjustment endpoint running on port 8080");
    }
});

Once deployed, you can send a POST request like http://localhost:8080/api/log-level?logger=io.vertx&level=FINER to update log levels instantly without a restart.

2. Use JMX to manage JUL logs without custom code #

JUL has built-in JMX support, which lets you modify log levels using tools like JConsole or VisualVM. Here's how to set it up:

• Start your Vert.x app with JMX enabled by adding these JVM arguments:

  -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=9010 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false
  

• Open JConsole, connect to your app's process, and navigate to the java.util.logging MBean.
• Under the LoggerNames tab, select the logger you want to modify, then update the Level attribute. You can also adjust handler levels here if needed.

This method requires no custom code—just JVM configuration and a JMX client for ad-hoc changes.

3. Switch to Logback (with SLF4J) for automatic config reloading #

If you're open to moving away from JUL, Logback (paired with SLF4J) offers out-of-the-box automatic configuration reloading. This means you can edit your log level settings in a config file and have changes take effect within seconds, no restart required.

To set this up:

1. Add SLF4J and Logback dependencies to your project (replace any JUL-specific dependencies if present).
2. Configure Vert.x to use the SLF4J log delegate by adding this system property at startup:

   -Dvertx.logger-delegate-factory-class-name=io.vertx.core.logging.SLF4JLogDelegateFactory
   

3. Create a logback.xml file with auto-scanning enabled:

   <configuration scan="true" scanPeriod="30 seconds">
       <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
           <encoder>
               <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
           </encoder>
       </appender>
       
       <root level="INFO">
           <appender-ref ref="CONSOLE"/>
       </root>
       
       <!-- Example: Set a specific logger to FINER level -->
       <logger name="io.vertx" level="FINER"/>
   </configuration>
   

Now, whenever you edit logback.xml to adjust log levels, Logback will detect the change within 30 seconds and apply it automatically.

Each approach has its strengths: the custom endpoint gives you full control over who can modify logs, JMX is great for quick, ad-hoc changes without code, and Logback is ideal for long-term maintainability with dynamic configuration.

内容的提问来源于stack exchange，提问作者nilesh