You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by cs...@apache.org on 2022/03/03 21:59:10 UTC
[activemq] branch activemq-5.17.x updated (d4222af -> b31cc6f)
This is an automated email from the ASF dual-hosted git repository.
cshannon pushed a change to branch activemq-5.17.x
in repository https://gitbox.apache.org/repos/asf/activemq.git.
from d4222af Merge pull request #786 from cshannon/AMQ-7309-revert
new efe3f5b AMQ-8520: Re-enable all modules to compile and build by default
new 4d66264 [AMQ-8520] WIP: Convert activemq-unit-tests to log4j2
new da9e527 AMQ-8520: Log4j2 test fixes
new b31cc6f AMQ-7309: Compilation fixes after revert of JMS 2.0 api change
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../activemq/broker/TransportConnection.java | 2 +-
.../activemq/broker/jmx/Log4JConfigView.java | 98 ++++++++--------
activemq-itests-spring31/pom.xml | 21 ++++
activemq-karaf-itest/pom.xml | 32 +++++-
activemq-osgi/pom.xml | 10 +-
.../activemq-perf-maven-plugin/pom.xml | 5 -
activemq-unit-tests/pom.xml | 43 +++++--
.../java/org/apache/activemq/JMSMessageTest.java | 20 ----
.../apache/activemq/ProducerFlowControlTest.java | 20 ++--
.../activemq/ReconnectWithSameClientIDTest.java | 28 +++--
.../activemq/TcpTransportCloseConnectionTest.java | 39 ++++---
.../activemq/broker/jmx/Log4JConfigTest.java | 19 ++--
.../broker/region/DestinationGCStressTest.java | 50 +++++----
.../activemq/broker/region/QueuePurgeTest.java | 21 ++--
.../broker/scheduler/JmsSchedulerTest.java | 14 +--
.../scheduler/JobSchedulerManagementTest.java | 5 +-
...chedulerRedliveryPluginDLQStoreCleanupTest.java | 5 +-
.../scheduler/JobSchedulerStoreCheckpointTest.java | 5 +-
.../scheduler/LostScheduledMessagesTest.java | 5 +-
.../java/org/apache/activemq/bugs/AMQ1936Test.java | 17 +--
.../java/org/apache/activemq/bugs/AMQ2902Test.java | 29 ++---
.../java/org/apache/activemq/bugs/AMQ3567Test.java | 38 ++++---
.../java/org/apache/activemq/bugs/AMQ3622Test.java | 38 ++++---
.../java/org/apache/activemq/bugs/AMQ3625Test.java | 36 +++---
.../java/org/apache/activemq/bugs/AMQ3779Test.java | 34 ++++--
.../java/org/apache/activemq/bugs/AMQ4221Test.java | 27 +++--
.../java/org/apache/activemq/bugs/AMQ5212Test.java | 7 +-
.../java/org/apache/activemq/bugs/AMQ5426Test.java | 41 ++++---
.../java/org/apache/activemq/bugs/AMQ5844Test.java | 45 ++++----
.../java/org/apache/activemq/bugs/AMQ6122Test.java | 9 +-
.../java/org/apache/activemq/bugs/AMQ6131Test.java | 5 +-
.../bugs/AMQ6133PersistJMSRedeliveryTest.java | 6 +-
.../java/org/apache/activemq/bugs/AMQ6432Test.java | 31 +++--
.../java/org/apache/activemq/bugs/AMQ6463Test.java | 30 +++--
.../java/org/apache/activemq/bugs/AMQ7067Test.java | 11 +-
.../activemq/bugs/MKahaDBTxRecoveryTest.java | 49 ++++----
.../TransactedStoreUsageSuspendResumeTest.java | 5 +-
.../activemq/bugs/TrapMessageInJDBCStoreTest.java | 5 +-
.../activemq/bugs/embedded/EmbeddedActiveMQ.java | 5 +-
.../activemq/bugs/embedded/ThreadExplorer.java | 6 +-
.../org/apache/activemq/jmx/JmxAuditLogTest.java | 125 +++++++++++----------
.../apache/activemq/security/SecurityJMXTest.java | 22 ++--
.../activemq/store/SharedFileLockerTest.java | 43 ++++---
.../activemq/store/jdbc/JDBCConcurrentDLQTest.java | 45 ++++++--
.../store/jdbc/JDBCIOExceptionHandlerTest.java | 53 ++++-----
.../store/kahadb/KahaDBPersistenceAdapterTest.java | 29 +++--
.../apache/activemq/store/kahadb/KahaDBTest.java | 24 ++--
.../activemq/transport/failover/AMQ1925Test.java | 5 +-
.../transport/failover/FailoverUpdateURIsTest.java | 13 ++-
.../activemq/transport/nio/NIOSSLBasicTest.java | 30 +++--
.../tcp/TcpTransportCloseSocketNoWarnTest.java | 58 ++++++----
.../TcpTransportInactiveDuringHandshakeTest.java | 29 +++--
.../transport/vm/VmTransportNetworkBrokerTest.java | 24 ++--
.../activemq/usage/StoreUsageLimitsTest.java | 42 ++++---
.../org/apache/activemq/usecases/AMQ6446Test.java | 43 ++++---
.../activemq/usecases/ClientRebalanceTest.java | 5 +-
.../activemq/usecases/DurableSubCacheTest.java | 29 +++--
.../activemq/usecases/EmptyTransactionTest.java | 27 +++--
.../OfflineDurableSubscriberTimeoutTest.java | 35 +++---
...equestReplyTempDestRemovalAdvisoryRaceTest.java | 29 +++--
.../usecases/TopicProducerFlowControlTest.java | 47 ++++----
.../usecases/UsageBlockedDispatchTest.java | 28 +++--
.../src/test/resources/log4j.properties | 47 --------
.../src/test/resources/log4j2-test.properties | 0
pom.xml | 12 +-
65 files changed, 1005 insertions(+), 755 deletions(-)
delete mode 100644 activemq-unit-tests/src/test/resources/log4j.properties
copy {activemq-client => activemq-unit-tests}/src/test/resources/log4j2-test.properties (100%)
[activemq] 04/04: AMQ-7309: Compilation fixes after revert of JMS 2.0 api change
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cshannon pushed a commit to branch activemq-5.17.x
in repository https://gitbox.apache.org/repos/asf/activemq.git
commit b31cc6f2cb6cc5092660279c7b21a06546eddafb
Author: Christopher L. Shannon (cshannon) <ch...@gmail.com>
AuthorDate: Thu Mar 3 16:51:08 2022 -0500
AMQ-7309: Compilation fixes after revert of JMS 2.0 api change
---
.../java/org/apache/activemq/JMSMessageTest.java | 20 -----------------
.../java/org/apache/activemq/bugs/AMQ5212Test.java | 7 +++---
.../java/org/apache/activemq/bugs/AMQ6122Test.java | 9 +++++---
.../store/jdbc/JDBCIOExceptionHandlerTest.java | 26 +++-------------------
4 files changed, 12 insertions(+), 50 deletions(-)
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/JMSMessageTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/JMSMessageTest.java
index f4749a1..a22e5e9 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/JMSMessageTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/JMSMessageTest.java
@@ -374,16 +374,6 @@ public class JMSMessageTest extends JmsTestSupport {
}
@Override
- public long getJMSDeliveryTime() throws JMSException {
- return 0;
- }
-
- @Override
- public void setJMSDeliveryTime(long l) throws JMSException {
-
- }
-
- @Override
public int getJMSPriority() throws JMSException {
return priority;
}
@@ -499,16 +489,6 @@ public class JMSMessageTest extends JmsTestSupport {
}
@Override
- public <T> T getBody(Class<T> aClass) throws JMSException {
- return null;
- }
-
- @Override
- public boolean isBodyAssignableTo(Class aClass) throws JMSException {
- return true;
- }
-
- @Override
public void setText(String arg0) throws JMSException {
text = arg0;
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5212Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5212Test.java
index f5d51d1..cc2602d 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5212Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5212Test.java
@@ -29,7 +29,6 @@ import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
-import javax.jms.CompletionListener;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;
@@ -124,7 +123,7 @@ public class AMQ5212Test {
}
ActiveMQTextMessage message = new ActiveMQTextMessage();
message.setDestination(dest);
- activeMQMessageProducer.send(message, (CompletionListener) null);
+ activeMQMessageProducer.send(message, null);
// send a duplicate
activeMQConnection.syncSendPacket(message);
@@ -165,7 +164,7 @@ public class AMQ5212Test {
ActiveMQMessageProducer activeMQMessageProducer = (ActiveMQMessageProducer) activeMQSession.createProducer(dest);
ActiveMQTextMessage message = new ActiveMQTextMessage();
message.setDestination(dest);
- activeMQMessageProducer.send(message, (CompletionListener) null);
+ activeMQMessageProducer.send(message, null);
// send a duplicate
activeMQConnection.syncSendPacket(message);
@@ -210,7 +209,7 @@ public class AMQ5212Test {
ActiveMQMessageProducer activeMQMessageProducer = (ActiveMQMessageProducer) activeMQSession.createProducer(dest);
ActiveMQTextMessage message = new ActiveMQTextMessage();
message.setDestination(dest);
- activeMQMessageProducer.send(message, (CompletionListener) null);
+ activeMQMessageProducer.send(message, null);
// send a duplicate
activeMQConnection.syncSendPacket(message);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6122Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6122Test.java
index 2c316ad..220d7fe 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6122Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6122Test.java
@@ -21,7 +21,10 @@ import static org.junit.Assert.assertNotNull;
import java.util.ArrayList;
import java.util.List;
-import javax.jms.*;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.Session;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
@@ -108,7 +111,7 @@ public class AMQ6122Test {
ActiveMQMessageProducer activeMQMessageProducer = (ActiveMQMessageProducer) activeMQSession.createProducer(dest);
ActiveMQTextMessage message = new ActiveMQTextMessage();
message.setDestination(dest);
- activeMQMessageProducer.send(message, (CompletionListener) null);
+ activeMQMessageProducer.send(message, null);
// send a duplicate
activeMQConnection.syncSendPacket(message);
@@ -146,7 +149,7 @@ public class AMQ6122Test {
@Override
public void run() {
try {
- producer.send(message, (CompletionListener) null);
+ producer.send(message, null);
} catch (JMSException e) {
e.printStackTrace();
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
index 2f212ae..13bec54 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
@@ -16,35 +16,20 @@
*/
package org.apache.activemq.store.jdbc;
-import java.io.File;
-import java.io.IOException;
-import java.io.ObjectInputStream;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.PrintWriter;
-import java.net.Socket;
-import java.rmi.registry.Registry;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
-
import javax.jms.Connection;
-import javax.management.*;
-import javax.management.loading.ClassLoaderRepository;
-import javax.management.remote.JMXConnectorServer;
-import javax.management.remote.JMXConnectorServerFactory;
-import javax.management.remote.JMXServiceURL;
-
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.ft.SyncCreateDataSource;
-import org.apache.activemq.broker.jmx.ManagementContext;
import org.apache.activemq.bugs.embedded.ThreadExplorer;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.LeaseLockerIOExceptionHandler;
import org.apache.activemq.util.Wait;
import org.apache.derby.jdbc.EmbeddedDataSource;
@@ -56,15 +41,10 @@ import org.apache.logging.log4j.core.config.Property;
import org.apache.logging.log4j.core.filter.AbstractFilter;
import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
-import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
/**
* Test to see if the JDBCExceptionIOHandler will restart the transport connectors correctly after
* the underlying DB has been stopped and restarted
[activemq] 02/04: [AMQ-8520] WIP: Convert activemq-unit-tests to log4j2
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cshannon pushed a commit to branch activemq-5.17.x
in repository https://gitbox.apache.org/repos/asf/activemq.git
commit 4d662648beab43e20331f46ee2b5e30120544c5e
Author: Matt Pavlovich <ma...@hyte.io>
AuthorDate: Wed Mar 2 09:13:55 2022 -0600
[AMQ-8520] WIP: Convert activemq-unit-tests to log4j2
(cherry picked from commit 7ec5254bb59924b09d124fc19c797c2587bceea6)
---
.../apache/activemq/ProducerFlowControlTest.java | 20 ++--
.../activemq/ReconnectWithSameClientIDTest.java | 28 +++--
.../activemq/TcpTransportCloseConnectionTest.java | 39 ++++---
.../activemq/broker/jmx/Log4JConfigTest.java | 15 +--
.../broker/region/DestinationGCStressTest.java | 50 +++++----
.../activemq/broker/region/QueuePurgeTest.java | 21 ++--
.../broker/scheduler/JmsSchedulerTest.java | 14 +--
.../scheduler/JobSchedulerManagementTest.java | 5 +-
...chedulerRedliveryPluginDLQStoreCleanupTest.java | 5 +-
.../scheduler/JobSchedulerStoreCheckpointTest.java | 5 +-
.../scheduler/LostScheduledMessagesTest.java | 5 +-
.../java/org/apache/activemq/bugs/AMQ1936Test.java | 17 +--
.../java/org/apache/activemq/bugs/AMQ2902Test.java | 29 ++---
.../java/org/apache/activemq/bugs/AMQ3567Test.java | 38 ++++---
.../java/org/apache/activemq/bugs/AMQ3622Test.java | 38 ++++---
.../java/org/apache/activemq/bugs/AMQ3625Test.java | 36 +++---
.../java/org/apache/activemq/bugs/AMQ3779Test.java | 34 ++++--
.../java/org/apache/activemq/bugs/AMQ4221Test.java | 27 +++--
.../java/org/apache/activemq/bugs/AMQ5426Test.java | 41 ++++---
.../java/org/apache/activemq/bugs/AMQ5844Test.java | 45 ++++----
.../java/org/apache/activemq/bugs/AMQ6131Test.java | 5 +-
.../bugs/AMQ6133PersistJMSRedeliveryTest.java | 6 +-
.../java/org/apache/activemq/bugs/AMQ6432Test.java | 31 +++--
.../java/org/apache/activemq/bugs/AMQ6463Test.java | 30 +++--
.../java/org/apache/activemq/bugs/AMQ7067Test.java | 11 +-
.../activemq/bugs/MKahaDBTxRecoveryTest.java | 49 ++++----
.../TransactedStoreUsageSuspendResumeTest.java | 5 +-
.../activemq/bugs/TrapMessageInJDBCStoreTest.java | 5 +-
.../activemq/bugs/embedded/EmbeddedActiveMQ.java | 5 +-
.../activemq/bugs/embedded/ThreadExplorer.java | 6 +-
.../org/apache/activemq/jmx/JmxAuditLogTest.java | 125 +++++++++++----------
.../apache/activemq/security/SecurityJMXTest.java | 15 +--
.../activemq/store/SharedFileLockerTest.java | 43 ++++---
.../activemq/store/jdbc/JDBCConcurrentDLQTest.java | 45 ++++++--
.../store/jdbc/JDBCIOExceptionHandlerTest.java | 27 +++--
.../store/kahadb/KahaDBPersistenceAdapterTest.java | 23 ++--
.../apache/activemq/store/kahadb/KahaDBTest.java | 24 ++--
.../activemq/transport/failover/AMQ1925Test.java | 5 +-
.../transport/failover/FailoverUpdateURIsTest.java | 13 ++-
.../activemq/transport/nio/NIOSSLBasicTest.java | 30 +++--
.../tcp/TcpTransportCloseSocketNoWarnTest.java | 55 +++++----
.../TcpTransportInactiveDuringHandshakeTest.java | 28 +++--
.../transport/vm/VmTransportNetworkBrokerTest.java | 24 ++--
.../activemq/usage/StoreUsageLimitsTest.java | 42 ++++---
.../org/apache/activemq/usecases/AMQ6446Test.java | 43 ++++---
.../activemq/usecases/ClientRebalanceTest.java | 5 +-
.../activemq/usecases/DurableSubCacheTest.java | 29 +++--
.../activemq/usecases/EmptyTransactionTest.java | 27 +++--
.../OfflineDurableSubscriberTimeoutTest.java | 35 +++---
...equestReplyTempDestRemovalAdvisoryRaceTest.java | 29 +++--
.../usecases/TopicProducerFlowControlTest.java | 47 ++++----
.../usecases/UsageBlockedDispatchTest.java | 28 +++--
.../src/test/resources/log4j.properties | 47 --------
.../src/test/resources/log4j2-test.properties | 55 +++++++++
54 files changed, 886 insertions(+), 623 deletions(-)
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/ProducerFlowControlTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/ProducerFlowControlTest.java
index 202d99e..01d6941 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/ProducerFlowControlTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/ProducerFlowControlTest.java
@@ -34,7 +34,6 @@ import javax.jms.TextMessage;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnector;
import org.apache.activemq.broker.region.Queue;
-import org.apache.activemq.broker.region.Topic;
import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.broker.region.policy.VMPendingQueueMessageStoragePolicy;
@@ -42,9 +41,10 @@ import org.apache.activemq.broker.region.policy.VMPendingSubscriberMessageStorag
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.transport.tcp.TcpTransport;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -261,22 +261,24 @@ public class ProducerFlowControlTest extends JmsTestSupport {
Appender appender = new DefaultTestAppender() {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getMessage().toString().contains("Usage Manager Memory Limit")) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("Usage Manager Memory Limit")) {
LOG.info("received warn log message: " + event.getMessage());
warnings.incrementAndGet();
}
- if (event.getLevel().equals(Level.DEBUG) && event.getMessage().toString().contains("Usage Manager Memory Limit")) {
+ if (event.getLevel().equals(Level.DEBUG) && event.getMessage().getFormattedMessage().contains("Usage Manager Memory Limit")) {
LOG.info("received debug log message: " + event.getMessage());
debugs.incrementAndGet();
}
}
};
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(Queue.class);
+ appender.start();
+
+ org.apache.logging.log4j.core.Logger log4jLogger = (org.apache.logging.log4j.core.Logger)LogManager.getLogger(Queue.class);
log4jLogger.addAppender(appender);
log4jLogger.setLevel(Level.DEBUG);
+
try {
ConnectionFactory factory = createConnectionFactory();
connection = (ActiveMQConnection)factory.createConnection();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/ReconnectWithSameClientIDTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/ReconnectWithSameClientIDTest.java
index 81d13b2..06ed2cd 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/ReconnectWithSameClientIDTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/ReconnectWithSameClientIDTest.java
@@ -24,9 +24,13 @@ import javax.jms.JMSException;
import javax.jms.Session;
import junit.framework.Test;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -48,20 +52,22 @@ public class ReconnectWithSameClientIDTest extends EmbeddedBrokerTestSupport {
public void testReconnectMultipleTimesWithSameClientID() throws Exception {
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(org.apache.activemq.broker.jmx.ManagedTransportConnection.class);
final AtomicBoolean failed = new AtomicBoolean(false);
-
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger((org.apache.activemq.broker.jmx.ManagedTransportConnection.class)));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage().toString().startsWith("Failed to register MBean")) {
+ public void append(LogEvent event) {
+ if (event.getMessage().getFormattedMessage().startsWith("Failed to register MBean")) {
LOG.info("received unexpected log message: " + event.getMessage());
failed.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
connection = connectionFactory.createConnection();
useConnection(connection);
@@ -85,7 +91,7 @@ public class ReconnectWithSameClientIDTest extends EmbeddedBrokerTestSupport {
connection = connectionFactory.createConnection();
useConnection(connection);
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
assertFalse("failed on unexpected log event", failed.get());
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/TcpTransportCloseConnectionTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/TcpTransportCloseConnectionTest.java
index 6237d5a..f7bd17e 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/TcpTransportCloseConnectionTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/TcpTransportCloseConnectionTest.java
@@ -18,39 +18,44 @@
package org.apache.activemq;
import org.apache.activemq.broker.jmx.ManagementContext;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.*;
import static org.junit.Assert.assertFalse;
import java.util.concurrent.*;
-
import org.apache.activemq.broker.BrokerService;
-
import javax.management.JMException;
import javax.management.ObjectName;
public class TcpTransportCloseConnectionTest {
static boolean transportConnectionFailed = false;
-
+ static final org.apache.logging.log4j.core.Appender appender;
private BrokerService broker;
private final String uri = "tcp://localhost:0?wireFormat.maxInactivityDuration=500";
- static final Appender appender = new DefaultTestAppender() {
- @Override
- public void doAppend(LoggingEvent event) {
- if(event.getMessage().toString().contains("Transport Connection")
- && event.getMessage().toString().contains("failed")
- && (event.getMessage().toString().contains("java.net.SocketException") || event.getMessage().toString().contains("java.io.EOFException"))) {
- transportConnectionFailed = true;
+ static {
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ String message = event.getMessage().getFormattedMessage();
+ if(message.contains("Transport Connection")
+ && message.contains("failed")
+ && (message.contains("java.net.SocketException") || message.contains("java.io.EOFException"))) {
+ transportConnectionFailed = true;
+ }
}
- }
- };
+ };
+ appender.start();
+ }
class CustomManagementContext extends ManagementContext {
@Override
@@ -67,12 +72,12 @@ public class TcpTransportCloseConnectionTest {
@BeforeClass
public static void setUp() throws Exception {
- org.apache.log4j.Logger.getRootLogger().addAppender(appender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).addAppender(appender);
}
@AfterClass
public static void setDown() throws Exception {
- org.apache.log4j.Logger.getRootLogger().removeAppender(appender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).removeAppender(appender);
}
@Before
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
index 2c2b373..a5255a6 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
@@ -27,8 +27,9 @@ import javax.management.ObjectName;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.EmbeddedBrokerTestSupport;
import org.apache.activemq.broker.BrokerService;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Logger;
import org.junit.Test;
import org.slf4j.LoggerFactory;
@@ -112,7 +113,7 @@ public class Log4JConfigTest extends EmbeddedBrokerTestSupport {
String level = log4jConfigView.getLogLevel("not.a.logger");
assertNotNull(level);
assertFalse(level.isEmpty());
- assertEquals(Logger.getRootLogger().getLevel().toString(), level);
+ assertEquals(LogManager.getRootLogger().getLevel().toString(), level);
}
@Test
@@ -166,7 +167,7 @@ public class Log4JConfigTest extends EmbeddedBrokerTestSupport {
assertNotNull(level);
assertFalse(level.isEmpty());
- String currentRootLevel = Logger.getRootLogger().getLevel().toString();
+ String currentRootLevel = LogManager.getRootLogger().getLevel().toString();
assertEquals(currentRootLevel, level);
}
@@ -177,12 +178,12 @@ public class Log4JConfigTest extends EmbeddedBrokerTestSupport {
Log4JConfigViewMBean log4jConfigView = MBeanServerInvocationHandler.newProxyInstance(
mbeanServer, log4jConfigViewName, Log4JConfigViewMBean.class, true);
- String currentRootLevel = Logger.getRootLogger().getLevel().toString();
+ String currentRootLevel = LogManager.getRootLogger().getLevel().toString();
log4jConfigView.setRootLogLevel("WARN");
- currentRootLevel = Logger.getRootLogger().getLevel().toString();
+ currentRootLevel = LogManager.getRootLogger().getLevel().toString();
assertEquals("WARN", currentRootLevel);
log4jConfigView.setRootLogLevel("INFO");
- currentRootLevel = Logger.getRootLogger().getLevel().toString();
+ currentRootLevel = LogManager.getRootLogger().getLevel().toString();
assertEquals("INFO", currentRootLevel);
Level level;
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/DestinationGCStressTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/DestinationGCStressTest.java
index 61c01d8..f473918 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/DestinationGCStressTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/DestinationGCStressTest.java
@@ -24,9 +24,13 @@ import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQTopic;
import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -90,20 +94,22 @@ public class DestinationGCStressTest {
@Test(timeout = 60000)
public void testClashWithPublishAndGC() throws Exception {
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(RegionBroker.class);
final AtomicBoolean failed = new AtomicBoolean(false);
-
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(RegionBroker.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.ERROR) && event.getMessage().toString().startsWith("Failed to remove inactive")) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.ERROR) && event.getMessage().getFormattedMessage().startsWith("Failed to remove inactive")) {
logger.info("received unexpected log message: " + event.getMessage());
failed.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
final AtomicInteger max = new AtomicInteger(20000);
@@ -147,7 +153,7 @@ public class DestinationGCStressTest {
connection.close();
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
assertFalse("failed on unexpected log event", failed.get());
@@ -156,16 +162,14 @@ public class DestinationGCStressTest {
@Test(timeout = 60000)
public void testAddRemoveWildcardWithGc() throws Exception {
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(RegionBroker.class);
final AtomicBoolean failed = new AtomicBoolean(false);
-
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(RegionBroker.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.ERROR) && event.getMessage().toString().startsWith("Failed to remove inactive")) {
- if (event.getThrowableInformation().getThrowable() != null
- && event.getThrowableInformation().getThrowable().getCause() instanceof BrokerStoppedException) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.ERROR) && event.getMessage().getFormattedMessage().startsWith("Failed to remove inactive")) {
+ if (event.getThrown() != null
+ && event.getThrown().getCause() instanceof BrokerStoppedException) {
// ok
} else {
logger.info("received unexpected log message: " + event.getMessage());
@@ -174,7 +178,11 @@ public class DestinationGCStressTest {
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
final AtomicInteger max = new AtomicInteger(10000);
@@ -241,7 +249,7 @@ public class DestinationGCStressTest {
connection.close();
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
assertFalse("failed on unexpected log event", failed.get());
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/QueuePurgeTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/QueuePurgeTest.java
index 3e8b647..2f837cc 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/QueuePurgeTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/region/QueuePurgeTest.java
@@ -43,9 +43,9 @@ import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -108,14 +108,15 @@ public class QueuePurgeTest extends CombinationTestSupport {
QueueViewMBean proxy = getProxyToQueueViewMBean();
LOG.info("purging..");
- org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger(org.apache.activemq.broker.jmx.QueueView.class);
+ org.apache.logging.log4j.core.Logger log4jLogger = (org.apache.logging.log4j.core.Logger)LogManager.getLogger(org.apache.activemq.broker.jmx.QueueView.class);
+
final AtomicBoolean gotPurgeLogMessage = new AtomicBoolean(false);
Appender appender = new DefaultTestAppender() {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage() instanceof String) {
- String message = (String) event.getMessage();
+ public void append(LogEvent event) {
+ if (event.getMessage() != null) {
+ String message = event.getMessage().getFormattedMessage();
if (message.contains("purge of " + NUM_TO_SEND +" messages")) {
LOG.info("Received a log message: {} ", event.getMessage());
gotPurgeLogMessage.set(true);
@@ -123,16 +124,14 @@ public class QueuePurgeTest extends CombinationTestSupport {
}
}
};
-
- Level level = log4jLogger.getLevel();
- log4jLogger.setLevel(Level.INFO);
+ appender.start();
log4jLogger.addAppender(appender);
+
try {
proxy.purge();
} finally {
- log4jLogger.setLevel(level);
log4jLogger.removeAppender(appender);
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JmsSchedulerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JmsSchedulerTest.java
index 6a061c7..dfa61ce 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JmsSchedulerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JmsSchedulerTest.java
@@ -40,9 +40,10 @@ import org.apache.activemq.store.kahadb.scheduler.JobSchedulerStoreImpl;
import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.ProducerThread;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -224,8 +225,8 @@ public class JmsSchedulerTest extends JobSchedulerTestSupport {
Appender appender = new DefaultTestAppender() {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage().toString().contains("Removed Job past last appened in the journal")) {
+ public void append(LogEvent event) {
+ if (event.getMessage() != null && event.getMessage().getFormattedMessage().contains("Removed Job past last appened in the journal")) {
numberOfDiscardedJobs.incrementAndGet();
}
}
@@ -263,8 +264,7 @@ public class JmsSchedulerTest extends JobSchedulerTestSupport {
}
private void registerLogAppender(final Appender appender) {
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(JobSchedulerStoreImpl.class);
+ org.apache.logging.log4j.core.Logger log4jLogger = (org.apache.logging.log4j.core.Logger)LogManager.getLogger(JobSchedulerStoreImpl.class);
log4jLogger.addAppender(appender);
log4jLogger.setLevel(Level.TRACE);
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerManagementTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerManagementTest.java
index b1f3b2e..39ba478 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerManagementTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerManagementTest.java
@@ -32,7 +32,6 @@ import org.apache.activemq.command.ActiveMQMessage;
import org.apache.activemq.store.kahadb.disk.journal.DataFile;
import org.apache.activemq.store.kahadb.disk.page.Transaction;
import org.apache.activemq.store.kahadb.scheduler.JobSchedulerStoreImpl;
-import org.apache.log4j.Level;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -49,6 +48,8 @@ import javax.jms.TextMessage;
import org.apache.activemq.ScheduledMessage;
import org.apache.activemq.command.ActiveMQMessage;
import org.apache.activemq.util.IdGenerator;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -69,7 +70,7 @@ public class JobSchedulerManagementTest extends JobSchedulerTestSupport {
@Test
public void testRemoveAllScheduled() throws Exception {
- org.apache.log4j.Logger.getLogger(Transaction.class).setLevel(Level.DEBUG);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(Transaction.class)).setLevel(Level.DEBUG);
final int COUNT = 5000;
System.setProperty("maxKahaDBTxSize", "" + (500*1024));
Connection connection = createConnection();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerRedliveryPluginDLQStoreCleanupTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerRedliveryPluginDLQStoreCleanupTest.java
index 5068f67..e049efe 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerRedliveryPluginDLQStoreCleanupTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerRedliveryPluginDLQStoreCleanupTest.java
@@ -52,7 +52,8 @@ import org.apache.activemq.store.kahadb.scheduler.JobSchedulerStoreImpl;
import org.apache.activemq.util.ByteSequence;
import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -76,7 +77,7 @@ public class JobSchedulerRedliveryPluginDLQStoreCleanupTest {
public void setUp() throws Exception {
// investigate gc issue - store usage not getting released
- org.apache.log4j.Logger.getLogger(JobSchedulerStoreImpl.class).setLevel(Level.TRACE);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(JobSchedulerStoreImpl.class)).setLevel(Level.TRACE);
File directory = new File("target/test/ScheduledJobsDB");
IOHelper.mkdirs(directory);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerStoreCheckpointTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerStoreCheckpointTest.java
index 3685f34..1c841aa 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerStoreCheckpointTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/JobSchedulerStoreCheckpointTest.java
@@ -29,7 +29,8 @@ import org.apache.activemq.store.kahadb.scheduler.JobSchedulerStoreImpl;
import org.apache.activemq.util.ByteSequence;
import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -48,7 +49,7 @@ public class JobSchedulerStoreCheckpointTest {
public void setUp() throws Exception {
// investigate gc issue - store usage not getting released
- org.apache.log4j.Logger.getLogger(JobSchedulerStoreImpl.class).setLevel(Level.TRACE);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(JobSchedulerStoreImpl.class)).setLevel(Level.TRACE);
File directory = new File("target/test/ScheduledJobsDB");
IOHelper.mkdirs(directory);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/LostScheduledMessagesTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/LostScheduledMessagesTest.java
index 53588b5..3e24a7d 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/LostScheduledMessagesTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/scheduler/LostScheduledMessagesTest.java
@@ -36,7 +36,6 @@ import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ScheduledMessage;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.util.IOHelper;
-import org.apache.log4j.BasicConfigurator;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -74,7 +73,9 @@ public class LostScheduledMessagesTest {
@After
public void tearDown() throws Exception {
broker.stop();
- BasicConfigurator.resetConfiguration();
+
+ // [AMQ-8520] FIXME: Convert or remove if not needed
+ //BasicConfigurator.resetConfiguration();
}
@Test
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ1936Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ1936Test.java
index e4c73ff..e6362ce 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ1936Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ1936Test.java
@@ -43,14 +43,15 @@ import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.AutoFailTestSupport;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* A AMQ1936Test
*
*/
public class AMQ1936Test extends TestCase {
- private final static Logger logger = Logger.getLogger(AMQ1936Test.class);
+ private final static Logger logger = LoggerFactory.getLogger(AMQ1936Test.class);
private final static String TEST_QUEUE_NAME = "dynamicQueues/duplicate.message.test.queue";
// //--
//
@@ -177,7 +178,7 @@ public class AMQ1936Test extends TestCase {
}
if (messages.containsKey(message.getJMSMessageID())) {
duplicateSignal.countDown();
- logger.fatal("duplicate message id detected:" + message.getJMSMessageID());
+ logger.error("duplicate message id detected:" + message.getJMSMessageID());
fail("Duplicate message id detected:" + message.getJMSMessageID());
} else {
messages.put(message.getJMSMessageID(), message.getJMSMessageID());
@@ -275,14 +276,14 @@ public class AMQ1936Test extends TestCase {
try {
receiver.close();
} catch (JMSException e) {
- logger.warn(e);
+ logger.warn(e.getMessage(), e);
}
}
if (session != null) {
try {
session.close();
} catch (JMSException e) {
- logger.warn(e);
+ logger.warn(e.getMessage(), e);
}
}
if (queueConnection != null) {
@@ -290,12 +291,12 @@ public class AMQ1936Test extends TestCase {
}
}
} catch (JMSException e) {
- logger.error(e);
+ logger.error(e.getMessage(), e);
e.printStackTrace();
} catch (NamingException e) {
- logger.error(e);
+ logger.error(e.getMessage(), e);
} catch (Exception e) {
- logger.error(e);
+ logger.error(e.getMessage(), e);
e.printStackTrace();
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ2902Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ2902Test.java
index 66ff094..05d3163 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ2902Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ2902Test.java
@@ -28,10 +28,10 @@ import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.TransportConnection;
import org.apache.activemq.transport.TransportDisposedIOException;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
import org.slf4j.LoggerFactory;
public class AMQ2902Test extends TestCase {
@@ -41,10 +41,11 @@ public class AMQ2902Test extends TestCase {
final AtomicBoolean failedToFindMDC = new AtomicBoolean(Boolean.FALSE);
Appender appender = new DefaultTestAppender() {
+ @SuppressWarnings("deprecation")
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getThrowableInformation() != null
- && event.getThrowableInformation().getThrowable() instanceof TransportDisposedIOException) {
+ public void append(LogEvent event) {
+ if (event.getThrown() != null
+ && event.getThrown() instanceof TransportDisposedIOException) {
// Prevent StackOverflowException so we can see a sane stack trace.
if (gotExceptionInLog.get()) {
@@ -52,11 +53,11 @@ public class AMQ2902Test extends TestCase {
}
gotExceptionInLog.set(Boolean.TRUE);
- LOG.error("got event: " + event + ", ex:" + event.getThrowableInformation().getThrowable(), event.getThrowableInformation().getThrowable());
+ LOG.error("got event: " + event + ", ex:" + event.getThrown(), event);
LOG.error("Event source: ", new Throwable("Here"));
}
- if( !((String) event.getMessage()).startsWith("Loaded the Bouncy Castle security provider at position") ) {
- if (event.getMDC("activemq.broker") == null) {
+ if( !((String) event.getMessage().getFormattedMessage()).startsWith("Loaded the Bouncy Castle security provider at position") ) {
+ if (event.getContextData().getValue("activemq.broker") == null) {
failedToFindMDC.set(Boolean.TRUE);
}
}
@@ -84,14 +85,14 @@ public class AMQ2902Test extends TestCase {
public void setUp() throws Exception {
gotExceptionInLog.set(Boolean.FALSE);
failedToFindMDC.set(Boolean.FALSE);
- Logger.getRootLogger().addAppender(appender);
- Logger.getLogger(TransportConnection.class.getName() + ".Transport").setLevel(Level.DEBUG);
- Logger.getLogger(TransportConnection.class.getName()).setLevel(Level.DEBUG);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getRootLogger()).addAppender(appender);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(TransportConnection.class.getName() + ".Transport")).setLevel(Level.DEBUG);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(TransportConnection.class)).setLevel(Level.DEBUG);
}
@Override
public void tearDown() throws Exception {
- Logger.getRootLogger().removeAppender(appender);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getRootLogger()).removeAppender(appender);
assertFalse("got unexpected ex in log on graceful close", gotExceptionInLog.get());
assertFalse("MDC is there", failedToFindMDC.get());
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3567Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3567Test.java
index b4ce82f..531a37a 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3567Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3567Test.java
@@ -32,10 +32,15 @@ import javax.jms.Session;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
+import org.apache.activemq.broker.region.cursors.AbstractStoreCursor;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
@@ -71,15 +76,15 @@ public class AMQ3567Test {
@Test
public void runTest() throws Exception {
produceSingleMessage();
- org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger("org.apache.activemq.util.ServiceSupport");
- final AtomicBoolean failed = new AtomicBoolean(false);
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger("org.apache.activemq.util.ServiceSupport"));
- Appender appender = new DefaultTestAppender() {
+ final AtomicBoolean failed = new AtomicBoolean(false);
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getThrowableInformation() != null) {
- if (event.getThrowableInformation().getThrowable() instanceof InterruptedException) {
- InterruptedException ie = (InterruptedException)event.getThrowableInformation().getThrowable();
+ public void append(LogEvent event) {
+ if (event.getThrown() != null) {
+ if (event.getThrown() instanceof InterruptedException) {
+ InterruptedException ie = (InterruptedException)event.getThrown();
if (ie.getMessage().startsWith("Could not stop service:")) {
logger.info("Received an interrupted exception : ", ie);
failed.set(true);
@@ -88,11 +93,14 @@ public class AMQ3567Test {
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
- Level level = log4jLogger.getLevel();
- log4jLogger.setLevel(Level.DEBUG);
+ Level level = logger.getLevel();
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+ logger.setLevel(Level.DEBUG);
+
try {
stopConsumer();
stopBroker();
@@ -101,8 +109,8 @@ public class AMQ3567Test {
}
} finally {
- log4jLogger.setLevel(level);
- log4jLogger.removeAppender(appender);
+ logger.setLevel(level);
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3622Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3622Test.java
index e08279c..0f6b7fb 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3622Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3622Test.java
@@ -30,35 +30,47 @@ import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.transport.stomp.Stomp;
import org.apache.activemq.transport.stomp.StompConnection;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class AMQ3622Test {
+ protected static final Appender appender;
+ protected static final AtomicBoolean failed = new AtomicBoolean(false);
protected BrokerService broker;
- protected AtomicBoolean failed = new AtomicBoolean(false);
protected String connectionUri;
- protected Appender appender = new DefaultTestAppender() {
+ protected Logger logger;
+ static {
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
System.err.println(event.getMessage());
- if (event.getThrowableInformation() != null) {
- if (event.getThrowableInformation().getThrowable() instanceof NullPointerException) {
+ if (event.getThrown() != null) {
+ if (event.getThrown() instanceof NullPointerException) {
failed.set(true);
}
}
- }
- };
+ }
+ };
+ appender.start();
+ }
@Before
public void before() throws Exception {
- Logger.getRootLogger().addAppender(appender);
+
+ logger = Logger.class.cast(LogManager.getRootLogger());
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
broker = new BrokerService();
broker.setDataDirectory("target" + File.separator + "activemq-data");
@@ -88,7 +100,7 @@ public class AMQ3622Test {
public void after() throws Exception {
broker.stop();
broker.waitUntilStopped();
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
}
@Test
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3625Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3625Test.java
index a9506c3..efa962f 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3625Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3625Test.java
@@ -18,10 +18,13 @@ package org.apache.activemq.bugs;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -80,27 +83,32 @@ public class AMQ3625Test {
@Test
public void go() throws Exception {
- Appender appender = new DefaultTestAppender() {
+
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage().toString().contains("java.lang.SecurityException")) {
+ public void append(LogEvent event) {
+ if (event.getMessage() != null && event.getMessage().getFormattedMessage().contains("java.lang.SecurityException")) {
authenticationFailed.set(true);
}
- if (event.getMessage().toString().contains("NullPointerException")) {
+ if (event.getMessage() != null && event.getMessage().getFormattedMessage().contains("NullPointerException")) {
gotNPE.set(true);
}
}
};
- Logger.getRootLogger().addAppender(appender);
-
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
String connectURI = broker1.getConnectorByName("openwire").getConnectUri().toString();
connectURI = connectURI.replace("?needClientAuth=true", "?verifyHostName=false");
broker2.addNetworkConnector("static:(" + connectURI + ")").start();
-
+
Thread.sleep(10 * 1000);
-
- Logger.getRootLogger().removeAppender(appender);
-
+
+ logger.removeAppender(appender);
+
assertTrue(authenticationFailed.get());
assertFalse(gotNPE.get());
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3779Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3779Test.java
index edd334a..172ad93 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3779Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ3779Test.java
@@ -26,10 +26,15 @@ import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.util.LoggingBrokerPlugin;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -38,8 +43,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class AMQ3779Test {
-
- private static final Logger LOG = Logger.getLogger(AMQ3779Test.class);
+ private static final Logger LOG = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(AMQ3779Test.class));
private static final String qName = "QNameToFind";
private BrokerService brokerService;
@@ -51,20 +55,28 @@ public class AMQ3779Test {
public void setUp() throws Exception {
ok.set(false);
- appender = new DefaultTestAppender() {
+ final var rootLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
if (event.getLoggerName().toString().contains(qName)) {
ok.set(true);
}
- if (event.getMessage().toString().contains("Sending") && event.getMessage().toString().contains("size = 0")) {
+ String msg = event.getMessage().getFormattedMessage();
+ if (msg.contains("Sending") && msg.contains("size = 0")) {
gotZeroSize.set(true);
}
}
};
+ appender.start();
+
+ LOG.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ LOG.addAppender(appender);
+ LOG.setLevel(Level.TRACE);
- Logger.getRootLogger().addAppender(appender);
+ rootLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ rootLogger.addAppender(appender);
try {
brokerService = new BrokerService();
@@ -89,7 +101,7 @@ public class AMQ3779Test {
brokerService.waitUntilStopped();
}
} finally {
- Logger.getRootLogger().removeAppender(appender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ4221Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ4221Test.java
index 0684cb6..1f55210 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ4221Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ4221Test.java
@@ -45,10 +45,13 @@ import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.store.kahadb.plist.PListStoreImpl;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.LogManager;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -84,17 +87,21 @@ public class AMQ4221Test extends TestSupport {
@Override
public void setUp() throws Exception {
- LogManager.getRootLogger().addAppender(new DefaultTestAppender() {
-
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().isGreaterOrEqual(Level.ERROR)) {
+ public void append(LogEvent event) {
+ if (event.getLevel().isMoreSpecificThan(Level.WARN)) {
System.err.println("Fail on error in log: " + event.getMessage());
done.set(true);
- errorsInLog.add(event.getRenderedMessage());
+ errorsInLog.add(event.getMessage().getFormattedMessage());
}
}
- });
+ };
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
done.set(false);
errorsInLog.clear();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5426Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5426Test.java
index da09aaf..5c7f4b4 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5426Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5426Test.java
@@ -41,10 +41,13 @@ import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
-import org.apache.log4j.Appender;
-import org.apache.log4j.AppenderSkeleton;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -61,7 +64,6 @@ public class AMQ5426Test {
private AtomicBoolean hasFailureInProducer = new AtomicBoolean(false);
private Thread producerThread;
private AtomicBoolean hasErrorInLogger;
- private Appender errorDetectorAppender;
protected ConnectionFactory createConnectionFactory() throws Exception {
ActiveMQConnectionFactory conFactory = new ActiveMQConnectionFactory(
@@ -92,25 +94,20 @@ public class AMQ5426Test {
// ActiveMQConnection.setClientInternalExceptionListener
// since ActiveMQMessageConsumer.dispatch will silently catch and
// discard any RuntimeException
- errorDetectorAppender = new AppenderSkeleton() {
- @Override
- public void close() {
- // Do nothing
- }
-
- @Override
- public boolean requiresLayout() {
- return false;
- }
-
- @Override
- protected void append(LoggingEvent event) {
- if (event.getLevel().isGreaterOrEqual(Level.ERROR))
- hasErrorInLogger.set(true);
- }
+
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ if (event.getLevel().isMoreSpecificThan(Level.WARN))
+ hasErrorInLogger.set(true);
+ }
};
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
- org.apache.log4j.Logger.getRootLogger().addAppender(errorDetectorAppender);
producerThread = new Thread(new Runnable() {
@Override
public void run() {
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5844Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5844Test.java
index 17db041..afdbc18 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5844Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ5844Test.java
@@ -31,16 +31,18 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import org.apache.log4j.Appender;
-import org.apache.log4j.spi.LoggingEvent;
-
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.apache.activemq.broker.BrokerService;
-import org.apache.activemq.broker.region.policy.AbortSlowConsumerStrategy;
import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.transport.failover.FailoverTransport;
import org.apache.activemq.util.DefaultIOExceptionHandler;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
import org.slf4j.Logger;
@@ -75,26 +77,31 @@ public class AMQ5844Test {
static boolean abortingSlowConsumer = false;
static boolean successfullyReconnected = false;
+ static final AbstractAppender appender;
- static final Appender appender = new DefaultTestAppender() {
- @Override
- public void doAppend(LoggingEvent event) {
- if(event.getMessage().toString().contains("aborting slow consumer")) {
- abortingSlowConsumer = true;
- }
-
- if(event.getMessage().toString().contains("Successfully reconnected to")) {
- successfullyReconnected = true;
+ static {
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ if(event.getMessage().getFormattedMessage().contains("aborting slow consumer")) {
+ abortingSlowConsumer = true;
+ }
+
+ if(event.getMessage().getFormattedMessage().contains("Successfully reconnected to")) {
+ successfullyReconnected = true;
+ }
}
- }
- };
+ };
+ appender.start();
+ }
@BeforeClass
public static void setUp() throws Exception {
- org.apache.log4j.Logger.getRootLogger().addAppender(appender);
+ org.apache.logging.log4j.core.Logger rootLogger = ((org.apache.logging.log4j.core.Logger)LogManager.getRootLogger());
+ rootLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ rootLogger.addAppender(appender);
}
-
@Before
/**
* Sets a AbortSlowConsumerStrategy policy entry on the broker and starts the broker.
@@ -133,7 +140,7 @@ public class AMQ5844Test {
broker.stop();
broker.waitUntilStopped();
}
- org.apache.log4j.Logger.getRootLogger().removeAppender(appender);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getRootLogger()).removeAppender(appender);
}
@Test
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6131Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6131Test.java
index 2abd33f..f653641 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6131Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6131Test.java
@@ -46,7 +46,7 @@ import org.apache.activemq.util.Wait.Condition;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -61,7 +61,8 @@ public class AMQ6131Test {
@Before
public void startBroker() throws Exception {
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).setLevel(Level.TRACE);
+ org.apache.logging.log4j.core.Logger logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class));
+ logger.setLevel(org.apache.logging.log4j.Level.TRACE);
setUpBroker(true);
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6133PersistJMSRedeliveryTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6133PersistJMSRedeliveryTest.java
index ea29638..d739cfd 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6133PersistJMSRedeliveryTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6133PersistJMSRedeliveryTest.java
@@ -48,7 +48,8 @@ import org.apache.activemq.store.kahadb.MessageDatabase;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -96,8 +97,7 @@ public class AMQ6133PersistJMSRedeliveryTest {
public void setup() throws Exception {
// Investigate loss of messages on message update in store.
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).setLevel(Level.TRACE);
-
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(MessageDatabase.class)).setLevel(Level.TRACE);
createBroker(true);
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6432Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6432Test.java
index de9dd63..596174b 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6432Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6432Test.java
@@ -22,11 +22,14 @@ import org.apache.activemq.broker.jmx.QueueViewMBean;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter;
import org.apache.activemq.store.kahadb.MessageDatabase;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -85,22 +88,26 @@ public class AMQ6432Test {
@Test
public void testTransactedStoreUsageSuspendResume() throws Exception {
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(MessageDatabase.class);
final AtomicBoolean failed = new AtomicBoolean(false);
final File journalDataDir = ((KahaDBPersistenceAdapter) broker.getPersistenceAdapter()).getStore().getJournal().getDirectory();
- Appender appender = new DefaultTestAppender() {
+
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getMessage().toString().startsWith("Failed to load next journal")) {
- LOG.info("received unexpected log message: " + event.getMessage());
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().startsWith("Failed to load next journal")) {
+ LOG.info("received unexpected log message: " + event.getMessage().getFormattedMessage());
failed.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
ExecutorService sendExecutor = Executors.newSingleThreadExecutor();
@@ -139,7 +146,7 @@ public class AMQ6432Test {
}));
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
assertFalse("failed on unexpected log event", failed.get());
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6463Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6463Test.java
index 31e1ec1..f3af4ba 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6463Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ6463Test.java
@@ -27,11 +27,16 @@ import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.broker.region.policy.VMPendingQueueMessageStoragePolicy;
import org.apache.activemq.broker.region.policy.VMPendingSubscriberMessageStoragePolicy;
import org.apache.activemq.command.ActiveMQQueue;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -48,7 +53,7 @@ public class AMQ6463Test extends JmsTestSupport {
ActiveMQQueue queueA = new ActiveMQQueue("QUEUE.A");
protected TransportConnector connector;
protected ActiveMQConnection connection;
- protected DefaultTestAppender appender;
+ protected Appender appender;
final AtomicInteger errors = new AtomicInteger(0);
final AtomicBoolean gotUsageBlocked = new AtomicBoolean();
@@ -120,25 +125,28 @@ public class AMQ6463Test extends JmsTestSupport {
public void setUp() throws Exception {
setAutoFail(true);
- appender = new DefaultTestAppender() {
+
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
if (event.getLevel().equals(Level.ERROR)) {
errors.incrementAndGet();
- } else if (event.getLevel().equals(Level.WARN) && event.getRenderedMessage().contains("Usage Manager Memory Limit")) {
+ } else if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("Usage Manager Memory Limit")) {
gotUsageBlocked.set(true);
}
}
};
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
- rootLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
super.setUp();
}
protected void tearDown() throws Exception {
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
- rootLogger.removeAppender(appender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).removeAppender(appender);
if (connection != null) {
connection.close();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ7067Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ7067Test.java
index 5da378e..fa24076 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ7067Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/AMQ7067Test.java
@@ -21,6 +21,7 @@ import org.apache.activemq.ActiveMQXAConnection;
import org.apache.activemq.ActiveMQXAConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;
+import org.apache.activemq.broker.TransportConnection;
import org.apache.activemq.broker.jmx.BrokerMBeanSupport;
import org.apache.activemq.broker.jmx.BrokerViewMBean;
import org.apache.activemq.broker.jmx.DestinationViewMBean;
@@ -34,7 +35,8 @@ import org.apache.activemq.store.kahadb.MessageDatabase;
import org.apache.activemq.util.JMXSupport;
import org.apache.activemq.util.Wait;
import org.apache.commons.lang.StringUtils;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -166,8 +168,8 @@ public class AMQ7067Test {
public void testXAPrepareWithAckCompactionDoesNotLooseInflight() throws Exception {
// investigate liner gc issue - store usage not getting released
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).setLevel(Level.TRACE);
-
+ org.apache.logging.log4j.core.Logger logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class));
+ logger.setLevel(org.apache.logging.log4j.Level.TRACE);
setupXAConnection();
@@ -242,8 +244,7 @@ public class AMQ7067Test {
((KahaDBPersistenceAdapter)broker.getPersistenceAdapter()).setCompactAcksAfterNoGC(2);
// investigate liner gc issue - store usage not getting released
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).setLevel(Level.TRACE);
-
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class)).setLevel(Level.TRACE);
setupXAConnection();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/MKahaDBTxRecoveryTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/MKahaDBTxRecoveryTest.java
index 9e9bcfd..4daa85b 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/MKahaDBTxRecoveryTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/MKahaDBTxRecoveryTest.java
@@ -34,11 +34,14 @@ import org.apache.activemq.store.kahadb.MultiKahaDBPersistenceAdapter;
import org.apache.activemq.store.kahadb.MultiKahaDBTransactionStore;
import org.apache.activemq.store.kahadb.disk.journal.Journal;
import org.apache.activemq.util.ByteSequence;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Test;
import org.slf4j.Logger;
@@ -280,20 +283,22 @@ public class MKahaDBTxRecoveryTest {
corruptTxStoreJournal(pathToDataDir);
// verify failure to load txStore via logging
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(MultiKahaDBTransactionStore.class);
-
AtomicBoolean foundSomeCorruption = new AtomicBoolean();
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MultiKahaDBTransactionStore.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.ERROR) && event.getMessage().toString().startsWith("Corrupt ")) {
+ public void append(LogEvent event) {
+ if (Level.ERROR.equals(event.getLevel()) && event.getMessage().getFormattedMessage().startsWith("Corrupt ")) {
LOG.info("received expected log message: " + event.getMessage());
foundSomeCorruption.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
prepareBrokerWithMultiStore(false);
@@ -367,7 +372,7 @@ public class MKahaDBTxRecoveryTest {
assertEquals(101, destination.getMessageStore().getMessageCount());
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
}
@@ -401,24 +406,26 @@ public class MKahaDBTxRecoveryTest {
corruptTxStoreJournalAndTruncate(pathToDataDir);
// verify failure to load txStore via logging
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(MultiKahaDBTransactionStore.class);
-
AtomicBoolean foundSomeCorruption = new AtomicBoolean();
AtomicBoolean ignoringCorruption = new AtomicBoolean();
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MultiKahaDBTransactionStore.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.ERROR) && event.getMessage().toString().startsWith("Corrupt ")) {
+ public void append(LogEvent event) {
+ if (Level.ERROR.equals(event.getLevel()) && event.getMessage().getFormattedMessage().startsWith("Corrupt ")) {
LOG.info("received expected log message: " + event.getMessage());
foundSomeCorruption.set(true);
- } else if (event.getLevel().equals(Level.INFO) && event.getMessage().toString().contains("auto resolving")) {
+ } else if (Level.INFO.equals(event.getLevel()) && event.getMessage().getFormattedMessage().contains("auto resolving")) {
ignoringCorruption.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
prepareBrokerWithMultiStore(false);
@@ -453,7 +460,7 @@ public class MKahaDBTxRecoveryTest {
broker.stop();
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TransactedStoreUsageSuspendResumeTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TransactedStoreUsageSuspendResumeTest.java
index e2d94f9..7620888 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TransactedStoreUsageSuspendResumeTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TransactedStoreUsageSuspendResumeTest.java
@@ -38,7 +38,8 @@ import org.apache.activemq.TestSupport;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter;
import org.apache.activemq.store.kahadb.MessageDatabase;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -108,7 +109,7 @@ public class TransactedStoreUsageSuspendResumeTest {
public void setup() throws Exception {
// investigate liner gc issue - store usage not getting released
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).setLevel(Level.TRACE);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class)).setLevel(Level.TRACE);
broker = new BrokerService();
broker.setDeleteAllMessagesOnStartup(true);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TrapMessageInJDBCStoreTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TrapMessageInJDBCStoreTest.java
index ae1c442..a0ae1f1 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TrapMessageInJDBCStoreTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/TrapMessageInJDBCStoreTest.java
@@ -41,7 +41,8 @@ import org.apache.activemq.store.jdbc.TransactionContext;
import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.LeaseLockerIOExceptionHandler;
import org.apache.derby.jdbc.EmbeddedDataSource;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -109,7 +110,7 @@ public class TrapMessageInJDBCStoreTest extends TestCase {
public void testDBCommitException() throws Exception {
- org.apache.log4j.Logger serviceLogger = org.apache.log4j.Logger.getLogger(TransportConnection.class.getName() + ".Service");
+ org.apache.logging.log4j.core.Logger serviceLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(TransportConnection.class.getName() + ".Service"));
serviceLogger.setLevel (Level.TRACE);
broker = this.createBroker(false);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/EmbeddedActiveMQ.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/EmbeddedActiveMQ.java
index 3b4f2fd..abfba57 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/EmbeddedActiveMQ.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/EmbeddedActiveMQ.java
@@ -26,12 +26,13 @@ import javax.jms.MessageProducer;
import javax.jms.Session;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class EmbeddedActiveMQ
{
- private static Logger logger = Logger.getLogger(EmbeddedActiveMQ.class);
+ private static Logger logger = LoggerFactory.getLogger(EmbeddedActiveMQ.class);
public static void main(String[] args)
{
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/ThreadExplorer.java b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/ThreadExplorer.java
index 1d6e204..cc6cbf3 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/ThreadExplorer.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/bugs/embedded/ThreadExplorer.java
@@ -18,11 +18,13 @@ package org.apache.activemq.bugs.embedded;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.apache.log4j.Logger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class ThreadExplorer
{
- static Logger logger = Logger.getLogger(ThreadExplorer.class);
+ static Logger logger = LoggerFactory.getLogger(ThreadExplorer.class);
public static Thread[] listThreads()
{
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/jmx/JmxAuditLogTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/jmx/JmxAuditLogTest.java
index 5256b96..d4014e6 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/jmx/JmxAuditLogTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/jmx/JmxAuditLogTest.java
@@ -35,11 +35,14 @@ import org.apache.activemq.broker.jmx.BrokerMBeanSupport;
import org.apache.activemq.broker.jmx.ManagementContext;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.command.ActiveMQQueue;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.Test;
import static org.apache.activemq.broker.util.JMXAuditLogEntry.VERBS;
@@ -119,31 +122,33 @@ public class JmxAuditLogTest extends TestSupport
@Test
public void testPasswordsAreNotLoggedWhenAuditIsTurnedOn() throws Exception
{
- Logger log4jLogger = Logger.getLogger("org.apache.activemq.audit");
- log4jLogger.setLevel(Level.INFO);
+ final var log4jLogger = (org.apache.logging.log4j.core.Logger)LogManager.getLogger("org.apache.activemq.audit");
+ Configurator.setLevel("org.apache.activemq.audit", Level.INFO);
final AtomicInteger logCount = new AtomicInteger(0);
final AtomicBoolean gotEnded = new AtomicBoolean(false);
- Appender appender = new DefaultTestAppender()
- {
- @Override
- public void doAppend(LoggingEvent event)
- {
- if (event.getMessage() instanceof String)
- {
- String message = (String) event.getMessage();
- System.out.println(message);
- if (message.contains("testPassword"))
- {
- fail("Password should not appear in log file");
- }
- if (message.contains(VERBS[1])) {
- gotEnded.set(true);
- }
- }
- logCount.incrementAndGet();
- }
+ // start new
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ if (event.getMessage() != null)
+ {
+ String message = event.getMessage().getFormattedMessage();
+ System.out.println(message);
+ if (message.contains("testPassword"))
+ {
+ fail("Password should not appear in log file");
+ }
+ if (message.contains(VERBS[1])) {
+ gotEnded.set(true);
+ }
+ }
+ logCount.incrementAndGet();
+ }
};
+ appender.start();
+
+ log4jLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
log4jLogger.addAppender(appender);
MBeanServerConnection conn = createJMXConnector(portToUse);
@@ -163,8 +168,6 @@ public class JmxAuditLogTest extends TestSupport
@Test
public void testNameTargetVisible() throws Exception
{
- Logger log4jLogger = Logger.getLogger("org.apache.activemq.audit");
- log4jLogger.setLevel(Level.INFO);
final AtomicInteger logCount = new AtomicInteger(0);
final AtomicBoolean gotEnded = new AtomicBoolean(false);
final AtomicBoolean gotQueueName = new AtomicBoolean(false);
@@ -172,36 +175,41 @@ public class JmxAuditLogTest extends TestSupport
final AtomicBoolean gotConnectorName = new AtomicBoolean(false);
final String queueName = queue.getQueueName();
- Appender appender = new DefaultTestAppender()
- {
- @Override
- public void doAppend(LoggingEvent event)
- {
- if (event.getMessage() instanceof String)
- {
- String message = (String) event.getMessage();
- System.out.println(message);
- if (message.contains(VERBS[0])) {
- if (message.contains(queueName)) {
- gotQueueName.set(true);
- }
- if (message.contains(broker.getBrokerName())) {
- gotBrokerName.set(true);
- }
-
- if (message.contains("TCP")) {
- gotConnectorName.set(true);
- }
- }
-
- if (message.contains(VERBS[1])) {
- gotEnded.set(true);
- }
- }
- logCount.incrementAndGet();
- }
+
+ // start new
+ final var logger = (org.apache.logging.log4j.core.Logger)LogManager.getLogger("org.apache.activemq.audit");
+ Configurator.setLevel("org.apache.activemq.audit", Level.INFO);
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ if (event.getMessage() != null)
+ {
+ String message = event.getMessage().getFormattedMessage();
+ System.out.println(message);
+ if (message.contains(VERBS[0])) {
+ if (message.contains(queueName)) {
+ gotQueueName.set(true);
+ }
+ if (message.contains(broker.getBrokerName())) {
+ gotBrokerName.set(true);
+ }
+
+ if (message.contains("TCP")) {
+ gotConnectorName.set(true);
+ }
+ }
+
+ if (message.contains(VERBS[1])) {
+ gotEnded.set(true);
+ }
+ }
+ logCount.incrementAndGet();
+ }
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
MBeanServerConnection conn = createJMXConnector(portToUse);
ObjectName queueObjName = new ObjectName(broker.getBrokerObjectName() + ",destinationType=Queue,destinationName=" + queueName);
@@ -226,7 +234,6 @@ public class JmxAuditLogTest extends TestSupport
assertEquals("got messages", 6, logCount.get());
assertTrue("got connectorName in called statement", gotConnectorName.get());
- log4jLogger.removeAppender(appender);
-
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
index 058a2eb..5bf176a 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
@@ -45,8 +45,9 @@ import org.apache.activemq.broker.jmx.QueueViewMBean;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.transport.stomp.StompConnection;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -71,17 +72,17 @@ public class SecurityJMXTest extends TestCase {
final AtomicReference<Object> stackTrace = new AtomicReference<Object>();
final Appender appender = new DefaultTestAppender() {
- public void doAppend(LoggingEvent event) {
- String message = event.getMessage().toString();
+ @Override
+ public void append(LogEvent event) {
+ String message = event.getMessage().getFormattedMessage();
if (message.contains("Async error occurred")) {
gotExpected.set(true);
- stackTrace.set(event.getThrowableInformation());
+ stackTrace.set(event.getThrown());
}
}
};
- final org.apache.log4j.Logger toVerify = org.apache.log4j.Logger.getLogger(TransportConnection.class.getName() + ".Service");
-
+ org.apache.logging.log4j.core.Logger toVerify = (org.apache.logging.log4j.core.Logger)LogManager.getLogger(TransportConnection.class.getName() + ".Service");
toVerify.addAppender(appender);
try {
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
index c22ec80..2ae8b5c 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
@@ -27,14 +27,18 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.activemq.broker.LockableServiceSupport;
import org.apache.activemq.broker.Locker;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.LockFile;
import org.apache.activemq.util.ServiceStopper;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -86,16 +90,22 @@ public class SharedFileLockerTest {
private void internalLoop(long timewait) throws Exception {
final AtomicInteger logCounts = new AtomicInteger(0);
- DefaultTestAppender appender = new DefaultTestAppender() {
+
+ // start new
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel() == Level.INFO) {
+ public void append(LogEvent event) {
+ if (Level.INFO.equals(event.getLevel())) {
logCounts.incrementAndGet();
}
}
};
+ appender.start();
- Logger.getRootLogger().addAppender(appender);
+ Configurator.setRootLevel(Level.DEBUG);
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
final AtomicInteger errors = new AtomicInteger(0);
@@ -163,8 +173,7 @@ public class SharedFileLockerTest {
} finally {
-
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
// to make sure we won't leak threads if the test ever failed for any reason
thread.join(1000);
@@ -182,14 +191,18 @@ public class SharedFileLockerTest {
public void verifyLockAcquireWaitsForLockDrop() throws Exception {
final AtomicInteger logCounts = new AtomicInteger(0);
- DefaultTestAppender appender = new DefaultTestAppender() {
+ // start new
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(SharedFileLocker.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
logCounts.incrementAndGet();
}
};
- Logger sharedFileLogger = Logger.getLogger(SharedFileLocker.class);
- sharedFileLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
LockableServiceSupport config = new LockableServiceSupport() {
@@ -261,7 +274,7 @@ public class SharedFileLockerTest {
executorService.shutdownNow();
underTest.stop();
lockFile.delete();
- sharedFileLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCConcurrentDLQTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCConcurrentDLQTest.java
index 8fc94d1..85b502c 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCConcurrentDLQTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCConcurrentDLQTest.java
@@ -23,9 +23,14 @@ import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.region.RegionBroker;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.util.DefaultIOExceptionHandler;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -61,22 +66,31 @@ public class JDBCConcurrentDLQTest {
broker.start();
broker.waitUntilStarted();
- appender = new DefaultTestAppender() {
+ final var jdbcLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(JDBCPersistenceAdapter.class));
+ final var regionLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(RegionBroker.class));
+
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(org.apache.log4j.spi.LoggingEvent event) {
- if (event.getLevel().toInt() > Level.INFO_INT) {
- LOG.error("Got error from log:" + event.getRenderedMessage());
+ public void append(LogEvent event) {
+ if (event.getLevel().isMoreSpecificThan(Level.INFO)) {
+ LOG.error("Got error from log:" + event.getMessage().getFormattedMessage());
gotError.set(true);
}
}
};
+ appender.start();
+
+ jdbcLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ jdbcLogger.addAppender(appender);
+
+ regionLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ regionLogger.addAppender(appender);
}
@After
public void tearDown() throws Exception {
- org.apache.log4j.Logger.getLogger(RegionBroker.class).removeAppender(appender);
- org.apache.log4j.Logger.getLogger(JDBCPersistenceAdapter.class).removeAppender(appender);
-
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(RegionBroker.class)).removeAppender(appender);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(JDBCPersistenceAdapter.class)).removeAppender(appender);
broker.stop();
}
@@ -108,8 +122,15 @@ public class JDBCConcurrentDLQTest {
gotError.set(true);
}
});
- org.apache.log4j.Logger.getLogger(RegionBroker.class).addAppender(appender);
- org.apache.log4j.Logger.getLogger(JDBCPersistenceAdapter.class).addAppender(appender);
+
+ final var loggerRB = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(RegionBroker.class));
+ final var loggerJDBC = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(JDBCPersistenceAdapter.class));
+
+ loggerRB.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ loggerRB.addAppender(appender);
+
+ loggerJDBC.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ loggerJDBC.addAppender(appender);
final int numMessages = 100;
final AtomicInteger consumed = new AtomicInteger(numMessages);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
index a88c50f..2f212ae 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/jdbc/JDBCIOExceptionHandlerTest.java
@@ -48,8 +48,13 @@ import org.apache.activemq.util.IOHelper;
import org.apache.activemq.util.LeaseLockerIOExceptionHandler;
import org.apache.activemq.util.Wait;
import org.apache.derby.jdbc.EmbeddedDataSource;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -124,25 +129,27 @@ public class JDBCIOExceptionHandlerTest {
final AtomicBoolean connectorStarted = new AtomicBoolean(false);
final AtomicBoolean connectorStopped = new AtomicBoolean(false);
- DefaultTestAppender appender = new DefaultTestAppender() {
-
+ // start new
+ final var rootLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage().toString().startsWith("JMX consoles can connect to")) {
+ public void append(LogEvent event) {
+ if (event.getMessage().getFormattedMessage().startsWith("JMX consoles can connect to")) {
connectorStarted.set(true);
}
- if (event.getMessage().toString().equals("Stopping jmx connector")) {
+ if (event.getMessage().getFormattedMessage().equals("Stopping jmx connector")) {
connectorStopped.set(true);
}
}
};
+ appender.start();
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
Level previousLevel = rootLogger.getLevel();
- rootLogger.setLevel(Level.DEBUG);
+ rootLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
rootLogger.addAppender(appender);
-
+ rootLogger.setLevel(Level.DEBUG);
+ // end new
BrokerService broker = new BrokerService();
broker.getManagementContext().setCreateConnector(true);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
index f509011..3e2b634 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
@@ -20,14 +20,15 @@ import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.store.PersistenceAdapter;
import org.apache.activemq.store.PersistenceAdapterTestSupport;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.logging.log4j.core.config.Configurator;
/**
*
@@ -53,19 +54,20 @@ public class KahaDBPersistenceAdapterTest extends PersistenceAdapterTestSupport
Appender appender = new DefaultTestAppender() {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
trappedLogMessages.set(true);
if (event.getLevel().equals(Level.INFO)) {
- if (event.getMessage().toString().contains("Recovery replayed ")) {
+ if (event.getMessage() != null && event.getMessage().getFormattedMessage().contains("Recovery replayed ")) {
gotSomeReplay.set(true);
}
}
}
};
+ appender.start();
try {
- Logger.getLogger(MessageDatabase.class.getName()).addAppender(appender);
- Logger.getLogger(MessageDatabase.class.getName()).setLevel(Level.INFO);
+ Configurator.setLevel(MessageDatabase.class.getName(), Level.INFO);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(MessageDatabase.class)).addAppender(appender);
brokerService = new BrokerService();
pa = createPersistenceAdapter(false);
@@ -73,8 +75,9 @@ public class KahaDBPersistenceAdapterTest extends PersistenceAdapterTestSupport
brokerService.start();
} finally {
- Logger.getRootLogger().removeAppender(appender);
- Logger.getLogger(MessageDatabase.class.getName()).removeAppender(appender);
+ appender.stop();
+ ((org.apache.logging.log4j.core.Logger)LogManager.getRootLogger()).removeAppender(appender);
+ ((org.apache.logging.log4j.core.Logger)LogManager.getLogger(MessageDatabase.class)).removeAppender(appender);
}
assertTrue("log capture working", trappedLogMessages.get());
assertFalse("no replay message in the log", gotSomeReplay.get());
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBTest.java
index 74d2bb8..53306bd 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBTest.java
@@ -32,10 +32,13 @@ import junit.framework.TestCase;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.command.ActiveMQQueue;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
/**
* @author chirino
@@ -209,16 +212,19 @@ public class KahaDBTest extends TestCase {
kaha.setCheckForCorruptJournalFiles(true);
final AtomicBoolean didSomeRecovery = new AtomicBoolean(false);
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel() == Level.INFO && event.getRenderedMessage().contains("Recovering from the journal @")) {
+ public void append(LogEvent event) {
+ if (Level.INFO.equals(event.getLevel()) && event.getMessage().getFormattedMessage().contains("Recovering from the journal @")) {
didSomeRecovery.set(true);
}
}
};
+ appender.start();
- Logger.getRootLogger().addAppender(appender);
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
broker = createBroker(kaha);
@@ -226,7 +232,7 @@ public class KahaDBTest extends TestCase {
assertEquals("Expected to received all messages.", count, 100);
broker.stop();
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
assertFalse("Did not replay any records from the journal", didSomeRecovery.get());
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/AMQ1925Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/AMQ1925Test.java
index dfb5dfd..16d3a9f 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/AMQ1925Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/AMQ1925Test.java
@@ -43,7 +43,8 @@ import org.apache.activemq.broker.region.Destination;
import org.apache.activemq.broker.region.Queue;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.util.ServiceStopper;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* TestCase showing the message-destroying described in AMQ-1925
@@ -51,7 +52,7 @@ import org.apache.log4j.Logger;
*
*/
public class AMQ1925Test extends TestCase implements ExceptionListener {
- private static final Logger log = Logger.getLogger(AMQ1925Test.class);
+ private static final Logger log = LoggerFactory.getLogger(AMQ1925Test.class);
private static final String QUEUE_NAME = "test.amq1925";
private static final String PROPERTY_MSG_NUMBER = "NUMBER";
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/FailoverUpdateURIsTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/FailoverUpdateURIsTest.java
index 9c9b2fd..9566cd8 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/FailoverUpdateURIsTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/failover/FailoverUpdateURIsTest.java
@@ -33,12 +33,13 @@ import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnector;
import org.apache.activemq.network.NetworkConnector;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class FailoverUpdateURIsTest extends TestCase {
private static final String QUEUE_NAME = "test.failoverupdateuris";
- private static final Logger LOG = Logger.getLogger(FailoverUpdateURIsTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(FailoverUpdateURIsTest.class);
String firstTcpUri = "tcp://localhost:61616";
String secondTcpUri = "tcp://localhost:61626";
@@ -64,10 +65,10 @@ public class FailoverUpdateURIsTest extends TestCase {
String targetDir = "target/" + getName();
new File(targetDir).mkdir();
File updateFile = new File(targetDir + "/updateURIsFile.txt");
- LOG.info(updateFile);
- LOG.info(updateFile.toURI());
- LOG.info(updateFile.getAbsoluteFile());
- LOG.info(updateFile.getAbsoluteFile().toURI());
+ LOG.info("updateFile:" + updateFile);
+ LOG.info("updateFileUri:" + updateFile.toURI());
+ LOG.info("updateFileAbsoluteFile:" + updateFile.getAbsoluteFile());
+ LOG.info("updateFileAbsoluteFileUri:" + updateFile.getAbsoluteFile().toURI());
FileOutputStream out = new FileOutputStream(updateFile);
out.write(firstTcpUri.getBytes());
out.close();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/nio/NIOSSLBasicTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/nio/NIOSSLBasicTest.java
index 2c64eb3..7fddb0e 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/nio/NIOSSLBasicTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/nio/NIOSSLBasicTest.java
@@ -17,21 +17,23 @@
package org.apache.activemq.transport.nio;
import javax.jms.Connection;
-import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
-import javax.net.ssl.SSLHandshakeException;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnector;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -114,21 +116,25 @@ public class NIOSSLBasicTest {
final CountDownLatch gotLogMessage = new CountDownLatch(1);
final AtomicBoolean gotRemoteAddressInLog = new AtomicBoolean();
- final DefaultTestAppender appender = new DefaultTestAppender() {
+ // start new
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getRenderedMessage().contains("Could not accept connection")) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("Could not accept connection")) {
gotLogMessage.countDown();
- if (event.getRenderedMessage().contains("tcp")) {
+ if (event.getMessage().getFormattedMessage().contains("tcp")) {
// got remote address
gotRemoteAddressInLog.set(true);
}
}
}
};
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
- rootLogger.addAppender(appender);
+ appender.start();
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
BrokerService broker = null;
try {
broker = createBroker("nio+ssl", getTransportType() + "://localhost:61616?transport.needClientAuth=true");
@@ -138,7 +144,7 @@ public class NIOSSLBasicTest {
if (broker != null) {
stopBroker(broker);
}
- rootLogger.removeAppender(appender);
+ logger.removeAppender(appender);
assertTrue("Got remote address in log", gotRemoteAddressInLog.get());
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
index 28c4c9d..3be00bd 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
@@ -19,11 +19,16 @@ package org.apache.activemq.transport.tcp;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnection;
import org.apache.activemq.broker.TransportConnector;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -32,7 +37,6 @@ import org.slf4j.LoggerFactory;
import javax.net.ssl.*;
import java.net.Socket;
import java.net.URI;
-import java.sql.Time;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -48,9 +52,11 @@ public class TcpTransportCloseSocketNoWarnTest {
public static final String PASSWORD = "password";
public static final String SERVER_KEYSTORE = "src/test/resources/server.keystore";
public static final String TRUST_KEYSTORE = "src/test/resources/client.keystore";
+ public static final Appender appender;
+ public static final AtomicBoolean gotExceptionInLog = new AtomicBoolean();
private BrokerService brokerService;
-
+ private Logger rootLogger;
static {
System.setProperty("javax.net.ssl.trustStore", TRUST_KEYSTORE);
@@ -59,20 +65,20 @@ public class TcpTransportCloseSocketNoWarnTest {
System.setProperty("javax.net.ssl.keyStore", SERVER_KEYSTORE);
System.setProperty("javax.net.ssl.keyStorePassword", PASSWORD);
System.setProperty("javax.net.ssl.keyStoreType", KEYSTORE_TYPE);
- }
-
- final AtomicBoolean gotExceptionInLog = new AtomicBoolean();
- Appender appender = new DefaultTestAppender() {
- @Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getRenderedMessage().contains("failed:")) {
- gotExceptionInLog.set(Boolean.TRUE);
- LOG.error("got event: " + event + ", ex:" + event.getRenderedMessage());
- LOG.error("Event source: ", new Throwable("Here"));
+
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ @Override
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("failed:")) {
+ gotExceptionInLog.set(Boolean.TRUE);
+ LOG.error("got event: " + event + ", ex:" + event.getMessage().getFormattedMessage());
+ LOG.error("Event source: ", new Throwable("Here"));
+ }
+ return;
}
- return;
- }
- };
+ };
+ appender.start();
+ }
@Before
public void before() throws Exception {
@@ -80,8 +86,11 @@ public class TcpTransportCloseSocketNoWarnTest {
brokerService.setPersistent(false);
brokerService.setUseJmx(false);
- Logger.getRootLogger().addAppender(appender);
- Logger.getLogger(TransportConnection.class.getName() + ".Transport").setLevel(Level.WARN);
+ rootLogger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ rootLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ rootLogger.addAppender(appender);
+
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(TransportConnection.class.getName() + ".Transport")).setLevel(Level.WARN);
}
@After
@@ -90,7 +99,7 @@ public class TcpTransportCloseSocketNoWarnTest {
brokerService.stop();
brokerService.waitUntilStopped();
}
- Logger.getRootLogger().removeAppender(appender);
+ rootLogger.removeAppender(appender);
}
@Test(timeout = 60000)
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
index 995f798..5c88fef 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
@@ -18,10 +18,15 @@ package org.apache.activemq.transport.tcp;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnector;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -59,7 +64,7 @@ public class TcpTransportInactiveDuringHandshakeTest {
}
private BrokerService brokerService;
- private DefaultTestAppender appender;
+ private Appender appender;
CountDownLatch inactivityMonitorFired;
CountDownLatch handShakeComplete;
@@ -71,23 +76,24 @@ public class TcpTransportInactiveDuringHandshakeTest {
inactivityMonitorFired = new CountDownLatch(1);
handShakeComplete = new CountDownLatch(1);
- appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getRenderedMessage().contains("InactivityIOException")) {
+ public void append(LogEvent event) {
+ if (Level.WARN.equals(event.getLevel()) && event.getMessage().getFormattedMessage().contains("InactivityIOException")) {
inactivityMonitorFired.countDown();
}
}
};
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
- rootLogger.addAppender(appender);
+ appender.start();
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
}
@After
public void after() throws Exception {
- org.apache.log4j.Logger rootLogger = org.apache.log4j.Logger.getRootLogger();
- rootLogger.removeAppender(appender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).removeAppender(appender);;
if (brokerService != null) {
brokerService.stop();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/vm/VmTransportNetworkBrokerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/vm/VmTransportNetworkBrokerTest.java
index dc782a2..77377c3 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/vm/VmTransportNetworkBrokerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/vm/VmTransportNetworkBrokerTest.java
@@ -35,10 +35,14 @@ import org.apache.activemq.command.ActiveMQTopic;
import org.apache.activemq.network.DurableConduitBridge;
import org.apache.activemq.network.NetworkConnector;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.Ignore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -158,16 +162,20 @@ public class VmTransportNetworkBrokerTest extends TestCase {
vmConnection.close();
final AtomicInteger logCounts = new AtomicInteger(0);
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(DurableConduitBridge.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel() == Level.ERROR) {
+ public void append(LogEvent event) {
+ if (Level.ERROR.equals(event.getLevel())) {
logCounts.incrementAndGet();
}
}
};
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
- org.apache.log4j.Logger.getLogger(DurableConduitBridge.class).addAppender(appender);
try {
NetworkConnector networkConnector = forwarder.addNetworkConnector("static:("
@@ -185,7 +193,7 @@ public class VmTransportNetworkBrokerTest extends TestCase {
assertEquals("no errors", 0, logCounts.get());
} finally {
- org.apache.log4j.Logger.getLogger(DurableConduitBridge.class).removeAppender(appender);
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usage/StoreUsageLimitsTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usage/StoreUsageLimitsTest.java
index 22d5fd0..40112e7 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usage/StoreUsageLimitsTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usage/StoreUsageLimitsTest.java
@@ -24,11 +24,13 @@ import org.apache.activemq.ConfigurationException;
import org.junit.Test;
import org.apache.activemq.broker.BrokerService;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
-
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -52,42 +54,50 @@ public class StoreUsageLimitsTest {
public void testCheckLimitsLogLevel() throws Exception {
final CountDownLatch foundMessage = new CountDownLatch(1);
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- String message = (String) event.getMessage();
+ public void append(LogEvent event) {
+ String message = event.getMessage().getFormattedMessage();
if (message.contains(toMatch) && event.getLevel().equals(Level.WARN)) {
foundMessage.countDown();
}
}
};
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
- Logger.getRootLogger().addAppender(appender);
BrokerService brokerService = createBroker();
brokerService.start();
brokerService.stop();
assertTrue("Fount log message", foundMessage.await(WAIT_TIME_MILLS, TimeUnit.MILLISECONDS));
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
}
@Test
public void testCheckLimitsFailStart() throws Exception {
final CountDownLatch foundMessage = new CountDownLatch(1);
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- String message = (String) event.getMessage();
+ public void append(LogEvent event) {
+ String message = event.getMessage().getFormattedMessage();
if (message.contains(toMatch) && event.getLevel().equals(Level.ERROR)) {
foundMessage.countDown();
}
}
};
+ appender.start();
- Logger.getRootLogger().addAppender(appender);
- BrokerService brokerService = createBroker();
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
+ BrokerService brokerService = createBroker();
brokerService.setAdjustUsageLimits(false);
try {
brokerService.start();
@@ -99,6 +109,6 @@ public class StoreUsageLimitsTest {
assertTrue("Fount log message", foundMessage.await(WAIT_TIME_MILLS, TimeUnit.MILLISECONDS));
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/AMQ6446Test.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/AMQ6446Test.java
index ecc570f..d94a2a5 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/AMQ6446Test.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/AMQ6446Test.java
@@ -19,12 +19,15 @@ package org.apache.activemq.usecases;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
-import org.junit.Before;
import org.junit.Test;
import javax.jms.Connection;
@@ -49,16 +52,19 @@ public class AMQ6446Test {
final HashSet<String> loggers = new HashSet<String>();
final HashSet<String> messages = new HashSet<String>();
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
loggers.add(event.getLoggerName());
- messages.add(event.getRenderedMessage());
+ messages.add(event.getMessage().getFormattedMessage());
}
};
+ appender.start();
- Logger.getRootLogger().addAppender(appender);
- Logger.getRootLogger().setLevel(Level.DEBUG);
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+ Configurator.setRootLevel(Level.DEBUG);
String brokerUrlWithTrace = brokerService.getTransportConnectorByScheme("tcp").getPublishableConnectString() +
urlTraceParam;
@@ -70,7 +76,7 @@ public class AMQ6446Test {
connections.add(c);
}
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
// no logger ends with :2
assertFalse(foundMatch(loggers, ".*:2$"));
@@ -101,16 +107,19 @@ public class AMQ6446Test {
final HashSet<String> loggers = new HashSet<String>();
final HashSet<String> messages = new HashSet<String>();
- DefaultTestAppender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
+ public void append(LogEvent event) {
loggers.add(event.getLoggerName());
- messages.add(event.getRenderedMessage());
+ messages.add(event.getMessage().getFormattedMessage());
}
};
+ appender.start();
- Logger.getRootLogger().addAppender(appender);
- Logger.getRootLogger().setLevel(Level.TRACE);
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+ Configurator.setRootLevel(Level.TRACE);
String brokerUrlWithTrace = brokerService.getTransportConnectorByScheme("tcp").getPublishableConnectString() +
legacySupportParam;
@@ -122,7 +131,7 @@ public class AMQ6446Test {
connections.add(c);
}
- Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
// logger ends with :2
assertTrue(foundMatch(loggers, ".*:2$"));
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/ClientRebalanceTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/ClientRebalanceTest.java
index 4094ed3..d57fe7f 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/ClientRebalanceTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/ClientRebalanceTest.java
@@ -30,11 +30,12 @@ import org.apache.activemq.JmsMultipleBrokersTestSupport;
import org.apache.activemq.broker.TransportConnection;
import org.apache.activemq.broker.TransportConnector;
import org.apache.activemq.command.ConnectionControl;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;
public class ClientRebalanceTest extends JmsMultipleBrokersTestSupport {
- private static final Logger LOG = Logger.getLogger(ClientRebalanceTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ClientRebalanceTest.class);
private static final String QUEUE_NAME = "Test.ClientRebalanceTest";
protected void setUp() throws Exception {
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/DurableSubCacheTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/DurableSubCacheTest.java
index 17d1931..db26cd3 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/DurableSubCacheTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/DurableSubCacheTest.java
@@ -23,10 +23,13 @@ import org.apache.activemq.broker.region.cursors.AbstractStoreCursor;
import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQTopic;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -99,24 +102,26 @@ public class DurableSubCacheTest {
publishMesssages(topic, 20);
- org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger(AbstractStoreCursor.class.getCanonicalName());
final AtomicBoolean failed = new AtomicBoolean(false);
-
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(AbstractStoreCursor.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel() == Level.WARN) {
- LOG.info("Got warn event:" + event.getRenderedMessage());
+ public void append(LogEvent event) {
+ if (Level.WARN.equals(event.getLevel())) {
+ LOG.info("Got warn event:" + event.getMessage().getFormattedMessage());
failed.set(true);
}
}
};
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
try {
consumeDurableSub(topic, "my_sub_1", 20, prefetch);
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
assertFalse("no warning from the cursor", failed.get());
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/EmptyTransactionTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/EmptyTransactionTest.java
index e4f6196..c148c2d 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/EmptyTransactionTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/EmptyTransactionTest.java
@@ -22,9 +22,6 @@ import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter;
import org.apache.activemq.store.kahadb.MessageDatabase;
-import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.spi.LoggingEvent;
-import org.junit.experimental.theories.Theories;
import javax.jms.Connection;
import javax.jms.DeliveryMode;
@@ -34,6 +31,14 @@ import javax.jms.Session;
import javax.jms.TextMessage;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
+
public class EmptyTransactionTest extends TestCase {
private static final int CHECKPOINT_INTERVAL = 500;
@@ -42,16 +47,20 @@ public class EmptyTransactionTest extends TestCase {
public void testEmptyTransactionsCheckpoint() throws Exception {
AtomicBoolean hadRecovery = new AtomicBoolean(false);
- DefaultTestAppender appender = new DefaultTestAppender() {
+
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(MessageDatabase.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getMessage().toString().contains("Recovering from the journal @")) {
- hadRecovery.set(true);
- }
+ public void append(LogEvent event) {
+ if (event.getMessage().toString().contains("Recovering from the journal @")) {
+ hadRecovery.set(true);
+ }
}
};
+ appender.start();
- org.apache.log4j.Logger.getLogger(MessageDatabase.class).addAppender(appender);
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
start(true);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/OfflineDurableSubscriberTimeoutTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/OfflineDurableSubscriberTimeoutTest.java
index 521e256..632471b 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/OfflineDurableSubscriberTimeoutTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/OfflineDurableSubscriberTimeoutTest.java
@@ -30,11 +30,14 @@ import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.command.ActiveMQTopic;
import org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -119,23 +122,25 @@ public class OfflineDurableSubscriberTimeoutTest extends org.apache.activemq.Tes
public void testOfflineDurableSubscriberTimeout() throws Exception {
final AtomicBoolean foundLogMessage = new AtomicBoolean(false);
- Appender appender = new DefaultTestAppender() {
+ // start new
+ final var loggerMRB = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(ManagedRegionBroker.class));
+ final var loggerTopic = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(org.apache.activemq.broker.region.Topic.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().isGreaterOrEqual(Level.WARN)) {
+ public void append(LogEvent event) {
+ if (event.getLevel().isLessSpecificThan(Level.WARN)) {
LOG.info("received unexpected log message: " + event.getMessage());
foundLogMessage.set(true);
}
}
};
+ appender.start();
- org.apache.log4j.Logger log4jLoggerMRB =
- org.apache.log4j.Logger.getLogger(ManagedRegionBroker.class);
- org.apache.log4j.Logger log4jLoggerT =
- org.apache.log4j.Logger.getLogger(org.apache.activemq.broker.region.Topic.class);
+ loggerMRB.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ loggerMRB.addAppender(appender);
- log4jLoggerMRB.addAppender(appender);
- log4jLoggerT.addAppender(appender);
+ loggerTopic.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ loggerTopic.addAppender(appender);
try {
@@ -199,8 +204,8 @@ public class OfflineDurableSubscriberTimeoutTest extends org.apache.activemq.Tes
assertFalse("have not found any log warn/error", foundLogMessage.get());
} finally {
- log4jLoggerMRB.removeAppender(appender);
- log4jLoggerT.removeAppender(appender);
+ loggerMRB.removeAppender(appender);
+ loggerTopic.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/RequestReplyTempDestRemovalAdvisoryRaceTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/RequestReplyTempDestRemovalAdvisoryRaceTest.java
index 4822e02..7163da1 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/RequestReplyTempDestRemovalAdvisoryRaceTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/RequestReplyTempDestRemovalAdvisoryRaceTest.java
@@ -52,9 +52,13 @@ import org.apache.activemq.network.DemandForwardingBridgeSupport;
import org.apache.activemq.network.NetworkBridge;
import org.apache.activemq.network.NetworkConnector;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -85,7 +89,7 @@ public class RequestReplyTempDestRemovalAdvisoryRaceTest extends JmsMultipleBrok
protected final AtomicBoolean shutdown = new AtomicBoolean(false);
HashSet<NetworkConnector> networkConnectors = new HashSet<NetworkConnector>();
HashSet<Connection> advisoryConsumerConnections = new HashSet<Connection>();
- Appender slowDownAppender;
+ AbstractAppender slowDownAppender;
CountDownLatch consumerDemandExists;
@@ -263,15 +267,16 @@ public class RequestReplyTempDestRemovalAdvisoryRaceTest extends JmsMultipleBrok
private void slowDownAdvisoryDispatch() throws Exception {
- org.apache.log4j.Logger.getLogger(DemandForwardingBridgeSupport.class).setLevel(Level.DEBUG);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(DemandForwardingBridgeSupport.class)).setLevel(Level.DEBUG);
// instrument a logger to block the processing of a remove sub advisory
// simulate a slow thread
- slowDownAppender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger());
+ slowDownAppender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent loggingEvent) {
- if (Level.DEBUG.equals(loggingEvent.getLevel())) {
- String message = loggingEvent.getMessage().toString();
+ public void append(LogEvent event) {
+ if (Level.DEBUG.equals(event.getLevel())) {
+ String message = event.getMessage().getFormattedMessage();
if (message.startsWith("BrokerB") && message.contains("remove local subscription")) {
// sleep for a bit
try {
@@ -285,8 +290,10 @@ public class RequestReplyTempDestRemovalAdvisoryRaceTest extends JmsMultipleBrok
}
}
};
+ slowDownAppender.start();
- org.apache.log4j.Logger.getRootLogger().addAppender(slowDownAppender);
+ logger.get().addAppender(slowDownAppender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(slowDownAppender);
}
@Override
@@ -320,7 +327,7 @@ public class RequestReplyTempDestRemovalAdvisoryRaceTest extends JmsMultipleBrok
@Override
protected void tearDown() throws Exception {
if (slowDownAppender != null) {
- org.apache.log4j.Logger.getRootLogger().removeAppender(slowDownAppender);
+ org.apache.logging.log4j.core.Logger.class.cast(LogManager.getRootLogger()).removeAppender(slowDownAppender);
}
for (Connection connection : advisoryConsumerConnections) {
connection.close();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/TopicProducerFlowControlTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/TopicProducerFlowControlTest.java
index b26f36e..6d3adf7 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/TopicProducerFlowControlTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/TopicProducerFlowControlTest.java
@@ -35,17 +35,19 @@ import org.apache.activemq.ActiveMQPrefetchPolicy;
import org.apache.activemq.advisory.AdvisorySupport;
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnection;
-import org.apache.activemq.broker.region.RegionBroker;
import org.apache.activemq.broker.region.Topic;
import org.apache.activemq.broker.region.policy.PolicyEntry;
import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.command.ActiveMQTopic;
-import org.apache.activemq.util.DefaultTestAppender;
import org.apache.activemq.util.Wait;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -141,18 +143,21 @@ public class TopicProducerFlowControlTest extends TestCase implements MessageLis
});
final AtomicInteger warnings = new AtomicInteger();
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(Topic.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getMessage().toString().contains("Usage Manager memory limit reached")) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("Usage Manager memory limit reached")) {
LOG.info("received log message: " + event.getMessage());
warnings.incrementAndGet();
}
}
};
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(Topic.class);
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
// Start producing the test messages
@@ -204,7 +209,7 @@ public class TopicProducerFlowControlTest extends TestCase implements MessageLis
assertTrue("warning limited", warnings.get() < blockedCounter.get());
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
}
@@ -234,20 +239,22 @@ public class TopicProducerFlowControlTest extends TestCase implements MessageLis
Session listenerSession = c.createSession(false, 1);
Destination destination = createDestination(listenerSession);
-
final AtomicInteger warnings = new AtomicInteger();
- Appender appender = new DefaultTestAppender() {
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(Topic.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel().equals(Level.WARN) && event.getMessage().toString().contains("Usage Manager memory limit reached")) {
+ public void append(LogEvent event) {
+ if (event.getLevel().equals(Level.WARN) && event.getMessage().getFormattedMessage().contains("Usage Manager memory limit reached")) {
LOG.info("received log message: " + event.getMessage());
warnings.incrementAndGet();
}
}
};
- org.apache.log4j.Logger log4jLogger =
- org.apache.log4j.Logger.getLogger(Topic.class);
- log4jLogger.addAppender(appender);
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
+
try {
// Start producing the test messages
@@ -319,7 +326,7 @@ public class TopicProducerFlowControlTest extends TestCase implements MessageLis
assertEquals("nothing sent during close", enqueueCountWhenBlocked, broker.getDestination(ActiveMQDestination.transform(destination)).getDestinationStatistics().getEnqueues().getCount());
}
} finally {
- log4jLogger.removeAppender(appender);
+ logger.removeAppender(appender);
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/UsageBlockedDispatchTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/UsageBlockedDispatchTest.java
index dba73c1..c29dd0f 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/UsageBlockedDispatchTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/usecases/UsageBlockedDispatchTest.java
@@ -26,10 +26,13 @@ import org.apache.activemq.broker.region.policy.PolicyMap;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.usage.SystemUsage;
import org.apache.activemq.util.DefaultTestAppender;
-import org.apache.log4j.Appender;
-import org.apache.log4j.Level;
-import org.apache.log4j.spi.LoggingEvent;
-
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import javax.jms.*;
import java.io.File;
import java.io.IOException;
@@ -134,18 +137,22 @@ public class UsageBlockedDispatchTest extends TestSupport {
consumer.receive(messageReceiveTimeout);
final AtomicBoolean gotExpectedLogEvent = new AtomicBoolean(false);
- Appender appender = new DefaultTestAppender() {
-
+ // start new
+ final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(Queue.class));
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
- public void doAppend(LoggingEvent event) {
- if (event.getLevel() == Level.WARN && event.getRenderedMessage().contains("cursor blocked")) {
+ public void append(LogEvent event) {
+ if (Level.WARN.equals(event.getLevel()) && event.getMessage().getFormattedMessage().contains("cursor blocked")) {
gotExpectedLogEvent.set(true);
}
}
};
+ appender.start();
+
+ logger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
+ logger.addAppender(appender);
try {
- org.apache.log4j.Logger.getLogger(Queue.class).addAppender(appender);
MessageConsumer noDispatchConsumer = consumerSession.createConsumer(shouldBeStuckForDispatch);
@@ -154,8 +161,7 @@ public class UsageBlockedDispatchTest extends TestSupport {
assertTrue("Got the new warning about the blocked cursor", gotExpectedLogEvent.get());
} finally {
- org.apache.log4j.Logger.getLogger(Queue.class).removeAppender(appender);
- org.apache.log4j.Logger.getRootLogger().removeAppender(appender);
+ logger.removeAppender(appender);
}
}
}
diff --git a/activemq-unit-tests/src/test/resources/log4j.properties b/activemq-unit-tests/src/test/resources/log4j.properties
deleted file mode 100644
index 42d8c80..0000000
--- a/activemq-unit-tests/src/test/resources/log4j.properties
+++ /dev/null
@@ -1,47 +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.
-## ---------------------------------------------------------------------------
-
-#
-# The logging properties used during tests..
-#
-log4j.rootLogger=INFO, out, stdout
-
-#log4j.logger.org.apache.activemq.broker.scheduler=DEBUG
-#log4j.logger.org.apache.activemq.store.kahadb.scheduler=DEBUG
-#log4j.logger.org.apache.activemq.network.DemandForwardingBridgeSupport=DEBUG
-#log4j.logger.org.apache.activemq.transport.failover=TRACE
-#log4j.logger.org.apache.activemq.transport.TransportLogger.Connection=TRACE
-#log4j.logger.org.apache.activemq.store.jdbc=TRACE
-#log4j.logger.org.apache.activemq.store.kahadb=TRACE
-#log4j.logger.org.apache.activemq.broker.region.cursors.AbstractStoreCursor=DEBUG
-#log4j.logger.org.apache.activemq.store.jdbc.JDBCMessageStore=DEBUG
-#log4j.logger.org.apache.activemq.store.kahadb.disk.journal=DEBUG
-#log4j.logger.org.apache.activemq.store.kahadb.AbstractKahaDBStore=DEBUG
-
-# CONSOLE appender not used by default
-log4j.appender.stdout=org.apache.log4j.ConsoleAppender
-log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
-log4j.appender.stdout.layout.ConversionPattern=%d [%-15.15t] - %-5p %-30.30c{1} - %m%n
-#log4j.appender.stdout.layout.ConversionPattern=%d [%-15.15t] - %-5p %-30.30c{1} - %-10.10X{activemq.broker} %-20.20X{activemq.connector} %-10.10X{activemq.destination} - %m%n
-
-# File appender
-log4j.appender.out=org.apache.log4j.FileAppender
-log4j.appender.out.layout=org.apache.log4j.PatternLayout
-log4j.appender.out.layout.ConversionPattern=%d [%-15.15t] - %-5p %-30.30c{1} - %m%n
-#log4j.appender.out.layout.ConversionPattern=%d [%-15.15t] - %-5p %-30.30c{1} - %-10.10X{activemq.broker} %-20.20X{activemq.connector} %-10.10X{activemq.destination} - %m%n
-log4j.appender.out.file=target/activemq-test.log
-log4j.appender.out.append=true
diff --git a/activemq-unit-tests/src/test/resources/log4j2-test.properties b/activemq-unit-tests/src/test/resources/log4j2-test.properties
new file mode 100644
index 0000000..16e26c5
--- /dev/null
+++ b/activemq-unit-tests/src/test/resources/log4j2-test.properties
@@ -0,0 +1,55 @@
+## ---------------------------------------------------------------------------
+## 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.
+## ---------------------------------------------------------------------------
+
+#
+# The logging properties used during tests
+#
+rootLogger.level=INFO
+
+rootLogger.appenderRef.console.ref=Console
+rootLogger.appenderRef.logfile.ref=RollingFile
+
+#logger.scheduler.name=org.apache.activemq.broker.scheduler
+#logger.scheduler.level=DEBUG
+#logger.network.name=org.apache.activemq.network.DemandForwardingBridgeSupport
+#logger.network.level=DEBUG
+#logger.failover.name=org.apache.activemq.transport.failover
+#logger.failover.level=TRACE
+#logger.jdbc.name=org.apache.activemq.store.jdbc
+#logger.jdbc.level=TRACE
+#logger.cursors.name=org.apache.activemq.broker.region.cursors.AbstractStoreCursor
+#logger.cursors.level=DEBUG
+
+# Console appender
+appender.console.type=Console
+appender.console.name=Console
+appender.console.layout.type=PatternLayout
+appender.console.layout.pattern=%d [%-15.15t] - %-5p %-30.30c{1} - %m%n
+#appender.console.layout.pattern=%d [%-15.15t] - %-5p %-30.30c{1} - %-10.10X{activemq.broker} %-20.20X{activemq.connector} %-10.10X{activemq.destination} - %m%n
+
+# RollingFile appender
+appender.logfile.type=RollingRandomAccessFile
+appender.logfile.name=RollingFile
+appender.logfile.fileName=target/activemq-test.log
+appender.logfile.filePattern=target/activemq-test.log.%i
+appender.logfile.append=true
+appender.logfile.layout.type=PatternLayout
+appender.logfile.layout.pattern=%d [%-15.15t] - %-5p %-30.30c{1} - %m%n
+#appender.logfile.layout.pattern=%d [%-15.15t] - %-5p %-30.30c{1} - %-10.10X{activemq.broker} %-20.20X{activemq.connector} %-10.10X{activemq.destination} - %m%n
+appender.logfile.policies.type=Policies
+appender.logfile.policies.size.type=SizeBasedTriggeringPolicy
+appender.logfile.policies.size.size=1MB
[activemq] 01/04: AMQ-8520: Re-enable all modules to compile and build by default
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cshannon pushed a commit to branch activemq-5.17.x
in repository https://gitbox.apache.org/repos/asf/activemq.git
commit efe3f5b7d4aefc715e0228452c23d1603b3e2c48
Author: Christopher L. Shannon (cshannon) <ch...@gmail.com>
AuthorDate: Tue Mar 1 12:10:52 2022 -0500
AMQ-8520: Re-enable all modules to compile and build by default
Updates the modules part of the previous full.test profile to always
build but skip running tests by default.
Also fixed miss dependency updates including log4j and jetty
(cherry picked from commit f240cb58067636e1b32d17f8748c8028019da262)
---
activemq-itests-spring31/pom.xml | 21 +++++++++++
activemq-karaf-itest/pom.xml | 32 +++++++++++++++-
activemq-osgi/pom.xml | 10 ++---
.../activemq-perf-maven-plugin/pom.xml | 5 ---
activemq-unit-tests/pom.xml | 43 +++++++++++++++++-----
pom.xml | 12 ++----
6 files changed, 93 insertions(+), 30 deletions(-)
diff --git a/activemq-itests-spring31/pom.xml b/activemq-itests-spring31/pom.xml
index ca814b3..bae3ebe 100644
--- a/activemq-itests-spring31/pom.xml
+++ b/activemq-itests-spring31/pom.xml
@@ -83,4 +83,25 @@
<scope>test</scope>
</dependency>
</dependencies>
+
+ <profiles>
+ <profile>
+ <!-- Default - no tests -->
+ <id>default</id>
+ <activation>
+ <activeByDefault>true</activeByDefault>
+ </activation>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <skipTests>true</skipTests>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
</project>
diff --git a/activemq-karaf-itest/pom.xml b/activemq-karaf-itest/pom.xml
index a596858..06424fe 100644
--- a/activemq-karaf-itest/pom.xml
+++ b/activemq-karaf-itest/pom.xml
@@ -133,8 +133,18 @@
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
@@ -216,6 +226,24 @@
<profiles>
<profile>
+ <!-- Default - no tests -->
+ <id>default</id>
+ <activation>
+ <activeByDefault>true</activeByDefault>
+ </activation>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <skipTests>true</skipTests>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ <profile>
<id>ci-build-profile</id>
<activation>
<property>
diff --git a/activemq-osgi/pom.xml b/activemq-osgi/pom.xml
index 9507cc0..2554745 100644
--- a/activemq-osgi/pom.xml
+++ b/activemq-osgi/pom.xml
@@ -499,15 +499,15 @@
<optional>true</optional>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
- <version>${slf4j-version}</version>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ <version>${log4j-version}</version>
<classifier>sources</classifier>
<optional>true</optional>
</dependency>
<dependency>
- <groupId>log4j</groupId>
- <artifactId>log4j</artifactId>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
<version>${log4j-version}</version>
<classifier>sources</classifier>
<optional>true</optional>
diff --git a/activemq-tooling/activemq-perf-maven-plugin/pom.xml b/activemq-tooling/activemq-perf-maven-plugin/pom.xml
index 398bf15..8b94cde 100644
--- a/activemq-tooling/activemq-perf-maven-plugin/pom.xml
+++ b/activemq-tooling/activemq-perf-maven-plugin/pom.xml
@@ -76,10 +76,5 @@
<artifactId>slf4j-simple</artifactId>
<version>${slf4j-version}</version>
</dependency>
- <!-- dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
- </dependency -->
-
</dependencies>
</project>
diff --git a/activemq-unit-tests/pom.xml b/activemq-unit-tests/pom.xml
index 11e175b..dfb9711 100644
--- a/activemq-unit-tests/pom.xml
+++ b/activemq-unit-tests/pom.xml
@@ -184,13 +184,18 @@
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>log4j</groupId>
- <artifactId>log4j</artifactId>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
<scope>test</scope>
</dependency>
<dependency>
@@ -260,9 +265,8 @@
</dependency>
<dependency>
<!-- using it for Jetty's JNDI context to work /w Joram tests. -->
- <groupId>org.eclipse.jetty.aggregate</groupId>
- <artifactId>jetty-all</artifactId>
- <classifier>uber</classifier>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-jndi</artifactId>
<scope>test</scope>
</dependency>
@@ -507,6 +511,24 @@
</build>
<profiles>
<profile>
+ <!-- Default - no tests -->
+ <id>default</id>
+ <activation>
+ <activeByDefault>true</activeByDefault>
+ </activation>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <skipTests>true</skipTests>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ <profile>
<id>activemq.tests-all</id>
<activation>
<property>
@@ -595,9 +617,9 @@
<profile>
<id>activemq.exclude-broken-tests</id>
<activation>
- <activeByDefault>true</activeByDefault>
<property>
<name>activemq.tests</name>
+ <value>excludeBroken</value>
</property>
</activation>
<build>
@@ -653,7 +675,10 @@
<profile>
<id>activemq.tests-quick</id>
<activation>
- <activeByDefault>true</activeByDefault>
+ <property>
+ <name>activemq.tests</name>
+ <value>quick</value>
+ </property>
</activation>
<build>
<plugins>
diff --git a/pom.xml b/pom.xml
index 85d9758..5966407 100644
--- a/pom.xml
+++ b/pom.xml
@@ -212,6 +212,7 @@
<module>activemq-amqp</module>
<module>activemq-kahadb-store</module>
<module>activemq-jdbc-store</module>
+ <module>activemq-unit-tests</module>
<module>activemq-all</module>
<module>activemq-console</module>
<module>activemq-jaas</module>
@@ -232,6 +233,8 @@
<module>activemq-blueprint</module>
<module>activemq-web-demo</module>
<module>activemq-web-console</module>
+ <module>activemq-karaf-itest</module>
+ <module>activemq-itests-spring31</module>
<module>assembly</module>
<module>activemq-log4j-appender</module>
<module>activemq-http</module>
@@ -1516,15 +1519,6 @@
<profiles>
- <profile>
- <id>full.test</id>
- <modules>
- <module>activemq-unit-tests</module>
- <module>activemq-karaf-itest</module>
- <module>activemq-itests-spring31</module>
- </modules>
- </profile>
-
<!-- If you enable this profile, the console message will have a timestamp -->
<profile>
<id>consolets</id>
[activemq] 03/04: AMQ-8520: Log4j2 test fixes
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cshannon pushed a commit to branch activemq-5.17.x
in repository https://gitbox.apache.org/repos/asf/activemq.git
commit da9e5276f1a20699bedf4c16229c96d6fc69e00f
Author: Christopher L. Shannon (cshannon) <ch...@gmail.com>
AuthorDate: Thu Mar 3 08:10:58 2022 -0500
AMQ-8520: Log4j2 test fixes
Also fixes Log4jConfigView
(cherry picked from commit ae30dce4e24ce5e0467d2a3219627cbefef1f0ae)
---
.../activemq/broker/TransportConnection.java | 2 +-
.../activemq/broker/jmx/Log4JConfigView.java | 98 +++++++++++-----------
.../activemq/broker/jmx/Log4JConfigTest.java | 6 +-
.../apache/activemq/security/SecurityJMXTest.java | 7 +-
.../activemq/store/SharedFileLockerTest.java | 2 +-
.../store/kahadb/KahaDBPersistenceAdapterTest.java | 8 +-
.../tcp/TcpTransportCloseSocketNoWarnTest.java | 5 +-
.../TcpTransportInactiveDuringHandshakeTest.java | 3 +-
8 files changed, 74 insertions(+), 57 deletions(-)
diff --git a/activemq-broker/src/main/java/org/apache/activemq/broker/TransportConnection.java b/activemq-broker/src/main/java/org/apache/activemq/broker/TransportConnection.java
index f239df1..7533a71 100644
--- a/activemq-broker/src/main/java/org/apache/activemq/broker/TransportConnection.java
+++ b/activemq-broker/src/main/java/org/apache/activemq/broker/TransportConnection.java
@@ -309,7 +309,7 @@ public class TransportConnection implements Connection, Task, CommandVisitor {
if (SERVICELOG.isDebugEnabled()) {
SERVICELOG.debug("Async error occurred: {}", e.getMessage(), e);
} else {
- SERVICELOG.warn("Async error occurred", e);
+ SERVICELOG.warn("Async error occurred", e.getMessage());
}
ConnectionError ce = new ConnectionError();
ce.setException(e);
diff --git a/activemq-broker/src/main/java/org/apache/activemq/broker/jmx/Log4JConfigView.java b/activemq-broker/src/main/java/org/apache/activemq/broker/jmx/Log4JConfigView.java
index b58d72e..cb601f7 100644
--- a/activemq-broker/src/main/java/org/apache/activemq/broker/jmx/Log4JConfigView.java
+++ b/activemq-broker/src/main/java/org/apache/activemq/broker/jmx/Log4JConfigView.java
@@ -22,10 +22,9 @@ import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Enumeration;
import java.util.List;
import java.util.Locale;
-
+import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -41,12 +40,13 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
return null;
}
+ Class<?> logManagerClass = getLogManagerClass(cl);
Class<?> loggerClass = getLoggerClass(cl);
- if (loggerClass == null) {
+ if (logManagerClass == null || loggerClass == null) {
return null;
}
- Method getRootLogger = loggerClass.getMethod("getRootLogger", new Class[]{});
+ Method getRootLogger = logManagerClass.getMethod("getRootLogger", new Class[]{});
Method getLevel = loggerClass.getMethod("getLevel", new Class[]{});
Object rootLogger = getRootLogger.invoke(null, (Object[])null);
@@ -61,16 +61,15 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
return;
}
+ Class<?> configuratorClass = getConfiguratorClass(cl);
Class<?> loggerClass = getLoggerClass(cl);
Class<?> levelClass = getLevelClass(cl);
- if (levelClass == null || loggerClass == null) {
+ if (configuratorClass == null || levelClass == null || loggerClass == null) {
return;
}
String targetLevel = level.toUpperCase(Locale.US);
- Method getRootLogger = loggerClass.getMethod("getRootLogger", new Class[]{});
- Method setLevel = loggerClass.getMethod("setLevel", levelClass);
- Object rootLogger = getRootLogger.invoke(null, (Object[])null);
+ Method setRootLevel = configuratorClass.getMethod("setRootLevel", levelClass);
Method toLevel = levelClass.getMethod("toLevel", String.class);
Object newLevel = toLevel.invoke(null, targetLevel);
@@ -80,7 +79,7 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
// matched what the user asked for.
if (newLevel != null && newLevel.toString().equals(targetLevel)) {
LOG.debug("Set level {} for root logger.", level);
- setLevel.invoke(rootLogger, newLevel);
+ setRootLevel.invoke(configuratorClass, newLevel);
}
}
@@ -95,18 +94,23 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
Class<?> logManagerClass = getLogManagerClass(cl);
Class<?> loggerClass = getLoggerClass(cl);
- if (logManagerClass == null || loggerClass == null) {
+ Class<?> loggerConfigClass = getLoggerConfigClass(cl);
+ if (logManagerClass == null || loggerClass == null || loggerConfigClass == null) {
return Collections.emptyList();
}
- Method getCurrentLoggers = logManagerClass.getMethod("getCurrentLoggers", new Class[]{});
- Method getName = loggerClass.getMethod("getName", new Class[]{});
+ Method getContext = logManagerClass.getMethod("getContext", boolean.class);
+ Object logContext = getContext.invoke(logManagerClass, false);
+ Method getConfiguration = logContext.getClass().getMethod("getConfiguration");
+ Object configuration = getConfiguration.invoke(logContext);
+ Method getLoggers = configuration.getClass().getMethod("getLoggers");
+
+ Method getName = loggerConfigClass.getMethod("getName");
List<String> list = new ArrayList<String>();
- Enumeration<?> loggers = (Enumeration<?>)getCurrentLoggers.invoke(null, (Object[])null);
+ Map<String, ?> loggers = (Map<String, ?>)getLoggers.invoke(configuration);
- while (loggers.hasMoreElements()) {
- Object logger = loggers.nextElement();
+ for (Object logger : loggers.values()) {
if (logger != null) {
list.add((String) getName.invoke(logger, (Object[])null));
}
@@ -126,12 +130,13 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
return null;
}
+ Class<?> logManagerClass = getLogManagerClass(cl);
Class<?> loggerClass = getLoggerClass(cl);
- if (loggerClass == null) {
+ if (logManagerClass == null || loggerClass == null) {
return null;
}
- Method getLogger = loggerClass.getMethod("getLogger", String.class);
+ Method getLogger = logManagerClass.getMethod("getLogger", String.class);
String logLevel = null;
if (loggerName != null && !loggerName.isEmpty()) {
@@ -172,29 +177,26 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
return;
}
+ Class<?> configuratorClass = getConfiguratorClass(cl);
Class<?> loggerClass = getLoggerClass(cl);
Class<?> levelClass = getLevelClass(cl);
- if (loggerClass == null || levelClass == null) {
+ if (configuratorClass == null || loggerClass == null || levelClass == null) {
return;
}
String targetLevel = level.toUpperCase(Locale.US);
- Method getLogger = loggerClass.getMethod("getLogger", String.class);
- Method setLevel = loggerClass.getMethod("setLevel", levelClass);
+ Method setLevel = configuratorClass.getMethod("setLevel", String.class, levelClass);
Method toLevel = levelClass.getMethod("toLevel", String.class);
- Object logger = getLogger.invoke(null, loggerName);
- if (logger != null) {
- Object newLevel = toLevel.invoke(null, targetLevel);
-
- // Check that the level conversion worked and that we got a level
- // that matches what was asked for. A bad level name will result
- // in the lowest level value and we don't want to change unless we
- // matched what the user asked for.
- if (newLevel != null && newLevel.toString().equals(targetLevel)) {
- LOG.debug("Set level {} for logger: {}", level, loggerName);
- setLevel.invoke(logger, newLevel);
- }
+ Object newLevel = toLevel.invoke(null, targetLevel);
+
+ // Check that the level conversion worked and that we got a level
+ // that matches what was asked for. A bad level name will result
+ // in the lowest level value and we don't want to change unless we
+ // matched what the user asked for.
+ if (newLevel != null && newLevel.toString().equals(targetLevel)) {
+ LOG.debug("Set level {} for logger: {}", level, loggerName);
+ setLevel.invoke(configuratorClass, loggerName, newLevel);
}
}
@@ -258,29 +260,31 @@ public class Log4JConfigView implements Log4JConfigViewMBean {
}
private static Class<?> getLogManagerClass(ClassLoader cl) {
- Class<?> logManagerClass = null;
- try {
- logManagerClass = cl.loadClass("org.apache.log4j.LogManager");
- } catch (ClassNotFoundException e) {
- }
- return logManagerClass;
+ return getClass(cl, "org.apache.logging.log4j.LogManager");
}
private static Class<?> getLoggerClass(ClassLoader cl) {
- Class<?> loggerClass = null;
- try {
- loggerClass = cl.loadClass("org.apache.log4j.Logger");
- } catch (ClassNotFoundException e) {
- }
- return loggerClass;
+ return getClass(cl, "org.apache.logging.log4j.Logger");
+ }
+
+ private static Class<?> getLoggerConfigClass(ClassLoader cl) {
+ return getClass(cl, "org.apache.logging.log4j.core.config.LoggerConfig");
}
private static Class<?> getLevelClass(ClassLoader cl) {
- Class<?> levelClass = null;
+ return getClass(cl, "org.apache.logging.log4j.Level");
+ }
+
+ private static Class<?> getConfiguratorClass(ClassLoader cl) {
+ return getClass(cl, "org.apache.logging.log4j.core.config.Configurator");
+ }
+
+ private static Class<?> getClass(ClassLoader cl, String clazz) {
+ Class<?> configuratorClass = null;
try {
- levelClass = cl.loadClass("org.apache.log4j.Level");
+ configuratorClass = cl.loadClass(clazz);
} catch (ClassNotFoundException e) {
}
- return levelClass;
+ return configuratorClass;
}
}
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
index a5255a6..1b37882 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/broker/jmx/Log4JConfigTest.java
@@ -17,19 +17,16 @@
package org.apache.activemq.broker.jmx;
import java.util.List;
-
import javax.jms.ConnectionFactory;
import javax.management.MBeanServer;
import javax.management.MBeanServerInvocationHandler;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
-
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.EmbeddedBrokerTestSupport;
import org.apache.activemq.broker.BrokerService;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.core.Logger;
import org.junit.Test;
import org.slf4j.LoggerFactory;
@@ -136,6 +133,9 @@ public class Log4JConfigTest extends EmbeddedBrokerTestSupport {
level = log4jConfigView.getLogLevel(BROKER_LOGGER);
assertNotNull(level);
assertEquals("INFO", level);
+
+ List<String> loggers = log4jConfigView.getLoggers();
+ assertEquals(2, loggers.size());
}
@Test
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
index 5bf176a..756c504 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/security/SecurityJMXTest.java
@@ -48,6 +48,10 @@ import org.apache.activemq.util.DefaultTestAppender;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -71,7 +75,7 @@ public class SecurityJMXTest extends TestCase {
final AtomicBoolean gotExpected = new AtomicBoolean(false);
final AtomicReference<Object> stackTrace = new AtomicReference<Object>();
- final Appender appender = new DefaultTestAppender() {
+ final Appender appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
public void append(LogEvent event) {
String message = event.getMessage().getFormattedMessage();
@@ -82,6 +86,7 @@ public class SecurityJMXTest extends TestCase {
}
};
+ appender.start();
org.apache.logging.log4j.core.Logger toVerify = (org.apache.logging.log4j.core.Logger)LogManager.getLogger(TransportConnection.class.getName() + ".Service");
toVerify.addAppender(appender);
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
index 2ae8b5c..0a2d1cb 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/SharedFileLockerTest.java
@@ -193,7 +193,7 @@ public class SharedFileLockerTest {
final AtomicInteger logCounts = new AtomicInteger(0);
// start new
final var logger = org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(SharedFileLocker.class));
- final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
+ final var appender = new AbstractAppender("testAppender2", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
public void append(LogEvent event) {
logCounts.incrementAndGet();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
index 3e2b634..c45ff80 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/store/kahadb/KahaDBPersistenceAdapterTest.java
@@ -28,7 +28,11 @@ import org.apache.logging.log4j.core.LogEvent;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.Property;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.apache.logging.log4j.core.layout.MessageLayout;
/**
*
@@ -52,7 +56,7 @@ public class KahaDBPersistenceAdapterTest extends PersistenceAdapterTestSupport
final AtomicBoolean gotSomeReplay = new AtomicBoolean(Boolean.FALSE);
final AtomicBoolean trappedLogMessages = new AtomicBoolean(Boolean.FALSE);
- Appender appender = new DefaultTestAppender() {
+ final var appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
public void append(LogEvent event) {
trappedLogMessages.set(true);
@@ -66,7 +70,7 @@ public class KahaDBPersistenceAdapterTest extends PersistenceAdapterTestSupport
appender.start();
try {
- Configurator.setLevel(MessageDatabase.class.getName(), Level.INFO);
+ Configurator.setLevel(MessageDatabase.class.getName(), Level.DEBUG);
((org.apache.logging.log4j.core.Logger)LogManager.getLogger(MessageDatabase.class)).addAppender(appender);
brokerService = new BrokerService();
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
index 3be00bd..d552995 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportCloseSocketNoWarnTest.java
@@ -20,12 +20,14 @@ import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.TransportConnection;
import org.apache.activemq.broker.TransportConnector;
+import org.apache.activemq.store.kahadb.MessageDatabase;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.Logger;
import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configurator;
import org.apache.logging.log4j.core.config.Property;
import org.apache.logging.log4j.core.filter.AbstractFilter;
import org.apache.logging.log4j.core.layout.MessageLayout;
@@ -82,6 +84,7 @@ public class TcpTransportCloseSocketNoWarnTest {
@Before
public void before() throws Exception {
+ gotExceptionInLog.set(false);
brokerService = new BrokerService();
brokerService.setPersistent(false);
brokerService.setUseJmx(false);
@@ -90,7 +93,7 @@ public class TcpTransportCloseSocketNoWarnTest {
rootLogger.get().addAppender(appender, Level.DEBUG, new AbstractFilter() {});
rootLogger.addAppender(appender);
- org.apache.logging.log4j.core.Logger.class.cast(LogManager.getLogger(TransportConnection.class.getName() + ".Transport")).setLevel(Level.WARN);
+ Configurator.setLevel(TransportConnection.class.getName() + ".Transport", Level.WARN);
}
@After
diff --git a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
index 5c88fef..959dd9c 100644
--- a/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
+++ b/activemq-unit-tests/src/test/java/org/apache/activemq/transport/tcp/TcpTransportInactiveDuringHandshakeTest.java
@@ -80,7 +80,8 @@ public class TcpTransportInactiveDuringHandshakeTest {
appender = new AbstractAppender("testAppender", new AbstractFilter() {}, new MessageLayout(), false, new Property[0]) {
@Override
public void append(LogEvent event) {
- if (Level.WARN.equals(event.getLevel()) && event.getMessage().getFormattedMessage().contains("InactivityIOException")) {
+ if (Level.WARN.equals(event.getLevel()) &&
+ event.getMessage().getFormattedMessage().contains("CONNECT frame not received with in connectionTimeout")) {
inactivityMonitorFired.countDown();
}
}