Upgrade to Maven 4.0.0-beta-1 (#974)

logging/pom.xml

@@ -35,6 +35,15 @@
       <groupId>org.apache.maven</groupId>
       <artifactId>maven-embedder</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-jline</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.sisu</groupId>
+      <artifactId>org.eclipse.sisu.inject</artifactId>
+      <scope>provided</scope>
+    </dependency>
     <dependency>
       <groupId>org.apache.maven.shared</groupId>
       <artifactId>maven-shared-utils</artifactId>
@@ -79,15 +88,8 @@
                   <version>${maven.version}</version>
                   <classifier>sources</classifier>
                 </artifactItem>
-                <artifactItem>
-                  <groupId>org.slf4j</groupId>
-                  <artifactId>slf4j-simple</artifactId>
-                  <version>${slf4j.version}</version>
-                  <classifier>sources</classifier>
-                </artifactItem>
               </artifactItems>
-              <includes>org/apache/maven/logwrapper/*.java,org/slf4j/impl/*.java</includes>
-              <excludes>**/StaticLoggerBinder.java,**/StaticMDCBinder.java</excludes>
+              <includes>org/apache/maven/logwrapper/*.java</includes>
               <outputDirectory>${project.build.directory}/generated-sources/unpack</outputDirectory>
             </configuration>
           </execution>

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndBaseLogger.java

@@ -0,0 +1,466 @@
+/*
+ * 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.mvndaemon.mvnd.logging.slf4j;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.event.LoggingEvent;
+import org.slf4j.helpers.LegacyAbstractLogger;
+import org.slf4j.helpers.MessageFormatter;
+import org.slf4j.helpers.NormalizedParameters;
+import org.slf4j.spi.LocationAwareLogger;
+
+/**
+ * <p>
+ * Simple implementation of {@link Logger} that sends all enabled log messages,
+ * for all defined loggers, to the console ({@code System.err}). The following
+ * system properties are supported to configure the behavior of this logger:
+ *
+ *
+ * <ul>
+ * <li><code>org.slf4j.simpleLogger.logFile</code> - The output target which can
+ * be the <em>path</em> to a file, or the special values "System.out" and
+ * "System.err". Default is "System.err".</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.cacheOutputStream</code> - If the output
+ * target is set to "System.out" or "System.err" (see preceding entry), by
+ * default, logs will be output to the latest value referenced by
+ * <code>System.out/err</code> variables. By setting this parameter to true, the
+ * output stream will be cached, i.e. assigned once at initialization time and
+ * re-used independently of the current value referenced by
+ * <code>System.out/err</code>.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.defaultLogLevel</code> - Default log level
+ * for all instances of SimpleLogger. Must be one of ("trace", "debug", "info",
+ * "warn", "error" or "off"). If not specified, defaults to "info".</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.log.<em>a.b.c</em></code> - Logging detail
+ * level for a SimpleLogger instance named "a.b.c". Right-side value must be one
+ * of "trace", "debug", "info", "warn", "error" or "off". When a SimpleLogger
+ * named "a.b.c" is initialized, its level is assigned from this property. If
+ * unspecified, the level of nearest parent logger will be used, and if none is
+ * set, then the value specified by
+ * <code>org.slf4j.simpleLogger.defaultLogLevel</code> will be used.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.showDateTime</code> - Set to
+ * <code>true</code> if you want the current date and time to be included in
+ * output messages. Default is <code>false</code></li>
+ *
+ * <li><code>org.slf4j.simpleLogger.dateTimeFormat</code> - The date and time
+ * format to be used in the output messages. The pattern describing the date and
+ * time format is defined by <a href=
+ * "http://docs.oracle.com/javase/1.5.0/docs/api/java/text/SimpleDateFormat.html">
+ * <code>SimpleDateFormat</code></a>. If the format is not specified or is
+ * invalid, the number of milliseconds since start up will be output.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.showThreadName</code> -Set to
+ * <code>true</code> if you want to output the current thread name. Defaults to
+ * <code>true</code>.</li>
+ *
+ * <li>(since version 1.7.33 and 2.0.0-alpha6) <code>org.slf4j.simpleLogger.showThreadId</code> -
+ * If you would like to output the current thread id, then set to
+ * <code>true</code>. Defaults to <code>false</code>.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.showLogName</code> - Set to
+ * <code>true</code> if you want the Logger instance name to be included in
+ * output messages. Defaults to <code>true</code>.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.showShortLogName</code> - Set to
+ * <code>true</code> if you want the last component of the name to be included
+ * in output messages. Defaults to <code>false</code>.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.levelInBrackets</code> - Should the level
+ * string be output in brackets? Defaults to <code>false</code>.</li>
+ *
+ * <li><code>org.slf4j.simpleLogger.warnLevelString</code> - The string value
+ * output for the warn level. Defaults to <code>WARN</code>.</li>
+ *
+ * </ul>
+ *
+ * <p>
+ * In addition to looking for system properties with the names specified above,
+ * this implementation also checks for a class loader resource named
+ * <code>"simplelogger.properties"</code>, and includes any matching definitions
+ * from this resource (if it exists).
+ *
+ *
+ * <p>
+ * With no configuration, the default output includes the relative time in
+ * milliseconds, thread name, the level, logger name, and the message followed
+ * by the line separator for the host. In log4j terms it amounts to the "%r [%t]
+ * %level %logger - %m%n" pattern.
+ *
+ * <p>
+ * Sample output follows.
+ *
+ *
+ * <pre>
+ * 176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse order.
+ * 225 [main] INFO examples.SortAlgo - Entered the sort method.
+ * 304 [main] INFO examples.SortAlgo - Dump of integer array:
+ * 317 [main] INFO examples.SortAlgo - Element [0] = 0
+ * 331 [main] INFO examples.SortAlgo - Element [1] = 1
+ * 343 [main] INFO examples.Sort - The next log statement should be an error message.
+ * 346 [main] ERROR examples.SortAlgo - Tried to dump an uninitialized array.
+ *   at org.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
+ *   at org.log4j.examples.Sort.main(Sort.java:64)
+ * 467 [main] INFO  examples.Sort - Exiting main method.
+ * </pre>
+ *
+ * <p>
+ * This implementation is heavily inspired by
+ * <a href="http://commons.apache.org/logging/">Apache Commons Logging</a>'s
+ * SimpleLog.
+ *
+ *
+ * @author Ceki G&uuml;lc&uuml;
+ * @author Scott Sanders
+ * @author Rod Waldhoff
+ * @author Robert Burrell Donkin
+ * @author C&eacute;drik LIME
+ */
+public class MvndBaseLogger extends LegacyAbstractLogger {
+
+    private static final long serialVersionUID = -632788891211436180L;
+
+    private static final long START_TIME = System.currentTimeMillis();
+
+    protected static final int LOG_LEVEL_TRACE = LocationAwareLogger.TRACE_INT;
+    protected static final int LOG_LEVEL_DEBUG = LocationAwareLogger.DEBUG_INT;
+    protected static final int LOG_LEVEL_INFO = LocationAwareLogger.INFO_INT;
+    protected static final int LOG_LEVEL_WARN = LocationAwareLogger.WARN_INT;
+    protected static final int LOG_LEVEL_ERROR = LocationAwareLogger.ERROR_INT;
+
+    static char SP = ' ';
+    static final String TID_PREFIX = "tid=";
+
+    // The OFF level can only be used in configuration files to disable logging.
+    // It has
+    // no printing method associated with it in o.s.Logger interface.
+    protected static final int LOG_LEVEL_OFF = LOG_LEVEL_ERROR + 10;
+
+    private static boolean INITIALIZED = false;
+    static final SimpleLoggerConfiguration CONFIG_PARAMS = new SimpleLoggerConfiguration();
+
+    static void lazyInit() {
+        if (INITIALIZED) {
+            return;
+        }
+        INITIALIZED = true;
+        init();
+    }
+
+    // external software might be invoking this method directly. Do not rename
+    // or change its semantics.
+    static void init() {
+        CONFIG_PARAMS.init();
+    }
+
+    /** The current log level */
+    protected int currentLogLevel = LOG_LEVEL_INFO;
+    /** The short name of this simple log instance */
+    private transient String shortLogName = null;
+
+    /**
+     * All system properties used by <code>SimpleLogger</code> start with this
+     * prefix
+     */
+    public static final String SYSTEM_PREFIX = "org.slf4j.simpleLogger.";
+
+    public static final String LOG_KEY_PREFIX = MvndBaseLogger.SYSTEM_PREFIX + "log.";
+
+    public static final String CACHE_OUTPUT_STREAM_STRING_KEY = MvndBaseLogger.SYSTEM_PREFIX + "cacheOutputStream";
+
+    public static final String WARN_LEVEL_STRING_KEY = MvndBaseLogger.SYSTEM_PREFIX + "warnLevelString";
+
+    public static final String LEVEL_IN_BRACKETS_KEY = MvndBaseLogger.SYSTEM_PREFIX + "levelInBrackets";
+
+    public static final String LOG_FILE_KEY = MvndBaseLogger.SYSTEM_PREFIX + "logFile";
+
+    public static final String SHOW_SHORT_LOG_NAME_KEY = MvndBaseLogger.SYSTEM_PREFIX + "showShortLogName";
+
+    public static final String SHOW_LOG_NAME_KEY = MvndBaseLogger.SYSTEM_PREFIX + "showLogName";
+
+    public static final String SHOW_THREAD_NAME_KEY = MvndBaseLogger.SYSTEM_PREFIX + "showThreadName";
+
+    public static final String SHOW_THREAD_ID_KEY = MvndBaseLogger.SYSTEM_PREFIX + "showThreadId";
+
+    public static final String DATE_TIME_FORMAT_KEY = MvndBaseLogger.SYSTEM_PREFIX + "dateTimeFormat";
+
+    public static final String SHOW_DATE_TIME_KEY = MvndBaseLogger.SYSTEM_PREFIX + "showDateTime";
+
+    public static final String DEFAULT_LOG_LEVEL_KEY = MvndBaseLogger.SYSTEM_PREFIX + "defaultLogLevel";
+
+    /**
+     * Protected access allows only {@link MvndLoggerFactory} and also derived classes to instantiate
+     * MvndBaseLogger instances.
+     */
+    protected MvndBaseLogger(String name) {
+        this.name = name;
+
+        String levelString = recursivelyComputeLevelString();
+        if (levelString != null) {
+            this.currentLogLevel = SimpleLoggerConfiguration.stringToLevel(levelString);
+        } else {
+            this.currentLogLevel = CONFIG_PARAMS.defaultLogLevel;
+        }
+    }
+
+    String recursivelyComputeLevelString() {
+        String tempName = name;
+        String levelString = null;
+        int indexOfLastDot = tempName.length();
+        while ((levelString == null) && (indexOfLastDot > -1)) {
+            tempName = tempName.substring(0, indexOfLastDot);
+            levelString = CONFIG_PARAMS.getStringProperty(MvndBaseLogger.LOG_KEY_PREFIX + tempName, null);
+            indexOfLastDot = String.valueOf(tempName).lastIndexOf(".");
+        }
+        return levelString;
+    }
+
+    /**
+     * To avoid intermingling of log messages and associated stack traces, the two
+     * operations are done in a synchronized block.
+     *
+     * @param buf
+     * @param t
+     */
+    void write(StringBuilder buf, Throwable t) {
+        PrintStream targetStream = CONFIG_PARAMS.outputChoice.getTargetPrintStream();
+
+        synchronized (CONFIG_PARAMS) {
+            targetStream.println(buf.toString());
+            writeThrowable(t, targetStream);
+            targetStream.flush();
+        }
+    }
+
+    protected void writeThrowable(Throwable t, PrintStream targetStream) {
+        if (t != null) {
+            t.printStackTrace(targetStream);
+        }
+    }
+
+    private String getFormattedDate() {
+        Date now = new Date();
+        String dateText;
+        synchronized (CONFIG_PARAMS.dateFormatter) {
+            dateText = CONFIG_PARAMS.dateFormatter.format(now);
+        }
+        return dateText;
+    }
+
+    private String computeShortName() {
+        return name.substring(name.lastIndexOf(".") + 1);
+    }
+
+    // /**
+    // * For formatted messages, first substitute arguments and then log.
+    // *
+    // * @param level
+    // * @param format
+    // * @param arg1
+    // * @param arg2
+    // */
+    // private void formatAndLog(int level, String format, Object arg1, Object arg2) {
+    // if (!isLevelEnabled(level)) {
+    // return;
+    // }
+    // FormattingTuple tp = MessageFormatter.format(format, arg1, arg2);
+    // log(level, tp.getMessage(), tp.getThrowable());
+    // }
+
+    // /**
+    // * For formatted messages, first substitute arguments and then log.
+    // *
+    // * @param level
+    // * @param format
+    // * @param arguments
+    // * a list of 3 ore more arguments
+    // */
+    // private void formatAndLog(int level, String format, Object... arguments) {
+    // if (!isLevelEnabled(level)) {
+    // return;
+    // }
+    // FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
+    // log(level, tp.getMessage(), tp.getThrowable());
+    // }
+
+    /**
+     * Is the given log level currently enabled?
+     *
+     * @param logLevel is this level enabled?
+     * @return whether the logger is enabled for the given level
+     */
+    protected boolean isLevelEnabled(int logLevel) {
+        // log level are numerically ordered so can use simple numeric
+        // comparison
+        return (logLevel >= currentLogLevel);
+    }
+
+    /** Are {@code trace} messages currently enabled? */
+    public boolean isTraceEnabled() {
+        return isLevelEnabled(LOG_LEVEL_TRACE);
+    }
+
+    /** Are {@code debug} messages currently enabled? */
+    public boolean isDebugEnabled() {
+        return isLevelEnabled(LOG_LEVEL_DEBUG);
+    }
+
+    /** Are {@code info} messages currently enabled? */
+    public boolean isInfoEnabled() {
+        return isLevelEnabled(LOG_LEVEL_INFO);
+    }
+
+    /** Are {@code warn} messages currently enabled? */
+    public boolean isWarnEnabled() {
+        return isLevelEnabled(LOG_LEVEL_WARN);
+    }
+
+    /** Are {@code error} messages currently enabled? */
+    public boolean isErrorEnabled() {
+        return isLevelEnabled(LOG_LEVEL_ERROR);
+    }
+
+    /**
+     * SimpleLogger's implementation of
+     * {@link org.slf4j.helpers.AbstractLogger#handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable) AbstractLogger#handleNormalizedLoggingCall}
+     * }
+     *
+     * @param level the SLF4J level for this event
+     * @param marker  The marker to be used for this event, may be null.
+     * @param messagePattern The message pattern which will be parsed and formatted
+     * @param arguments  the array of arguments to be formatted, may be null
+     * @param throwable  The exception whose stack trace should be logged, may be null
+     */
+    @Override
+    protected void handleNormalizedLoggingCall(
+            Level level, Marker marker, String messagePattern, Object[] arguments, Throwable throwable) {
+
+        List<Marker> markers = null;
+
+        if (marker != null) {
+            markers = new ArrayList<>();
+            markers.add(marker);
+        }
+
+        innerHandleNormalizedLoggingCall(level, markers, messagePattern, arguments, throwable);
+    }
+
+    private void innerHandleNormalizedLoggingCall(
+            Level level, List<Marker> markers, String messagePattern, Object[] arguments, Throwable t) {
+
+        StringBuilder buf = new StringBuilder(32);
+
+        // Append date-time if so configured
+        if (CONFIG_PARAMS.showDateTime) {
+            if (CONFIG_PARAMS.dateFormatter != null) {
+                buf.append(getFormattedDate());
+                buf.append(SP);
+            } else {
+                buf.append(System.currentTimeMillis() - START_TIME);
+                buf.append(SP);
+            }
+        }
+
+        // Append current thread name if so configured
+        if (CONFIG_PARAMS.showThreadName) {
+            buf.append('[');
+            buf.append(Thread.currentThread().getName());
+            buf.append("] ");
+        }
+
+        if (CONFIG_PARAMS.showThreadId) {
+            buf.append(TID_PREFIX);
+            buf.append(Thread.currentThread().getId());
+            buf.append(SP);
+        }
+
+        if (CONFIG_PARAMS.levelInBrackets) buf.append('[');
+
+        // Append a readable representation of the log level
+        String levelStr = renderLevel(level.toInt());
+        buf.append(levelStr);
+        if (CONFIG_PARAMS.levelInBrackets) buf.append(']');
+        buf.append(SP);
+
+        // Append the name of the log instance if so configured
+        if (CONFIG_PARAMS.showShortLogName) {
+            if (shortLogName == null) shortLogName = computeShortName();
+            buf.append(String.valueOf(shortLogName)).append(" - ");
+        } else if (CONFIG_PARAMS.showLogName) {
+            buf.append(String.valueOf(name)).append(" - ");
+        }
+
+        if (markers != null) {
+            buf.append(SP);
+            for (Marker marker : markers) {
+                buf.append(marker.getName()).append(SP);
+            }
+        }
+
+        String formattedMessage = MessageFormatter.basicArrayFormat(messagePattern, arguments);
+
+        // Append the message
+        buf.append(formattedMessage);
+
+        write(buf, t);
+    }
+
+    protected String renderLevel(int levelInt) {
+        switch (levelInt) {
+            case LOG_LEVEL_TRACE:
+                return "TRACE";
+            case LOG_LEVEL_DEBUG:
+                return ("DEBUG");
+            case LOG_LEVEL_INFO:
+                return "INFO";
+            case LOG_LEVEL_WARN:
+                return "WARN";
+            case LOG_LEVEL_ERROR:
+                return "ERROR";
+        }
+        throw new IllegalStateException("Unrecognized level [" + levelInt + "]");
+    }
+
+    public void log(LoggingEvent event) {
+        int levelInt = event.getLevel().toInt();
+
+        if (!isLevelEnabled(levelInt)) {
+            return;
+        }
+
+        NormalizedParameters np = NormalizedParameters.normalize(event);
+
+        innerHandleNormalizedLoggingCall(
+                event.getLevel(), event.getMarkers(), np.getMessage(), np.getArguments(), event.getThrowable());
+    }
+
+    @Override
+    protected String getFullyQualifiedCallerName() {
+        return null;
+    }
+}

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndConfiguration.java

@@ -16,10 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.slf4j.impl;
+package org.mvndaemon.mvnd.logging.slf4j;
 
 import org.apache.maven.cli.logging.Slf4jConfiguration;
 import org.slf4j.ILoggerFactory;
+import org.slf4j.LoggerFactory;
 
 public class MvndConfiguration implements Slf4jConfiguration {
     @Override
@@ -43,7 +44,7 @@ public class MvndConfiguration implements Slf4jConfiguration {
 
     @Override
     public void activate() {
-        ILoggerFactory lf = StaticLoggerBinder.getSingleton().getLoggerFactory();
+        ILoggerFactory lf = LoggerFactory.getILoggerFactory();
         if (lf instanceof MvndLoggerFactory) {
             ((MvndLoggerFactory) lf).reconfigure();
         }

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndDaemonLogger.java

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.slf4j.impl;
+package org.mvndaemon.mvnd.logging.slf4j;
 
 import java.io.PrintStream;
 import java.io.PrintWriter;
@@ -25,6 +25,10 @@ import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
 
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.helpers.MessageFormatter;
+
 public class MvndDaemonLogger extends MvndBaseLogger {
 
     final DateTimeFormatter dateTimeFormatter =
@@ -37,32 +41,35 @@ public class MvndDaemonLogger extends MvndBaseLogger {
     }
 
     @Override
-    protected void doLog(int level, String message, Throwable t) {
+    protected String renderLevel(int levelInt) {
+        switch (levelInt) {
+            case LOG_LEVEL_ERROR:
+                return "E";
+            case LOG_LEVEL_WARN:
+                return "W";
+            case LOG_LEVEL_INFO:
+                return "I";
+            case LOG_LEVEL_DEBUG:
+                return "D";
+            case LOG_LEVEL_TRACE:
+                return "T";
+        }
+        throw new IllegalStateException("Unrecognized level [" + levelInt + "]");
+    }
+
+    @Override
+    protected void handleNormalizedLoggingCall(
+            Level level, Marker marker, String messagePattern, Object[] arguments, Throwable throwable) {
         StringWriter sw = new StringWriter();
         PrintWriter pw = new PrintWriter(sw);
         pw.append(dateTimeFormatter.format(LocalTime.now()));
         pw.append(" ");
-        switch (level) {
-            case LOG_LEVEL_ERROR:
-                pw.append("E");
-                break;
-            case LOG_LEVEL_WARN:
-                pw.append("W");
-                break;
-            case LOG_LEVEL_INFO:
-                pw.append("I");
-                break;
-            case LOG_LEVEL_DEBUG:
-                pw.append("D");
-                break;
-            case LOG_LEVEL_TRACE:
-                pw.append("T");
-                break;
-        }
+        pw.append(renderLevel(level.toInt()));
         pw.append(" ");
+        String message = MessageFormatter.basicArrayFormat(messagePattern, arguments);
         pw.append(message);
-        if (t != null) {
-            t.printStackTrace(pw);
+        if (throwable != null) {
+            throwable.printStackTrace(pw);
         }
         PrintStream printStream = MvndSimpleLogger.CONFIG_PARAMS.outputChoice.getTargetPrintStream();
         printStream.println(sw);

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndFailOnSeverityLogger.java

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.slf4j.impl;
+package org.mvndaemon.mvnd.logging.slf4j;
 
 import org.apache.maven.logwrapper.LogLevelRecorder;
 import org.slf4j.event.Level;

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndLoggerFactory.java

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.slf4j.impl;
+package org.mvndaemon.mvnd.logging.slf4j;
 
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndServiceProvider.java

@@ -0,0 +1,65 @@
+/*
+ * 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.mvndaemon.mvnd.logging.slf4j;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.helpers.BasicMDCAdapter;
+import org.slf4j.helpers.BasicMarkerFactory;
+import org.slf4j.spi.MDCAdapter;
+import org.slf4j.spi.SLF4JServiceProvider;
+
+public class MvndServiceProvider implements SLF4JServiceProvider {
+
+    /**
+     * Declare the version of the SLF4J API this implementation is compiled against.
+     * The value of this field is modified with each major release.
+     */
+    // to avoid constant folding by the compiler, this field must *not* be final
+    @SuppressWarnings({"checkstyle:StaticVariableName", "checkstyle:VisibilityModifier"})
+    public static String REQUESTED_API_VERSION = "2.0.99"; // !final
+
+    private MvndLoggerFactory loggerFactory = new MvndLoggerFactory();
+    private IMarkerFactory markerFactory = new BasicMarkerFactory();
+    private MDCAdapter mdcAdapter = new BasicMDCAdapter();
+
+    public ILoggerFactory getLoggerFactory() {
+        return loggerFactory;
+    }
+
+    @Override
+    public IMarkerFactory getMarkerFactory() {
+        return markerFactory;
+    }
+
+    @Override
+    public MDCAdapter getMDCAdapter() {
+        return mdcAdapter;
+    }
+
+    @Override
+    public String getRequestedApiVersion() {
+        return REQUESTED_API_VERSION;
+    }
+
+    @Override
+    public void initialize() {
+        // already initialized
+    }
+}

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/MvndSimpleLogger.java

@@ -16,15 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.slf4j.impl;
+package org.mvndaemon.mvnd.logging.slf4j;
 
-import java.util.Date;
 import java.util.function.Consumer;
 
-import org.apache.maven.shared.utils.logging.MessageBuilder;
-import org.apache.maven.shared.utils.logging.MessageUtils;
+import org.apache.maven.api.services.MessageBuilder;
+import org.apache.maven.jline.MessageUtils;
 
-import static org.apache.maven.shared.utils.logging.MessageUtils.level;
+import static org.apache.maven.jline.MessageUtils.builder;
 
 /**
  * Logger for Maven, that support colorization of levels and stacktraces. This class implements 2 methods introduced in
@@ -34,12 +33,12 @@ import static org.apache.maven.shared.utils.logging.MessageUtils.level;
  */
 public class MvndSimpleLogger extends MvndBaseLogger {
 
+    /*
     static final String TID_PREFIX = "tid=";
 
     static long START_TIME = System.currentTimeMillis();
 
     static boolean INITIALIZED = false;
-    static final SimpleLoggerConfiguration CONFIG_PARAMS = new SimpleLoggerConfiguration();
 
     static void lazyInit() {
         if (INITIALIZED) {
@@ -55,6 +54,8 @@ public class MvndSimpleLogger extends MvndBaseLogger {
         CONFIG_PARAMS.init();
     }
 
+     */
+
     static Consumer<String> LOG_SINK;
 
     public static void setLogSink(Consumer<String> logSink) {
@@ -69,67 +70,9 @@ public class MvndSimpleLogger extends MvndBaseLogger {
         configure(CONFIG_PARAMS.defaultLogLevel);
     }
 
-    String recursivelyComputeLevelString() {
-        String tempName = name;
-        String levelString = null;
-        int indexOfLastDot = tempName.length();
-        while ((levelString == null) && (indexOfLastDot > -1)) {
-            tempName = tempName.substring(0, indexOfLastDot);
-            levelString = CONFIG_PARAMS.getStringProperty(SimpleLogger.LOG_KEY_PREFIX + tempName, null);
-            indexOfLastDot = tempName.lastIndexOf(".");
-        }
-        return levelString;
-    }
-
     @Override
-    protected void doLog(int level, String message, Throwable t) {
-        StringBuilder buf = new StringBuilder(32);
-
-        // Append date-time if so configured
-        if (CONFIG_PARAMS.showDateTime) {
-            if (CONFIG_PARAMS.dateFormatter != null) {
-                buf.append(getFormattedDate());
-                buf.append(' ');
-            } else {
-                buf.append(System.currentTimeMillis() - START_TIME);
-                buf.append(' ');
-            }
-        }
-
-        // Append current thread name if so configured
-        if (CONFIG_PARAMS.showThreadName) {
-            buf.append('[');
-            buf.append(Thread.currentThread().getName());
-            buf.append("] ");
-        }
-
-        if (CONFIG_PARAMS.showThreadId) {
-            buf.append(TID_PREFIX);
-            buf.append(Thread.currentThread().getId());
-            buf.append(' ');
-        }
-
-        if (CONFIG_PARAMS.levelInBrackets) buf.append('[');
-
-        // Append a readable representation of the log level
-        String levelStr = renderLevel(level);
-        buf.append(levelStr);
-        if (CONFIG_PARAMS.levelInBrackets) buf.append(']');
-        buf.append(' ');
-
-        // Append the name of the log instance if so configured
-        if (CONFIG_PARAMS.showShortLogName) {
-            if (shortLogName == null) shortLogName = computeShortName();
-            buf.append(String.valueOf(shortLogName)).append(" - ");
-        } else if (CONFIG_PARAMS.showLogName) {
-            buf.append(String.valueOf(name)).append(" - ");
-        }
-
-        // Append the message
-        buf.append(message);
-
+    void write(StringBuilder buf, Throwable t) {
         writeThrowable(t, buf);
-
         Consumer<String> sink = LOG_SINK;
         if (sink != null) {
             sink.accept(buf.toString());
@@ -138,28 +81,19 @@ public class MvndSimpleLogger extends MvndBaseLogger {
         }
     }
 
-    protected String getFormattedDate() {
-        Date now = new Date();
-        return CONFIG_PARAMS.dateFormatter.format(now);
-    }
-
-    private String computeShortName() {
-        return name.substring(name.lastIndexOf(".") + 1);
-    }
-
     protected String renderLevel(int level) {
         switch (level) {
             case LOG_LEVEL_TRACE:
-                return level().debug("TRACE").toString();
+                return builder().trace("TRACE").build();
             case LOG_LEVEL_DEBUG:
-                return level().debug("DEBUG").toString();
+                return builder().debug("DEBUG").build();
             case LOG_LEVEL_INFO:
-                return level().info("INFO").toString();
+                return builder().info("INFO").build();
             case LOG_LEVEL_WARN:
-                return level().warning("WARNING").toString();
+                return builder().warning("WARNING").build();
             case LOG_LEVEL_ERROR:
             default:
-                return level().error("ERROR").toString();
+                return builder().error("ERROR").build();
         }
     }
 
@@ -167,13 +101,14 @@ public class MvndSimpleLogger extends MvndBaseLogger {
         if (t == null) {
             return;
         }
-        MessageBuilder builder = MessageUtils.buffer(sb);
+        MessageBuilder builder = MessageUtils.builder();
         builder.failure(t.getClass().getName());
         if (t.getMessage() != null) {
             builder.a(": ");
             builder.failure(t.getMessage());
         }
         builder.newline();
+        sb.append(builder);
 
         printStackTrace(t, builder, "");
     }

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/OutputChoice.java

@@ -0,0 +1,75 @@
+/*
+ * 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.mvndaemon.mvnd.logging.slf4j;
+
+import java.io.PrintStream;
+
+/**
+ * This class encapsulates the user's choice of output target.
+ *
+ * @author Ceki Gülcü
+ *
+ */
+class OutputChoice {
+
+    enum OutputChoiceType {
+        SYS_OUT,
+        CACHED_SYS_OUT,
+        SYS_ERR,
+        CACHED_SYS_ERR,
+        FILE;
+    }
+
+    final OutputChoiceType outputChoiceType;
+    final PrintStream targetPrintStream;
+
+    OutputChoice(OutputChoiceType outputChoiceType) {
+        if (outputChoiceType == OutputChoiceType.FILE) {
+            throw new IllegalArgumentException();
+        }
+        this.outputChoiceType = outputChoiceType;
+        if (outputChoiceType == OutputChoiceType.CACHED_SYS_OUT) {
+            this.targetPrintStream = System.out;
+        } else if (outputChoiceType == OutputChoiceType.CACHED_SYS_ERR) {
+            this.targetPrintStream = System.err;
+        } else {
+            this.targetPrintStream = null;
+        }
+    }
+
+    OutputChoice(PrintStream printStream) {
+        this.outputChoiceType = OutputChoiceType.FILE;
+        this.targetPrintStream = printStream;
+    }
+
+    PrintStream getTargetPrintStream() {
+        switch (outputChoiceType) {
+            case SYS_OUT:
+                return System.out;
+            case SYS_ERR:
+                return System.err;
+            case CACHED_SYS_ERR:
+            case CACHED_SYS_OUT:
+            case FILE:
+                return targetPrintStream;
+            default:
+                throw new IllegalArgumentException();
+        }
+    }
+}

logging/src/main/java/org/mvndaemon/mvnd/logging/slf4j/SimpleLoggerConfiguration.java

@@ -0,0 +1,207 @@
+/*
+ * 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.mvndaemon.mvnd.logging.slf4j;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Properties;
+
+import org.mvndaemon.mvnd.logging.slf4j.OutputChoice.OutputChoiceType;
+import org.slf4j.helpers.Reporter;
+
+/**
+ * This class holds configuration values for {@link MvndBaseLogger}. The
+ * values are computed at runtime. See {@link MvndBaseLogger} documentation for
+ * more information.
+ *
+ *
+ * @author Ceki Gülcü
+ * @author Scott Sanders
+ * @author Rod Waldhoff
+ * @author Robert Burrell Donkin
+ * @author Cédrik LIME
+ *
+ * @since 1.7.25
+ */
+public class SimpleLoggerConfiguration {
+
+    private static final String CONFIGURATION_FILE = "simplelogger.properties";
+
+    static int DEFAULT_LOG_LEVEL_DEFAULT = MvndBaseLogger.LOG_LEVEL_INFO;
+    int defaultLogLevel = DEFAULT_LOG_LEVEL_DEFAULT;
+
+    private static final boolean SHOW_DATE_TIME_DEFAULT = false;
+    boolean showDateTime = SHOW_DATE_TIME_DEFAULT;
+
+    private static final String DATE_TIME_FORMAT_STR_DEFAULT = null;
+    private static String dateTimeFormatStr = DATE_TIME_FORMAT_STR_DEFAULT;
+
+    DateFormat dateFormatter = null;
+
+    private static final boolean SHOW_THREAD_NAME_DEFAULT = true;
+    boolean showThreadName = SHOW_THREAD_NAME_DEFAULT;
+
+    /**
+     * See https://jira.qos.ch/browse/SLF4J-499
+     * @since 1.7.33 and 2.0.0-alpha6
+     */
+    private static final boolean SHOW_THREAD_ID_DEFAULT = false;
+
+    boolean showThreadId = SHOW_THREAD_ID_DEFAULT;
+
+    static final boolean SHOW_LOG_NAME_DEFAULT = true;
+    boolean showLogName = SHOW_LOG_NAME_DEFAULT;
+
+    private static final boolean SHOW_SHORT_LOG_NAME_DEFAULT = false;
+    boolean showShortLogName = SHOW_SHORT_LOG_NAME_DEFAULT;
+
+    private static final boolean LEVEL_IN_BRACKETS_DEFAULT = false;
+    boolean levelInBrackets = LEVEL_IN_BRACKETS_DEFAULT;
+
+    private static final String LOG_FILE_DEFAULT = "System.err";
+    private String logFile = LOG_FILE_DEFAULT;
+    OutputChoice outputChoice = null;
+
+    private static final boolean CACHE_OUTPUT_STREAM_DEFAULT = false;
+    private boolean cacheOutputStream = CACHE_OUTPUT_STREAM_DEFAULT;
+
+    private static final String WARN_LEVELS_STRING_DEFAULT = "WARN";
+    String warnLevelString = WARN_LEVELS_STRING_DEFAULT;
+
+    private final Properties properties = new Properties();
+
+    void init() {
+        loadProperties();
+
+        String defaultLogLevelString = getStringProperty(MvndBaseLogger.DEFAULT_LOG_LEVEL_KEY, null);
+        if (defaultLogLevelString != null) defaultLogLevel = stringToLevel(defaultLogLevelString);
+
+        showLogName =
+                getBooleanProperty(MvndBaseLogger.SHOW_LOG_NAME_KEY, SimpleLoggerConfiguration.SHOW_LOG_NAME_DEFAULT);
+        showShortLogName = getBooleanProperty(MvndBaseLogger.SHOW_SHORT_LOG_NAME_KEY, SHOW_SHORT_LOG_NAME_DEFAULT);
+        showDateTime = getBooleanProperty(MvndBaseLogger.SHOW_DATE_TIME_KEY, SHOW_DATE_TIME_DEFAULT);
+        showThreadName = getBooleanProperty(MvndBaseLogger.SHOW_THREAD_NAME_KEY, SHOW_THREAD_NAME_DEFAULT);
+        showThreadId = getBooleanProperty(MvndBaseLogger.SHOW_THREAD_ID_KEY, SHOW_THREAD_ID_DEFAULT);
+        dateTimeFormatStr = getStringProperty(MvndBaseLogger.DATE_TIME_FORMAT_KEY, DATE_TIME_FORMAT_STR_DEFAULT);
+        levelInBrackets = getBooleanProperty(MvndBaseLogger.LEVEL_IN_BRACKETS_KEY, LEVEL_IN_BRACKETS_DEFAULT);
+        warnLevelString = getStringProperty(MvndBaseLogger.WARN_LEVEL_STRING_KEY, WARN_LEVELS_STRING_DEFAULT);
+
+        logFile = getStringProperty(MvndBaseLogger.LOG_FILE_KEY, logFile);
+
+        cacheOutputStream =
+                getBooleanProperty(MvndBaseLogger.CACHE_OUTPUT_STREAM_STRING_KEY, CACHE_OUTPUT_STREAM_DEFAULT);
+        outputChoice = computeOutputChoice(logFile, cacheOutputStream);
+
+        if (dateTimeFormatStr != null) {
+            try {
+                dateFormatter = new SimpleDateFormat(dateTimeFormatStr);
+            } catch (IllegalArgumentException e) {
+                Reporter.error("Bad date format in " + CONFIGURATION_FILE + "; will output relative time", e);
+            }
+        }
+    }
+
+    private void loadProperties() {
+        // Add props from the resource simplelogger.properties
+        InputStream in = AccessController.doPrivileged((PrivilegedAction<InputStream>) () -> {
+            ClassLoader threadCL = Thread.currentThread().getContextClassLoader();
+            if (threadCL != null) {
+                return threadCL.getResourceAsStream(CONFIGURATION_FILE);
+            } else {
+                return ClassLoader.getSystemResourceAsStream(CONFIGURATION_FILE);
+            }
+        });
+        if (null != in) {
+            try {
+                properties.load(in);
+            } catch (java.io.IOException e) {
+                // ignored
+            } finally {
+                try {
+                    in.close();
+                } catch (java.io.IOException e) {
+                    // ignored
+                }
+            }
+        }
+    }
+
+    String getStringProperty(String name, String defaultValue) {
+        String prop = getStringProperty(name);
+        return (prop == null) ? defaultValue : prop;
+    }
+
+    boolean getBooleanProperty(String name, boolean defaultValue) {
+        String prop = getStringProperty(name);
+        return (prop == null) ? defaultValue : "true".equalsIgnoreCase(prop);
+    }
+
+    String getStringProperty(String name) {
+        String prop = null;
+        try {
+            prop = System.getProperty(name);
+        } catch (SecurityException e) {
+            ; // Ignore
+        }
+        return (prop == null) ? properties.getProperty(name) : prop;
+    }
+
+    static int stringToLevel(String levelStr) {
+        if ("trace".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_TRACE;
+        } else if ("debug".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_DEBUG;
+        } else if ("info".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_INFO;
+        } else if ("warn".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_WARN;
+        } else if ("error".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_ERROR;
+        } else if ("off".equalsIgnoreCase(levelStr)) {
+            return MvndBaseLogger.LOG_LEVEL_OFF;
+        }
+        // assume INFO by default
+        return MvndBaseLogger.LOG_LEVEL_INFO;
+    }
+
+    private static OutputChoice computeOutputChoice(String logFile, boolean cacheOutputStream) {
+        if ("System.err".equalsIgnoreCase(logFile))
+            if (cacheOutputStream) return new OutputChoice(OutputChoiceType.CACHED_SYS_ERR);
+            else return new OutputChoice(OutputChoiceType.SYS_ERR);
+        else if ("System.out".equalsIgnoreCase(logFile)) {
+            if (cacheOutputStream) return new OutputChoice(OutputChoiceType.CACHED_SYS_OUT);
+            else return new OutputChoice(OutputChoiceType.SYS_OUT);
+        } else {
+            try {
+                FileOutputStream fos = new FileOutputStream(logFile);
+                PrintStream printStream = new PrintStream(fos);
+                return new OutputChoice(printStream);
+            } catch (FileNotFoundException e) {
+                Reporter.error("Could not open [" + logFile + "]. Defaulting to System.err", e);
+                return new OutputChoice(OutputChoiceType.SYS_ERR);
+            }
+        }
+    }
+}

logging/src/main/java/org/mvndaemon/mvnd/logging/smart/ProjectBuildLogAppender.java

@@ -18,8 +18,8 @@
  */
 package org.mvndaemon.mvnd.logging.smart;
 
+import org.mvndaemon.mvnd.logging.slf4j.MvndSimpleLogger;
 import org.slf4j.MDC;
-import org.slf4j.impl.MvndSimpleLogger;
 
 /**
  * Forwards log messages to the client.

logging/src/main/java/org/slf4j/impl/MvndBaseLogger.java

@@ -1,299 +0,0 @@
-/*
- * 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.slf4j.impl;
-
-import org.slf4j.event.LoggingEvent;
-import org.slf4j.helpers.FormattingTuple;
-import org.slf4j.helpers.MarkerIgnoringBase;
-import org.slf4j.helpers.MessageFormatter;
-import org.slf4j.spi.LocationAwareLogger;
-
-public abstract class MvndBaseLogger extends MarkerIgnoringBase {
-
-    protected static final int LOG_LEVEL_TRACE = LocationAwareLogger.TRACE_INT;
-    protected static final int LOG_LEVEL_DEBUG = LocationAwareLogger.DEBUG_INT;
-    protected static final int LOG_LEVEL_INFO = LocationAwareLogger.INFO_INT;
-    protected static final int LOG_LEVEL_WARN = LocationAwareLogger.WARN_INT;
-    protected static final int LOG_LEVEL_ERROR = LocationAwareLogger.ERROR_INT;
-
-    /** The current log level */
-    protected int currentLogLevel = LOG_LEVEL_INFO;
-
-    public MvndBaseLogger(String name) {
-        this.name = name;
-    }
-
-    protected void formatAndLog(int level, String format, Object arg1, Object arg2) {
-        if (!isLevelEnabled(level)) {
-            return;
-        }
-        FormattingTuple tp = MessageFormatter.format(format, arg1, arg2);
-        log(level, tp.getMessage(), tp.getThrowable());
-    }
-
-    protected void formatAndLog(int level, String format, Object... arguments) {
-        if (!isLevelEnabled(level)) {
-            return;
-        }
-        FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
-        log(level, tp.getMessage(), tp.getThrowable());
-    }
-
-    protected void log(int level, String message, Throwable t) {
-        if (!isLevelEnabled(level)) {
-            return;
-        }
-        doLog(level, message, t);
-    }
-
-    protected abstract void doLog(int level, String message, Throwable t);
-
-    /**
-     * Is the given log level currently enabled?
-     *
-     * @param logLevel
-     *            is this level enabled?
-     */
-    protected boolean isLevelEnabled(int logLevel) {
-        // log level are numerically ordered so can use simple numeric
-        // comparison
-        return (logLevel >= currentLogLevel);
-    }
-
-    /** Are {@code trace} messages currently enabled? */
-    public boolean isTraceEnabled() {
-        return isLevelEnabled(LOG_LEVEL_TRACE);
-    }
-
-    /**
-     * A simple implementation which logs messages of level TRACE according to
-     * the format outlined above.
-     */
-    public void trace(String msg) {
-        log(LOG_LEVEL_TRACE, msg, null);
-    }
-
-    /**
-     * Perform single parameter substitution before logging the message of level
-     * TRACE according to the format outlined above.
-     */
-    public void trace(String format, Object param1) {
-        formatAndLog(LOG_LEVEL_TRACE, format, param1, null);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * TRACE according to the format outlined above.
-     */
-    public void trace(String format, Object param1, Object param2) {
-        formatAndLog(LOG_LEVEL_TRACE, format, param1, param2);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * TRACE according to the format outlined above.
-     */
-    public void trace(String format, Object... argArray) {
-        formatAndLog(LOG_LEVEL_TRACE, format, argArray);
-    }
-
-    /** Log a message of level TRACE, including an exception. */
-    public void trace(String msg, Throwable t) {
-        log(LOG_LEVEL_TRACE, msg, t);
-    }
-
-    /** Are {@code debug} messages currently enabled? */
-    public boolean isDebugEnabled() {
-        return isLevelEnabled(LOG_LEVEL_DEBUG);
-    }
-
-    /**
-     * A simple implementation which logs messages of level DEBUG according to
-     * the format outlined above.
-     */
-    public void debug(String msg) {
-        log(LOG_LEVEL_DEBUG, msg, null);
-    }
-
-    /**
-     * Perform single parameter substitution before logging the message of level
-     * DEBUG according to the format outlined above.
-     */
-    public void debug(String format, Object param1) {
-        formatAndLog(LOG_LEVEL_DEBUG, format, param1, null);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * DEBUG according to the format outlined above.
-     */
-    public void debug(String format, Object param1, Object param2) {
-        formatAndLog(LOG_LEVEL_DEBUG, format, param1, param2);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * DEBUG according to the format outlined above.
-     */
-    public void debug(String format, Object... argArray) {
-        formatAndLog(LOG_LEVEL_DEBUG, format, argArray);
-    }
-
-    /** Log a message of level DEBUG, including an exception. */
-    public void debug(String msg, Throwable t) {
-        log(LOG_LEVEL_DEBUG, msg, t);
-    }
-
-    /** Are {@code info} messages currently enabled? */
-    public boolean isInfoEnabled() {
-        return isLevelEnabled(LOG_LEVEL_INFO);
-    }
-
-    /**
-     * A simple implementation which logs messages of level INFO according to
-     * the format outlined above.
-     */
-    public void info(String msg) {
-        log(LOG_LEVEL_INFO, msg, null);
-    }
-
-    /**
-     * Perform single parameter substitution before logging the message of level
-     * INFO according to the format outlined above.
-     */
-    public void info(String format, Object arg) {
-        formatAndLog(LOG_LEVEL_INFO, format, arg, null);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * INFO according to the format outlined above.
-     */
-    public void info(String format, Object arg1, Object arg2) {
-        formatAndLog(LOG_LEVEL_INFO, format, arg1, arg2);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * INFO according to the format outlined above.
-     */
-    public void info(String format, Object... argArray) {
-        formatAndLog(LOG_LEVEL_INFO, format, argArray);
-    }
-
-    /** Log a message of level INFO, including an exception. */
-    public void info(String msg, Throwable t) {
-        log(LOG_LEVEL_INFO, msg, t);
-    }
-
-    /** Are {@code warn} messages currently enabled? */
-    public boolean isWarnEnabled() {
-        return isLevelEnabled(LOG_LEVEL_WARN);
-    }
-
-    /**
-     * A simple implementation which always logs messages of level WARN
-     * according to the format outlined above.
-     */
-    public void warn(String msg) {
-        log(LOG_LEVEL_WARN, msg, null);
-    }
-
-    /**
-     * Perform single parameter substitution before logging the message of level
-     * WARN according to the format outlined above.
-     */
-    public void warn(String format, Object arg) {
-        formatAndLog(LOG_LEVEL_WARN, format, arg, null);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * WARN according to the format outlined above.
-     */
-    public void warn(String format, Object arg1, Object arg2) {
-        formatAndLog(LOG_LEVEL_WARN, format, arg1, arg2);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * WARN according to the format outlined above.
-     */
-    public void warn(String format, Object... argArray) {
-        formatAndLog(LOG_LEVEL_WARN, format, argArray);
-    }
-
-    /** Log a message of level WARN, including an exception. */
-    public void warn(String msg, Throwable t) {
-        log(LOG_LEVEL_WARN, msg, t);
-    }
-
-    /** Are {@code error} messages currently enabled? */
-    public boolean isErrorEnabled() {
-        return isLevelEnabled(LOG_LEVEL_ERROR);
-    }
-
-    /**
-     * A simple implementation which always logs messages of level ERROR
-     * according to the format outlined above.
-     */
-    public void error(String msg) {
-        log(LOG_LEVEL_ERROR, msg, null);
-    }
-
-    /**
-     * Perform single parameter substitution before logging the message of level
-     * ERROR according to the format outlined above.
-     */
-    public void error(String format, Object arg) {
-        formatAndLog(LOG_LEVEL_ERROR, format, arg, null);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * ERROR according to the format outlined above.
-     */
-    public void error(String format, Object arg1, Object arg2) {
-        formatAndLog(LOG_LEVEL_ERROR, format, arg1, arg2);
-    }
-
-    /**
-     * Perform double parameter substitution before logging the message of level
-     * ERROR according to the format outlined above.
-     */
-    public void error(String format, Object... argArray) {
-        formatAndLog(LOG_LEVEL_ERROR, format, argArray);
-    }
-
-    /** Log a message of level ERROR, including an exception. */
-    public void error(String msg, Throwable t) {
-        log(LOG_LEVEL_ERROR, msg, t);
-    }
-
-    public void log(LoggingEvent event) {
-        int levelInt = event.getLevel().toInt();
-
-        if (!isLevelEnabled(levelInt)) {
-            return;
-        }
-        FormattingTuple tp =
-                MessageFormatter.arrayFormat(event.getMessage(), event.getArgumentArray(), event.getThrowable());
-        log(levelInt, tp.getMessage(), event.getThrowable());
-    }
-}

logging/src/main/java/org/slf4j/impl/StaticLoggerBinder.java

@@ -1,82 +0,0 @@
-/*
- * 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.slf4j.impl;
-
-import org.slf4j.ILoggerFactory;
-import org.slf4j.spi.LoggerFactoryBinder;
-
-/**
- * SLF4J LoggerFactoryBinder implementation using MavenSimpleLogger.
- * This class is part of the required classes used to specify an
- * SLF4J logger provider implementation.
- *
- * @since 3.5.1
- */
-public final class StaticLoggerBinder implements LoggerFactoryBinder {
-    /**
-     * Declare the version of the SLF4J API this implementation is compiled
-     * against. The value of this field is usually modified with each release.
-     */
-    // to avoid constant folding by the compiler, this field must *not* be final
-    @SuppressWarnings({"checkstyle:staticvariablename", "checkstyle:visibilitymodifier"})
-    public static String REQUESTED_API_VERSION = "1.7.25"; // !final
-
-    private static final String LOGGER_FACTORY_CLASS_STR = MvndLoggerFactory.class.getName();
-
-    /**
-     * The unique instance of this class.
-     */
-    private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();
-
-    /**
-     * The ILoggerFactory instance returned by the {@link #getLoggerFactory}
-     * method should always be the same object
-     */
-    private final ILoggerFactory loggerFactory;
-
-    /**
-     * Private constructor to prevent instantiation
-     */
-    private StaticLoggerBinder() {
-        loggerFactory = new MvndLoggerFactory();
-    }
-
-    /**
-     * Returns the singleton of this class.
-     */
-    public static StaticLoggerBinder getSingleton() {
-        return SINGLETON;
-    }
-
-    /**
-     * Returns the factory.
-     */
-    @Override
-    public ILoggerFactory getLoggerFactory() {
-        return loggerFactory;
-    }
-
-    /**
-     * Returns the class name.
-     */
-    @Override
-    public String getLoggerFactoryClassStr() {
-        return LOGGER_FACTORY_CLASS_STR;
-    }
-}

logging/src/main/java/org/slf4j/impl/StaticMDCBinder.java

@@ -1,57 +0,0 @@
-/*
- * 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.slf4j.impl;
-
-import org.slf4j.helpers.BasicMDCAdapter;
-import org.slf4j.spi.MDCAdapter;
-
-/**
- * This implementation is bound to {@link BasicMDCAdapter}.
- */
-public class StaticMDCBinder {
-
-    /**
-     * The unique instance of this class.
-     */
-    public static final StaticMDCBinder SINGLETON = new StaticMDCBinder();
-
-    private StaticMDCBinder() {}
-
-    /**
-     * Return the singleton of this class.
-     *
-     * @return the StaticMDCBinder singleton
-     * @since 1.7.14
-     */
-    public static final StaticMDCBinder getSingleton() {
-        return SINGLETON;
-    }
-
-    /**
-     * Currently this method always returns an instance of
-     * {@link StaticMDCBinder}.
-     */
-    public MDCAdapter getMDCA() {
-        return new BasicMDCAdapter();
-    }
-
-    public String getMDCAdapterClassStr() {
-        return BasicMDCAdapter.class.getName();
-    }
-}

logging/src/main/resources/META-INF/maven/slf4j-configuration.properties

@@ -17,4 +17,4 @@
 
 # key = Slf4j effective logger factory implementation
 # value = corresponding o.a.m.cli.logging.Slf4jConfiguration class
-org.slf4j.impl.MvndLoggerFactory org.slf4j.impl.MvndConfiguration
+org.mvndaemon.mvnd.logging.slf4j.MvndLoggerFactory org.mvndaemon.mvnd.logging.slf4j.MvndConfiguration

logging/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider

@@ -0,0 +1 @@
+org.mvndaemon.mvnd.logging.slf4j.MvndServiceProvider