This plugin adds delayed-messaging (or scheduled-messaging) to RabbitMQ. Its current design has plenty of limitation (documented below), consider using an external scheduler and a data store that fits your needs first.
This plugin badly needs a new design and a reimplementation from the ground up.
If you accept the limitations, please read on.
With this plugin enabled, a user can declare an exchange with the type x-delayed-message and
then publish messages with the custom header x-delay expressing in
milliseconds a delay time for the message. The message will be
delivered to the respective queues after x-delay milliseconds.
This plugin was designed for delaying message publishing for a number of seconds, minutes, or hours. A day or two at most.
It is not a longer term scheduling solution. If you need to delay publishing by days, weeks, months, or years, consider using a data store suitable for long-term storage, and an external scheduling tool of some kind.
The most recent release of this plugin targets RabbitMQ 3.12.x.
The latest version of this plugin requires Erlang 25.0 or later versions, same as RabbitMQ 3.12.x.
The current design of this plugin is mature and potential suitable for production use as long as the user is aware of its limitations and the intended use cases.
This plugin is not commercially supported by VMware at the moment but it doesn't mean that it will be abandoned or team RabbitMQ is not interested in improving it in the future. It is not, however, a high priority for our small team.
So, give it a try with your workload and decide for yourself.
Binary builds are distributed via GitHub releases.
As with all 3rd party plugins, the .ez file must be placed into a node's plugins directory
and be readable by the effective user of the RabbitMQ process.
To find out what the plugins directory is, use rabbitmq-plugins directories
rabbitmq-plugins directories -sThen run the following command:
rabbitmq-plugins enable rabbitmq_delayed_message_exchangeTo use the delayed-messaging feature, declare an exchange with the
type x-delayed-message:
// ... elided code ...
Map<String, Object> args = new HashMap<String, Object>();
args.put("x-delayed-type", "direct");
channel.exchangeDeclare("my-exchange", "x-delayed-message", true, false, args);
// ... more code ...Note that we pass an extra header called x-delayed-type, more on it
under the Routing section.
Once we have the exchange declared we can publish messages providing a header telling the plugin for how long to delay our messages:
// ... elided code ...
byte[] messageBodyBytes = "delayed payload".getBytes("UTF-8");
Map<String, Object> headers = new HashMap<String, Object>();
headers.put("x-delay", 5000);
AMQP.BasicProperties.Builder props = new AMQP.BasicProperties.Builder().headers(headers);
channel.basicPublish("my-exchange", "", props.build(), messageBodyBytes);
byte[] messageBodyBytes2 = "more delayed payload".getBytes("UTF-8");
Map<String, Object> headers2 = new HashMap<String, Object>();
headers2.put("x-delay", 1000);
AMQP.BasicProperties.Builder props2 = new AMQP.BasicProperties.Builder().headers(headers2);
channel.basicPublish("my-exchange", "", props2.build(), messageBodyBytes2);
// ... more code ...In the above example we publish two messages, specifying the delay
time with the x-delay header. For this example, the plugin will
deliver to our queues first the message with the body "more delayed payload" and then the one with the body "delayed payload".
If the x-delay header is not present, then the plugin will proceed
to route the message without delay.
This plugin allows for flexible routing via the x-delayed-type
arguments that can be passed during exchange.declare. In the example
above we used "direct" as exchange type. That means the plugin
will have the same routing behavior shown by the direct exchange.
If you want a different routing behavior, then you could provide a
different exchange type, like "topic" for example. You can also
specify exchange types provided by plugins. Note that this argument is
required and must refer to an existing exchange type.
Due to the "x-delayed-type" argument, one could use this exchange in
place of other exchanges, since the "x-delayed-message" exchange
will just act as proxy. Note that there might be some performance
implications if you do this.
For each message that crosses an "x-delayed-message" exchange, the
plugin will try to determine if the message has to be expired by
making sure the delay is within range, ie: Delay > 0, Delay =< ?ERL_MAX_T (In Erlang a timer can be set up to (2^32)-1 milliseconds
in the future).
If the previous condition holds, then the message will be persisted to Mnesia and some other logic will kick in to determine if this particular message delay needs to replace the current scheduled timer and so on.
This means that while one could use this exchange in place of a direct or fanout exchange (or any other exchange for that matter), it will be slower than using the actual exchange. If you don't need to delay messages, then use the actual exchange.
Delayed messages are stored in a Mnesia table (also see Limitations below) with a single disk replica on the current node. They will survive a node restart. While timer(s) that triggered scheduled delivery are not persisted, it will be re-initialised during plugin activation on node start. Obviously, only having one copy of a scheduled message in a cluster means that losing that node or disabling the plugin on it will lose the messages residing on that node.
This plugin was created with disk nodes in mind. RAM nodes are currently unsupported and adding support for them is not a priority (if you aren't sure what RAM nodes are and whether you need to use them, you almost certainly don't).
The plugin only performs one attempt at publishing each message but since publishing is local, in practice the only issue that may prevent delivery is the lack of queues (or bindings) to route to.
Closely related to the above, the mandatory flag is not supported by this exchange: we cannot be sure that at the future publishing point in time
- there is at least one queue we can route to
- the original connection is still around to send a
basic.returnto
Current design of this plugin doesn't really fit scenarios with a high number of delayed messages (e.g. 100s of thousands or millions). See #72 for details.
You can disable this plugin by calling rabbitmq-plugins disable rabbitmq_delayed_message_exchange but note that ALL DELAYED MESSAGES THAT
HAVEN'T BEEN DELIVERED WILL BE LOST.
bazel build //:erlang_app
bazel build :ezThe EZ file is created in the bazel-bin directory.
- Update
broker_version_requirementsinhelpers.bzl&Makefile(Optional) - Update the plugin version in
MODULE.bazel - Push a tag (i.e.
v3.12.0) with the matching version - Allow the Release workflow to run and create a draft release
- Review and publish the release
See the LICENSE file.