[ISSUE apache#4697] Use Fluent Logging API to provide accurate, concise, and elegant logging (apache#4698)

* upgrade log4j and slf4j

* recommanded example

* add known dependencies

* remove log4j-to-slf4j

* Revert "recommanded example"

This reverts commit 3c52810.

* Deprecate `LogUtils` for removal

The `LogUtils` class is not useful because:

 * it wraps every logger call in `isLevelEnabled`. These are not
   necessary since the arguments to the logger calls are simple
   variables and not computationally complex expressions,
 * currently it breaks location detection of the logger calls, which
   will always show `LogUtils` as origin,
 * it prevents the project from using source code rewrite tools like
   [`rewrite-logging-frameworks`](https://github.com/openrewrite/rewrite-logging-frameworks).

This commit adds deprecates the class for removal in the next major
version and adds Error Prone's `@InlineMe` annotations, to help users
automatically rewrite code based on `LogUtils`.

* Add minimal `errorPronePatch` task

This task patches the codebase based on Error Prone suggestions (cf.
[patching](https://errorprone.info/docs/patching), without adding Error
Prone to the main compile task.

It is a simplified version of the `gradle-errorprone-plugin` (cf.
[installing](https://errorprone.info/docs/installation) and only works
on a clean tree using JDK 11.

Use as:

./gradlew clean errorPronePatch errorPronePatchTest

* Rewrite `LogUtils` call sites

This commit contains exclusively code changes performed by Error Prone
and rewrites all the callsites to `LogUtils` to use the `Logger` object
directly.

* add suppliers

* Revert "Rewrite `LogUtils` call sites"

This reverts commit 1dc6bf4.

* Replace the time-consuming method parms with the supplier usage of LogUtil

* Execute errorProne scripts and remove blank line by IDEA optimize import

* Remove non-supplier methods in LogUtils

* Remove unused trace and error log level

* Rename LogUtils to LogUtil to save space

* Fix checkstyle

* Replace isXXXXEnabled to normal use

* Rename messageLogger to static final MESSAGE_LOGGER

* Fix all checkstyle warnings

* run spotlessApply

* Fix JDK11 Javadoc task failed

* Add {} and fix javadoc task

* Revert "Add minimal `errorPronePatch` task"

This reverts commit 0407bda.

* Turn back to surpress javadoc only on JDK8

* Fix logging lack param

* Merge branch 'master' into pil0txia_enhance_4697

---------

Co-authored-by: Piotr P. Karwasz <piotr.github@karwasz.org>

Author: Pil0tXia

.gitignore

@@ -23,7 +23,6 @@ classes
 package-lock.json
 node_modules
 .run
-*.log
 
 h2/db.mv.db
 

build.gradle

@@ -40,11 +40,11 @@ buildscript {
     }
 }
 
-//Remove doclint warnings that pollute javadoc logs when building with java8
-if(JavaVersion.current().isJava8()){
+// Remove doclint warnings that pollute javadoc logs when building
+if (JavaVersion.current().isJava8()) {
     allprojects {
-        tasks.withType(Javadoc){
-            options.addStringOption('xdoclint:none','-quiet')
+        tasks.withType(Javadoc) {
+            options.addStringOption('xdoclint:none', '-quiet')
         }
     }
 }
@@ -473,6 +473,7 @@ subprojects {
     }
 
     def grpcVersion = '1.43.2'
+    def log4jVersion = '2.22.1'
 
     dependencyManagement {
         dependencies {
@@ -486,10 +487,11 @@ subprojects {
 
             dependency "com.google.guava:guava:31.0.1-jre"
 
-            dependency "org.slf4j:slf4j-api:1.7.30"
-            dependency "org.apache.logging.log4j:log4j-api:2.17.1"
-            dependency "org.apache.logging.log4j:log4j-core:2.17.1"
-            dependency "org.apache.logging.log4j:log4j-slf4j-impl:2.17.1"
+            dependency "org.slf4j:slf4j-api:2.0.9"
+            dependency "org.apache.logging.log4j:log4j-api:${log4jVersion}"
+            dependency "org.apache.logging.log4j:log4j-core:${log4jVersion}"
+            dependency "org.apache.logging.log4j:log4j-slf4j2-impl:${log4jVersion}"
+            dependency "org.apache.logging.log4j:log4j-slf4j-impl:${log4jVersion}" // used with SLF4J 1.7.x or older for third-party dependencies
 
             dependency "com.lmax:disruptor:3.4.2"
 

eventmesh-common/build.gradle

@@ -32,7 +32,7 @@ dependencies {
 
     implementation "org.apache.logging.log4j:log4j-api"
     implementation "org.apache.logging.log4j:log4j-core"
-    implementation "org.apache.logging.log4j:log4j-slf4j-impl"
+    implementation "org.apache.logging.log4j:log4j-slf4j2-impl"
 
     implementation 'com.github.seancfoley:ipaddress'
 
@@ -67,7 +67,7 @@ dependencies {
     testImplementation "org.slf4j:slf4j-api"
     testImplementation "org.apache.logging.log4j:log4j-api"
     testImplementation "org.apache.logging.log4j:log4j-core"
-    testImplementation "org.apache.logging.log4j:log4j-slf4j-impl"
+    testImplementation "org.apache.logging.log4j:log4j-slf4j2-impl"
 
     testImplementation "com.lmax:disruptor"
 

eventmesh-common/src/main/java/org/apache/eventmesh/common/file/WatchFileManager.java

@@ -17,8 +17,6 @@
 
 package org.apache.eventmesh.common.file;
 
-import org.apache.eventmesh.common.utils.LogUtils;
-
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -62,10 +60,10 @@ private static void shutdown() {
             return;
         }
 
-        LogUtils.info(log, "[WatchFileManager] start close");
+        log.info("[WatchFileManager] start close");
 
         for (Map.Entry<String, WatchFileTask> entry : WATCH_FILE_TASK_MAP.entrySet()) {
-            LogUtils.info(log, "[WatchFileManager] start to shutdown : {}", entry.getKey());
+            log.info("[WatchFileManager] start to shutdown : {}", entry.getKey());
 
             try {
                 entry.getValue().shutdown();

eventmesh-common/src/main/java/org/apache/eventmesh/common/file/WatchFileTask.java

@@ -17,8 +17,6 @@
 
 package org.apache.eventmesh.common.file;
 
-import org.apache.eventmesh.common.utils.LogUtils;
-
 import java.io.IOException;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
@@ -105,15 +103,15 @@ public void run() {
                 for (WatchEvent<?> event : events) {
                     WatchEvent.Kind<?> kind = event.kind();
                     if (kind.equals(StandardWatchEventKinds.OVERFLOW)) {
-                        LogUtils.warn(log, "[WatchFileTask] file overflow: {}", event.context());
+                        log.warn("[WatchFileTask] file overflow: {}", event.context());
                         continue;
                     }
                     precessWatchEvent(event);
                 }
             } catch (InterruptedException ex) {
                 boolean interrupted = Thread.interrupted();
                 if (interrupted) {
-                    LogUtils.debug(log, "[WatchFileTask] file watch is interrupted");
+                    log.debug("[WatchFileTask] file watch is interrupted");
                 }
             } catch (Exception ex) {
                 log.error("[WatchFileTask] an exception occurred during file listening : ", ex);

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/tcp/codec/Codec.java

@@ -25,7 +25,7 @@
 import org.apache.eventmesh.common.protocol.tcp.Subscription;
 import org.apache.eventmesh.common.protocol.tcp.UserAgent;
 import org.apache.eventmesh.common.utils.JsonUtils;
-import org.apache.eventmesh.common.utils.LogUtils;
+import org.apache.eventmesh.common.utils.LogUtil;
 
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -61,9 +61,7 @@ public void encode(ChannelHandlerContext ctx, Package pkg, ByteBuf out) throws E
             Preconditions.checkNotNull(pkg, "TcpPackage cannot be null");
             final Header header = pkg.getHeader();
             Preconditions.checkNotNull(header, "TcpPackage header cannot be null", header);
-            if (log.isDebugEnabled()) {
-                log.debug("Encoder pkg={}", JsonUtils.toJSONString(pkg));
-            }
+            LogUtil.debug(log, "Encode pkg={}", () -> JsonUtils.toJSONString(pkg));
 
             final byte[] headerData = JsonUtils.toJSONBytes(header);
             final byte[] bodyData;
@@ -180,7 +178,7 @@ private Header parseHeader(ByteBuf in, int headerLength) throws JsonProcessingEx
             }
             final byte[] headerData = new byte[headerLength];
             in.readBytes(headerData);
-            LogUtils.debug(log, "Decode headerJson={}", deserializeBytes(headerData));
+            LogUtil.debug(log, "Decode headerJson={}", () -> deserializeBytes(headerData));
             return JsonUtils.parseObject(headerData, Header.class);
         }
 
@@ -190,7 +188,7 @@ private Object parseBody(ByteBuf in, Header header, int bodyLength) throws JsonP
             }
             final byte[] bodyData = new byte[bodyLength];
             in.readBytes(bodyData);
-            LogUtils.debug(log, "Decode bodyJson={}", deserializeBytes(bodyData));
+            LogUtil.debug(log, "Decode bodyJson={}", () -> deserializeBytes(bodyData));
             return deserializeBody(deserializeBytes(bodyData), header);
         }
 
@@ -242,7 +240,7 @@ private static Object deserializeBody(String bodyJsonString, Header header) thro
             case REDIRECT_TO_CLIENT:
                 return JsonUtils.parseObject(bodyJsonString, RedirectInfo.class);
             default:
-                LogUtils.warn(log, "Invalidate TCP command: {}", command);
+                log.warn("Invalidate TCP command: {}", command);
                 return null;
         }
     }

eventmesh-common/src/main/java/org/apache/eventmesh/common/utils/LogUtil.java

@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ *     http://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 org.apache.eventmesh.common.utils;
+
+import java.util.function.Supplier;
+
+import org.slf4j.Logger;
+import org.slf4j.spi.CallerBoundaryAware;
+import org.slf4j.spi.LoggingEventBuilder;
+
+import lombok.experimental.UtilityClass;
+
+/**
+ * This class provides logging methods that encapsulate SLF4J and Supplier.
+ * If the log level is not enabled, the passed Supplier is invoked lazily,
+ * thereby avoiding unnecessary method execution time.
+ * <p>
+ * The statement
+ * <pre>
+ * {@code
+ * LogUtil.debug(log, "A time-consuming method: {}", () -> myMethod());
+ * }
+ * </pre>
+ * is equivalent to:
+ * <pre>
+ * {@code
+ * if (logger.isDebugEnabled()) {
+ *     logger.debug("A time-consuming method: {}", myMethod());
+ * }
+ * }
+ * </pre>
+ * If no object parameters are passed or existing objects are referenced, use
+ * <pre>
+ * {@code
+ * log.debug("No time-consuming methods: {}", myObject);
+ * }
+ * </pre>
+ * instead.
+ */
+
+@UtilityClass
+public final class LogUtil {
+
+    private static final String FQCN = LogUtil.class.getName();
+
+    public static void debug(Logger logger, String format, Supplier<?> objectSupplier) {
+        final LoggingEventBuilder builder = logger.atDebug();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).log(format);
+    }
+
+    public static void debug(Logger logger, String format, Supplier<?> objectSupplier, Throwable t) {
+        final LoggingEventBuilder builder = logger.atDebug();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).setCause(t).log(format);
+    }
+
+    public static void debug(Logger logger, String format, Supplier<?>... objectSuppliers) {
+        LoggingEventBuilder builder = logger.atDebug();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        for (Supplier<?> objectSupplier : objectSuppliers) {
+            builder = builder.addArgument(objectSupplier);
+        }
+        builder.log(format);
+    }
+
+    public static void info(Logger logger, String format, Supplier<?> objectSupplier) {
+        final LoggingEventBuilder builder = logger.atInfo();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).log(format);
+    }
+
+    public static void info(Logger logger, String format, Supplier<?> objectSupplier, Throwable t) {
+        final LoggingEventBuilder builder = logger.atInfo();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).setCause(t).log(format);
+    }
+
+    public static void info(Logger logger, String format, Supplier<?>... objectSuppliers) {
+        LoggingEventBuilder builder = logger.atInfo();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        for (Supplier<?> objectSupplier : objectSuppliers) {
+            builder = builder.addArgument(objectSupplier);
+        }
+        builder.log(format);
+    }
+
+    public static void warn(Logger logger, String format, Supplier<?> objectSupplier) {
+        final LoggingEventBuilder builder = logger.atWarn();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).log(format);
+    }
+
+    public static void warn(Logger logger, String format, Supplier<?> objectSupplier, Throwable t) {
+        final LoggingEventBuilder builder = logger.atWarn();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        builder.addArgument(objectSupplier).setCause(t).log(format);
+    }
+
+    public static void warn(Logger logger, String format, Supplier<?>... objectSuppliers) {
+        LoggingEventBuilder builder = logger.atWarn();
+        if (builder instanceof CallerBoundaryAware) {
+            ((CallerBoundaryAware) builder).setCallerBoundary(FQCN);
+        }
+        for (Supplier<?> objectSupplier : objectSuppliers) {
+            builder = builder.addArgument(objectSupplier);
+        }
+        builder.log(format);
+    }
+}