SLF4J Logging Best Practices

To apply SLF4J logging best practices to your codebase, you can use the OpenRewrite recipe org.openrewrite.java.logging.slf4j.Slf4jBestPractices from rewrite-logging-frameworks.

This recipe applies a comprehensive set of logging best practices including parameterized logging, proper logger declarations, and other common SLF4J usage patterns that improve performance and maintainability.

You can run the migration recipe using one of the following methods.

Moderne CLI

The Moderne CLI allows you to run OpenRewrite recipes on your project without needing to modify your build files, against serialized Lossless Semantic Tree (LST) of your project for a considerable performance boost & across projects.

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

1. If project serialized Lossless Semantic Tree is not yet available locally, then build the LST. This is only needed the first time, or after extensive changes:
   shell

   mod build ~/workspace/

2. If the recipe is not available locally yet, then you can install it once using:
   shell

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

3. Run the recipe.
   shell

   mod run ~/workspace/ --recipe org.openrewrite.java.logging.slf4j.Slf4jBestPractices

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 --define rewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-logging-frameworks:RELEASE --define rewrite.activeRecipes=org.openrewrite.java.logging.slf4j.Slf4jBestPractices --define rewrite.exportDatatables=true

Maven POM

You may add the plugin to your pom.xml file, so that it is available for all developers and CI/CD pipelines.

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>LATEST</version>
           <configuration>
             <exportDatatables>true</exportDatatables>
             <activeRecipes>
               <recipe>org.openrewrite.java.logging.slf4j.Slf4jBestPractices</recipe>
             </activeRecipes>
           </configuration>
           <dependencies>
             <dependency>
               <groupId>org.openrewrite.recipe</groupId>
               <artifactId>rewrite-logging-frameworks</artifactId>
               <version>LATEST</version>
             </dependency>
           </dependencies>
         </plugin>
       </plugins>
     </build>
   </project>

2. Run the recipe.
   shell

   mvn rewrite:run

Gradle init script

Gradle init scripts are a good way to try out a recipe without modifying your build.gradle file.

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:latest.release") }
   }
   rootProject {
       plugins.apply(org.openrewrite.gradle.RewritePlugin)
       dependencies {
           rewrite("org.openrewrite.recipe:rewrite-logging-frameworks:latest.release")
       }
       rewrite {
           activeRecipe("org.openrewrite.java.logging.slf4j.Slf4jBestPractices")
           setExportDatatables(true)
       }
       afterEvaluate {
           if (repositories.isEmpty()) {
               repositories {
                   mavenCentral()
               }
           }
       }
   }

2. Run the recipe.
   shell

   gradle --init-script init.gradle rewriteRun

Gradle init script (Kotlin)

Gradle init scripts are a good way to try out a recipe without modifying your build.gradle.kts file.

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

   initscript {
       repositories {
           maven { url = uri("https://plugins.gradle.org/m2") }
       }
       dependencies { classpath("org.openrewrite:plugin:latest.release") }
   }
   rootProject {
       plugins.apply(org.openrewrite.gradle.RewritePlugin::class.java)
       dependencies {
           add("rewrite", "org.openrewrite.recipe:rewrite-logging-frameworks:latest.release")
       }
       extensions.configure<org.openrewrite.gradle.RewriteExtension> {
           activeRecipe("org.openrewrite.java.logging.slf4j.Slf4jBestPractices")
           setExportDatatables(true)
       }
       afterEvaluate {
           if (repositories.isEmpty()) {
               repositories {
                   mavenCentral()
               }
           }
       }
   }

2. Run the recipe.
   shell

   gradle --init-script init.gradle.kts rewriteRun

Gradle

You can add the plugin to your build.gradle file, so that it is available for all developers and CI/CD pipelines.

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.Slf4jBestPractices")
       setExportDatatables(true)
   }
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       rewrite("org.openrewrite.recipe:rewrite-logging-frameworks:latest.release")
   }

2. Run gradle rewriteRun to run the recipe.

IntelliJ IDEA Ultimate

You can run OpenRewrite recipes directly from IntelliJ IDEA Ultimate, after installing the OpenRewrite plugin, by adding a rewrite.yml file to your project.

rewrite.yml

---
type: specs.openrewrite.org/v1beta/recipe
name: com.yourorg.SLF4JLoggingBestPractices
displayName: SLF4J Logging Best Practices
description: SLF4J Logging Best Practices
recipeList:
  - org.openrewrite.java.logging.slf4j.Slf4jBestPractices

After adding the file, you should see a run icon in the left margin offering to run the recipe.