Everybody is now moving from ActiveMQ to Apache Kafka or RabbitMQ. Apache Kafka is much higher in terms of scalability and stability; it's way ahead.

So, there is room for improvement in terms of stability. 

The UI. It's both a good thing and a bad thing. The UI is too simple. Sometimes you wanna see the messages coming to the queue, and you have to refresh the dashboard, the console of the product. Maybe the UI could be improved.

There are two areas that the product should improve. One, the solution needs to be maintained manually and two, there are some stability issues.

In terms of improvement, one potential area would be the complexity of the initial setup. It is not overly complex, but it could pose challenges for first-time users.

We have had problems with the message selector as when the queue size reaches a certain level, the message selector does not have enough time to run and finish before the JMS reply timeout. In this case the client will not consume the JMS reply message even when the correlation ID matches.

Try not to use the hawt.io feature but use the AMQ console which is much better. If you have to use hawt.io , you may need to configure Jolokia, which is the JMX layer of hawt.io, to display queues properly if you have a lot of queues.

I would like the tool to improve compliance and stability. We will encounter issues while using the central applications. In the solution's future releases, I want to control and set limitations for databases. 

The solution can improve the other protocols to equal the AMQ protocol they offer.

From our perspective, it does not require improvement, because our use case is limited to pushing and consuming messages, and we will not be using the product extensively in terms of their life cycle or broadcasting, or message broadcasting, as a normal MQ would. 

That's why I am not sure because this is based on our use cases. Most of the features that we are looking for are present, and because we are not using any of the mirroring queues, destination options, or anything else, delivery policies, and so on. That is managing within the application itself. It is dependent on the pattern of use cases to use cases.

Because this is an open-source project, there is no support. We don't have any help or anything like that. 

This is usually us, otherwise, we have to search for it, who is the consumer, and search for who is supporting it. 

When it comes to new implementations, ActiveMQ is usually one of the applications and one of the ActiveMQs that we support out of the box. That requires the use cases that you support and are taking.

I am not sure if that capability exists or not but it i's more like scalability exists, but it's more like the partition siding.

It would be great if it is included as part of the solution, as Kafka is doing. Even though the use case of Kafka is different, If something like data extraction is possible, or if we can experiment with partition tolerance and other such things, that will be great.

In terms of the graphical user interface, it is providing whatever is required in our cases. I don't have a proper status to give it, because instead of the queue size, I need to visually show the queue depth and all that stuff, that statistics and queue data and all that stuff. All of these are features that can be included in this.

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.

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.

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 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.

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.

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.

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.

• 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.

Apache ActiveMQ needs some improvement playing with multi-platform message clients. It already plays really well with Java clients since it’s a JMS implementation, but it needs some improvement supporting clients written in other languages (like C#).

There is need for more protocols and maybe they should provide documentation on the internet as well.

During my summer internship, I developed a IoT application (a proof of concept). We had some Texas Instruments CC2650 sensors emitting to MQTT. For the first time, we wanted them to AMQP protocol with RabbitMQ, but the MQQT QoS 2 on RabbitMQ was a big problem. Thus, we switched to ActiveMQ. Unfortunately, we had to stay in MQTT, as ActiveMQ can’t translate protocols like RabbitMQ.

In the end, we used the ActiveMQ broker to get the messages from our sensors (using the Java Library by Hiram Chirino, mqtt-client), then we parsed the messages from the sensors and stored them in Apache Hbase. With all of this data, we made some statistics, graphs and various other useful stuff for the industrials.

About the documentation, it is more about the ActiveMQ advanced concepts such as using the KahaDB etc. For the protocols, maybe a translator is needed for example integration of AMQP to MQTT or XMPP to CoAP.

The clustering for sure needs improvement. When we were using it, the only thing available was an active/passive relationship that had to be maintained via shared file storage. That model includes a single point of failure in that storage medium.

The included admin web app is not sufficient and we ended up disabling it. Instead, we are instead using hawtio and Jolokia.

However, the audit logging in Jolokia is not detailed enough and we were forced to write our own audit filter.

Even with hawtio, some JMX operations are awkward. A better admin tool would be nice.

Even though there is support from many open source communities, there is still weakness in ease-of-use and ease-of-configuration for more complex scenarios.

The speed is not the highest ranking, but it's well known by users. They chose ActiveMQ for other features, because they know there are other messaging solutions that can work faster, like RabbitMQ, which is not Java written, but rather Erlang.

It does not scale out well. It ends up being very complex if you have a lot of mirror queues.

I would like to see improvement in the clustering brokers. Configuring ActiveMQ brokers for working in a cluster is difficult and has many constraints. Also, the configuration files are not intuitive.