Use SLF4J Parameterized Logging

In this guide we'll look at using OpenRewrite to automatically refactor logging statements to take advantage of performance improvements offered by using slf4j parameterized logging over String concatenation.

Example Configuration

The ParameterizedLogging recipe has no required configuration options and can be activated directly after taking a dependency on rewrite-logging-frameworks in your build file:

This recipe has no required configuration options. It can be activated by adding a dependency on `org.openrewrite.recipe:rewrite-logging-frameworks` in your build file or by running a shell command (in which case no build changes are needed):

Gradle

1. Add the following to your build.gradle file:
   build.gradle

   plugins {
       id("org.openrewrite.rewrite") version("latest.release")
   }
   
   rewrite {
       activeRecipe("org.openrewrite.java.logging.slf4j.ParameterizedLogging")
   }
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       rewrite("org.openrewrite.recipe:rewrite-logging-frameworks:3.26.0")
   }

2. Run gradle rewriteRun to run the recipe.

Gradle init script

1. Create a file named init.gradle in the root of your project.
   init.gradle

   initscript {
       repositories {
           maven { url "https://plugins.gradle.org/m2" }
       }
       dependencies { classpath("org.openrewrite:plugin:7.28.2") }
   }
   rootProject {
       plugins.apply(org.openrewrite.gradle.RewritePlugin)
       dependencies {
           rewrite("org.openrewrite.recipe:rewrite-logging-frameworks:3.26.0")
       }
       rewrite {
           activeRecipe("org.openrewrite.java.logging.slf4j.ParameterizedLogging")
       }
       afterEvaluate {
           if (repositories.isEmpty()) {
               repositories {
                   mavenCentral()
               }
           }
       }
   }

2. Run the recipe.
   shell

   gradle --init-script init.gradle rewriteRun

Maven POM

1. Add the following to your pom.xml file:
   pom.xml

   <project>
     <build>
       <plugins>
         <plugin>
           <groupId>org.openrewrite.maven</groupId>
           <artifactId>rewrite-maven-plugin</artifactId>
           <version>6.34.0</version>
           <configuration>
             <activeRecipes>
               <recipe>org.openrewrite.java.logging.slf4j.ParameterizedLogging</recipe>
             </activeRecipes>
           </configuration>
           <dependencies>
             <dependency>
               <groupId>org.openrewrite.recipe</groupId>
               <artifactId>rewrite-logging-frameworks</artifactId>
               <version>3.26.0</version>
             </dependency>
           </dependencies>
         </plugin>
       </plugins>
     </build>
   </project>

2. Run mvn rewrite:run to run the recipe.

Maven Command Line

You will need to have Maven installed on your machine before you can run the following command.

shell

mvn -U org.openrewrite.maven:rewrite-maven-plugin:run -Drewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-logging-frameworks:RELEASE -Drewrite.activeRecipes=org.openrewrite.java.logging.slf4j.ParameterizedLogging

Moderne CLI

You will need to have configured the Moderne CLI on your machine before you can run the following command.

shell

mod run . --recipe ParameterizedLogging

If the recipe is not available locally, then you can install it using:

mod config recipes jar install org.openrewrite.recipe:rewrite-logging-frameworks:3.26.0

At this point, you're ready to execute the migration by running mvn rewrite:run or gradlew rewriteRun. After running the migration you can inspect the results with git diff (or equivalent), manually fix anything that wasn't able to be migrated automatically, and commit the results.

For the full list of changes, see the recipe's reference documentation.

Example Class (Before)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class Example {
    Logger logger = LoggerFactory.getLogger(Example.class);

    void method(String name, double percent) {
        logger.debug("Process [" + name + "] is at [" + percent * 100 + "%]");
    }

    void asInteger(String numberString) {
        try {
            Integer i = Integer.valueOf(numberString);
        } catch (NumberFormatException ex) {
            logger.warn("some big error: " + ex.getMessage(), ex);
        }
    }
}

Example Class (After)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class Example {
    Logger logger = LoggerFactory.getLogger(Example.class);

    void method(String name, double percent) {
        logger.debug("Process [{}] is at [{}%]", name, percent * 100);
    }

    void asInteger(String numberString) {
        try {
            Integer i = Integer.valueOf(numberString);
        } catch (NumberFormatException ex) {
            logger.warn("some big error: {}", ex.getMessage(), ex);
        }
    }
}

See how this recipe works across multiple open-source repositories

Run this recipe on OSS repos at scale with the Moderne SaaS.

Run this recipe here

The community edition of the Moderne platform enables you to easily run recipes across thousands of open-source repositories.

Please contact Moderne for more information about safely running the recipes on your own codebase in a private SaaS.