ActiveMQ Reviews

We are using ActiveMQ in our customers' companies, so all of the integrations are there. We use this solution for microservices intercommunication.

ActiveMQ is very lightweight and quick.

For Kafka, we mainly use it for event sourcing. We have huge concurrent events. From the TPS point of view, it's like 100,000 transactions that need to be admitted from different devices and also from the different minor small systems. Those are best fit for Kafka. We have used it on the customer side, and we thought of giving a try to ActiveMQ, but we have to do a lot of performance tests and approval is required before we can use it for this scale. I think Kafka is best suited for the concurrent high volume of events.

If these capabilities can be incorporated into ActiveMQ, it would be good to not have to use a second product. As a Q technology, everything in ActiveMQ works perfectly. But if that aspect of Kafka can be integrated or be a sub-component of ActiveMQ, it would be really great for enterprise-wide users.

We have been using this solution for three years.

The product is very stable. We haven't had any issues so far.

It's absolutely scalable. We are using the broker technology.

We don't have any subscription because we use the open-source version. But there have been a few queries around it, like if there's any support group that can provide commercial support. We were not able to find any company in the region with the support and upgrade patching, etc.

Before using this solution, we worked with IBM MQ more than four years ago. We switched because the first issue was scalability. I'm not sure about the current version, but when our team was working on the older version, scalability was one bottleneck. Second, we had challenges with the upgrades. From version six to seven, it was a challenge.

Initial setup was very easy. We used the containerized version. It took less than 30 seconds or so to boot the containers.

We are using the open-source version, so we have not looked at any pricing.

I would give this solution 10 out of 10.

It's a very easy-to-use product. Documentation is sufficient, and anyone with a bit of knowledge about technology, like Java, can quickly set it up and it could be up and running in minutes.

Most architecture nowadays requires too much performance. We can use products like ActiveMQ to improve our architecture.

I implemented a micro-services based architecture and did some of the communication via queues. I used actors with the Akka framework, and not only threads in Java.

The most important feature is that it's best for JVM-related languages and JMS integration.

The product is really straightforward. All the operations that you use are pretty simple and worked fine.

The deal is to write the correct logic.

Message Management: Better management of the messages. Perhaps persist them, or put in another queue with another life cycle.

To clarify, it needs some queues in memory with the same abstract logic that ActiveMQ provides. An interesting example could be the embedded Redis framework, or the Derby database for integration tests.

ActiveMQ does not persist the messages in the queue. So it would be fine if active has that feature, or some way to do it. So you can grab that message any time during the application lifecycle.

Apache Kafka has that feature.

The improvement could be the availability to persist the message in the
queue for any time along the app running.

Testing: I did not find a correct way to test the integration using Java, but rather only with manual testing.

We did not encounter any stability issues.

There were no scalability issues. With a good strategy, we can scale onto large systems using ActiveMQ.

I would give technical support a rating of 10/10. Despite the doubts that I encountered during the development, I could get the answer in the documentation.

The initial setup is very easy. You don't need to install anything. Just run the start command or put the URL in the browser.

I think the software is free.

We evaluated Apache Kafka and also RabbitMQ. The choice was about the better integration with JMS.

I fully recommend this product, but you need to have some expertise working with JMS and asynchronous tasks. You also need a correct strategy, or at least think about one.

One of the most important features of ActiveMQ is the ability to set up a network of brokers, and the ability to forward the message to another broker in the network, where there is a demand for messages from a consumer. These brokers could span over WANs and geographies. The messages will get forwarded to the broker where the demand is, which is what makes this a distributed messaging system.

The 'Shared nothing' configuration, where each broker has its own DB instance, is very important. It ensures that every message is accounted for and persisted in the DB to be replayed in case of failure.

Load balancing is important when huge numbers of messages are coming in. The messages get distributed to all the brokers, which are connected. In case of failure of any one broker, the message automatically gets routed to other brokers, ensuring no loss of messages.

By default, the failover protocol uses a random algorithm to choose one of the underlying connectors. If the connection fails, the transport will pick another URI and try to make a connection. The network automatically passes messages to connected brokers that have interested consumers. The failover protocol ensures clients do not need to be manually restarted in the case of a broker failure. As soon as the broker becomes available again, the client will automatically reconnect.

We also appreciate the easy setup of persistent messages using a DB like Oracle.

The master-slave relationship between brokers needs some improvement.

In case of shared architecture between brokers (i.e., both brokers sharing same the DB instance), one becomes master and the others become slaves. In this situation, the master always consumes the message and the slave is always in a dormant condition. This makes load balancing impossible. Probably this can be improved upon.

Another area of improvement is the monitoring console, which is kind of rudimentary. There is no facility to trace the entire XML message and take corrective action, such as resending the message.

If these facilities are added, it will be very good.

I have been using ActiveMQ for 2 months.

We have not had any stability issues.

We have not tested scalability.

We considered switching from WebLogic JMS, since we faced many issues including message affinity and lost messages.

The initial setup was straightforward.

The pricing and license policies are pretty good.

We use this product to provide us with a real time solution. It has helped us find ways to:

• Message or pass data, aside from hitting and saving data in a database.
• Perform asynchronous messaging.
• Queue database messages so requests are serial, if needed.
• Scale the application by increasing worker nodes via topics and queue load balancing.

I appreciate many features including queue, topic, durable topic, and selectors. I also value a different support for different protocols such as MQTT and AMQP. It has full support for EIP, REST, Message Groups, UDP, and TCP.

I would like to see the following improvements:

