+ * JMS connection and session manager. Can be used to access MessageProducer, MessageConsumer, and Message objects
+ * involving a configured ConnectionFactory and Destination.
+ *
+ */
+public final class JmsManager extends AbstractManager {
+
+ public static final class JmsManagerConfiguration {
+ private final Properties jndiProperties;
+ private final String connectionFactoryName;
+ private final String destinationName;
+ private final String userName;
+ private final char[] password;
+ private final boolean immediateFail;
+ private final boolean retry;
+ private final long reconnectIntervalMillis;
+
+ JmsManagerConfiguration(
+ final Properties jndiProperties,
+ final String connectionFactoryName,
+ final String destinationName,
+ final String userName,
+ final char[] password,
+ final boolean immediateFail,
+ final long reconnectIntervalMillis) {
+ this.jndiProperties = jndiProperties;
+ this.connectionFactoryName = connectionFactoryName;
+ this.destinationName = destinationName;
+ this.userName = userName;
+ this.password = password;
+ this.immediateFail = immediateFail;
+ this.reconnectIntervalMillis = reconnectIntervalMillis;
+ this.retry = reconnectIntervalMillis > 0;
+ }
+
+ public String getConnectionFactoryName() {
+ return connectionFactoryName;
+ }
+
+ public String getDestinationName() {
+ return destinationName;
+ }
+
+ public JndiManager getJndiManager() {
+ return JndiManager.getJndiManager(getJndiProperties());
+ }
+
+ public Properties getJndiProperties() {
+ return jndiProperties;
+ }
+
+ public char[] getPassword() {
+ return password;
+ }
+
+ public long getReconnectIntervalMillis() {
+ return reconnectIntervalMillis;
+ }
+
+ public String getUserName() {
+ return userName;
+ }
+
+ public boolean isImmediateFail() {
+ return immediateFail;
+ }
+
+ public boolean isRetry() {
+ return retry;
+ }
+
+ @Override
+ public String toString() {
+ return "JmsManagerConfiguration [jndiProperties=" + jndiProperties + ", connectionFactoryName="
+ + connectionFactoryName + ", destinationName=" + destinationName + ", userName=" + userName
+ + ", immediateFail=" + immediateFail + ", retry=" + retry + ", reconnectIntervalMillis="
+ + reconnectIntervalMillis + "]";
+ }
+ }
+
+ private static final class JmsManagerFactory implements ManagerFactory {
+
+ @Override
+ public JmsManager createManager(final String name, final JmsManagerConfiguration data) {
+ if (JndiManager.isJndiJmsEnabled()) {
+ try {
+ return new JmsManager(name, data);
+ } catch (final Exception e) {
+ logger().error("Error creating JmsManager using JmsManagerConfiguration [{}]", data, e);
+ return null;
+ }
+ }
+ logger().error("JNDI must be enabled by setting log4j2.enableJndiJms=true");
+ return null;
+ }
+ }
+
+ /**
+ * Handles reconnecting to JMS on a Thread.
+ */
+ private final class Reconnector extends Log4jThread {
+
+ private final CountDownLatch latch = new CountDownLatch(1);
+
+ private volatile boolean shutdown;
+
+ private final Object owner;
+
+ private Reconnector(final Object owner) {
+ super("JmsManager-Reconnector");
+ this.owner = owner;
+ }
+
+ public void latch() {
+ try {
+ latch.await();
+ } catch (final InterruptedException ex) {
+ // Ignore the exception.
+ }
+ }
+
+ void reconnect() throws NamingException, JMSException {
+ final JndiManager jndiManager2 = getJndiManager();
+ final Connection connection2 = createConnection(jndiManager2);
+ final Session session2 = createSession(connection2);
+ final Destination destination2 = createDestination(jndiManager2);
+ final MessageProducer messageProducer2 = createMessageProducer(session2, destination2);
+ connection2.start();
+ synchronized (owner) {
+ jndiManager = jndiManager2;
+ connection = connection2;
+ session = session2;
+ destination = destination2;
+ messageProducer = messageProducer2;
+ reconnector = null;
+ shutdown = true;
+ }
+ logger().debug("Connection reestablished to {}", configuration);
+ }
+
+ @Override
+ public void run() {
+ while (!shutdown) {
+ try {
+ sleep(configuration.getReconnectIntervalMillis());
+ reconnect();
+ } catch (final InterruptedException | JMSException | NamingException e) {
+ logger().debug(
+ "Cannot reestablish JMS connection to {}: {}",
+ configuration,
+ e.getLocalizedMessage(),
+ e);
+ } finally {
+ latch.countDown();
+ }
+ }
+ }
+
+ public void shutdown() {
+ shutdown = true;
+ }
+ }
+
+ static final JmsManagerFactory FACTORY = new JmsManagerFactory();
+
+ /**
+ * Gets a JmsManager using the specified configuration parameters.
+ *
+ * @param name
+ * The name to use for this JmsManager.
+ * @param connectionFactoryName
+ * The binding name for the {@link javax.jms.ConnectionFactory}.
+ * @param destinationName
+ * The binding name for the {@link javax.jms.Destination}.
+ * @param userName
+ * The userName to connect with or {@code null} for no authentication.
+ * @param password
+ * The password to use with the given userName or {@code null} for no authentication.
+ * @param immediateFail
+ * Whether or not to fail immediately with a {@link AppenderLoggingException} when connecting to JMS
+ * fails.
+ * @param reconnectIntervalMillis
+ * How to log sleep in milliseconds before trying to reconnect to JMS.
+ * @param jndiProperties
+ * JNDI properties.
+ * @return The JmsManager as configured.
+ */
+ public static JmsManager getJmsManager(
+ final String name,
+ final Properties jndiProperties,
+ final String connectionFactoryName,
+ final String destinationName,
+ final String userName,
+ final char[] password,
+ final boolean immediateFail,
+ final long reconnectIntervalMillis) {
+ final JmsManagerConfiguration configuration = new JmsManagerConfiguration(
+ jndiProperties,
+ connectionFactoryName,
+ destinationName,
+ userName,
+ password,
+ immediateFail,
+ reconnectIntervalMillis);
+ return getManager(name, FACTORY, configuration);
+ }
+
+ private final JmsManagerConfiguration configuration;
+
+ private volatile Reconnector reconnector;
+ private volatile JndiManager jndiManager;
+ private volatile Connection connection;
+ private volatile Session session;
+ private volatile Destination destination;
+ private volatile MessageProducer messageProducer;
+
+ private JmsManager(final String name, final JmsManagerConfiguration configuration) {
+ super(null, name);
+ this.configuration = configuration;
+ this.jndiManager = configuration.getJndiManager();
+ try {
+ this.connection = createConnection(this.jndiManager);
+ this.session = createSession(this.connection);
+ this.destination = createDestination(this.jndiManager);
+ this.messageProducer = createMessageProducer(this.session, this.destination);
+ this.connection.start();
+ } catch (NamingException | JMSException e) {
+ this.reconnector = createReconnector();
+ this.reconnector.start();
+ }
+ }
+
+ private boolean closeConnection() {
+ if (connection == null) {
+ return true;
+ }
+ final Connection temp = connection;
+ connection = null;
+ try {
+ temp.close();
+ return true;
+ } catch (final JMSException e) {
+ StatusLogger.getLogger()
+ .debug(
+ "Caught exception closing JMS Connection: {} ({}); continuing JMS manager shutdown",
+ e.getLocalizedMessage(),
+ temp,
+ e);
+ return false;
+ }
+ }
+
+ private boolean closeJndiManager() {
+ if (jndiManager == null) {
+ return true;
+ }
+ final JndiManager tmp = jndiManager;
+ jndiManager = null;
+ tmp.close();
+ return true;
+ }
+
+ private boolean closeMessageProducer() {
+ if (messageProducer == null) {
+ return true;
+ }
+ final MessageProducer temp = messageProducer;
+ messageProducer = null;
+ try {
+ temp.close();
+ return true;
+ } catch (final JMSException e) {
+ StatusLogger.getLogger()
+ .debug(
+ "Caught exception closing JMS MessageProducer: {} ({}); continuing JMS manager shutdown",
+ e.getLocalizedMessage(),
+ temp,
+ e);
+ return false;
+ }
+ }
+
+ private boolean closeSession() {
+ if (session == null) {
+ return true;
+ }
+ final Session temp = session;
+ session = null;
+ try {
+ temp.close();
+ return true;
+ } catch (final JMSException e) {
+ StatusLogger.getLogger()
+ .debug(
+ "Caught exception closing JMS Session: {} ({}); continuing JMS manager shutdown",
+ e.getLocalizedMessage(),
+ temp,
+ e);
+ return false;
+ }
+ }
+
+ private Connection createConnection(final JndiManager jndiManager) throws NamingException, JMSException {
+ final ConnectionFactory connectionFactory = jndiManager.lookup(configuration.getConnectionFactoryName());
+ if (configuration.getUserName() != null && configuration.getPassword() != null) {
+ return connectionFactory.createConnection(
+ configuration.getUserName(),
+ configuration.getPassword() == null ? null : String.valueOf(configuration.getPassword()));
+ }
+ return connectionFactory.createConnection();
+ }
+
+ private Destination createDestination(final JndiManager jndiManager) throws NamingException {
+ return jndiManager.lookup(configuration.getDestinationName());
+ }
+
+ /**
+ * Creates a TextMessage, MapMessage, or ObjectMessage from a Serializable object.
+ *
+ * For instance, when using a text-based {@link org.apache.logging.log4j.core.Layout} such as
+ * {@link org.apache.logging.log4j.core.layout.PatternLayout}, the {@link org.apache.logging.log4j.core.LogEvent}
+ * message will be serialized to a String.
+ *
+ *
+ * When using a layout such as {@link org.apache.logging.log4j.core.layout.SerializedLayout}, the LogEvent message
+ * will be serialized as a Java object.
+ *
+ *
+ * When using a layout such as {@link org.apache.logging.log4j.core.layout.MessageLayout} and the LogEvent message
+ * is a Log4j MapMessage, the message will be serialized as a JMS MapMessage.
+ *
+ *
+ * @param object
+ * The LogEvent or String message to wrap.
+ * @return A new JMS message containing the provided object.
+ * @throws JMSException if the JMS provider fails to create this message due to some internal error.
+ */
+ private Message createMessage(final Serializable object) throws JMSException {
+ if (object instanceof String) {
+ return session.createTextMessage((String) object);
+ } else if (object instanceof org.apache.logging.log4j.message.MapMessage) {
+ return map((org.apache.logging.log4j.message.MapMessage) object, session.createMapMessage());
+ }
+ return session.createObjectMessage(object);
+ }
+
+ private void createMessageAndSend(final LogEvent event, final Serializable serializable) throws JMSException {
+ final Message message = createMessage(serializable);
+ message.setJMSTimestamp(event.getTimeMillis());
+ messageProducer.send(message);
+ }
+
+ /**
+ * Creates a MessageProducer on this Destination using the current Session.
+ *
+ * @param session
+ * The JMS Session to use to create the MessageProducer
+ * @param destination
+ * The JMS Destination for the MessageProducer
+ * @return A MessageProducer on this Destination.
+ * @throws JMSException if the session fails to create a MessageProducer due to some internal error.
+ */
+ private MessageProducer createMessageProducer(final Session session, final Destination destination)
+ throws JMSException {
+ return session.createProducer(destination);
+ }
+
+ private Reconnector createReconnector() {
+ final Reconnector recon = new Reconnector(this);
+ recon.setDaemon(true);
+ recon.setPriority(Thread.MIN_PRIORITY);
+ return recon;
+ }
+
+ private Session createSession(final Connection connection) throws JMSException {
+ return connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+ }
+
+ public JmsManagerConfiguration getJmsManagerConfiguration() {
+ return configuration;
+ }
+
+ JndiManager getJndiManager() {
+ return configuration.getJndiManager();
+ }
+
+ T lookup(final String destinationName) throws NamingException {
+ return jndiManager.lookup(destinationName);
+ }
+
+ private MapMessage map(
+ final org.apache.logging.log4j.message.MapMessage log4jMapMessage, final MapMessage jmsMapMessage) {
+ // Map without calling org.apache.logging.log4j.message.MapMessage#getData() which makes a copy of the map.
+ log4jMapMessage.forEach((key, value) -> {
+ try {
+ jmsMapMessage.setObject(key, value);
+ } catch (final JMSException e) {
+ throw new IllegalArgumentException(
+ String.format(
+ "%s mapping key '%s' to value '%s': %s",
+ e.getClass(), key, value, e.getLocalizedMessage()),
+ e);
+ }
+ });
+ return jmsMapMessage;
+ }
+
+ @Override
+ protected boolean releaseSub(final long timeout, final TimeUnit timeUnit) {
+ if (reconnector != null) {
+ reconnector.shutdown();
+ reconnector.interrupt();
+ reconnector = null;
+ }
+ boolean closed = false;
+ closed &= closeJndiManager();
+ closed &= closeMessageProducer();
+ closed &= closeSession();
+ closed &= closeConnection();
+ return closed && jndiManager.stop(timeout, timeUnit);
+ }
+
+ void send(final LogEvent event, final Serializable serializable) {
+ if (messageProducer == null) {
+ if (reconnector != null && !configuration.isImmediateFail()) {
+ reconnector.latch();
+ if (messageProducer == null) {
+ throw new AppenderLoggingException(
+ "Error sending to JMS Manager '" + getName() + "': JMS message producer not available");
+ }
+ }
+ }
+ synchronized (this) {
+ try {
+ createMessageAndSend(event, serializable);
+ } catch (final JMSException causeEx) {
+ if (configuration.isRetry() && reconnector == null) {
+ reconnector = createReconnector();
+ try {
+ closeJndiManager();
+ reconnector.reconnect();
+ } catch (NamingException | JMSException reconnEx) {
+ logger().debug(
+ "Cannot reestablish JMS connection to {}: {}; starting reconnector thread {}",
+ configuration,
+ reconnEx.getLocalizedMessage(),
+ reconnector.getName(),
+ reconnEx);
+ reconnector.start();
+ throw new AppenderLoggingException(
+ String.format("JMS exception sending to %s for %s", getName(), configuration), causeEx);
+ }
+ try {
+ createMessageAndSend(event, serializable);
+ } catch (final JMSException e) {
+ throw new AppenderLoggingException(
+ String.format(
+ "Error sending to %s after reestablishing JMS connection for %s",
+ getName(), configuration),
+ causeEx);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/log4j-jakarta-jms/src/main/java/org/apache/logging/log4j/core/appender/mom/jakarta/package-info.java b/log4j-jakarta-jms/src/main/java/org/apache/logging/log4j/core/appender/mom/jakarta/package-info.java
new file mode 100644
index 00000000000..a5651b62751
--- /dev/null
+++ b/log4j-jakarta-jms/src/main/java/org/apache/logging/log4j/core/appender/mom/jakarta/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+/**
+ * Jakarta-based JMS Appender.
+ */
+@Export
+@Version("2.25.0")
+package org.apache.logging.log4j.core.appender.mom.jakarta;
+
+import org.osgi.annotation.bundle.Export;
+import org.osgi.annotation.versioning.Version;
diff --git a/log4j-jakarta-jms/src/test/java/org/apache/logging/log4j/core/appender/mom/jakarta/JmsAppenderTest.java b/log4j-jakarta-jms/src/test/java/org/apache/logging/log4j/core/appender/mom/jakarta/JmsAppenderTest.java
new file mode 100644
index 00000000000..5d730fc47b4
--- /dev/null
+++ b/log4j-jakarta-jms/src/test/java/org/apache/logging/log4j/core/appender/mom/jakarta/JmsAppenderTest.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.core.appender.mom.jakarta;
+
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.Destination;
+import jakarta.jms.MapMessage;
+import jakarta.jms.MessageProducer;
+import jakarta.jms.ObjectMessage;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
+import java.io.Serializable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.test.categories.Appenders;
+import org.apache.logging.log4j.core.test.junit.JndiRule;
+import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
+import org.apache.logging.log4j.message.Message;
+import org.apache.logging.log4j.message.SimpleMessage;
+import org.apache.logging.log4j.message.StringMapMessage;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.RuleChain;
+
+@Category(Appenders.Jms.class)
+public class JmsAppenderTest {
+
+ private static final String CONNECTION_FACTORY_NAME = "jms/connectionFactory";
+ private static final String QUEUE_FACTORY_NAME = "jms/queues";
+ private static final String TOPIC_FACTORY_NAME = "jms/topics";
+ private static final String DESTINATION_NAME = "jms/destination";
+ private static final String DESTINATION_NAME_ML = "jms/destination-ml";
+ private static final String QUEUE_NAME = "jms/queue";
+ private static final String TOPIC_NAME = "jms/topic";
+ private static final String LOG_MESSAGE = "Hello, world!";
+
+ private final ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
+ private final Connection connection = mock(Connection.class);
+ private final Session session = mock(Session.class);
+ private final Destination destination = mock(Destination.class);
+ private final Destination destinationMl = mock(Destination.class);
+ private final MessageProducer messageProducer = mock(MessageProducer.class);
+ private final MessageProducer messageProducerMl = mock(MessageProducer.class);
+ private final TextMessage textMessage = mock(TextMessage.class);
+ private final ObjectMessage objectMessage = mock(ObjectMessage.class);
+ private final MapMessage mapMessage = mock(MapMessage.class);
+
+ private final JndiRule jndiRule = new JndiRule(createBindings());
+ private final LoggerContextRule ctx = new LoggerContextRule("JmsJakartaAppenderTest.xml");
+
+ @Rule
+ public RuleChain rules = RuleChain.outerRule(jndiRule).around(ctx);
+
+ @AfterClass
+ public static void afterClass() throws Exception {
+ System.clearProperty("log4j2.enableJndiJms");
+ }
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ System.setProperty("log4j2.enableJndiJms", "true");
+ }
+
+ public JmsAppenderTest() throws Exception {
+ // this needs to set up before LoggerContextRule
+ given(connectionFactory.createConnection()).willReturn(connection);
+ given(connectionFactory.createConnection(anyString(), anyString())).willThrow(IllegalArgumentException.class);
+ given(connection.createSession(eq(false), eq(Session.AUTO_ACKNOWLEDGE))).willReturn(session);
+ given(session.createProducer(eq(destination))).willReturn(messageProducer);
+ given(session.createProducer(eq(destinationMl))).willReturn(messageProducerMl);
+ given(session.createTextMessage(anyString())).willReturn(textMessage);
+ given(session.createObjectMessage(isA(Serializable.class))).willReturn(objectMessage);
+ given(session.createMapMessage()).willReturn(mapMessage);
+ }
+
+ private Map createBindings() {
+ final ConcurrentHashMap map = new ConcurrentHashMap<>();
+ map.put(CONNECTION_FACTORY_NAME, connectionFactory);
+ map.put(DESTINATION_NAME, destination);
+ map.put(DESTINATION_NAME_ML, destinationMl);
+ map.put(QUEUE_FACTORY_NAME, connectionFactory);
+ map.put(QUEUE_NAME, destination);
+ map.put(TOPIC_FACTORY_NAME, connectionFactory);
+ map.put(TOPIC_NAME, destination);
+ return map;
+ }
+
+ private Log4jLogEvent createLogEvent() {
+ return createLogEvent(new SimpleMessage(LOG_MESSAGE));
+ }
+
+ private Log4jLogEvent createLogEvent(final Message message) {
+ // @formatter:off
+ return Log4jLogEvent.newBuilder()
+ .setLoggerName(JmsAppenderTest.class.getName())
+ .setLoggerFqcn(JmsAppenderTest.class.getName())
+ .setLevel(Level.INFO)
+ .setMessage(message)
+ .build();
+ // @formatter:on
+ }
+
+ private Log4jLogEvent createMapMessageLogEvent() {
+ final StringMapMessage mapMessage = new StringMapMessage();
+ return createLogEvent(mapMessage.with("testMesage", LOG_MESSAGE));
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ // we have 4 appenders all connecting to the same ConnectionFactory
+ then(connection).should(times(4)).start();
+ }
+
+ @Test
+ public void testAppendToQueue() throws Exception {
+ final JmsAppender appender = (JmsAppender) ctx.getRequiredAppender("JmsAppender");
+ final LogEvent event = createLogEvent();
+ appender.append(event);
+ then(session).should().createTextMessage(eq(LOG_MESSAGE));
+ then(textMessage).should().setJMSTimestamp(anyLong());
+ then(messageProducer).should().send(textMessage);
+ appender.stop();
+ then(session).should().close();
+ then(connection).should().close();
+ }
+
+ @Test
+ public void testAppendToQueueWithMessageLayout() throws Exception {
+ final JmsAppender appender = (JmsAppender) ctx.getRequiredAppender("JmsAppender-MessageLayout");
+ final LogEvent event = createMapMessageLogEvent();
+ appender.append(event);
+ then(session).should().createMapMessage();
+ then(mapMessage).should().setJMSTimestamp(anyLong());
+ then(messageProducerMl).should().send(mapMessage);
+ appender.stop();
+ then(session).should().close();
+ then(connection).should().close();
+ }
+
+ @Test
+ public void testJmsQueueAppenderCompatibility() throws Exception {
+ final JmsAppender appender = (JmsAppender) ctx.getRequiredAppender("JmsQueueAppender");
+ final LogEvent expected = createLogEvent();
+ appender.append(expected);
+ then(session).should().createObjectMessage(eq(expected));
+ then(objectMessage).should().setJMSTimestamp(anyLong());
+ then(messageProducer).should().send(objectMessage);
+ appender.stop();
+ then(session).should().close();
+ then(connection).should().close();
+ }
+
+ @Test
+ public void testJmsTopicAppenderCompatibility() throws Exception {
+ final JmsAppender appender = (JmsAppender) ctx.getRequiredAppender("JmsTopicAppender");
+ final LogEvent expected = createLogEvent();
+ appender.append(expected);
+ then(session).should().createObjectMessage(eq(expected));
+ then(objectMessage).should().setJMSTimestamp(anyLong());
+ then(messageProducer).should().send(objectMessage);
+ appender.stop();
+ then(session).should().close();
+ then(connection).should().close();
+ }
+}
diff --git a/log4j-jakarta-jms/src/test/resources/JmsJakartaAppenderTest.xml b/log4j-jakarta-jms/src/test/resources/JmsJakartaAppenderTest.xml
new file mode 100644
index 00000000000..e1d660d1c17
--- /dev/null
+++ b/log4j-jakarta-jms/src/test/resources/JmsJakartaAppenderTest.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pom.xml b/pom.xml
index cc0fed3561b..74394de40c6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -249,6 +249,7 @@
log4j-docker
log4j-fuzz-test
log4j-iostreams
+ log4j-jakarta-jms
log4j-jakarta-smtp
log4j-jakarta-web
log4j-jcl
@@ -446,6 +447,12 @@
${project.version}
+
+ org.apache.logging.log4j
+ log4j-jakarta-jms
+ ${project.version}
+
+
org.apache.logging.log4j
log4j-jakarta-smtp
diff --git a/src/changelog/.2.x.x/2295_add_JMS_Jakarta_Appender.xml b/src/changelog/.2.x.x/2295_add_JMS_Jakarta_Appender.xml
new file mode 100644
index 00000000000..fd40164e1b8
--- /dev/null
+++ b/src/changelog/.2.x.x/2295_add_JMS_Jakarta_Appender.xml
@@ -0,0 +1,8 @@
+
+
+
+ Add a Jakarta-based JMS Appender module log4j-jakarta-jms and deprecate the Javax version.
+
diff --git a/src/site/antora/modules/ROOT/pages/manual/appenders/message-queue.adoc b/src/site/antora/modules/ROOT/pages/manual/appenders/message-queue.adoc
index 3adb9f8b90d..d032c53de30 100644
--- a/src/site/antora/modules/ROOT/pages/manual/appenders/message-queue.adoc
+++ b/src/site/antora/modules/ROOT/pages/manual/appenders/message-queue.adoc
@@ -423,8 +423,8 @@ This example cannot be configured using Java properties.
[#JmsAppender]
== JMS Appender
-The JMS Appender sends the formatted log event to a
-https://jakarta.ee/specifications/messaging/2.0/[Jakarta Messaging API]
+The JMS Appender sends a formatted log event to a
+https://jakarta.ee/specifications/messaging/3.0/[Jakarta] or https://jakarta.ee/specifications/messaging/2.0/[Javax] Messaging API
destination.
[IMPORTANT]
@@ -432,10 +432,12 @@ destination.
As of Log4j `2.17.0` you need to enable the JMS Appender **explicitly** by setting the
xref:manual/systemproperties.adoc#log4j2.enableJndiJms[`log4j2.enableJndiJms`]
configuration property to `true`.
-
-Due to breaking changes in the underlying API, the JMS Appender cannot be used with Jakarta Messaging API 3.0 or later.
====
+For Jakarta, use the `JMS-Jakarta` element name in the `log4j-jakarta-jms` Maven module.
+
+For Javax, use the `JMS-Javax` element name; the names `JMS`, `JMSQueue`, and `JMSTopic` are provided for backward compatibility.
+
[#JmsAppender-attributes]
.JMS Appender configuration attributes
[cols="1m,1,1,5"]
@@ -601,6 +603,8 @@ https://jakarta.ee/specifications/platform/8/apidocs/javax/jms/objectmessage[`Ob
[#JmsAppender-examples]
=== Configuration examples
+In the examples below, to use Jakarta, replace `JMS` with `JMS-Jakarta`.
+
Here is a sample JMS Appender configuration:
[tabs]
diff --git a/src/site/antora/modules/ROOT/pages/manual/messages.adoc b/src/site/antora/modules/ROOT/pages/manual/messages.adoc
index 2e123a8022d..d678fe8e11a 100644
--- a/src/site/antora/modules/ROOT/pages/manual/messages.adoc
+++ b/src/site/antora/modules/ROOT/pages/manual/messages.adoc
@@ -233,7 +233,7 @@ It supports following formats:
Some appenders handle ``MapMessage``s differently when there is no layout:
-* JMS Appender converts to a JMS `javax.jms.MapMessage`
+* JMS Appender converts to a JMS `javax.jms.MapMessage` or `jakarta.jms.MapMessage`
* xref:manual/appenders/database.adoc#JdbcAppender[JDBC Appender] converts to values in an `SQL INSERT` statement
* xref:manual/appenders/database.adoc#MongoDbProvider[MongoDB NoSQL provider] converts to fields in a MongoDB object