<a id="jms-sink-connector"></a>

# JMS Sink Connector for Confluent Platform

The Kafka Connect JMS Sink connector is used to move messages from Apache Kafka® to any JMS-compliant broker.

This connector uses Java Naming and Directory Interface™ ([JNDI](https://docs.oracle.com/javase/tutorial/jndi/overview/index.html)) to create
an instance of the JMS [ConnectionFactory](https://docs.oracle.com/javaee/7/api/javax/jms/ConnectionFactory.html) for
your messaging system. Additional details can be found in
[Client Library JARs](#jms-sink-connector-client-libs).

Some of the supported JMS Brokers include:

* [ActiveMQ](http://activemq.apache.org/)
* [Solace](https://docs.solace.com/Solace-PubSub-Messaging-APIs/Solace-APIs-Overview.htm)
* [IBM MQ](https://www-03.ibm.com/software/products/en/ibm-mq)
* [TIBCO EMS](https://www.tibco.com/products/tibco-enterprise-message-service)

#### IMPORTANT
<!-- WARNING: THIS IS A SHARED FILE AND THE SOURCE IS LOCATED IN DOCS-COMMON. DO NOT ADD TO ANY OTHER REPO. -->

Effective July 6, 2025, only self-managed connector versions that meet or exceed the minimum version listed on the
[Supported Connector Versions](https://docs.confluent.io/platform/7.8/connect/supported-connector-version.html#supported-connector-versions-till-cp-7-8)
page receive support from Confluent. Older, unsupported connector versions have been removed from Confluent Marketplace and
are no longer available for download.

## Features

The JMS Sink connector includes the following features:

- [At least once delivery](#jms-sink-at-least-once-delivery)
- [Dead Letter Queue](#jms-sink-dead-letter-queue)
- [Multiple tasks](#jms-sink-multiple-tasks)
- [Client-side encryption](#jms-sink-csfle-sm)

<a id="jms-sink-at-least-once-delivery"></a>

### At least once delivery

This connector guarantees that records are delivered at least once from the Kafka
topic.

<a id="jms-sink-dead-letter-queue"></a>

### Dead Letter Queue

This connector supports the Dead Letter Queue (DLQ) functionality. For
information about accessing and using the DLQ, see [Confluent Platform
Dead Letter Queue](/platform/2.2/connect/concepts.html#dead-letter-queue).

<a id="jms-sink-multiple-tasks"></a>

### Multiple tasks

The JMS Sink connector supports running one or more tasks. You can
specify the number of tasks in the `tasks.max` configuration parameter. This
can lead to performance gains when multiple files need to be parsed.

<a id="jms-sink-csfle-sm"></a>

### Client-side encryption

This connector supports Client-Side Field Level Encryption (CSFLE) and Client-Side Payload Encryption (CSPE). For more information, see [Manage Client-Side Encryption](https://docs.confluent.io/platform/current/connect/manage-csfle.html).

## Install the JMS Sink Connector

You can install this connector by using the [Confluent Hub Client installation
instructions](https://docs.confluent.io/home/connect/confluent-hub/client.html), or by
manually downloading the ZIP file.

### Prerequisites

- You must install the connector on every machine where Connect will run.
- If you want to install the connector using Confluent Marketplace, you must install
  the [Confluent Hub Client](https://docs.confluent.io/home/connect/confluent-hub/client.html). This
  is installed by default with Confluent Enterprise.
- Kafka Broker: Confluent Platform 3.3.0 or later, or Kafka 0.11.0 or later
- Connect: Confluent Platform 4.1.0 or later, or Kafka 1.1.0 or later (requires header support in Connect)
- Java 1.8
- An installation of the JMS 1.1+ client library JAR files. For help with
  downloading the JAR files, see the [Client Library JARs](#jms-sink-connector-client-libs)
  section.

### Install the connector using the Confluent CLI

To install the `latest` connector version using [Confluent Hub Client](https://www.confluent.io/hub/), navigate to your Confluent Platform installation directory
and run the following command:

```bash
confluent connect plugin install confluentinc/kafka-connect-jms-sink:latest
```

You can install a specific version by replacing `latest` with a version number
as shown in the following example:

```bash
confluent connect plugin install confluentinc/kafka-connect-jms-sink:2.2.0
```

### Install the connector manually

[Download and extract the ZIP file](https://www.confluent.io/hub/confluentinc/kafka-connect-jms-sink) for your
connector and then follow the manual connector installation
[instructions](/kafka-connectors/self-managed/install.html).

## License

You can use this connector for a 30-day trial period without a license key.

After 30 days, you must purchase a connector subscription which includes [Confluent enterprise license](/platform/2.2/installation/license.html#enterprise-subscription-license) keys to subscribers, along with [enterprise-level support](https://www.confluent.io/subscription/) for Confluent Platform and your connectors. If you are a subscriber, you can contact [Confluent Support](https://support.confluent.io/) for more information.

See [Confluent Platform license](connector_config.md#jms-sink-connector-license-config) for license properties and [License topic configuration](connector_config.md#jms-sink-connector-license-topic-configuration) for information about the license topic.

## Linux on IBM Z (s390x) support

Starting with Confluent Platform 8.2, this connector supports Linux on IBM Z (s390x).
The connector supports the same capability available on x86_64 unless
otherwise noted. For more information, see [Linux on IBM Z (s390x) support](https://docs.confluent.io/platform/current/installation/versions-interoperability.html#linux-on-ibm-z-s390x-support).

## Configuration Properties

For a complete list of configuration properties for this connector, see [Configuration Reference for JMS Sink Connector for Confluent Platform](connector_config.md#jms-sink-connector-config).

<a id="jms-sink-connector-client-libs"></a>

## Client Library JARs

The Kafka Connect JMS connector works with any JMS 1.1 compliant system. The
connector does not come with client libraries.

If you are running a multi-node Connect cluster, the JMS connector and JMS
Client JARs must be installed on every
Connect worker in the cluster. See below for details.

<a id="installing-jms-client-jars"></a>

### Install JMS Client Libraries

This connector uses Java Naming and Directory
Interface™ ([JNDI](https://docs.oracle.com/javase/tutorial/jndi/overview/index.html))
to create an instance of the
JMS [ConnectionFactory](https://docs.oracle.com/javaee/7/api/javax/jms/ConnectionFactory.html)
for your messaging system.
In order for this to work, the connectors must have the relevant JMS client
jars on the classpath adjacent to the connector.

The installation steps are:

1. Find the JMS client library JAR for any JMS system that will be used.
2. Place these JAR files into the `share/confluent-hub-components/kafka-connect-jms-sink/lib`
   directory of your Confluent Platform installation **on each worker node**.
   See the note below if you do not see this directory.
3. Restart all of the Connect worker nodes.

#### NOTE
The `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory mentioned above is the default
installation directory used by the Confluent Marketplace client. If you have customized this directory or are
using a different installation method, find the location of the Confluent JMS sink connector JAR files
and place the JMS client JAR file(s) into the same directory.

Instructions for several JMS providers are listed below.

### TIBCO EMS

The following steps show how to download the client JAR for TIBCO EMS v8.5.0. These steps should also apply to other versions.

1. Navigate to [TIBCO EMS Downloads](https://www.tibco.com/products/tibco-messaging/downloads#ems).
2. Accept the User Agreement for the “TIBCO Enterprise Message Service™” download.
3. Download “TIBCO Enterprise Message Service™ - Community Edition – Free Download - **Linux**”
4. Unzip the `TIB_ems-ce_8.5.0.zip` file. This should result in a `TIB_ems-ce_8.5.0` directory.
5. In the `TIB_ems-ce_8.5.0/tar` directory, extract the
   contents of `TIB_ems-ce_8.5.0_linux_x86_64-java_client.tar.gz` into a temporary directory.
6. In the temporary directory, copy **only** the `tibco/ems/8.5/lib/tibjms.jar` file into
   the `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory
   of your Confluent Platform installation **on each worker node**.
7. Restart all of the Connect worker nodes.

#### IMPORTANT
Do not place any other files from the TIBCO download into
the `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory in your Confluent Platform installation.

### IBM MQ

1. Follow IBM’s guide on
   [Getting the IBM MQ classes for Java and JMS](https://www-01.ibm.com/support/docview.wss?uid=swg21683398)
   to download the IBM MQ client JAR.
2. Copy **only** the `com.ibm.mq.allclient.jar` file into
   the `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory
   of your Confluent Platform installation **on each worker node**.
3. Restart all of the Connect worker nodes.

#### IMPORTANT
Do not place any other files from the IBM download into
the `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory in your Confluent Platform installation.

### Solace

#### IMPORTANT
When using the JMS Sink connector with Solace, you must manually install the
`commons-lang-<version-A>.jar` file into the `lib/` directory, where
`<version-A>` is the version number of `common-lang` your
`sol-jms-<version-B>.jar` file depends on.

1. Download the [Solace JMS Client JAR](https://products.solace.com/download/JMS_API)
   from Solace’s Open APIs and Protocols.
2. Copy the downloaded `sol-jms-<version-B>.jar` file and its dependencies,
   including the `commons-lang-<version-A>.jar` file into the
   `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory of
   your Confluent Platform installation **on each worker node**.
3. Restart all of the Connect worker nodes.

#### NOTE
A comprehensive list of Solace JMS Client JAR versions can be found on
Maven at [com.solacesystems:sol-jms](https://mvnrepository.com/artifact/com.solacesystems/sol-jms).

### ActiveMQ

1. Download the latest [ActiveMQ Release](https://activemq.apache.org/download-archives)
   in the `tar.gz` format (Unix/Linux/Cygwin).
2. Extract the contents of the `tar.gz` download to a temporary directory.
3. From the temporary directory, copy **only** the `activemq-all-{version}.jar`
   file into the `share/confluent-hub-components/kafka-connect-jms-sink/lib`
   directory of your Confluent Platform installation **on each worker node**.
4. Restart all of the Connect worker nodes.

#### IMPORTANT
Do not place any other files from the ActiveMQ download into
the `share/confluent-hub-components/kafka-connect-jms-sink/lib` directory in your Confluent Platform installation.

## JMS Message Formats

The format of outgoing JMS Message values is configured with the
`jms.message.format` property, using one of the following options:

### string (*default*)

When using the `string` Message Format, record values are run through
`Values.convertToString(...)` from the Connect Data package and produced as a
JMS `TextMessage`.

Primitive values are converted to their String equivalent and structured objects
are transformed to a sensible string representation that is similar to the JSON
representation, with the exception of simple string values (not in objects or
arrays) which are unquoted.

### avro

Record values are serialized without the Avro schema information and produced as
a JMS `BytesMessage`. JMS consumers **must have the schema** to deserialize
the data.

#### IMPORTANT
The connector attempts to infer the Avro schema for records that have no
schema. If the connector cannot infer the schema, the task is killed. If you
are processing data without a schema, consider using one of the other
`jms.message.format` configurations.

### json

Record values are converted to a UTF-8 encoded JSON representation and produced
as a JMS `TextMessage`.

### bytes

Record values are passed along in bytes form without any conversion.

#### IMPORTANT
Record values must be converted to bytes form before the connector processes
them. Configure the `value.converter` property to
`org.apache.kafka.connect.converters.ByteArrayConverter` to ensure that
record values arrive in byte format.

## Forwarding Kafka Properties to JMS

The connector can be configured to forward various values from the Kafka record
to the JMS Message.

* Enable `jms.forward.kafka.key` to convert the record’s key to a String and
  forward it as the `JMSCorrelationID`.
* Enable `jms.forward.kafka.metadata` to forward the record’s topic,
  partition, and offset on JMS Message properties.
  * Kafka topic is applied to the message as a String property named `KAFKA_TOPIC`.
  * Partition is applied to the message as an Int property named `KAFKA_PARTITION`.
  * Offset is applied to the message as a Long property named `KAFKA_OFFSET`.
* Enable `jms.forward.kafka.headers` to add each header from the SinkRecord to
  the JMS Message as a String property.

#### NOTE
The connector converts the record key and headers to a sensible string
representation that is similar to the JSON representation, with the
exception of simple string values (not in objects or arrays) which are
unquoted. No other conversion is done to the key and headers before
forwarding them on the JMS Message. If another format is needed,
out-of-the-box or custom [Single Message
Transformation](/platform/2.2/connect/transforms/index.html) can be used with the connector
to transform the record keys and/or headers to the desired string
representation before the JMS sink connector processes each record.

## JMS Reconnection

Each JMS provider handles broken connections, reconnections, and failovers in their own way. As a result, the JMS sink
connector delegates most client reconnection capabilities to the provider. The reconnection examples below
illustrate some of the configurations exposed to enable reconnection and failover capabilities. It is recommended
that you review your JMS provider documentation to find examples of how the provider implements and exposes
these features. Any configurations given to the connector that are not part of the connector’s primary configurations
are passed along to the `InitialContext` when setting up the JMS connection.

The JMS sink connector tasks handle JMS Exceptions thrown from the JMS Producer by rethrowing them
as a `RetriableException`. This triggers the connector to retry the entire batch. To avoid sending
duplicate data to JMS, the connector tasks track the most recent offset processed for a topic and partition and
skips ahead to the first record that has **not** already been sent to JMS. When retrying a batch in this scenario,
the task automatically refreshes the JMS connection to ensure that any transient connection failures are mitigated.

### Reconnection Examples

* [ActiveMQ Failover Transport](https://activemq.apache.org/failover-transport-reference)  and [Auto Reconnection](https://activemq.apache.org/how-can-i-support-auto-reconnection)
  ```properties
  java.naming.provider.url=failover:(tcp://amq-1:61616,tcp://amq-2:61616)

  # all other properties follow quick start example
  ```
* [Solace Reconnect Retries](https://docs.solace.com/Solace-JMS-API/JNDI-Connection-Properti.htm#jms_properties_39190069_302454)
  ```properties
  java.naming.provider.url=smf://sol-1:55555,smf://sol-2:55555
  SOLACE_JMS_JNDI_RECONNECT_RETRIES=25

  # all other properties follow quick start example
  ```
* [TIBCO EMS FACTORY_RECONNECT_ATTEMPT_COUNT](https://docs.tibco.com/pub/enterprise_message_service/7.0.1-march-2013/doc/html/tib_ems_api_reference/api/javadoc/com/tibco/tibjms/Tibjms.html#FACTORY_RECONNECT_ATTEMPT_COUNT)
  ```properties
  java.naming.provider.url=tibjmsnaming://tibco-1:7222,tibjmsnaming://tibco-2:7222
  com.tibco.tibjms.reconnect.attemptcount=25

  # all other properties follow quick start example
  ```
* [IBM MQ Automatic Client Reconnection](https://www.ibm.com/support/knowledgecenter/en/SSFKSJ_9.0.0/com.ibm.mq.dev.doc/q032520_.htm)

## ActveMQ Quick Start

For an example of how to get Kafka Connect connected to [Confluent Cloud](/cloud/current/index.html), see
[Connect Self-Managed Kafka Connect to Confluent Cloud](/cloud/current/cp-component/connect-cloud-config.html#distributed-cluster).

This quick start uses the JMS Sink connector to consume records from Kafka and send them to an ActiveMQ broker.

Prerequisites
: - [Confluent Platform](/platform/2.2/installation/index.html)
  - [Confluent CLI](/confluent-cli/current/installing.html) (requires separate installation)

1. [Install ActiveMQ](https://activemq.apache.org/getting-started#installation-procedure-for-unix)
2. [Start ActiveMQ](https://activemq.apache.org/getting-started#starting-activemq)
3. Install the connector by using the following [CLI
   command](/confluent-cli/current/command-reference/connect/plugin/confluent_connect_plugin_install.html):
   ```bash
   # run from your Confluent Platform installation directory
   confluent connect plugin install confluentinc/kafka-connect-jms-sink:latest
   ```
4. [Download the activemq-all JAR](https://repo1.maven.org/maven2/org/apache/activemq/activemq-all/5.15.4/activemq-all-5.15.4.jar) and copy it into the JMS Sink connector’s plugin folder. This needs to be done on every Connect worker node and you must restart the workers pick up the client JAR.
5. Start Confluent Platform using the [confluent local](/confluent-cli/current/command-reference/local/index.html) command.
   ```bash
   confluent local start
   ```
6. [Produce](https://docs.confluent.io/current/cli/command-reference/confluent-produce.html) test data to the `jms-messages` topic in Kafka.
   ```bash
   seq 10 | confluent local produce jms-messages
   ```
7. Create a `jms-sink.json` file with the following contents:
   ```json
   {
     "name": "JmsSinkConnector",
     "config": {
       "connector.class": "io.confluent.connect.jms.JmsSinkConnector",
       "tasks.max": "1",
       "topics": "jms-messages",
       "java.naming.factory.initial": "org.apache.activemq.jndi.ActiveMQInitialContextFactory",
       "java.naming.provider.url": "tcp://localhost:61616",
       "java.naming.security.principal": "connectuser",
       "java.naming.security.credentials": "connectpassword",
       "connection.factory.name": "connectionFactory",
       "jms.destination.type": "queue",
       "jms.destination.name": "connector-quickstart",
       "key.converter": "org.apache.kafka.connect.storage.StringConverter",
       "value.converter": "org.apache.kafka.connect.storage.StringConverter",
       "confluent.topic.bootstrap.servers": "localhost:9092",
       "confluent.topic.replication.factor": "1"
     }
   }
   ```
8. Load the JMS Sink connector.
   ```bash
   confluent local load jms --config jms-sink.json
   ```

   #### IMPORTANT
   Don’t use the [Confluent CLI](/confluent-cli/current/index.html) in production environments.
9. Confirm that the connector is in a `RUNNING` state.
   ```bash
   confluent local status jms
   ```
10. Navigate to the [ActiveMQ Admin UI](http://localhost:8161/admin) to confirm the messages were delivered to the `connector-quickstart` queue.

## Solace Quick Start

This quick start uses the JMS Sink connector to consume records from Kafka and send them to a Solace PubSub+ broker.

1. Start the [Solace PubSub+ Standard](https://solace.com/software/) broker.
   ```bash
   docker run -d --name "solace" \
       -p 8080:8080 -p 55555:55555 \
       --shm-size=1000000000 \
       --ulimit nofile=2448:38048 \
       -e username_admin_globalaccesslevel=admin \
       -e username_admin_password=admin \
       -e system_scaling_maxconnectioncount=100 \
       solace/solace-pubsub-standard:9.1.0.77
   ```
2. Create a Solace Queue in the `default` Message VPN.
   1. Once the solace docker container has started, navigate to [http://localhost:8080](http://localhost:8080) in your browser and login with `admin`/`admin`.
   2. Select the `default` Message VPN on the home screen.
   3. Select “Queues” in the left menu to navigate to the Queues page.
   4. On the Queues page, select the “+ Queue” button in the upper right and name the Queue `connector-quickstart`.
3. Install the connector through the [Confluent Hub Client](/kafka-connectors/self-managed/confluent-hub/client.html).
   ```bash
   # run from your Confluent Platform installation directory
   confluent connect plugin install confluentinc/kafka-connect-jms-sink:latest
   ```
4. [Download the sol-jms jar](https://mvnrepository.com/artifact/com.solacesystems/sol-jms) and copy it into the JMS Sink connector’s plugin folder. This needs to be done on every Connect worker node and the workers must be restarted to pick up the client jar.
5. Start Confluent Platform.
   ```bash
   confluent local start
   ```
6. [Produce](https://docs.confluent.io/current/cli/command-reference/confluent-produce.html) test data to the `jms-messages` topic in Kafka.
   ```bash
   seq 10 | confluent local produce jms-messages
   ```
7. Create a `jms-sink.json` file with the following contents:
   ```json
   {
     "name": "JmsSinkConnector",
     "config": {
       "connector.class": "io.confluent.connect.jms.JmsSinkConnector",
       "tasks.max": "1",
       "topics": "jms-messages",
       "java.naming.factory.initial": "com.solacesystems.jndi.SolJNDIInitialContextFactory",
       "java.naming.provider.url": "smf://localhost:55555",
       "java.naming.security.principal": "admin",
       "java.naming.security.credentials": "admin",
       "connection.factory.name": "/jms/cf/default",
       "Solace_JMS_VPN": "default",
       "jms.destination.type": "queue",
       "jms.destination.name": "connector-quickstart",
       "key.converter": "org.apache.kafka.connect.storage.StringConverter",
       "value.converter": "org.apache.kafka.connect.storage.StringConverter",
       "confluent.topic.bootstrap.servers": "localhost:9092",
       "confluent.topic.replication.factor": "1"
     }
   }
   ```
8. Load the JMS Sink connector.
   ```bash
   confluent local load jms --config jms-sink.json
   ```

   #### IMPORTANT
   Don’t use the [Confluent CLI](/confluent-cli/current/index.html) in production environments.
9. Confirm that the connector is in a `RUNNING` state.
   ```bash
   confluent local status jms
   ```
10. Navigate to the [Solace UI](http://localhost:8080) to confirm the messages were delivered to the `connector-quickstart` queue.

## TIBCO EMS Quick Start

This quick start uses the JMS Sink connector to consume records from Kafka and send them to TIBCO Enterprise Message Service - Community Edition.

1. Download and unzip [TIBCO EMS Community Edition](https://www.tibco.com/resources/product-download/tibco-enterprise-message-service-community-edition-free-download-mac).
2. Run the `TIBCOUniversalInstaller-mac.command` and step through the TIBCO Universal Installer.
3. Start TIBCO EMS with default configurations.
   ```bash
   ~/TIBCO_HOME/ems/8.4/bin/tibemsd
   ```
4. Install the connector through the [Confluent Hub Client](/kafka-connectors/self-managed/confluent-hub/client.html).
   ```bash
   # run from your Confluent Platform installation directory
   confluent connect plugin install confluentinc/kafka-connect-jms-sink:latest
   ```
5. Copy `~/TIBCO_HOME/ems/8.4/lib/tibjms.jar` into the JMS Sink connector’s plugin folder. This needs to be done on every Connect worker node and the workers must be restarted to pick up the client jar.
6. Start Confluent Platform.
   ```bash
   confluent local start
   ```
7. [Produce](https://docs.confluent.io/current/cli/command-reference/confluent-produce.html) test data to the `jms-messages` topic in Kafka.
   ```bash
   seq 10 | confluent local produce jms-messages
   ```
8. Create a `jms-sink.json` file with the following contents:
   ```json
   {
     "name": "JmsSinkConnector",
     "config": {
       "connector.class": "io.confluent.connect.jms.JmsSinkConnector",
       "tasks.max": "1",
       "topics": "jms-messages",
       "java.naming.provider.url": "tibjmsnaming://localhost:7222",
       "java.naming.factory.initial": "com.tibco.tibjms.naming.TibjmsInitialContextFactory",
       "connection.factory.name": "QueueConnectionFactory",
       "java.naming.security.principal": "admin",
       "java.naming.security.credentials": "",
       "jms.destination.type": "queue",
       "jms.destination.name": "connector-quickstart",
       "key.converter": "org.apache.kafka.connect.storage.StringConverter",
       "value.converter": "org.apache.kafka.connect.storage.StringConverter",
       "confluent.topic.bootstrap.servers": "localhost:9092",
       "confluent.topic.replication.factor": "1"
     }
   }
   ```
9. Load the JMS Sink connector.
   ```bash
   confluent local load jms --config jms-sink.json
   ```

   #### IMPORTANT
   Don’t use the [Confluent CLI](/confluent-cli/current/index.html) in production environments.
10. Confirm that the connector is in a `RUNNING` state.
    ```bash
    confluent local status jms
    ```
11. Validate that there are messages on the queue using the `tibemsadmin` tool.
    ```bash
    ~/TIBCO_HOME/ems/8.4/bin/tibemsadmin -server "tcp://localhost:7222" -user admin
    # admin password is blank by default

    tcp://localhost:7222> show queue connector-quickstart
    ```

## Connecting to Oracle WebLogic Server

You can connect to [Oracle’s WebLogic Server](https://www.oracle.com/java/weblogic/) using the JMS Sink connector. For a working example, see
[Oracle Weblogic Sink with JMS connector](https://github.com/vdesabou/kafka-docker-playground/tree/master/connect/connect-jms-weblogic-sink).

The following is a sample connector configuration:

```json
{
     "connector.class": "io.confluent.connect.jms.JmsSinkConnector",
     "confluent.topic.bootstrap.servers": "broker:9092",
     "topics": "sink-messages",
     "java.naming.factory.initial": "weblogic.jndi.WLInitialContextFactory",
     "java.naming.provider.url": "t3://weblogic-jms:7001",
     "jms.destination.name": "myJMSServer/mySystemModule!myJMSServer@MyDistributedQueue",
     "confluent.license": "",
     "connection.factory.name": "myFactory",
     "java.naming.security.principal": "weblogic",
     "confluent.topic.replication.factor": "1",
     "name": "jms-weblogic-topic-sink",
     "jms.destination.type": "queue",
     "value.converter": "org.apache.kafka.connect.storage.StringConverter",
     "java.naming.security.credentials": "welcome1",
     "key.converter": "org.apache.kafka.connect.storage.StringConverter"
}
```

You must add the Weblogic client library JAR to the connector `/lib`
folder:

1. Enter the following command to check the connector path:
   ```bash
   grep plugin /etc/kafka-connect/kafka-connect.properties
   ```
2. Your output should resemble:
   ```text
   plugin.path=/usr/share/confluent-hub-components/confluentinc-kafka-connect-jms-sink
   ```
3. Add the JAR file to the  `/lib` folder and verify the file is present
   in the folder:
   ```bash
   ls -larth /usr/share/confluent-hub-components/confluentinc-kafka-connect-jms-sink/lib/example3client.jar
   -rw-r--r-- 1 <username> <username> 8.7M Sep 29 10:29 /usr/share/confluent-hub-components/confluentinc-kafka-connect-jms-sink/lib/example3client.jar
   ```

   See [Client Library JARs](#jms-sink-connector-client-libs) for more information about
   installing client JARs.