RabbitMQ (AMQP 1.0) Connector Reference¶ This documentation provides a reference guide for the RabbitMQ Connector. The RabbitMQ connector enables you to connect to a RabbitMQ broker, a reliable messaging system, and perform message publishing operations. Click an operation name to see parameter details and samples on how to use it. Connection Configurations¶ The WSO2 RabbitMQ Connector allows you to establish connections to the RabbitMQ broker using either SSL or non-SSL protocols. Connection Configuration Parameters¶ RABBITMQThis operation allows you to initialize the connection to RabbitMQ Broker. Parameter Name Display Name Description Required Default Value connectionName Connection Name The name for the rabbitmq connection Yes RABBITMQ_CONNECTION_1 General serverUrls RabbitMQ Broker Urls Enter RabbitMQ server URLs as a comma-separated list (e.g., host1:port1,host2:port2). Yes localhost:5672 Auth Configuration saslMechanism SASL Mechanism Select the SASL mechanism to use for connection authentication. Possible values: PLAIN: The default, standard authentication method that transmits username and password credentials in plain text. This mechanism is simple and widely supported but requires secure transport (TLS/SSL) to protect credentials during transmission. When OAuth2 authentication is enabled, the SASL mechanism should be set to PLAIN, as the OAuth2 token is passed as the password field. EXTERNAL: Delegates authentication to an external mechanism, bypassing RabbitMQ's internal user database. This typically works in conjunction with the rabbitmq_auth_backend_external plugin or certificate-based authentication (TLS/SSL mutual authentication). Common use cases: Client Certificate Authentication: The client's identity is extracted from the TLS certificate's Distinguished Name (DN) during the TLS handshake, eliminating the need for username/password credentials. External Authentication Scripts: When using rabbitmq_auth_backend_external, authentication and authorization are delegated to external scripts or programs that can integrate with LDAP, Kerberos, custom databases, or other identity providers. This mechanism is suitable for enterprise environments requiring centralized identity management or certificate-based security models. Security Considerations: PLAIN: Always use with TLS/SSL encryption to prevent credential interception. Never use over unencrypted connections in production environments. EXTERNAL: Requires proper certificate management and PKI infrastructure for certificate-based auth, or secure configuration of external authentication backends. Provides stronger authentication but increases setup and maintenance complexity. Yes PLAIN username Server Username Username for PLAIN authentication. No guest password Server Password Password for PLAIN authentication. No guest oAuth2Enabled OAuth2 Enabled Enable if using OAuth 2.0 (e.g., Client Credentials or Password Grant) for authentication instead of a simple username/password. When OAuth 2.0 is enabled, RabbitMQ validates access tokens presented by clients against a configured authorization server. The OAuth 2.0 plugin uses JWT (JSON Web Token) tokens and can verify them either by validating the token's signature using public keys or by introspecting the token with the authorization server. Please refer to the RabbitMQ OAuth 2.0 plugin documentation for detailed configuration instructions and supported Identity providers. No false OAuth2 Configurations tokenEndpoint Token Endpoint Enter Identity Provider/Token Service token endpoint URL to generate the access token. Note Provide the HTTPS URL for the token endpoint and import the Identity Provider's public certificate into the WSO2 MI client-truststore.jks. See importing SSL certificates to a truststore for instructions on importing the certificate into client-truststore.jks. No - grantType Grant Type Select the OAuth2 grant type to use for token generation. Options: client_credentials: Used for machine-to-machine (M2M) authentication where the application authenticates using its own credentials (client ID and client secret) without user involvement. This is the most common grant type for service-to-service communication and background processes. Recommended for most RabbitMQ integration scenarios. password: Also known as Resource Owner Password Credentials (ROPC) grant. The application collects the user's username and password directly and exchanges them for an access token. This grant type should only be used when there is a high degree of trust between the user and the application, as it requires handling user credentials directly. Generally discouraged for security reasons unless legacy systems require it. No client_credentials clientId Client ID The client ID for token generation. No - clientSecret Client Secret The client secret for token generation. No - oAuth2UserName User Name Enter the username to use with password grant type for token generation. No - oAuth2Password Password Enter the password to use with password grant type for token generation. No - scope Scope Scopes to include in the OAuth 2.0 token request (space-separated if multiple). The required scopes depend on the RabbitMQ OAuth 2.0 authorization configuration and the intended use case. If the integration only needs to consume and publish messages to RabbitMQ, it can be configured with scopes that grant read and write permissions. However, if the integration also needs to create or manage queues, exchanges, bindings, or other broker resources, additional management-related scopes must be included. Note The exact scope values depend on the RabbitMQ OAuth 2.0 configuration. Some deployments may use aliases such as read, write, and management, while others may require RabbitMQ-specific scopes such as rabbitmq.read:/, rabbitmq.write:/, and rabbitmq.configure:/. Refer to the RabbitMQ OAuth 2.0 documentation for details on scope aliases and scope-to-permission mapping. No - SSL Configuration sslEnabled SSL Enabled Enable SSL/TLS for the RabbitMQ connection. No false trustEverything Trust Everything If enabled, all server certificates will be accepted, regardless of validity. Not recommended for production environments. No false keyStoreLocation Keystore Location The file path to the Keystore containing the client's private key and certificate. No - keyStoreType Keystore Type The type of the Keystore (e.g., JKS). No JKS keyStorePassword Keystore Password The password to access the Keystore. No - trustStoreLocation Truststore Location The file path to the Truststore containing trusted server certificates. No - trustStoreType Truststore Type The type of the Truststore (e.g., JKS). No JKS trustStorePassword Truststore Password The password to access the Truststore. No - sslVersion SSL Version The preferred SSL/TLS protocol version (e.g., 'TLSv1.2', 'TLSv1.3'). No TLSv1.2 hostnameVerificationEnabled Enabled SSL Hostname Verification If enabled, the hostname in the server's certificate must match the server host name you are connecting to. No false Advanced virtualHost Virtual Host The virtual host (vhost) within the RabbitMQ server to connect to. Leave blank for the default '/' vhost. No / connectionIdleTimeout Connection Idle Timeout The maximum period (in milliseconds) the connection can remain idle without any activity before it is closed by the server. No 60000 connectionEstablishRetryCount Connection Establish Retry Count The number of times to retry establishing the connection to the RabbitMQ server. Leave blank for default. No 5 connectionEstablishRetryInterval Connection Establish Retry Interval The interval (in milliseconds) between retries when establishing the connection. No 1000 connectionRecoveryPolicyType Connection Recovery Policy Type Defines the strategy for automatic connection recovery after a disconnection. Options: FIXED: Attempts to reconnect immediately after a connection failure with a fixed interval between retry attempts. This provides the fastest reconnection but may overwhelm the broker if it's experiencing issues or during network instability. FIXED_WITH_INITIAL_DELAY: Waits for a specified initial delay before attempting the first reconnection, then continues with fixed intervals for subsequent retries. This gives the broker or network time to stabilize before reconnection attempts begin, reducing unnecessary load during transient failures. FIXED_WITH_INITIAL_DELAY_AND_TIMEOUT: Combines an initial delay before the first retry attempt with a maximum timeout limit for the entire recovery process. If the connection cannot be re-established within the timeout period, recovery attempts cease. This prevents indefinite reconnection attempts and allows the application to fail gracefully or implement alternative handling. Recommended for production environments to balance resilience with resource management. No FIXED_WITH_INITIAL_DELAY_AND_TIMEOUT connectionRecoveryInitialDelay Connection Recovery Initial Delay The initial delay (in milliseconds) before the first recovery attempt starts. No 5000 connectionRecoveryInterval Connection Recovery Interval The fixed interval (in milliseconds) between connection recovery retries. No 10000 connectionRecoveryTimeout Connection Recovery Timeout The total time (in milliseconds) allowed for the connection recovery process before giving up. No 60000 Sample configuration Given below is a sample configuration to create a client connection. <rabbitmq.init> <connectionType>RABBITMQ</connectionType> <name>rabbitMQConnection1</name> <serverUrls>localhost:5673</serverUrls> <saslMechanism>PLAIN</saslMechanism> <oAuth2Enabled>true</oAuth2Enabled> <tokenEndpoint>https://localhost:9443/oauth2/token</tokenEndpoint> <grantType>client_credentials</grantType> <clientId>****************</clientId> <clientSecret>****************</clientSecret> <sslEnabled>true</sslEnabled> <keyStoreLocation>/path/to/keystore.jks</keyStoreLocation> <keyStoreType>JKS</keyStoreType> <keyStorePassword>pasword</keyStorePassword> <trustStoreLocation>/path/to/client-truststore.jks</trustStoreLocation> <trustStoreType>JKS</trustStoreType> <trustStorePassword>password</trustStorePassword> <sslVersion>TLSv1.2</sslVersion> <connectionIdleTimeout>180000</connectionIdleTimeout> <connectionRecoveryPolicyType>FIXED_WITH_INITIAL_DELAY_AND_TIMEOUT</connectionRecoveryPolicyType> <connectionRecoveryInitialDelay>5000</connectionRecoveryInitialDelay> <connectionRecoveryInterval>10000</connectionRecoveryInterval> <connectionRecoveryTimeout>60000</connectionRecoveryTimeout> </rabbitmq.init> Operations¶ The following operations allow you to work with the RabbitMQ Connector. Click an operation name to see parameter details and samples on how to use it. Message Publishing Operations¶ The following operations allows you to send messages to RabbitMQ queues or exchanges. Publish MessageThe publishMessage operation allows you to publish messages to the RabbitMQ brokers. Parameter Name Display Name Description Required Default Value RabbitMQ Connection name The name of the RabbitMQ connection configuration to use. Yes - Destination Queue/Exchange Configuration queue Queue Specify the name of the RabbitMQ queue to publish to. No - queueType Queue Type Select the type of RabbitMQ queue to interact with. Options: CLASSIC: The traditional RabbitMQ queue type with support for all messaging patterns and features. Offers flexibility and full protocol compatibility but provides limited fault tolerance as queues are stored on a single node. Suitable for development, testing, or non-critical workloads where high availability is not required. QUORUM: A replicated queue type built on the Raft consensus algorithm, providing high availability and data safety through replication across multiple cluster nodes. Automatically handles leader election and failover. Designed for critical workloads requiring message durability and resilience against node failures. Recommended for production environments where message loss is unacceptable. Note: Does not support all classic queue features (e.g., priority queues, message TTL at message level). STREAM: A persistent, append-only log structure optimized for high-throughput, large-volume message flows with non-destructive consumption. Messages are retained on disk and can be consumed multiple times by different consumers from any offset. Ideal for event streaming, audit logs, time-series data, and scenarios requiring message replay or long-term retention. Requires RabbitMQ 3.9+ and uses a different consumption model than traditional queues. No QUORUM queueAutoDeclare Queue Auto Declare If enabled, the connector will attempt to declare the specified queue on the RabbitMQ server if it doesn't already exist. No true exchange Exchange Name Specify exchange name and routing key to publish message via an exchange instead of a queue. If using an exchange, leave queue blank—the routing key controls message delivery based on exchange type. No - exchangeType Exchange Type Defines how the exchange routes messages to queues based on routing rules. Options: DIRECT: Routes messages to queues based on an exact match between the routing key and the binding key. Simple and efficient for point-to-point messaging where each message should be delivered to specific queues. Ideal for task distribution and targeted message delivery scenarios. FANOUT: Broadcasts all messages to all bound queues, ignoring routing keys entirely. Every queue bound to the exchange receives a copy of each message. Perfect for publish-subscribe patterns, notifications, and scenarios where the same message needs to reach multiple independent consumers simultaneously. TOPIC: Routes messages based on wildcard pattern matching between the routing key and binding patterns. Binding keys can use wildcards: * (matches exactly one word) and # (matches zero or more words). Enables flexible, hierarchical routing based on multi-part routing keys (e.g., stock.usa.tech). Suitable for complex routing scenarios like log aggregation, multi-criteria filtering, and selective subscription patterns. HEADERS: Routes messages based on matching message header attributes rather than routing keys. Uses the x-match binding argument to specify whether all headers must match or any header match is sufficient. Provides the most flexible routing but with higher overhead. Best for complex routing rules based on multiple message properties or when routing logic cannot be expressed through routing keys alone. No DIRECT exchangeAutoDeclare Exchange Auto Declare If enabled, the connector will attempt to declare the specified exchange on the RabbitMQ server if it doesn't already exist. No true routingKey Routing Key Specify a routing key when binding a queue to a DIRECT or TOPIC exchange. If omitted, the queue name will be used as the routing key. No - Request Message Configuration headers Headers Key value pairs for headers No - requestBodyType Content Type The content type of the request body. Options: JSON, XML, TEXT No JSON requestBodyJson Request Body Request body when content type is JSON No {payload}</td> </tr> <tr> <td>requestBodyXml</td> <td>Request Body</td> <td>Request body when content type is XML</td> <td>No</td> <td>{xpath('body/node()')}</td> </tr> <tr> <td>requestBodyText</td> <td>Request Body</td> <td>Request body when content type is TEXT</td> <td>No</td> <td> Publisher Client Configuration publisherConfirms Publisher Confirms Enable publisher confirms to ensure message delivery acknowledgment from the RabbitMQ broker. No true publishTimeout Publish Timeout (ms) The maximum time (in milliseconds) to wait for the message to be published before timing out. No 60000 Queue Properties queueArguments Queue Arguments Additional arguments to customize queue behavior when declaring the queue. Specify as comma-separated key=value pairs (e.g., x-message-ttl=60000,x-max-length=1000). Common queue arguments: x-message-ttl: Sets the time-to-live (TTL) for messages in milliseconds. Messages older than this value are automatically discarded or dead-lettered. Example: x-message-ttl=60000 (1 minute). Useful for time-sensitive data like session tokens or temporary notifications. x-max-length: Limits the maximum number of messages the queue can hold. When exceeded, the overflow strategy (see queueOverflowStrategy) determines what happens. Example: x-max-length=10000. Prevents unbounded queue growth. x-max-length-bytes: Limits the maximum total size of messages in bytes. Alternative to message count limit. Example: x-max-length-bytes=10485760 (10MB). Useful for controlling memory usage. x-dead-letter-exchange: Specifies the exchange to route dead-lettered messages (expired, rejected, or exceeding delivery limits). Example: x-dead-letter-exchange=dlx. Essential for handling failed or problematic messages. x-dead-letter-routing-key: Optional routing key for dead-lettered messages. If not set, the original routing key is used. Example: x-dead-letter-routing-key=failed.orders. x-expires: Auto-deletes the queue after specified milliseconds of inactivity (no consumers, no messages published). Example: x-expires=1800000 (30 minutes). Useful for temporary or session-based queues. x-single-active-consumer: When set to true, ensures only one consumer receives messages at a time (others are on standby). Example: x-single-active-consumer=true. Useful for ordered processing or leader election patterns. Format: Use the syntax key1=value1,key2=value2 with no spaces. Numeric values should be in milliseconds for time-based arguments or plain integers/bytes for counts and sizes. Boolean values should be true or false. Note: Arguments specified here are applied during queue declaration. If the queue already exists with different arguments, the declaration will fail unless the arguments match exactly. Some arguments are queue-type specific (e.g., x-max-priority for CLASSIC queues only). Leave blank if no custom queue arguments are needed. No - rabbitmq.classic.version Queue Version For Classic Queues, select the queue implementation version. Options: V1: The legacy classic queue implementation available in all RabbitMQ versions. Uses the original message storage and indexing mechanism. While mature and stable, it has known performance limitations with large queues, high message rates, and memory efficiency. Consider using V1 only for backward compatibility or if running RabbitMQ versions prior to 3.10. V2: The modern classic queue implementation introduced in RabbitMQ 3.10, also known as CQv2 (Classic Queue version 2). Provides significantly improved performance, memory efficiency, and scalability through optimized message storage and reduced per-message overhead. Offers better handling of large queues (millions of messages) and higher throughput. Recommended for all new deployments and production workloads running RabbitMQ 3.10 or later. Note: Once a queue is created with a specific version, it cannot be changed without recreating the queue. Important: This setting only applies to CLASSIC queue types and is ignored for QUORUM and STREAM queues. No V2 maxPriority Queue Max Priority For Classic Queues: defines the maximum priority level the queue should support (valid range: 0-255). When set, this parameter adds the x-max-priority argument to the queue declaration, enabling priority queue functionality. How it works: Messages published with a priority value (0 to the specified max) are delivered to consumers in priority order, with higher priority messages consumed first. Messages without an explicit priority are treated as priority 0 (lowest). Performance considerations: Priority queues have additional CPU and memory overhead compared to standard queues. Higher max priority values increase this overhead. For most use cases, a max priority of 10 or less is sufficient and recommended. Use cases: Suitable for scenarios requiring differentiated message handling, such as urgent alerts, high-priority transactions, or tiered job processing systems. Important: Priority queues are only supported by CLASSIC queues. This setting is ignored for QUORUM and STREAM queue types. Leave empty or set to 0 to disable priority functionality. No - initialMemberCount Queue Initial Member Count Specifies the initial number of cluster nodes that will host replicas of the queue. This setting applies differently based on queue type: For Quorum Queues: Defines the initial replication factor (number of replica nodes) for the queue. The default is 3 replicas if not specified, which provides a good balance between availability and resource usage. Quorum queues require a majority (quorum) of replicas to be available for operation. For example, with 3 replicas, the queue tolerates 1 node failure; with 5 replicas, it tolerates 2 node failures. Higher replica counts improve fault tolerance but increase network overhead and resource consumption. For Stream Queues: Determines the initial number of stream replicas across cluster nodes. Similar to quorum queues, this affects data redundancy and availability. Streams use leader-based replication where one replica is the leader handling writes, while followers replicate data. Considerations: The cluster must have at least as many nodes as the specified member count Odd numbers (3, 5, 7) are recommended for quorum-based systems to avoid split-brain scenarios Leave blank to use RabbitMQ's default behavior (typically 3 replicas) Important: This setting only applies to QUORUM and STREAM queue types and is ignored for CLASSIC queues. No - deliveryLimit Queue Delivery Limit For Quorum Queues: defines the maximum number of delivery attempts for a message before it is automatically dead-lettered or discarded. This setting adds the x-delivery-limit argument to the queue declaration. How it works: When a message is negatively acknowledged (nack/reject) or requeued by a consumer, RabbitMQ increments its delivery counter. Once the delivery count reaches the specified limit, the message is either moved to a configured dead letter exchange (DLX) or dropped if no DLX is configured. Use cases: Prevents poison messages (messages that repeatedly fail processing) from blocking the queue indefinitely. Essential for building resilient systems where problematic messages can be isolated for manual inspection or alternative handling without affecting other messages. Best practices: Always configure a dead letter exchange when using delivery limits to capture failed messages for analysis Typical values range from 3-10 depending on your tolerance for retries Consider implementing exponential backoff in consumers before relying solely on delivery limits Important: This setting only applies to QUORUM queue types and is ignored for CLASSIC and STREAM queues. Leave blank to disable delivery limit enforcement (messages can be redelivered indefinitely). No - deadLetterStrategy Quorum Queue Dead Letter Strategy For Quorum Queues: defines how messages are handled when being dead-lettered, controlling the delivery guarantee semantics. This setting adds the x-dead-letter-strategy argument to the queue declaration. Options: AT_MOST_ONCE: The default and safer strategy. Messages are removed from the original queue before being published to the dead letter exchange (DLX). This guarantees that a message will not be duplicated if the dead-lettering process fails - it will either be in the original queue or successfully dead-lettered, but never in both. However, in case of broker failure during dead-lettering, the message may be lost. Recommended for most use cases where preventing duplicate processing is more critical than preventing message loss. AT_LEAST_ONCE: Messages are published to the dead letter exchange first, then removed from the original queue only after successful publication. This ensures no message is lost during the dead-lettering process, but in case of failures, the same message might be dead-lettered multiple times, resulting in duplicates in the DLX. Use this when message loss is unacceptable and your downstream systems can handle duplicate messages (idempotent processing). Trade-offs: AT_MOST_ONCE: Prevents duplicates, risks message loss on failure AT_LEAST_ONCE: Prevents message loss, risks duplicates on failure Important: This setting only applies to QUORUM queue types and requires a dead letter exchange to be configured. It is ignored for CLASSIC and STREAM queues. No AT_MOST_ONCE maxAge Queue Max Age For STREAM queues: defines the maximum time-based retention period for messages in the stream. This setting adds the x-max-age argument to the queue declaration. How it works: Messages older than the specified age are automatically deleted from the stream to manage disk space. Age is calculated from the message timestamp. The retention policy is evaluated periodically, not in real-time, so messages may persist slightly beyond the specified age. Format: Specify the duration using time units: Y - Years (e.g., 1Y) M - Months (e.g., 3M) D - Days (e.g., 7D) h - Hours (e.g., 24h) m - Minutes (e.g., 30m) s - Seconds (e.g., 3600s) Use cases: Essential for managing storage costs and compliance requirements in event streaming scenarios. For example, audit logs might retain data for 90 days, while real-time analytics streams might only need 24 hours. Considerations: Can be combined with maxLengthBytes - whichever limit is reached first triggers deletion Deleted messages cannot be recovered Leave blank for unlimited retention (not recommended for production - may exhaust disk space) Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. No - maxSegmentSize Queue Max Segment Size (Bytes) For STREAM queues: defines the maximum size in bytes for individual segment files in the stream's underlying storage. This setting adds the x-stream-max-segment-size-bytes argument to the queue declaration. How it works: RabbitMQ streams store messages in append-only segment files on disk. When a segment reaches the specified size, it is closed and a new segment is created. Smaller segments are rotated more frequently, while larger segments reduce the number of files but increase individual file sizes. Performance implications: Smaller segments (e.g., 100MB-250MB): More frequent rotation, faster deletion of old data when retention policies apply, better for scenarios with frequent retention policy enforcement, but higher file system overhead Larger segments (e.g., 500MB-1GB): Fewer files, reduced I/O overhead, better sequential write performance, but slower retention cleanup and potentially longer recovery times Default behavior: If not specified, RabbitMQ uses a default value of 500MB (524,288,000 bytes), which balances performance and manageability for most workloads. Best practices: Consider your retention period: shorter retention periods benefit from smaller segments for faster cleanup Match to your message rate: high-throughput streams may benefit from larger segments Ensure adequate disk I/O capacity for your chosen segment size Typical range: 100MB to 1GB depending on workload characteristics Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. Leave blank to use the RabbitMQ default (500MB). No - queueExclusive Queue Exclusive If enabled, the queue will be deleted when the connection that declared it closes. Only one consumer can use an exclusive queue. No false queueAutoDelete Queue Auto Delete If enabled, the queue will be automatically deleted when the last consumer disconnects from it. No false queueOverflowStrategy Queue Overflow Strategy Defines the behavior when a queue reaches its maximum length limit (set via maxLength or maxLengthBytes). This setting adds the x-overflow argument to the queue declaration. Options: DROP_HEAD: Automatically discards the oldest messages from the front of the queue to make room for new incoming messages. The queue maintains its maximum size by continuously dropping the oldest data. Publishers are not notified of the drops, and messages are silently discarded without any delivery guarantees. Best for scenarios where recent data is more valuable than old data, such as real-time metrics, live sensor readings, or recent activity feeds where historical data can be safely discarded. REJECT_PUBLISH: Refuses to accept new messages when the queue is full. Publishers receive a negative acknowledgment (basic.return or exception depending on the client), allowing them to handle the rejection (retry, log error, route elsewhere). The queue preserves all existing messages without dropping any. Suitable for workloads where message loss is unacceptable and publishers can implement backpressure handling or alternative routing strategies. REJECT_PUBLISH_DLX: Similar to REJECT_PUBLISH, but rejected messages are automatically routed to the configured Dead Letter Exchange (DLX) instead of being lost. This allows rejected messages to be captured, inspected, and potentially reprocessed later. Requires a DLX to be configured on the queue; otherwise, behaves like REJECT_PUBLISH. Ideal for critical workflows where overflow messages need preservation and manual review, or for implementing overflow queues as a secondary processing tier. Use case guidance: DROP_HEAD: Circular buffers, caching layers, monitoring dashboards, sliding time windows REJECT_PUBLISH: Task queues with strict ordering, financial transactions, systems with explicit backpressure REJECT_PUBLISH_DLX: Audit systems, compliance-sensitive workflows, overflow handling with recovery options Important: This setting applies to CLASSIC and QUORUM queues when length limits are defined. STREAM queues handle overflow through their own retention mechanisms (maxAge, maxLengthBytes). No DROP_HEAD Exchange Properties exchangeArguments Exchange Arguments Additional arguments to customize exchange behavior when declaring the exchange. Specify as comma-separated key=value pairs (e.g., alternate-exchange=my-ae,internal=true). Common exchange arguments: alternate-exchange: Specifies an alternate exchange to route messages that cannot be routed by the primary exchange (no matching bindings). Useful for capturing unroutable messages instead of returning them to the publisher or silently dropping them. Example: alternate-exchange=unrouted-messages internal: When set to true, marks the exchange as internal, preventing direct publishing from clients. Internal exchanges can only receive messages from other exchanges via exchange-to-exchange bindings. Useful for building complex routing topologies. Example: internal=true Format: Use the syntax key1=value1,key2=value2 with no spaces around the equals sign or commas. Boolean values should be specified as true or false. Use cases: Alternate exchanges: Error handling, audit trails for unrouted messages, fallback routing Internal exchanges: Multi-stage routing pipelines, routing abstraction layers, exchange federation Note: Arguments specified here are applied during exchange declaration. If the exchange already exists with different arguments, the declaration will fail unless the arguments match exactly. Leave blank if no custom exchange arguments are needed. No - headerExchangeArguments Header Exchange Binding Arguments For HEADERS exchanges: defines the header matching criteria used to route messages from the exchange to the bound queue. Specify as comma-separated key=value pairs (e.g., x-match=all,format=pdf,type=report). Required argument: x-match: Controls the matching logic for header-based routing. Must be specified for HEADERS exchange bindings. x-match=any: Routes the message if any of the binding headers match the message headers. Acts as a logical OR operation. Example: binding with x-match=any,priority=high,urgent=true will match messages with either priority=high OR urgent=true (or both). x-match=all: Routes the message only if all binding headers match the message headers. Acts as a logical AND operation. Example: binding with x-match=all,format=pdf,type=report requires both format=pdf AND type=report in the message headers for routing to succeed. Additional headers: Any other key=value pairs specified (beyond x-match) define the actual header criteria for matching. Message headers must contain matching key-value pairs according to the x-match logic. Format: Use the syntax x-match=any|all,header1=value1,header2=value2. Header values are case-sensitive and must match exactly. Examples: x-match=all,type=order,priority=high - Matches only messages with both headers x-match=any,region=us,region=eu - Matches messages from either US or EU region x-match=all,format=json - Matches only JSON format messages Important: This setting only applies when using HEADERS exchange type and is ignored for DIRECT, FANOUT, and TOPIC exchanges. Messages are evaluated based on their header properties, not their routing key. No - exchangeAutoDelete Exchange Auto Delete If enabled, the exchange will be automatically deleted when the last queue is unbound from it. No false Other requestCharSet Request Content Encoding (Charset) The content encoding/character set (e.g., UTF-8) used for the message body if the encoding/character set cannot be determined from the request message. No UTF-8 Output responseVariable Output Variable Name Name of the variable to which the output of the operation should be assigned Yes rabbitmq_response_variable1 Sample configuration <rabbitmq.publishMessage configKey="RabbitMQConnection"> <queue>{${payload.queue}}</queue> <queueAutoDeclare>true</queueAutoDeclare> <queueType>QUORUM</queueType> <queueArguments></queueArguments> <deliveryLimit></deliveryLimit> <deadLetterStrategy></deadLetterStrategy> <queueAutoDelete>false</queueAutoDelete> <queueOverflowStrategy>DROP_HEAD</queueOverflowStrategy> <exchange></exchange> <exchangeAutoDeclare>false</exchangeAutoDeclare> <exchangeType>DIRECT</exchangeType> <routingKey></routingKey> <exchangeArguments></exchangeArguments> <exchangeAutoDelete>false</exchangeAutoDelete> <publishTimeout>60000</publishTimeout> <publisherConfirms>true</publisherConfirms> <headers>[]</headers> <requestBodyType>TEXT</requestBodyType> <requestBodyText>${payload.message}</requestBodyText> <requestCharSet></requestCharSet> <responseVariable>rabbitmq_publishMessage_1</responseVariable> <overwriteBody>false</overwriteBody> </rabbitmq.publishMessage> The following properties will be set to a new variable upon receiving a successful acknowledgment (Accept) from the RabbitMQ broker. { "success": "true" "msgid: "urn:uuid:a40ec122-e3eb-4915-aafe-5686f90871eb" } Send RPC RequestThe sendRpc operation allows you to send an RPC request to the RabbitMQ broker. This is a synchronous operation that waits for the response from the broker before proceeding. This is the operation that initiates the dual-channel scenario. Parameter Name Display Name Description Required Default Value RabbitMQ Connection name The name of the RabbitMQ connection configuration to use. Yes - Destination Queue Configuration queue Queue The name of the Queue. Yes - queueType Queue Type Select the type of RabbitMQ queue to interact with: Classic, Quorum (for high availability), or Stream (for large, continuous message flows). Options: CLASSIC, QUORUM, STREAM Yes QUORUM queueType Queue Type Select the type of RabbitMQ queue to interact with. Options: CLASSIC: The traditional RabbitMQ queue type with support for all messaging patterns and features. Offers flexibility and full protocol compatibility but provides limited fault tolerance as queues are stored on a single node. Suitable for development, testing, or non-critical workloads where high availability is not required. QUORUM: A replicated queue type built on the Raft consensus algorithm, providing high availability and data safety through replication across multiple cluster nodes. Automatically handles leader election and failover. Designed for critical workloads requiring message durability and resilience against node failures. Recommended for production environments where message loss is unacceptable. Note: Does not support all classic queue features (e.g., priority queues, message TTL at message level). STREAM: A persistent, append-only log structure optimized for high-throughput, large-volume message flows with non-destructive consumption. Messages are retained on disk and can be consumed multiple times by different consumers from any offset. Ideal for event streaming, audit logs, time-series data, and scenarios requiring message replay or long-term retention. Requires RabbitMQ 3.9+ and uses a different consumption model than traditional queues. No QUORUM Reply-To Queue Configuration replyToQueue Reply-To Queue The name of the Reply-To Queue. Yes - replyToQueueType Reply-To Queue Type Select the type of RabbitMQ queue to interact with. Options: CLASSIC: The traditional RabbitMQ queue type with support for all messaging patterns and features. Offers flexibility and full protocol compatibility but provides limited fault tolerance as queues are stored on a single node. Suitable for development, testing, or non-critical workloads where high availability is not required. QUORUM: A replicated queue type built on the Raft consensus algorithm, providing high availability and data safety through replication across multiple cluster nodes. Automatically handles leader election and failover. Designed for critical workloads requiring message durability and resilience against node failures. Recommended for production environments where message loss is unacceptable. Note: Does not support all classic queue features (e.g., priority queues, message TTL at message level). STREAM: A persistent, append-only log structure optimized for high-throughput, large-volume message flows with non-destructive consumption. Messages are retained on disk and can be consumed multiple times by different consumers from any offset. Ideal for event streaming, audit logs, time-series data, and scenarios requiring message replay or long-term retention. Requires RabbitMQ 3.9+ and uses a different consumption model than traditional queues. Yes QUORUM replyToQueueAutoDeclare Reply-To Queue Auto Declare If enabled, the connector will attempt to declare the specified queue on the RabbitMQ server if it doesn't already exist. No true Request Message Configuration headers Request Headers Key value pairs for headers No - requestBodyType Request Content Type The content type of the request body. Options: JSON, XML, TEXT No JSON requestBodyJson Request Body Request body when content type is JSON No {payload}</td> </tr> <tr> <td>requestBodyXml</td> <td>Request Body</td> <td>Request body when content type is XML</td> <td>No</td> <td>{xpath('body/node()')}</td> </tr> <tr> <td>requestBodyText</td> <td>Request Body</td> <td>Request body when content type is TEXT</td> <td>No</td> <td> RPC Client Configuration requestTimeout Request Timeout (ms) The maximum time (in milliseconds) to wait for sending the RPC request. No 60000 Response Message Configuration responseBodyType Response Content Type Set the desired content type for the response if the content type cannot be determined from the RabbitMQ response message. Options: JSON, XML, TEXT No JSON Queue Properties queueArguments Queue Arguments Additional arguments to customize queue behavior when declaring the queue. Specify as comma-separated key=value pairs (e.g., x-message-ttl=60000,x-max-length=1000). Common queue arguments: x-message-ttl: Sets the time-to-live (TTL) for messages in milliseconds. Messages older than this value are automatically discarded or dead-lettered. Example: x-message-ttl=60000 (1 minute). Useful for time-sensitive data like session tokens or temporary notifications. x-max-length: Limits the maximum number of messages the queue can hold. When exceeded, the overflow strategy (see queueOverflowStrategy) determines what happens. Example: x-max-length=10000. Prevents unbounded queue growth. x-max-length-bytes: Limits the maximum total size of messages in bytes. Alternative to message count limit. Example: x-max-length-bytes=10485760 (10MB). Useful for controlling memory usage. x-dead-letter-exchange: Specifies the exchange to route dead-lettered messages (expired, rejected, or exceeding delivery limits). Example: x-dead-letter-exchange=dlx. Essential for handling failed or problematic messages. x-dead-letter-routing-key: Optional routing key for dead-lettered messages. If not set, the original routing key is used. Example: x-dead-letter-routing-key=failed.orders. x-expires: Auto-deletes the queue after specified milliseconds of inactivity (no consumers, no messages published). Example: x-expires=1800000 (30 minutes). Useful for temporary or session-based queues. x-single-active-consumer: When set to true, ensures only one consumer receives messages at a time (others are on standby). Example: x-single-active-consumer=true. Useful for ordered processing or leader election patterns. Format: Use the syntax key1=value1,key2=value2 with no spaces. Numeric values should be in milliseconds for time-based arguments or plain integers/bytes for counts and sizes. Boolean values should be true or false. Note: Arguments specified here are applied during queue declaration. If the queue already exists with different arguments, the declaration will fail unless the arguments match exactly. Some arguments are queue-type specific (e.g., x-max-priority for CLASSIC queues only). Leave blank if no custom queue arguments are needed. No - rabbitmq.classic.version Queue Version For Classic Queues, select the queue implementation version. Options: V1: The legacy classic queue implementation available in all RabbitMQ versions. Uses the original message storage and indexing mechanism. While mature and stable, it has known performance limitations with large queues, high message rates, and memory efficiency. Consider using V1 only for backward compatibility or if running RabbitMQ versions prior to 3.10. V2: The modern classic queue implementation introduced in RabbitMQ 3.10, also known as CQv2 (Classic Queue version 2). Provides significantly improved performance, memory efficiency, and scalability through optimized message storage and reduced per-message overhead. Offers better handling of large queues (millions of messages) and higher throughput. Recommended for all new deployments and production workloads running RabbitMQ 3.10 or later. Note: Once a queue is created with a specific version, it cannot be changed without recreating the queue. Important: This setting only applies to CLASSIC queue types and is ignored for QUORUM and STREAM queues. No V2 maxPriority Queue Max Priority For Classic Queues: defines the maximum priority level the queue should support (valid range: 0-255). When set, this parameter adds the x-max-priority argument to the queue declaration, enabling priority queue functionality. How it works: Messages published with a priority value (0 to the specified max) are delivered to consumers in priority order, with higher priority messages consumed first. Messages without an explicit priority are treated as priority 0 (lowest). Performance considerations: Priority queues have additional CPU and memory overhead compared to standard queues. Higher max priority values increase this overhead. For most use cases, a max priority of 10 or less is sufficient and recommended. Use cases: Suitable for scenarios requiring differentiated message handling, such as urgent alerts, high-priority transactions, or tiered job processing systems. Important: Priority queues are only supported by CLASSIC queues. This setting is ignored for QUORUM and STREAM queue types. Leave empty or set to 0 to disable priority functionality. No - initialMemberCount Queue Initial Member Count Specifies the initial number of cluster nodes that will host replicas of the queue. This setting applies differently based on queue type: For Quorum Queues: Defines the initial replication factor (number of replica nodes) for the queue. The default is 3 replicas if not specified, which provides a good balance between availability and resource usage. Quorum queues require a majority (quorum) of replicas to be available for operation. For example, with 3 replicas, the queue tolerates 1 node failure; with 5 replicas, it tolerates 2 node failures. Higher replica counts improve fault tolerance but increase network overhead and resource consumption. For Stream Queues: Determines the initial number of stream replicas across cluster nodes. Similar to quorum queues, this affects data redundancy and availability. Streams use leader-based replication where one replica is the leader handling writes, while followers replicate data. Considerations: The cluster must have at least as many nodes as the specified member count Odd numbers (3, 5, 7) are recommended for quorum-based systems to avoid split-brain scenarios Leave blank to use RabbitMQ's default behavior (typically 3 replicas) Important: This setting only applies to QUORUM and STREAM queue types and is ignored for CLASSIC queues. No - deliveryLimit Queue Delivery Limit For Quorum Queues: defines the maximum number of delivery attempts for a message before it is automatically dead-lettered or discarded. This setting adds the x-delivery-limit argument to the queue declaration. How it works: When a message is negatively acknowledged (nack/reject) or requeued by a consumer, RabbitMQ increments its delivery counter. Once the delivery count reaches the specified limit, the message is either moved to a configured dead letter exchange (DLX) or dropped if no DLX is configured. Use cases: Prevents poison messages (messages that repeatedly fail processing) from blocking the queue indefinitely. Essential for building resilient systems where problematic messages can be isolated for manual inspection or alternative handling without affecting other messages. Best practices: Always configure a dead letter exchange when using delivery limits to capture failed messages for analysis Typical values range from 3-10 depending on your tolerance for retries Consider implementing exponential backoff in consumers before relying solely on delivery limits Important: This setting only applies to QUORUM queue types and is ignored for CLASSIC and STREAM queues. Leave blank to disable delivery limit enforcement (messages can be redelivered indefinitely). No - deadLetterStrategy Quorum Queue Dead Letter Strategy For Quorum Queues: defines how messages are handled when being dead-lettered, controlling the delivery guarantee semantics. This setting adds the x-dead-letter-strategy argument to the queue declaration. Options: AT_MOST_ONCE: The default and safer strategy. Messages are removed from the original queue before being published to the dead letter exchange (DLX). This guarantees that a message will not be duplicated if the dead-lettering process fails - it will either be in the original queue or successfully dead-lettered, but never in both. However, in case of broker failure during dead-lettering, the message may be lost. Recommended for most use cases where preventing duplicate processing is more critical than preventing message loss. AT_LEAST_ONCE: Messages are published to the dead letter exchange first, then removed from the original queue only after successful publication. This ensures no message is lost during the dead-lettering process, but in case of failures, the same message might be dead-lettered multiple times, resulting in duplicates in the DLX. Use this when message loss is unacceptable and your downstream systems can handle duplicate messages (idempotent processing). Trade-offs: AT_MOST_ONCE: Prevents duplicates, risks message loss on failure AT_LEAST_ONCE: Prevents message loss, risks duplicates on failure Important: This setting only applies to QUORUM queue types and requires a dead letter exchange to be configured. It is ignored for CLASSIC and STREAM queues. No AT_MOST_ONCE maxAge Queue Max Age For STREAM queues: defines the maximum time-based retention period for messages in the stream. This setting adds the x-max-age argument to the queue declaration. How it works: Messages older than the specified age are automatically deleted from the stream to manage disk space. Age is calculated from the message timestamp. The retention policy is evaluated periodically, not in real-time, so messages may persist slightly beyond the specified age. Format: Specify the duration using time units: Y - Years (e.g., 1Y) M - Months (e.g., 3M) D - Days (e.g., 7D) h - Hours (e.g., 24h) m - Minutes (e.g., 30m) s - Seconds (e.g., 3600s) Use cases: Essential for managing storage costs and compliance requirements in event streaming scenarios. For example, audit logs might retain data for 90 days, while real-time analytics streams might only need 24 hours. Considerations: Can be combined with maxLengthBytes - whichever limit is reached first triggers deletion Deleted messages cannot be recovered Leave blank for unlimited retention (not recommended for production - may exhaust disk space) Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. No - maxSegmentSize Queue Max Segment Size (Bytes) For STREAM queues: defines the maximum size in bytes for individual segment files in the stream's underlying storage. This setting adds the x-stream-max-segment-size-bytes argument to the queue declaration. How it works: RabbitMQ streams store messages in append-only segment files on disk. When a segment reaches the specified size, it is closed and a new segment is created. Smaller segments are rotated more frequently, while larger segments reduce the number of files but increase individual file sizes. Performance implications: Smaller segments (e.g., 100MB-250MB): More frequent rotation, faster deletion of old data when retention policies apply, better for scenarios with frequent retention policy enforcement, but higher file system overhead Larger segments (e.g., 500MB-1GB): Fewer files, reduced I/O overhead, better sequential write performance, but slower retention cleanup and potentially longer recovery times Default behavior: If not specified, RabbitMQ uses a default value of 500MB (524,288,000 bytes), which balances performance and manageability for most workloads. Best practices: Consider your retention period: shorter retention periods benefit from smaller segments for faster cleanup Match to your message rate: high-throughput streams may benefit from larger segments Ensure adequate disk I/O capacity for your chosen segment size Typical range: 100MB to 1GB depending on workload characteristics Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. Leave blank to use the RabbitMQ default (500MB). No - queueExclusive Queue Exclusive If enabled, the queue will be deleted when the connection that declared it closes. Only one consumer can use an exclusive queue. No false queueAutoDelete Queue Auto Delete If enabled, the queue will be automatically deleted when the last consumer disconnects from it. No false queueOverflowStrategy Queue Overflow Strategy Defines the behavior when a queue reaches its maximum length limit (set via maxLength or maxLengthBytes). This setting adds the x-overflow argument to the queue declaration. Options: DROP_HEAD: Automatically discards the oldest messages from the front of the queue to make room for new incoming messages. The queue maintains its maximum size by continuously dropping the oldest data. Publishers are not notified of the drops, and messages are silently discarded without any delivery guarantees. Best for scenarios where recent data is more valuable than old data, such as real-time metrics, live sensor readings, or recent activity feeds where historical data can be safely discarded. REJECT_PUBLISH: Refuses to accept new messages when the queue is full. Publishers receive a negative acknowledgment (basic.return or exception depending on the client), allowing them to handle the rejection (retry, log error, route elsewhere). The queue preserves all existing messages without dropping any. Suitable for workloads where message loss is unacceptable and publishers can implement backpressure handling or alternative routing strategies. REJECT_PUBLISH_DLX: Similar to REJECT_PUBLISH, but rejected messages are automatically routed to the configured Dead Letter Exchange (DLX) instead of being lost. This allows rejected messages to be captured, inspected, and potentially reprocessed later. Requires a DLX to be configured on the queue; otherwise, behaves like REJECT_PUBLISH. Ideal for critical workflows where overflow messages need preservation and manual review, or for implementing overflow queues as a secondary processing tier. Use case guidance: DROP_HEAD: Circular buffers, caching layers, monitoring dashboards, sliding time windows REJECT_PUBLISH: Task queues with strict ordering, financial transactions, systems with explicit backpressure REJECT_PUBLISH_DLX: Audit systems, compliance-sensitive workflows, overflow handling with recovery options Important: This setting applies to CLASSIC and QUORUM queues when length limits are defined. STREAM queues handle overflow through their own retention mechanisms (maxAge, maxLengthBytes). No DROP_HEAD Reply-To Queue Properties replyToQueueArguments Reply-To Queue Arguments Additional arguments to customize queue behavior when declaring the queue. Specify as comma-separated key=value pairs (e.g., x-message-ttl=60000,x-max-length=1000). Common queue arguments: x-message-ttl: Sets the time-to-live (TTL) for messages in milliseconds. Messages older than this value are automatically discarded or dead-lettered. Example: x-message-ttl=60000 (1 minute). Useful for time-sensitive data like session tokens or temporary notifications. x-max-length: Limits the maximum number of messages the queue can hold. When exceeded, the overflow strategy (see queueOverflowStrategy) determines what happens. Example: x-max-length=10000. Prevents unbounded queue growth. x-max-length-bytes: Limits the maximum total size of messages in bytes. Alternative to message count limit. Example: x-max-length-bytes=10485760 (10MB). Useful for controlling memory usage. x-dead-letter-exchange: Specifies the exchange to route dead-lettered messages (expired, rejected, or exceeding delivery limits). Example: x-dead-letter-exchange=dlx. Essential for handling failed or problematic messages. x-dead-letter-routing-key: Optional routing key for dead-lettered messages. If not set, the original routing key is used. Example: x-dead-letter-routing-key=failed.orders. x-expires: Auto-deletes the queue after specified milliseconds of inactivity (no consumers, no messages published). Example: x-expires=1800000 (30 minutes). Useful for temporary or session-based queues. x-single-active-consumer: When set to true, ensures only one consumer receives messages at a time (others are on standby). Example: x-single-active-consumer=true. Useful for ordered processing or leader election patterns. Format: Use the syntax key1=value1,key2=value2 with no spaces. Numeric values should be in milliseconds for time-based arguments or plain integers/bytes for counts and sizes. Boolean values should be true or false. Note: Arguments specified here are applied during queue declaration. If the queue already exists with different arguments, the declaration will fail unless the arguments match exactly. Some arguments are queue-type specific (e.g., x-max-priority for CLASSIC queues only). Leave blank if no custom queue arguments are needed. No - replyToQueueClassicVersion Reply-To Queue Version For Classic Queues, select the queue implementation version. Options: V1: The legacy classic queue implementation available in all RabbitMQ versions. Uses the original message storage and indexing mechanism. While mature and stable, it has known performance limitations with large queues, high message rates, and memory efficiency. Consider using V1 only for backward compatibility or if running RabbitMQ versions prior to 3.10. V2: The modern classic queue implementation introduced in RabbitMQ 3.10, also known as CQv2 (Classic Queue version 2). Provides significantly improved performance, memory efficiency, and scalability through optimized message storage and reduced per-message overhead. Offers better handling of large queues (millions of messages) and higher throughput. Recommended for all new deployments and production workloads running RabbitMQ 3.10 or later. Note: Once a queue is created with a specific version, it cannot be changed without recreating the queue. Important: This setting only applies to CLASSIC queue types and is ignored for QUORUM and STREAM queues. No - replyToQueueMaxPriority Reply-To Queue Max Priority For Classic Queues: defines the maximum priority level the queue should support (valid range: 0-255). When set, this parameter adds the x-max-priority argument to the queue declaration, enabling priority queue functionality. How it works: Messages published with a priority value (0 to the specified max) are delivered to consumers in priority order, with higher priority messages consumed first. Messages without an explicit priority are treated as priority 0 (lowest). Performance considerations: Priority queues have additional CPU and memory overhead compared to standard queues. Higher max priority values increase this overhead. For most use cases, a max priority of 10 or less is sufficient and recommended. Use cases: Suitable for scenarios requiring differentiated message handling, such as urgent alerts, high-priority transactions, or tiered job processing systems. Important: Priority queues are only supported by CLASSIC queues. This setting is ignored for QUORUM and STREAM queue types. Leave empty or set to 0 to disable priority functionality. No - replyToQueueInitialMemberCount Reply-To Queue Initial Member Count Specifies the initial number of cluster nodes that will host replicas of the queue. This setting applies differently based on queue type: For Quorum Queues: Defines the initial replication factor (number of replica nodes) for the queue. The default is 3 replicas if not specified, which provides a good balance between availability and resource usage. Quorum queues require a majority (quorum) of replicas to be available for operation. For example, with 3 replicas, the queue tolerates 1 node failure; with 5 replicas, it tolerates 2 node failures. Higher replica counts improve fault tolerance but increase network overhead and resource consumption. For Stream Queues: Determines the initial number of stream replicas across cluster nodes. Similar to quorum queues, this affects data redundancy and availability. Streams use leader-based replication where one replica is the leader handling writes, while followers replicate data. Considerations: The cluster must have at least as many nodes as the specified member count Odd numbers (3, 5, 7) are recommended for quorum-based systems to avoid split-brain scenarios Leave blank to use RabbitMQ's default behavior (typically 3 replicas) Important: This setting only applies to QUORUM and STREAM queue types and is ignored for CLASSIC queues. No - replyToQueueDeliveryLimit Reply-To Queue Delivery Limit For Quorum Queues: defines the maximum number of delivery attempts for a message before it is automatically dead-lettered or discarded. This setting adds the x-delivery-limit argument to the queue declaration. How it works: When a message is negatively acknowledged (nack/reject) or requeued by a consumer, RabbitMQ increments its delivery counter. Once the delivery count reaches the specified limit, the message is either moved to a configured dead letter exchange (DLX) or dropped if no DLX is configured. Use cases: Prevents poison messages (messages that repeatedly fail processing) from blocking the queue indefinitely. Essential for building resilient systems where problematic messages can be isolated for manual inspection or alternative handling without affecting other messages. Best practices: Always configure a dead letter exchange when using delivery limits to capture failed messages for analysis Typical values range from 3-10 depending on your tolerance for retries Consider implementing exponential backoff in consumers before relying solely on delivery limits Important: This setting only applies to QUORUM queue types and is ignored for CLASSIC and STREAM queues. Leave blank to disable delivery limit enforcement (messages can be redelivered indefinitely). No - replyToQueueDeadLetterStrategy Reply-To Queue Dead Letter Strategy For Quorum Queues: defines how messages are handled when being dead-lettered, controlling the delivery guarantee semantics. This setting adds the x-dead-letter-strategy argument to the queue declaration. Options: AT_MOST_ONCE: The default and safer strategy. Messages are removed from the original queue before being published to the dead letter exchange (DLX). This guarantees that a message will not be duplicated if the dead-lettering process fails - it will either be in the original queue or successfully dead-lettered, but never in both. However, in case of broker failure during dead-lettering, the message may be lost. Recommended for most use cases where preventing duplicate processing is more critical than preventing message loss. AT_LEAST_ONCE: Messages are published to the dead letter exchange first, then removed from the original queue only after successful publication. This ensures no message is lost during the dead-lettering process, but in case of failures, the same message might be dead-lettered multiple times, resulting in duplicates in the DLX. Use this when message loss is unacceptable and your downstream systems can handle duplicate messages (idempotent processing). Trade-offs: AT_MOST_ONCE: Prevents duplicates, risks message loss on failure AT_LEAST_ONCE: Prevents message loss, risks duplicates on failure Important: This setting only applies to QUORUM queue types and requires a dead letter exchange to be configured. It is ignored for CLASSIC and STREAM queues. No - replyToQueueMaxAge Reply-To Queue Max Age For STREAM queues: defines the maximum time-based retention period for messages in the stream. This setting adds the x-max-age argument to the queue declaration. How it works: Messages older than the specified age are automatically deleted from the stream to manage disk space. Age is calculated from the message timestamp. The retention policy is evaluated periodically, not in real-time, so messages may persist slightly beyond the specified age. Format: Specify the duration using time units: Y - Years (e.g., 1Y) M - Months (e.g., 3M) D - Days (e.g., 7D) h - Hours (e.g., 24h) m - Minutes (e.g., 30m) s - Seconds (e.g., 3600s) Use cases: Essential for managing storage costs and compliance requirements in event streaming scenarios. For example, audit logs might retain data for 90 days, while real-time analytics streams might only need 24 hours. Considerations: Can be combined with maxLengthBytes - whichever limit is reached first triggers deletion Deleted messages cannot be recovered Leave blank for unlimited retention (not recommended for production - may exhaust disk space) Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. No - replyToQueueMaxSegmentSize Reply-To Queue Max Segment Size (Bytes) For STREAM queues: defines the maximum size in bytes for individual segment files in the stream's underlying storage. This setting adds the x-stream-max-segment-size-bytes argument to the queue declaration. How it works: RabbitMQ streams store messages in append-only segment files on disk. When a segment reaches the specified size, it is closed and a new segment is created. Smaller segments are rotated more frequently, while larger segments reduce the number of files but increase individual file sizes. Performance implications: Smaller segments (e.g., 100MB-250MB): More frequent rotation, faster deletion of old data when retention policies apply, better for scenarios with frequent retention policy enforcement, but higher file system overhead Larger segments (e.g., 500MB-1GB): Fewer files, reduced I/O overhead, better sequential write performance, but slower retention cleanup and potentially longer recovery times Default behavior: If not specified, RabbitMQ uses a default value of 500MB (524,288,000 bytes), which balances performance and manageability for most workloads. Best practices: Consider your retention period: shorter retention periods benefit from smaller segments for faster cleanup Match to your message rate: high-throughput streams may benefit from larger segments Ensure adequate disk I/O capacity for your chosen segment size Typical range: 100MB to 1GB depending on workload characteristics Important: This setting only applies to STREAM queue types and is ignored for CLASSIC and QUORUM queues. Leave blank to use the RabbitMQ default (500MB). No - replyToQueueExclusive Reply-To Queue Exclusive If enabled, the queue will be deleted when the connection that declared it closes. Only one consumer can use an exclusive queue. No false replyToQueueAutoDelete Reply-To Queue Auto Delete If enabled, the queue will be automatically deleted when the last consumer disconnects from it. No false replyToQueueOverflowStrategy Reply-To Queue Overflow Strategy Defines the behavior when a queue reaches its maximum length limit (set via maxLength or maxLengthBytes). This setting adds the x-overflow argument to the queue declaration. Options: DROP_HEAD: Automatically discards the oldest messages from the front of the queue to make room for new incoming messages. The queue maintains its maximum size by continuously dropping the oldest data. Publishers are not notified of the drops, and messages are silently discarded without any delivery guarantees. Best for scenarios where recent data is more valuable than old data, such as real-time metrics, live sensor readings, or recent activity feeds where historical data can be safely discarded. REJECT_PUBLISH: Refuses to accept new messages when the queue is full. Publishers receive a negative acknowledgment (basic.return or exception depending on the client), allowing them to handle the rejection (retry, log error, route elsewhere). The queue preserves all existing messages without dropping any. Suitable for workloads where message loss is unacceptable and publishers can implement backpressure handling or alternative routing strategies. REJECT_PUBLISH_DLX: Similar to REJECT_PUBLISH, but rejected messages are automatically routed to the configured Dead Letter Exchange (DLX) instead of being lost. This allows rejected messages to be captured, inspected, and potentially reprocessed later. Requires a DLX to be configured on the queue; otherwise, behaves like REJECT_PUBLISH. Ideal for critical workflows where overflow messages need preservation and manual review, or for implementing overflow queues as a secondary processing tier. Use case guidance: DROP_HEAD: Circular buffers, caching layers, monitoring dashboards, sliding time windows REJECT_PUBLISH: Task queues with strict ordering, financial transactions, systems with explicit backpressure REJECT_PUBLISH_DLX: Audit systems, compliance-sensitive workflows, overflow handling with recovery options Important: This setting applies to CLASSIC and QUORUM queues when length limits are defined. STREAM queues handle overflow through their own retention mechanisms (maxAge, maxLengthBytes). No DROP_HEAD Other requestCharSet Request Content Encoding (Charset) The content encoding/character set (e.g., UTF-8) used for the message body if the encoding/character set cannot be determined from the request message. No - responseCharSet Response Content Encoding (Charset) The content encoding/character set (e.g., UTF-8) used for the message body if the encoding/character set cannot be determined from the response message. No - Output responseVariable Output Variable Name Name of the variable to which the output of the operation should be assigned Yes - overwriteBody Overwrite Message Body Replace the Message Body in Message Context with the output of the operation (This will remove the payload from the above variable). No false Sample configuration <rabbitmq.sendRpc configKey="RabbitMQConnection"> <headers>[]</headers> <requestBodyType>JSON</requestBodyType> <requestBodyJson>${payload.message}</requestBodyJson> <responseBodyType>JSON</responseBodyType> <requestCharSet></requestCharSet> <responseCharSet></responseCharSet> <queue>{${payload.queue}}</queue> <queueAutoDeclare>true</queueAutoDeclare> <queueType>QUORUM</queueType> <queueArguments></queueArguments> <deliveryLimit></deliveryLimit> <deadLetterStrategy></deadLetterStrategy> <queueAutoDelete>false</queueAutoDelete> <queueOverflowStrategy>DROP_HEAD</queueOverflowStrategy> <replyToQueue>{${payload.reply-to-queue}}</replyToQueue> <replyToQueueAutoDeclare>true</replyToQueueAutoDeclare> <replyToQueueType>QUORUM</replyToQueueType> <replyToQueueArguments></replyToQueueArguments> <replyToQueueDeliveryLimit></replyToQueueDeliveryLimit> <replyToQueueDeadLetterStrategy></replyToQueueDeadLetterStrategy> <replyToQueueAutoDelete>false</replyToQueueAutoDelete> <replyToQueueOverflowStrategy>DROP_HEAD</replyToQueueOverflowStrategy> <requestTimeout>60000</requestTimeout> <responseVariable>rabbitmq_sendRpc_1</responseVariable> <overwriteBody>true</overwriteBody> </rabbitmq.sendRpc> The response from the RabbitMQ broker will be stored in a new variable if the overwriteBody property is set to false. The variable name will be taken from the responseVariable property. If overwriteBody is set to true, the response will replace the existing message body in the message context, and the responseVariable property will not be used to store the output. Message Acknowledgment Operations¶ The following operations can be used with the RabbitMQ inbound endpoint to handle message acknowledgments from RabbitMQ queues. These operations enable you to control message flow and ensure messages are processed correctly. Note These operations do not require a configured RabbitMQ connection, as they handle acknowledgments at the MI server level. Accept MessageThe accept operation allows you to acknowledge the message with the AMQP 1.0 ‘Accepted’ outcome. This indicates that the message has been successfully processed and that the broker can safely remove it from the queue. Parameter Name Display Name Description Required Default Value Output responseVariable Output Variable Name Name of the variable to which the output of the operation should be assigned Yes Sample configuration <rabbitmq.accept> <responseVariable>rabbitmq_accept_1</responseVariable> <overwriteBody>false</overwriteBody> </rabbitmq.accept> This operation will acknowledge the message as accepted, allowing the RabbitMQ broker to remove it from the queue. The response from the acknowledgment operation will be stored in a new variable named rabbitmq_accept_1. Requeue MessageThe requeue operation allows you to release the message with the AMQP 1.0 'Released' outcome. This indicates the message was not processed, and the broker can requeue it for delivery to the same or a different consumer. Parameter Name Display Name Description Required Default Value Output responseVariable Output Variable Name Name of the variable to which the output of the operation should be assigned Yes Sample configuration <rabbitmq.requeue> <responseVariable>rabbitmq_requeue_1</responseVariable> <overwriteBody>false</overwriteBody> </rabbitmq.requeue> This operation will acknowledge the message as released, indicating to the RabbitMQ broker that the message was not processed and that the broker can requeue it for delivery to the same or a different consumer. The response from the acknowledgment operation will be stored in a new variable named rabbitmq_requeue_1. Discard MessageThe discard operation allows you to reject the message with the AMQP 1.0 'Rejected' outcome. This indicates the message is invalid, and the broker can either discard it or move it to a dead-letter queue if configured. Parameter Name Display Name Description Required Default Value Output responseVariable Output Variable Name Name of the variable to which the output of the operation should be assigned Yes Sample configuration <rabbitmq.discard> <responseVariable>rabbitmq_discard_1</responseVariable> <overwriteBody>false</overwriteBody> </rabbitmq.discard> This operation will acknowledge the message as discarded, indicating that the message is invalid. The broker can either discard it or move it to a dead-letter queue if configured. The response from the acknowledgment operation will be stored in a new variable named rabbitmq_discard_1.