diff --git a/.travis.yml b/.travis.yml index 74f2ed9..af8e2b8 100755 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,9 @@ language: java + +jdk: + - openjdk8 + notifications: email: - notification@qos.ch + diff --git a/integration/build.xml b/integration/build.xml index 6f7bb03..e4ce964 100755 --- a/integration/build.xml +++ b/integration/build.xml @@ -56,7 +56,12 @@ - + + + + + + @@ -102,11 +107,12 @@ @@ -215,7 +221,17 @@ - + + + + + + + + + diff --git a/integration/pom.xml b/integration/pom.xml index b612ae6..a34a9a2 100755 --- a/integration/pom.xml +++ b/integration/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 integration diff --git a/integration/src/test/java/org/slf4j/helpers/LoggerAccessingThread2.java b/integration/src/test/java/org/slf4j/helpers/LoggerAccessingThread2.java new file mode 100644 index 0000000..86590b3 --- /dev/null +++ b/integration/src/test/java/org/slf4j/helpers/LoggerAccessingThread2.java @@ -0,0 +1,65 @@ +/** + * Copyright (c) 2004-2016 QOS.ch + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package org.slf4j.helpers; + +import java.util.List; +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.atomic.AtomicLong; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class LoggerAccessingThread2 extends Thread { + private static int LOOP_LEN = 64; + + final CyclicBarrier barrier; + final int count; + final AtomicLong eventCount; + List loggerList; + + public LoggerAccessingThread2(final CyclicBarrier barrier, List loggerList, final int count, final AtomicLong eventCount) { + this.barrier = barrier; + this.loggerList = loggerList; + this.count = count; + this.eventCount = eventCount; + } + + public void run() { + try { + barrier.await(); + } catch (Exception e) { + e.printStackTrace(); + } + + String loggerNamePrefix = this.getClass().getName(); + for (int i = 0; i < LOOP_LEN; i++) { + Logger logger = LoggerFactory.getLogger(loggerNamePrefix + "-" + count + "-" + i); + loggerList.add(logger); + Thread.yield(); + logger.info("in run method"); + eventCount.getAndIncrement(); + } + } +} diff --git a/integration/src/test/java/org/slf4j/helpers/NoBindingMultithreadedInitializationTest2.java b/integration/src/test/java/org/slf4j/helpers/NoBindingMultithreadedInitializationTest2.java new file mode 100644 index 0000000..6de0f8e --- /dev/null +++ b/integration/src/test/java/org/slf4j/helpers/NoBindingMultithreadedInitializationTest2.java @@ -0,0 +1,112 @@ +/** + * Copyright (c) 2004-2016 QOS.ch + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package org.slf4j.helpers; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.atomic.AtomicLong; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.slf4j.event.EventRecodingLogger; + +import junit.framework.TestCase; + +public class NoBindingMultithreadedInitializationTest2 extends TestCase { + final protected static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; + + private final List createdLoggers = Collections.synchronizedList(new ArrayList()); + + protected final AtomicLong eventCount = new AtomicLong(0); + final private CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); + + int diff = new Random().nextInt(10000); + + + public NoBindingMultithreadedInitializationTest2(String name) { + super(name); + } + + public void testNoBindingMultiThreadedInitialization() throws InterruptedException, BrokenBarrierException { + @SuppressWarnings("unused") + LoggerAccessingThread2[] accessors = harness(); + + Logger logger = LoggerFactory.getLogger(getClass().getName()); + logger.info("hello"); + eventCount.getAndIncrement(); + + assertAllSubstLoggersAreFixed(); + long recordedEventCount = getRecordedEventCount(); + int LENIENCY_COUNT = 16; + + long expectedEventCount = eventCount.get() + extraLogEvents(); + + assertTrue(expectedEventCount + " >= " + recordedEventCount, expectedEventCount >= recordedEventCount); + assertTrue(expectedEventCount + " < " + recordedEventCount + "+" + LENIENCY_COUNT, + expectedEventCount < recordedEventCount + LENIENCY_COUNT); + } + + protected int extraLogEvents() { + return 0; + } + + private void assertAllSubstLoggersAreFixed() { + for (Logger logger : createdLoggers) { + if (logger instanceof SubstituteLogger) { + SubstituteLogger substLogger = (SubstituteLogger) logger; + if (substLogger.delegate() instanceof EventRecodingLogger) + fail("substLogger " + substLogger.getName() + " has a delegate of type EventRecodingLogger"); + } + } + } + + private LoggerAccessingThread2[] harness() throws InterruptedException, BrokenBarrierException { + LoggerAccessingThread2[] threads = new LoggerAccessingThread2[THREAD_COUNT]; + for (int i = 0; i < THREAD_COUNT; i++) { + threads[i] = new LoggerAccessingThread2(barrier, createdLoggers, i, eventCount); + threads[i].start(); + } + + // trigger barrier + barrier.await(); + + for (int i = 0; i < THREAD_COUNT; i++) { + threads[i].join(); + } + + return threads; + } + + final String loggerName = this.getClass().getName(); + + protected long getRecordedEventCount() { + return eventCount.get(); + } + +} diff --git a/jcl-over-slf4j/pom.xml b/jcl-over-slf4j/pom.xml index 7173c01..2c3c7a6 100755 --- a/jcl-over-slf4j/pom.xml +++ b/jcl-over-slf4j/pom.xml @@ -5,7 +5,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 4.0.0 @@ -15,6 +15,14 @@ JCL 1.2 implemented over SLF4J JCL 1.2 implemented over SLF4J http://www.slf4j.org + + + + Apache License, Version 2.0 + https://www.apache.org/licenses/LICENSE-2.0.txt + repo + + diff --git a/jcl-over-slf4j/src/main/resources/META-INF/MANIFEST.MF b/jcl-over-slf4j/src/main/resources/META-INF/MANIFEST.MF index bb1d43e..3b3a1bf 100755 --- a/jcl-over-slf4j/src/main/resources/META-INF/MANIFEST.MF +++ b/jcl-over-slf4j/src/main/resources/META-INF/MANIFEST.MF @@ -4,6 +4,7 @@ Bundle-Name: jcl-over-slf4j Bundle-Vendor: SLF4J.ORG Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.apache.commons.logging Export-Package: org.apache.commons.logging;version=1.2, org.apache.commons.logging.impl;version=1.2 Import-Package: org.slf4j;version=${parsedVersion.osgiVersion}, org.slf4j.spi;version=${parsedVersion.osgiVersion} diff --git a/jul-to-slf4j/pom.xml b/jul-to-slf4j/pom.xml index 9f1c8b2..85ea8d0 100755 --- a/jul-to-slf4j/pom.xml +++ b/jul-to-slf4j/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 jul-to-slf4j diff --git a/log4j-over-slf4j/pom.xml b/log4j-over-slf4j/pom.xml index 2e6f87f..80226f5 100755 --- a/log4j-over-slf4j/pom.xml +++ b/log4j-over-slf4j/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 diff --git a/log4j-over-slf4j/src/main/resources/META-INF/MANIFEST.MF b/log4j-over-slf4j/src/main/resources/META-INF/MANIFEST.MF index b63540a..4137322 100755 --- a/log4j-over-slf4j/src/main/resources/META-INF/MANIFEST.MF +++ b/log4j-over-slf4j/src/main/resources/META-INF/MANIFEST.MF @@ -4,6 +4,7 @@ Bundle-Name: log4j-over-slf4j Bundle-Vendor: SLF4J.ORG Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.apache.log4j Export-Package: org.apache.log4j;version=${log4j.version}, org.apache.log4j.helpers;version=${log4j.version}, org.apache.log4j.spi;version=${log4j.version}, diff --git a/osgi-over-slf4j/pom.xml b/osgi-over-slf4j/pom.xml index 967c369..9237dec 100755 --- a/osgi-over-slf4j/pom.xml +++ b/osgi-over-slf4j/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 osgi-over-slf4j diff --git a/pom.xml b/pom.xml index e39dafe..8e71283 100755 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 pom SLF4J @@ -47,7 +47,8 @@ 4.12 3.3 3.0.1 - 2.10.4 + 3.1.0 + none @@ -326,6 +327,9 @@ org.apache.maven.plugins maven-javadoc-plugin ${javadoc.plugin.version} + + none + attach-javadocs diff --git a/slf4j-android/pom.xml b/slf4j-android/pom.xml index bd3d651..1b86e27 100644 --- a/slf4j-android/pom.xml +++ b/slf4j-android/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-android diff --git a/slf4j-api/pom.xml b/slf4j-api/pom.xml index 587adfe..78e96a9 100755 --- a/slf4j-api/pom.xml +++ b/slf4j-api/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-api diff --git a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java index 30b5c72..9ed2c19 100755 --- a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java @@ -150,10 +150,6 @@ StaticLoggerBinder.getSingleton(); INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION; reportActualBinding(staticLoggerBinderPathSet); - fixSubstituteLoggers(); - replayEvents(); - // release all resources in SUBST_FACTORY - SUBST_FACTORY.clear(); } catch (NoClassDefFoundError ncde) { String msg = ncde.getMessage(); if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) { @@ -177,8 +173,17 @@ } catch (Exception e) { failedBinding(e); throw new IllegalStateException("Unexpected initialization failure", e); - } - } + } finally { + postBindCleanUp(); + } + } + + private static void postBindCleanUp() { + fixSubstituteLoggers(); + replayEvents(); + // release all resources in SUBST_FACTORY + SUBST_FACTORY.clear(); + } private static void fixSubstituteLoggers() { synchronized (SUBST_FACTORY) { diff --git a/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java b/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java index b43a32d..978d12d 100755 --- a/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java +++ b/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java @@ -4,13 +4,27 @@ import org.slf4j.Logger; import org.slf4j.Marker; +import org.slf4j.helpers.MessageFormatter; import org.slf4j.helpers.SubstituteLogger; +/** + * + * This class is used to record events during the initialization phase of the + * underlying logging framework. It is called by {@link SubstituteLogger}. + * + * + * @author Ceki Gülcü + * @author Wessel van Norel + * + */ public class EventRecodingLogger implements Logger { String name; SubstituteLogger logger; Queue eventQueue; + + // as an event recording logger we have no choice but to record all events + final static boolean RECORD_ALL_EVENTS = true; public EventRecodingLogger(SubstituteLogger logger, Queue eventQueue) { this.logger = logger; @@ -22,12 +36,276 @@ return name; } - private void recordEvent(Level level, String msg, Object[] args, Throwable throwable) { - recordEvent(level, null, msg, args, throwable); - } - + public boolean isTraceEnabled() { + return RECORD_ALL_EVENTS; + } + + public void trace(String msg) { + recordEvent_0Args(Level.TRACE, null, msg, null); + } + + public void trace(String format, Object arg) { + recordEvent_1Args(Level.TRACE, null, format, arg); + } + + public void trace(String format, Object arg1, Object arg2) { + recordEvent2Args(Level.TRACE, null, format, arg1, arg2); + } + + public void trace(String format, Object... arguments) { + recordEventArgArray(Level.TRACE, null, format, arguments); + } + + public void trace(String msg, Throwable t) { + recordEvent_0Args(Level.TRACE, null, msg, t); + } + + public boolean isTraceEnabled(Marker marker) { + return RECORD_ALL_EVENTS; + } + + public void trace(Marker marker, String msg) { + recordEvent_0Args(Level.TRACE, marker, msg, null); + } + + public void trace(Marker marker, String format, Object arg) { + recordEvent_1Args(Level.TRACE, marker, format, arg); + } + + public void trace(Marker marker, String format, Object arg1, Object arg2) { + recordEvent2Args(Level.TRACE, marker, format, arg1, arg2); + } + + public void trace(Marker marker, String format, Object... argArray) { + recordEventArgArray(Level.TRACE, marker, format, argArray); + } + + public void trace(Marker marker, String msg, Throwable t) { + recordEvent_0Args(Level.TRACE, marker, msg, t); + } + + public boolean isDebugEnabled() { + return RECORD_ALL_EVENTS; + } + + public void debug(String msg) { + recordEvent_0Args(Level.DEBUG, null, msg, null); + } + + public void debug(String format, Object arg) { + recordEvent_1Args(Level.DEBUG, null, format, arg); + } + + public void debug(String format, Object arg1, Object arg2) { + recordEvent2Args(Level.DEBUG, null, format, arg1, arg2); + } + + public void debug(String format, Object... arguments) { + recordEventArgArray(Level.DEBUG, null, format, arguments); + } + + public void debug(String msg, Throwable t) { + recordEvent_0Args(Level.DEBUG, null, msg, t); + } + + public boolean isDebugEnabled(Marker marker) { + return RECORD_ALL_EVENTS; + } + + public void debug(Marker marker, String msg) { + recordEvent_0Args(Level.DEBUG, marker, msg, null); + } + + public void debug(Marker marker, String format, Object arg) { + recordEvent_1Args(Level.DEBUG, marker, format, arg); + } + + public void debug(Marker marker, String format, Object arg1, Object arg2) { + recordEvent2Args(Level.DEBUG, marker, format, arg1, arg2); + } + + public void debug(Marker marker, String format, Object... arguments) { + recordEventArgArray(Level.DEBUG, marker, format, arguments); + } + + public void debug(Marker marker, String msg, Throwable t) { + recordEvent_0Args(Level.DEBUG, marker, msg, t); + } + + public boolean isInfoEnabled() { + return RECORD_ALL_EVENTS; + } + + public void info(String msg) { + recordEvent_0Args(Level.INFO, null, msg, null); + } + + public void info(String format, Object arg) { + recordEvent_1Args(Level.INFO, null, format, arg); + } + + public void info(String format, Object arg1, Object arg2) { + recordEvent2Args(Level.INFO, null, format, arg1, arg2); + } + + public void info(String format, Object... arguments) { + recordEventArgArray(Level.INFO, null, format, arguments); + } + + public void info(String msg, Throwable t) { + recordEvent_0Args(Level.INFO, null, msg, t); + } + + public boolean isInfoEnabled(Marker marker) { + return RECORD_ALL_EVENTS; + } + + public void info(Marker marker, String msg) { + recordEvent_0Args(Level.INFO, marker, msg, null); + } + + public void info(Marker marker, String format, Object arg) { + recordEvent_1Args(Level.INFO, marker, format, arg); + } + + public void info(Marker marker, String format, Object arg1, Object arg2) { + recordEvent2Args(Level.INFO, marker, format, arg1, arg2); + } + + public void info(Marker marker, String format, Object... arguments) { + recordEventArgArray(Level.INFO, marker, format, arguments); + } + + public void info(Marker marker, String msg, Throwable t) { + recordEvent_0Args(Level.INFO, marker, msg, t); + + } + + public boolean isWarnEnabled() { + return RECORD_ALL_EVENTS; + } + + public void warn(String msg) { + recordEvent_0Args(Level.WARN, null, msg, null); + } + + public void warn(String format, Object arg) { + recordEvent_1Args(Level.WARN, null, format, arg); + } + + public void warn(String format, Object arg1, Object arg2) { + recordEvent2Args(Level.WARN, null, format, arg1, arg2); + } + + public void warn(String format, Object... arguments) { + recordEventArgArray(Level.WARN, null, format, arguments); + } + + public void warn(String msg, Throwable t) { + recordEvent_0Args(Level.WARN, null, msg, t); + } + + public boolean isWarnEnabled(Marker marker) { + return RECORD_ALL_EVENTS; + } + + public void warn(Marker marker, String msg) { + recordEvent_0Args(Level.WARN, marker, msg, null); + } + + public void warn(Marker marker, String format, Object arg) { + recordEvent_1Args(Level.WARN, marker, format, arg); + } + + public void warn(Marker marker, String format, Object arg1, Object arg2) { + recordEvent2Args(Level.WARN, marker, format, arg1, arg2); + } + + public void warn(Marker marker, String format, Object... arguments) { + recordEventArgArray(Level.WARN, marker, format, arguments); + } + + public void warn(Marker marker, String msg, Throwable t) { + recordEvent_0Args(Level.WARN, marker, msg, t); + } + + public boolean isErrorEnabled() { + return RECORD_ALL_EVENTS; + } + + public void error(String msg) { + recordEvent_0Args(Level.ERROR, null, msg, null); + } + + public void error(String format, Object arg) { + recordEvent_1Args(Level.ERROR, null, format, arg); + } + + public void error(String format, Object arg1, Object arg2) { + recordEvent2Args(Level.ERROR, null, format, arg1, arg2); + } + + public void error(String format, Object... arguments) { + recordEventArgArray(Level.ERROR, null, format, arguments); + } + + public void error(String msg, Throwable t) { + recordEvent_0Args(Level.ERROR, null, msg, t); + } + + public boolean isErrorEnabled(Marker marker) { + return RECORD_ALL_EVENTS; + } + + public void error(Marker marker, String msg) { + recordEvent_0Args(Level.ERROR, marker, msg, null); + } + + public void error(Marker marker, String format, Object arg) { + recordEvent_1Args(Level.ERROR, marker, format, arg); + } + + public void error(Marker marker, String format, Object arg1, Object arg2) { + recordEvent2Args(Level.ERROR, marker, format, arg1, arg2); + } + + public void error(Marker marker, String format, Object... arguments) { + recordEventArgArray(Level.ERROR, marker, format, arguments); + } + + public void error(Marker marker, String msg, Throwable t) { + recordEvent_0Args(Level.ERROR, marker, msg, t); + } + + private void recordEvent_0Args(Level level, Marker marker, String msg, Throwable t) { + recordEvent(level, marker, msg, null, t); + } + + private void recordEvent_1Args(Level level, Marker marker, String msg, Object arg1) { + recordEvent(level, marker, msg, new Object[] { arg1 }, null); + } + + private void recordEvent2Args(Level level, Marker marker, String msg, Object arg1, Object arg2) { + if (arg2 instanceof Throwable) { + recordEvent(level, marker, msg, new Object[] { arg1 }, (Throwable) arg2); + } else { + recordEvent(level, marker, msg, new Object[] { arg1, arg2 }, null); + } + } + + private void recordEventArgArray(Level level, Marker marker, String msg, Object[] args) { + Throwable throwableCandidate = MessageFormatter.getThrowableCandidate(args); + if (throwableCandidate != null) { + Object[] trimmedCopy = MessageFormatter.trimmedCopy(args); + recordEvent(level, marker, msg, trimmedCopy, throwableCandidate); + } else { + recordEvent(level, marker, msg, args, null); + } + } + + + // WARNING: this method assumes that any throwable is properly extracted private void recordEvent(Level level, Marker marker, String msg, Object[] args, Throwable throwable) { - // System.out.println("recording logger:"+name+", msg:"+msg); SubstituteLoggingEvent loggingEvent = new SubstituteLoggingEvent(); loggingEvent.setTimeStamp(System.currentTimeMillis()); loggingEvent.setLevel(level); @@ -35,262 +313,11 @@ loggingEvent.setLoggerName(name); loggingEvent.setMarker(marker); loggingEvent.setMessage(msg); + loggingEvent.setThreadName(Thread.currentThread().getName()); + loggingEvent.setArgumentArray(args); loggingEvent.setThrowable(throwable); - loggingEvent.setThreadName(Thread.currentThread().getName()); + eventQueue.add(loggingEvent); } - - public boolean isTraceEnabled() { - return true; - } - - public void trace(String msg) { - recordEvent(Level.TRACE, msg, null, null); - } - - public void trace(String format, Object arg) { - recordEvent(Level.TRACE, format, new Object[] { arg }, null); - } - - public void trace(String format, Object arg1, Object arg2) { - recordEvent(Level.TRACE, format, new Object[] { arg1, arg2 }, null); - } - - public void trace(String format, Object... arguments) { - recordEvent(Level.TRACE, format, arguments, null); - } - - public void trace(String msg, Throwable t) { - recordEvent(Level.TRACE, msg, null, t); - } - - public boolean isTraceEnabled(Marker marker) { - return true; - } - - public void trace(Marker marker, String msg) { - recordEvent(Level.TRACE, marker, msg, null, null); - - } - - public void trace(Marker marker, String format, Object arg) { - recordEvent(Level.TRACE, marker, format, new Object[] { arg }, null); - } - - public void trace(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.TRACE, marker, format, new Object[] { arg1, arg2 }, null); - } - - public void trace(Marker marker, String format, Object... argArray) { - recordEvent(Level.TRACE, marker, format, argArray, null); - - } - - public void trace(Marker marker, String msg, Throwable t) { - recordEvent(Level.TRACE, marker, msg, null, t); - } - - public boolean isDebugEnabled() { - return true; - } - - public void debug(String msg) { - recordEvent(Level.TRACE, msg, null, null); - } - - public void debug(String format, Object arg) { - recordEvent(Level.DEBUG, format, new Object[] { arg }, null); - - } - - public void debug(String format, Object arg1, Object arg2) { - recordEvent(Level.DEBUG, format, new Object[] { arg1, arg2 }, null); - - } - - public void debug(String format, Object... arguments) { - recordEvent(Level.DEBUG, format, arguments, null); - } - - public void debug(String msg, Throwable t) { - recordEvent(Level.DEBUG, msg, null, t); - } - - public boolean isDebugEnabled(Marker marker) { - return true; - } - - public void debug(Marker marker, String msg) { - recordEvent(Level.DEBUG, marker, msg, null, null); - } - - public void debug(Marker marker, String format, Object arg) { - recordEvent(Level.DEBUG, marker, format, new Object[] { arg }, null); - } - - public void debug(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.DEBUG, marker, format, new Object[] { arg1, arg2 }, null); - } - - public void debug(Marker marker, String format, Object... arguments) { - recordEvent(Level.DEBUG, marker, format, arguments, null); - } - - public void debug(Marker marker, String msg, Throwable t) { - recordEvent(Level.DEBUG, marker, msg, null, t); - } - - public boolean isInfoEnabled() { - return true; - } - - public void info(String msg) { - recordEvent(Level.INFO, msg, null, null); - } - - public void info(String format, Object arg) { - recordEvent(Level.INFO, format, new Object[] { arg }, null); - } - - public void info(String format, Object arg1, Object arg2) { - recordEvent(Level.INFO, format, new Object[] { arg1, arg2 }, null); - } - - public void info(String format, Object... arguments) { - recordEvent(Level.INFO, format, arguments, null); - } - - public void info(String msg, Throwable t) { - recordEvent(Level.INFO, msg, null, t); - } - - public boolean isInfoEnabled(Marker marker) { - return true; - } - - public void info(Marker marker, String msg) { - recordEvent(Level.INFO, marker, msg, null, null); - } - - public void info(Marker marker, String format, Object arg) { - recordEvent(Level.INFO, marker, format, new Object[] { arg }, null); - } - - public void info(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.INFO, marker, format, new Object[] { arg1, arg2 }, null); - } - - public void info(Marker marker, String format, Object... arguments) { - recordEvent(Level.INFO, marker, format, arguments, null); - } - - public void info(Marker marker, String msg, Throwable t) { - recordEvent(Level.INFO, marker, msg, null, t); - - } - - public boolean isWarnEnabled() { - return true; - } - - public void warn(String msg) { - recordEvent(Level.WARN, msg, null, null); - } - - public void warn(String format, Object arg) { - recordEvent(Level.WARN, format, new Object[] { arg }, null); - - } - - public void warn(String format, Object arg1, Object arg2) { - recordEvent(Level.WARN, format, new Object[] { arg1, arg2 }, null); - } - - public void warn(String format, Object... arguments) { - recordEvent(Level.WARN, format, arguments, null); - } - - public void warn(String msg, Throwable t) { - recordEvent(Level.WARN, msg, null, t); - } - - public boolean isWarnEnabled(Marker marker) { - return true; - } - - public void warn(Marker marker, String msg) { - recordEvent(Level.WARN, msg, null, null); - } - - public void warn(Marker marker, String format, Object arg) { - recordEvent(Level.WARN, format, new Object[] { arg }, null); - } - - public void warn(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.WARN, marker, format, new Object[] { arg1, arg2 }, null); - - } - - public void warn(Marker marker, String format, Object... arguments) { - recordEvent(Level.WARN, marker, format, arguments, null); - } - - public void warn(Marker marker, String msg, Throwable t) { - recordEvent(Level.WARN, marker, msg, null, t); - } - - public boolean isErrorEnabled() { - return true; - } - - public void error(String msg) { - recordEvent(Level.ERROR, msg, null, null); - } - - public void error(String format, Object arg) { - recordEvent(Level.ERROR, format, new Object[] { arg }, null); - - } - - public void error(String format, Object arg1, Object arg2) { - recordEvent(Level.ERROR, format, new Object[] { arg1, arg2 }, null); - - } - - public void error(String format, Object... arguments) { - recordEvent(Level.ERROR, format, arguments, null); - - } - - public void error(String msg, Throwable t) { - recordEvent(Level.ERROR, msg, null, t); - } - - public boolean isErrorEnabled(Marker marker) { - return true; - } - - public void error(Marker marker, String msg) { - recordEvent(Level.ERROR, marker, msg, null, null); - - } - - public void error(Marker marker, String format, Object arg) { - recordEvent(Level.ERROR, marker, format, new Object[] { arg }, null); - - } - - public void error(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.ERROR, marker, format, new Object[] { arg1, arg2 }, null); - } - - public void error(Marker marker, String format, Object... arguments) { - recordEvent(Level.ERROR, marker, format, arguments, null); - } - - public void error(Marker marker, String msg, Throwable t) { - recordEvent(Level.ERROR, marker, msg, null, t); - } - } diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java index bdbfb19..d23a3a6 100755 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java @@ -152,35 +152,13 @@ } - static final Throwable getThrowableCandidate(Object[] argArray) { - if (argArray == null || argArray.length == 0) { - return null; - } - - final Object lastEntry = argArray[argArray.length - 1]; - if (lastEntry instanceof Throwable) { - return (Throwable) lastEntry; - } - return null; - } - final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray) { - Throwable throwableCandidate = getThrowableCandidate(argArray); + Throwable throwableCandidate = MessageFormatter.getThrowableCandidate(argArray); Object[] args = argArray; if (throwableCandidate != null) { - args = trimmedCopy(argArray); + args = MessageFormatter.trimmedCopy(argArray); } return arrayFormat(messagePattern, args, throwableCandidate); - } - - private static Object[] trimmedCopy(Object[] argArray) { - if (argArray == null || argArray.length == 0) { - throw new IllegalStateException("non-sensical empty or null argument array"); - } - final int trimemdLen = argArray.length - 1; - Object[] trimmed = new Object[trimemdLen]; - System.arraycopy(argArray, 0, trimmed, 0, trimemdLen); - return trimmed; } final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray, Throwable throwable) { @@ -411,4 +389,49 @@ sbuf.append(']'); } + /** + * Helper method to determine if an {@link Object} array contains a {@link Throwable} as last element + * + * @param argArray + * The arguments off which we want to know if it contains a {@link Throwable} as last element + * @return if the last {@link Object} in argArray is a {@link Throwable} this method will return it, + * otherwise it returns null + */ + public static Throwable getThrowableCandidate(final Object[] argArray) { + if (argArray == null || argArray.length == 0) { + return null; + } + + final Object lastEntry = argArray[argArray.length - 1]; + if (lastEntry instanceof Throwable) { + return (Throwable) lastEntry; + } + + return null; + } + + /** + * Helper method to get all but the last element of an array + * + * @param argArray + * The arguments from which we want to remove the last element + * + * @return a copy of the array without the last element + */ + public static Object[] trimmedCopy(final Object[] argArray) { + if (argArray == null || argArray.length == 0) { + throw new IllegalStateException("non-sensical empty or null argument array"); + } + + final int trimmedLen = argArray.length - 1; + + Object[] trimmed = new Object[trimmedLen]; + + if (trimmedLen > 0) { + System.arraycopy(argArray, 0, trimmed, 0, trimmedLen); + } + + return trimmed; + } + } diff --git a/slf4j-api/src/main/resources/META-INF/MANIFEST.MF b/slf4j-api/src/main/resources/META-INF/MANIFEST.MF index bd79f8b..6a19bfe 100755 --- a/slf4j-api/src/main/resources/META-INF/MANIFEST.MF +++ b/slf4j-api/src/main/resources/META-INF/MANIFEST.MF @@ -4,6 +4,7 @@ Bundle-Name: slf4j-api Bundle-Vendor: SLF4J.ORG Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.slf4j Export-Package: org.slf4j;version=${parsedVersion.osgiVersion}, org.slf4j.spi;version=${parsedVersion.osgiVersion}, org.slf4j.helpers;version=${parsedVersion.osgiVersion}, diff --git a/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java b/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java new file mode 100644 index 0000000..fa47efb --- /dev/null +++ b/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java @@ -0,0 +1,525 @@ +package org.slf4j.event; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.slf4j.Marker; +import org.slf4j.helpers.BasicMarkerFactory; +import org.slf4j.helpers.SubstituteLogger; + +import java.util.Queue; +import java.util.concurrent.LinkedBlockingQueue; + +import static org.junit.Assert.*; + +public class EventRecodingLoggerTest { + private Queue queue; + private EventRecodingLogger logger; + private String message; + private Object param1; + private Object param2; + private Object param3; + private Object[] oneParam; + private Object[] twoParams; + private Object[] threeParams; + private Throwable exception; + private Marker marker; + + @Before + public void setUp() { + queue = new LinkedBlockingQueue(); + logger = new EventRecodingLogger(new SubstituteLogger("testLogger", queue, true), queue); + message = "Test message with 3 parameters {} {} {} {}"; + param1 = 1; + param2 = 2; + param3 = 3; + oneParam = new Object[] { param1 }; + twoParams = new Object[] { param1, param2 }; + threeParams = new Object[] { param1, param2, param3 }; + exception = new IllegalStateException("We just need an exception"); + marker = new BasicMarkerFactory().getMarker("testMarker"); + } + + @After + public void tearDown() { + assertTrue(queue.isEmpty()); + } + + @Test + public void singleMessage() { + for (Level level : Level.values()) { + singleMessageCheck(level); + } + } + + private void singleMessageCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message); + break; + case DEBUG: + logger.debug(message); + break; + case INFO: + logger.info(message); + break; + case WARN: + logger.warn(message); + break; + case ERROR: + logger.error(message); + break; + } + verifyMessageWithoutMarker(level, null, null); + } + + @Test + public void oneParameter() { + for (Level level : Level.values()) { + oneParameterCheck(level); + } + } + private void oneParameterCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1); + break; + case DEBUG: + logger.debug(message, param1); + break; + case INFO: + logger.info(message, param1); + break; + case WARN: + logger.warn(message, param1); + break; + case ERROR: + logger.error(message, param1); + break; + } + verifyMessageWithoutMarker(level, oneParam, null); + } + + @Test + public void messageTwoParameters() { + for (Level level : Level.values()) { + messageTwoParametersCheck(level); + } + } + + private void messageTwoParametersCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1, param2); + break; + case DEBUG: + logger.debug(message, param1, param2); + break; + case INFO: + logger.info(message, param1, param2); + break; + case WARN: + logger.warn(message, param1, param2); + break; + case ERROR: + logger.error(message, param1, param2); + break; + } + verifyMessageWithoutMarker(level, twoParams, null); + } + + @Test + public void traceMessageThreeParameters() { + for (Level level : Level.values()) { + threeParameterCheck(level); + } + } + + private void threeParameterCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1, param2, param3); + break; + case DEBUG: + logger.debug(message, param1, param2, param3); + break; + case INFO: + logger.info(message, param1, param2, param3); + break; + case WARN: + logger.warn(message, param1, param2, param3); + break; + case ERROR: + logger.error(message, param1, param2, param3); + break; + } + verifyMessageWithoutMarker(level, threeParams, null); + } + + @Test + public void testMessageThrowable() { + for (Level level : Level.values()) { + throwableCheck(level); + } + } + + private void throwableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, exception); + break; + case DEBUG: + logger.debug(message, exception); + break; + case INFO: + logger.info(message, exception); + break; + case WARN: + logger.warn(message, exception); + break; + case ERROR: + logger.error(message, exception); + break; + } + verifyMessageWithoutMarker(level, null, exception); + } + + @Test + public void traceMessageOneParameterThrowable() { + for (Level level : Level.values()) { + oneParamThrowableCheck(level); + } + } + + private void oneParamThrowableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1, exception); + break; + case DEBUG: + logger.debug(message, param1, exception); + break; + case INFO: + logger.info(message, param1, exception); + break; + case WARN: + logger.warn(message, param1, exception); + break; + case ERROR: + logger.error(message, param1, exception); + break; + } + verifyMessageWithoutMarker(level, oneParam, exception); + } + + @Test + public void traceMessageTwoParametersThrowable() { + for (Level level : Level.values()) { + twoParamThrowableCheck(level); + } + } + + private void twoParamThrowableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1, param2, exception); + break; + case DEBUG: + logger.debug(message, param1, param2, exception); + break; + case INFO: + logger.info(message, param1, param2, exception); + break; + case WARN: + logger.warn(message, param1, param2, exception); + break; + case ERROR: + logger.error(message, param1, param2, exception); + break; + } + verifyMessageWithoutMarker(level, twoParams, exception); + } + + @Test + public void testMessageThreeParametersThrowable() { + for (Level level : Level.values()) { + messageWith3ArgsPlusException(level); + } + } + + private void messageWith3ArgsPlusException(Level level) { + switch (level) { + case TRACE: + logger.trace(message, param1, param2, param3, exception); + break; + case DEBUG: + logger.debug(message, param1, param2, param3, exception); + break; + case INFO: + logger.info(message, param1, param2, param3, exception); + break; + case WARN: + logger.warn(message, param1, param2, param3, exception); + break; + case ERROR: + logger.error(message, param1, param2, param3, exception); + break; + } + verifyMessageWithoutMarker(level, threeParams, exception); + } + + @Test + public void markerMessage() { + for (Level level : Level.values()) { + markerMessageCheck(level); + } + } + private void markerMessageCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message); + break; + case DEBUG: + logger.debug(marker, message); + break; + case INFO: + logger.info(marker, message); + break; + case WARN: + logger.warn(marker, message); + break; + case ERROR: + logger.error(marker, message); + break; + } + verifyMessage(level, marker, null, null); + } + + @Test + public void markerMessageOneParameter() { + for (Level level : Level.values()) { + markerMessageOneParameter(level); + } + } + private void markerMessageOneParameter(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1); + break; + case DEBUG: + logger.debug(marker, message, param1); + break; + case INFO: + logger.info(marker, message, param1); + break; + case WARN: + logger.warn(marker, message, param1); + break; + case ERROR: + logger.error(marker, message, param1); + break; + } + verifyMessage(level, marker, oneParam, null); + } + + @Test + public void traceMarkerMessageTwoParameters() { + for (Level level : Level.values()) { + markerMessageTwoParameters(level); + } + } + + private void markerMessageTwoParameters(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1, param2); + break; + case DEBUG: + logger.debug(marker, message, param1, param2); + break; + case INFO: + logger.info(marker, message, param1, param2); + break; + case WARN: + logger.warn(marker, message, param1, param2); + break; + case ERROR: + logger.error(marker, message, param1, param2); + break; + } + verifyMessage(level, marker, twoParams, null); + } + + @Test + public void traceMarkerMessageThreeParameters() { + for (Level level : Level.values()) { + markerMessageThreeParameters(level); + } + } + + private void markerMessageThreeParameters(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1, param2, param3); + break; + case DEBUG: + logger.debug(marker, message, param1, param2, param3); + break; + case INFO: + logger.info(marker, message, param1, param2, param3); + break; + case WARN: + logger.warn(marker, message, param1, param2, param3); + break; + case ERROR: + logger.error(marker, message, param1, param2, param3); + break; + } + verifyMessage(level, marker, threeParams, null); + } + + @Test + public void markerMessageThrowable() { + for (Level level : Level.values()) { + markerMessageThrowable(level); + } + } + + private void markerMessageThrowable(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, exception); + break; + case DEBUG: + logger.debug(marker, message, exception); + break; + case INFO: + logger.info(marker, message, exception); + break; + case WARN: + logger.warn(marker, message, exception); + break; + case ERROR: + logger.error(marker, message, exception); + break; + } + verifyMessage(level, marker, null, exception); + } + + @Test + public void markerMessageOneParameterThrowable() { + for (Level level : Level.values()) { + markerMessageOneParameterThrowableCheck(level); + } + } + + private void markerMessageOneParameterThrowableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1, exception); + break; + case DEBUG: + logger.debug(marker, message, param1, exception); + break; + case INFO: + logger.info(marker, message, param1, exception); + break; + case WARN: + logger.warn(marker, message, param1, exception); + break; + case ERROR: + logger.error(marker, message, param1, exception); + break; + } + verifyMessage(level, marker, oneParam, exception); + } + + @Test + public void traceMarkerMessageTwoParametersThrowable() { + for (Level level : Level.values()) { + markerMessageTwoParametersThrowableCheck(level); + } + } + + private void markerMessageTwoParametersThrowableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1, param2, exception); + break; + case DEBUG: + logger.debug(marker, message, param1, param2, exception); + break; + case INFO: + logger.info(marker, message, param1, param2, exception); + break; + case WARN: + logger.warn(marker, message, param1, param2, exception); + break; + case ERROR: + logger.error(marker, message, param1, param2, exception); + break; + } + verifyMessage(level, marker, twoParams, exception); + } + + @Test + public void traceMarkerMessageThreeParametersThrowable() { + for (Level level : Level.values()) { + markerMessageThreeParametersThrowableCheck(level); + } + } + + private void markerMessageThreeParametersThrowableCheck(Level level) { + switch (level) { + case TRACE: + logger.trace(marker, message, param1, param2, param3, exception); + break; + case DEBUG: + logger.debug(marker, message, param1, param2, param3, exception); + break; + case INFO: + logger.info(marker, message, param1, param2, param3, exception); + break; + case WARN: + logger.warn(marker, message, param1, param2, param3, exception); + break; + case ERROR: + logger.error(marker, message, param1, param2, param3, exception); + break; + } + verifyMessage(level, marker, threeParams, exception); + } + + private void verifyMessageWithoutMarker(Level level, Object[] arguments, Throwable exception) { + verifyMessage(level, null, arguments, exception); + } + + private void verifyMessage(Level level, Marker marker, Object[] arguments, Throwable exception) { + + assertEquals("missing event: ", 1, queue.size()); + SubstituteLoggingEvent event = queue.poll(); + assertNotNull(event); + + if (marker == null) { + assertNull(event.getMarker()); + } else { + assertEquals(marker, event.getMarker()); + } + + assertEquals(message, event.getMessage()); + + if (arguments == null) { + assertNull(event.getArgumentArray()); + } else { + assertArrayEquals(arguments, event.getArgumentArray()); + } + + assertEquals("wrong level: ", level, event.getLevel()); + + if (exception == null) { + assertNull(event.getThrowable()); + } else { + assertEquals(exception, event.getThrowable()); + } + } +} diff --git a/slf4j-api/src/test/java/org/slf4j/helpers/MultithreadedInitializationTest.java b/slf4j-api/src/test/java/org/slf4j/helpers/MultithreadedInitializationTest.java index 6cf3613..c9e38ea 100644 --- a/slf4j-api/src/test/java/org/slf4j/helpers/MultithreadedInitializationTest.java +++ b/slf4j-api/src/test/java/org/slf4j/helpers/MultithreadedInitializationTest.java @@ -22,7 +22,7 @@ private final List createdLoggers = Collections.synchronizedList(new ArrayList()); - final private AtomicLong eventCount = new AtomicLong(0); + protected final AtomicLong eventCount = new AtomicLong(0); final private CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); int diff = new Random().nextInt(10000); diff --git a/slf4j-ext/pom.xml b/slf4j-ext/pom.xml index 9a69b3c..9acc1e2 100755 --- a/slf4j-ext/pom.xml +++ b/slf4j-ext/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-ext diff --git a/slf4j-jcl/pom.xml b/slf4j-jcl/pom.xml index 1ad7e9e..d9fa8c9 100755 --- a/slf4j-jcl/pom.xml +++ b/slf4j-jcl/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-jcl diff --git a/slf4j-jdk14/pom.xml b/slf4j-jdk14/pom.xml index 90d375f..d343309 100755 --- a/slf4j-jdk14/pom.xml +++ b/slf4j-jdk14/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-jdk14 diff --git a/slf4j-jdk14/src/main/resources/META-INF/MANIFEST.MF b/slf4j-jdk14/src/main/resources/META-INF/MANIFEST.MF index 05056de..5b7871d 100755 --- a/slf4j-jdk14/src/main/resources/META-INF/MANIFEST.MF +++ b/slf4j-jdk14/src/main/resources/META-INF/MANIFEST.MF @@ -4,6 +4,7 @@ Bundle-Name: slf4j-jdk14 Bundle-Vendor: SLF4J.ORG Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.slf4j.jul Export-Package: org.slf4j.impl;version=${parsedVersion.osgiVersion} Import-Package: org.slf4j;version=${parsedVersion.osgiVersion}, org.slf4j.spi;version=${parsedVersion.osgiVersion}, diff --git a/slf4j-log4j12/pom.xml b/slf4j-log4j12/pom.xml index afdfc41..bc40ac8 100755 --- a/slf4j-log4j12/pom.xml +++ b/slf4j-log4j12/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-log4j12 diff --git a/slf4j-migrator/pom.xml b/slf4j-migrator/pom.xml index 203ec8e..2a516a1 100755 --- a/slf4j-migrator/pom.xml +++ b/slf4j-migrator/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-migrator diff --git a/slf4j-nop/pom.xml b/slf4j-nop/pom.xml index f6aaaec..8f78462 100755 --- a/slf4j-nop/pom.xml +++ b/slf4j-nop/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-nop diff --git a/slf4j-nop/src/main/resources/META-INF/MANIFEST.MF b/slf4j-nop/src/main/resources/META-INF/MANIFEST.MF index 8de6024..ed6bdd3 100755 --- a/slf4j-nop/src/main/resources/META-INF/MANIFEST.MF +++ b/slf4j-nop/src/main/resources/META-INF/MANIFEST.MF @@ -4,6 +4,7 @@ Bundle-Name: slf4j-nop Bundle-Vendor: SLF4J.ORG Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.slf4j.nop Export-Package: org.slf4j.impl;version=${parsedVersion.osgiVersion} Import-Package: org.slf4j;version=${parsedVersion.osgiVersion}, org.slf4j.spi;version=${parsedVersion.osgiVersion}, diff --git a/slf4j-simple/pom.xml b/slf4j-simple/pom.xml index 0c02ce5..9de2a31 100755 --- a/slf4j-simple/pom.xml +++ b/slf4j-simple/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-simple diff --git a/slf4j-simple/src/main/resources/META-INF/MANIFEST.MF b/slf4j-simple/src/main/resources/META-INF/MANIFEST.MF index 3d15864..0477c0f 100755 --- a/slf4j-simple/src/main/resources/META-INF/MANIFEST.MF +++ b/slf4j-simple/src/main/resources/META-INF/MANIFEST.MF @@ -5,6 +5,7 @@ Bundle-Vendor: SLF4J.ORG Require-Bundle: slf4j.api Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Automatic-Module-Name: org.slf4j.simple Export-Package: org.slf4j.impl;version=${parsedVersion.osgiVersion} Import-Package: org.slf4j;version=${parsedVersion.osgiVersion}, org.slf4j.spi;version=${parsedVersion.osgiVersion}, diff --git a/slf4j-site/pom.xml b/slf4j-site/pom.xml index 53eea33..6869e58 100755 --- a/slf4j-site/pom.xml +++ b/slf4j-site/pom.xml @@ -7,7 +7,7 @@ org.slf4j slf4j-parent - 1.7.26 + 1.7.30 slf4j-site @@ -31,6 +31,16 @@ + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + org.apache.maven.plugins maven-source-plugin @@ -40,9 +50,6 @@ **/META-INF/* - - x** -