• The way it stores data
• Needs to focus on a certain facet and be good at it, instead of handling support for most of the available message brokers.
• For example, AMQP is a different flavor of message broker. However, adding it to ActiveMQ dramatically shifts its methodology and design. It can handle it, but it will be bad at it. Either you create a new forked solution of AMQ with AMQP and align only with AMQP, or just don't do it.

There were stability issues. With a network of brokers, you get a lot of issues, especially if you have the publisher and consumer using the same channel or connection, on different topics and/or queues. It’s causing a lot of issues and weirdness.

Setting up a network of brokers is problematic. The best thing is to do master-slave with a cold backup.

It is open source, so you get a very good response from the community. I heard Fuse is good, but I never talked to them.

We used to deploy Apache Kafka, as it was best for big data.

The initial setup is easy, and you can embed the ActiveMQ on the test.

Depending on the problem, AMQ resolved nearly everything. However, it may not be suitable for complex issues.

For what and where it is used, depending on the project, it will be very good.

For example, if I need to use a web application that will have ability to have an embedded message queue, it can work perfectly.

But if I need to have solution for big data, it may not be the best, especially for large streaming data. It varies by use.

Vet other solutions before implementing anything. Run multiple tests, like multi- thread and flood it with messages, as well as large messages, and combinations of both. See how it behaves.

We use the solution to manage the event messages by controlling the flow rate, handling error resubmissions, and ensuring the controlled processing of events.

The solution provides the best support services. It prevents losing messages with reliable techniques. Also, we can set thresholds for messages using it.

The solution's dashboard needs improvement. Presently, we cannot see the actual count of the messages. Also, we encounter downtime issues while queuing messages for third-party systems. They need to improve this particular area.

We have been using the solution for the last six months.

The solution's stability needs improvement.

We have around 300 applications for the solution.

The solution's technical support is good. Although, it took longer to respond to some of the queries related to licensing and stability.

Positive

I used JMS before.

The solution is less expensive than JMS and Kafka.

I rate the solution an eight out of ten.

I am impressed with the tool’s latency. Also, the messages in ActiveMQ wait in a queue. The messages will start to move when the system reopens after getting stuck.

The tool needs to improve its installation part which is lengthy. The product is already working on that aspect so that the complete installation gets completed within a month.

I have been using the solution for a year.

I would rate the tool's stability a seven-point five out of ten. The tool is highly stable.

My company has more than 1000 users for the solution.

The tool’s installation is tricky for someone who is installing it for the first time or has little experience with it.

I would rate the tool an eight out of ten.

We use this solution for messaging.

For any messaging system, I think that messaging, in general, is fundamental to software development.

This solution could improve by providing better documentation. IBM MQ has 30 years of experience to build upon and has had 30 years to grow and improve, while ActiveMQ does not have the same kind of heritage that IBM MQ has. In comparison, I find that IBM documentation is better, but it has had a lot more investment behind it.

In the next release, I think that a roadmap would be interesting. If we look at ActiveMQ and the ActiveMQ Artemis which are parallel streams that might merge, but it's not clear on whether it will or when will it happen. That would be useful.

Also, it is not that clear who offers what implementations. ActiveMQ is available as a managed service in AWS, but it is not clear whenever Red Hat AMQ is camping base around Artemis. It helps in terms of selecting why someone would want to use ActiveMQ.

I have had experience with ActiveMQ, on and off, for approximately five years.

I have not used it heavily in a production environment, but at the moment, I don't have any issues to report. 

I am currently working with some clients to investigate some stability issues they are experiencing, but it could be the result of the way it was implemented.

In terms of performance, I have not any extensive performance tests as a comparison.

I have looked at other messaging providers, and I don't think that it's any worse than any other solution available. I think that it's reasonable.

There is a little bit of community support, but when you have 30 years of experience, it is not difficult to work out. With messaging, you pick up on new messaging products and you can fill in the gaps very quickly.

The initial setup is straightforward.

I have also had experience with IBM MQ for the last 30 years. I am comparing between different products and messaging scenario expertise.

I work in consultancies with many clients who have many different versions.

All messaging whether it's ActiveMQ, Amazon MQ which is Active MQ, or it's IBM MQ, they are all very similar, they all have strengths and weaknesses.

We have clients from small to large enterprises.

I would recommend this solution but it depends on the requirements. For example, what kind of support does the vendor want? What kind of managed services do they want? It is important because you can run ActiveMQ on AWS to get a managed service. It always depends on what their clients are looking for.

I'm impressed, I think that ActiveMQ is great.

I would rate this solution a seven out of ten.

It has improved message processing. It removes the tight coupling and asynchronous invocation.

• Sequential message processing.
• Message broadcasting: There could be a use case sending the same message to all consumers. So as a producer, I broadcast the message to a topic. Then, whichever consumers are subscribed to the topic can consume the same message.
• JMX console: Provides a UI to visualize a list of queues and topics on the broker. We can see any pending message for particular topic/queue. It displays how many consumers are connected to a topic/queue. We can send a message from the JMX console to a topic/queue without the need of a producer to distribute the message.

• Distributed message processing would be a nice addition.
• An older version of ActiveMQ only provided failover, without a message spread across multiple nodes/broker. As with clusters (three nodes/broker), if one of the nodes goes down, other nodes should take the message and process it. If a message is consumed by a client, there was only one way to get the same message again.

We did not encounter many stability issues.

We did not encounter many scalability issues.

It’s open source, so we can’t expect more tech support. But the documentation has helped a lot.

We used JMS embedded in an application. Because of scalability issues, the JMS console, and isolation, we switched to ActiveMQ.

The setup was straightforward. Just download the extract and begin the startup script. That’s it.

I use open source with standard Apache licensing.

ActiveMQ is a great messaging system for synchronizing call and "fire and forget" types of calls. It can be integrated with Spring, Camel, and Struts.