Qulice maven plugin 0.23.0

pom.xml

@@ -109,9 +109,9 @@
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>log4j</groupId>
-      <artifactId>log4j</artifactId>
-      <version>1.2.17</version>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <version>2.24.1</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -209,7 +209,7 @@
           <plugin>
             <groupId>com.qulice</groupId>
             <artifactId>qulice-maven-plugin</artifactId>
-            <version>0.22.0</version>
+            <version>0.23.0</version>
             <configuration>
               <excludes combine.children="append">
                 <exclude>checkstyle:/src/it.*</exclude>

src/it/fake-validation/src/main/resources/META-INF/services/javax.validation.spi.ValidationProvider

@@ -1 +1,5 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2012-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+#
 com.jcabi.aspects.FakeValidationProvider

src/main/java/com/jcabi/aspects/aj/ExceptionsLogger.java

@@ -13,8 +13,8 @@
 /**
  * Logs all exceptions thrown out of a method.
  *
- * @since 0.1.10
  * @see com.jcabi.aspects.LogExceptions
+ * @since 0.1.10
  * @checkstyle IllegalThrows (100 lines)
  * @checkstyle NonStaticMethodCheck (100 lines)
  */

src/main/java/com/jcabi/aspects/aj/MethodCacher.java

@@ -161,9 +161,9 @@ private static boolean isCreateTunnel(final MethodCacher.Tunnel tunnel) {
      * Flush cache.
      * @param point Join point
      * @return Value of the method
+     * @throws Throwable If something goes wrong inside
      * @since 0.7.14
      * @deprecated Since 0.7.17, and preflush() should be used
-     * @throws Throwable If something goes wrong inside
      * @checkstyle IllegalThrows (4 lines)
      * @checkstyle MethodsOrderCheck (3 lines)
      */

src/main/java/com/jcabi/aspects/aj/MethodLogger.java

@@ -33,11 +33,11 @@
 @Aspect
 @SuppressWarnings
     (
-        {
-            "PMD.AvoidCatchingThrowable",
-            "PMD.TooManyMethods",
-            "PMD.CyclomaticComplexity"
-        }
+    {
+    "PMD.AvoidCatchingThrowable",
+    "PMD.TooManyMethods",
+    "PMD.CyclomaticComplexity"
+    }
     )
 public final class MethodLogger {
 
@@ -52,7 +52,8 @@ public final class MethodLogger {
     @SuppressWarnings(
         {
             "PMD.DoNotUseThreads",
-            "PMD.ConstructorOnlyInitializesOrCallOtherConstructors"
+            "PMD.ConstructorOnlyInitializesOrCallOtherConstructors",
+            "PMD.CloseResource"
         }
     )
     public MethodLogger() {
@@ -158,88 +159,125 @@ public Object wrapMethod(final ProceedingJoinPoint point) throws Throwable {
         "PMD.AvoidThreadGroup",
         "PMD.GuardLogStatement"
     })
-    private Object wrap(final ProceedingJoinPoint point, final Method method,
-        final Loggable annotation) throws Throwable {
+    // @checkstyle IllegalCatchCheck (15 lines)
+    private Object wrap(
+        final ProceedingJoinPoint point,
+        final Method method,
+        final Loggable annotation
+    ) throws Throwable {
+        this.checkThreadInterruption();
+        final long start = System.nanoTime();
+        final MethodLogger.Marker marker = new MethodLogger.Marker(point, annotation);
+        this.running.add(marker);
+        try {
+            logMethodEntry(point, method, annotation);
+            final Object result = point.proceed();
+            logMethodExit(point, method, annotation, result, start);
+            return result;
+        } catch (final Throwable exc) {
+            handleException(exc, point, method, annotation, start);
+            throw exc;
+        } finally {
+            this.running.remove(marker);
+        }
+    }
+
+    private void checkThreadInterruption() {
         if (Thread.interrupted()) {
             throw new IllegalStateException(
                 String.format(
-                    "thread '%s' in group '%s' interrupted",
-                    Thread.currentThread().getName(),
-                    Thread.currentThread().getThreadGroup().getName()
+                    "thread '%s' was interrupted",
+                    Thread.currentThread().getName()
                 )
             );
         }
-        final long start = System.nanoTime();
-        final MethodLogger.Marker marker =
-            new MethodLogger.Marker(point, annotation);
-        this.running.add(marker);
-        int level = annotation.value();
-        try {
+    }
+
+    private static void logMethodEntry(
+        final ProceedingJoinPoint point,
+        final Method method,
+        final Loggable annotation
+    ) {
+        if (annotation.prepend()) {
             final Object logger = MethodLogger.logger(method, annotation.name());
-            if (annotation.prepend()) {
+            LogHelper.log(
+                annotation.value(),
+                logger,
+                new StringBuilder(
+                    Mnemos.toText(
+                        point,
+                        annotation.trim(),
+                        annotation.skipArgs(),
+                        annotation.logThis()
+                    )
+                ).append(": entered").toString()
+            );
+        }
+    }
+
+    // @checkstyle ParameterNumberCheck (7 lines)
+    private static void logMethodExit(
+        final ProceedingJoinPoint point,
+        final Method method,
+        final Loggable annotation,
+        final Object result,
+        final long start
+    ) {
+        final long nano = System.nanoTime() - start;
+        final Object logger = MethodLogger.logger(method, annotation.name());
+        int level = annotation.value();
+        if (LogHelper.enabled(level, logger) || MethodLogger.over(annotation, nano)) {
+            if (MethodLogger.over(annotation, nano)) {
+                level = Loggable.WARN;
+            }
+            LogHelper.log(
+                level, logger,
+                MethodLogger.message(point, method, annotation, result, nano)
+            );
+        }
+    }
+
+    // @checkstyle ParameterNumberCheck (7 lines)
+    private static void handleException(
+        final Throwable exc,
+        final ProceedingJoinPoint point,
+        final Method method,
+        final Loggable annotation,
+        final long start
+    ) {
+        if (!MethodLogger.contains(annotation.ignore(), exc)
+            && !exc.getClass().isAnnotationPresent(Loggable.Quiet.class)) {
+            final String origin = getExceptionOrigin(exc);
+            if (LogHelper.enabled(annotation.value(), method.getDeclaringClass())) {
                 LogHelper.log(
-                    level,
-                    logger,
-                    new StringBuilder(
+                    annotation.value(),
+                    method.getDeclaringClass(),
+                    Logger.format(
+                        "%s: thrown %s out of %s in %[nano]s",
                         Mnemos.toText(
                             point,
                             annotation.trim(),
                             annotation.skipArgs(),
                             annotation.logThis()
-                        )
-                    ).append(": entered").toString()
-                );
-            }
-            final Object result = point.proceed();
-            final long nano = System.nanoTime() - start;
-            if (LogHelper.enabled(level, logger)
-                || MethodLogger.over(annotation, nano)) {
-                if (MethodLogger.over(annotation, nano)) {
-                    level = Loggable.WARN;
-                }
-                LogHelper.log(
-                    level, logger,
-                    MethodLogger.message(point, method, annotation, result, nano)
+                        ),
+                        Mnemos.toText(exc),
+                        origin,
+                        System.nanoTime() - start
+                    )
                 );
             }
-            return result;
-        // @checkstyle IllegalCatch (1 line)
-        } catch (final Throwable ex) {
-            if (!MethodLogger.contains(annotation.ignore(), ex)
-                && !ex.getClass().isAnnotationPresent(Loggable.Quiet.class)) {
-                final StackTraceElement[] traces = ex.getStackTrace();
-                final String origin;
-                if (traces.length > 0) {
-                    final StackTraceElement trace = traces[0];
-                    origin = MethodLogger.oneText(trace);
-                } else {
-                    origin = "somewhere";
-                }
-                if (LogHelper.enabled(level, method.getDeclaringClass())) {
-                    LogHelper.log(
-                        level,
-                        method.getDeclaringClass(),
-                        Logger.format(
-                            "%s: thrown %s out of %s in %[nano]s",
-                            Mnemos.toText(
-                                point,
-                                annotation.trim(),
-                                annotation.skipArgs(),
-                                annotation.logThis()
-                            ),
-                            Mnemos.toText(ex),
-                            origin,
-                            System.nanoTime() - start
-                        )
-                    );
-                }
-            }
-            throw ex;
-        } finally {
-            this.running.remove(marker);
         }
     }
 
+    private static String getExceptionOrigin(final Throwable exc) {
+        final StackTraceElement[] traces = exc.getStackTrace();
+        String res = "somewhere";
+        if (traces.length > 0) {
+            res = MethodLogger.oneText(traces[0]);
+        }
+        return res;
+    }
+
     /**
      * Has time for method execution passed.
      * @param annotation Loggable annotation.

src/main/java/com/jcabi/aspects/aj/MethodValidator.java

@@ -29,9 +29,9 @@
  *
  * <p>The class is thread-safe.
  *
- * @since 0.1.10
  * @see <a href="http://beanvalidation.org/1.0/spec/#appendix-methodlevelvalidation">Appendix C</a>
  * @see <a href="http://aspects.jcabi.com/jsr-303.html">How it works</a>
+ * @since 0.1.10
  */
 @Aspect
 @SuppressWarnings({ "PMD.CyclomaticComplexity", "PMD.TooManyMethods" })
@@ -73,7 +73,11 @@ public void beforeMethod(final JoinPoint point) {
      * @param point Join point
      * @checkstyle LineLength (3 lines)
      */
-    @Before("preinitialization(*.new(.., @(javax.validation.* || javax.validation.constraints.*) (*), ..))")
+    @Before(
+        // @checkstyle StringLiteralsConcatenation (2 lines)
+        "preinitialization(*.new(.., @(javax.validation.* || javax.validation.constraints.*)"
+        + " (*), ..))"
+    )
     public void beforeCtor(final JoinPoint point) {
         if (this.validator != null) {
             @SuppressWarnings("unchecked")

src/main/java/com/jcabi/aspects/aj/Parallelizer.java

@@ -24,8 +24,8 @@
 /**
  * Execute method in multiple threads.
  *
- * @since 0.10
  * @see Parallel
+ * @since 0.10
  * @checkstyle NonStaticMethodCheck (100 lines)
  */
 @Aspect
@@ -46,6 +46,7 @@ public final class Parallelizer {
      * @checkstyle IllegalThrowsCheck (4 lines)
      */
     @Around("execution(@com.jcabi.aspects.Parallel * * (..))")
+    @SuppressWarnings("PMD.CloseResource")
     public Object wrap(final ProceedingJoinPoint point)
         throws Parallelizer.ParallelException {
         final int total = ((MethodSignature) point.getSignature())

src/main/java/com/jcabi/aspects/aj/QuietExceptionsLogger.java

@@ -14,8 +14,8 @@
 /**
  * Logs all exceptions thrown out of a method and swallow exception.
  *
- * @since 0.1.10
  * @see com.jcabi.aspects.LogExceptions
+ * @since 0.1.10
  * @checkstyle IllegalThrows (100 lines)
  * @checkstyle NonStaticMethodCheck (100 lines)
  */