Apache JMeter Reviews

I mainly used Apache JMeter for manufacturing environments at an enterprise level. One specific use case was where we had to send bulk files via API, which we could not replicate with LoadRunner as it might require additional protocol purchases. With Apache JMeter, we could simulate this scenario, uploading millions of files via API.

There is no significant financial investment as Apache JMeter is a free tool, which helps in scenarios where cost constraints are present.

One valuable feature of Apache JMeter is the ability to replicate scenarios where bulk files have to be uploaded via API. This is something we couldn't simulate with LoadRunner without purchasing another protocol.

The user interface is not as user-friendly as LoadRunner. The scripting, which is a record-and-replay setup, seems less intuitive, potentially since I have more experience with LoadRunner. 

Documentation is not comprehensive, making it difficult to find the right answers.

I have used Apache JMeter for around two to three years.

I have not seen Apache JMeter getting crashed in between uses, and it is generally stable without major issues.

Apache JMeter has limitations as it only supports one protocol: the web protocol.

Apache JMeter does not have direct support due to it being open-source, however, there are online communities where I search for answers.

Neutral

I have not used any other open-source tool for performance testing. I have used LoadRunner, but given the choice between LoadRunner and Apache JMeter as a tester, I would choose LoadRunner. However, from a purchasing perspective, I would not go with LoadRunner due to its cost.

The setup of Apache JMeter is straightforward and not complex.

We have a production support team, which is a large team. They handle various tasks besides deployments, supporting all enterprise-level tools.

As Apache JMeter is a free tool, there is no direct investment, making it cost-effective for web protocol jobs.

There were no costs involved as Apache JMeter is a free tool.

I have not used any open-source performance testing tool other than Apache JMeter.

I would recommend Apache JMeter to others if there are cost constraints.

I'd rate the solution six out of ten.

We use the tool for data load testing. 

Most of our products and the entire industry operate on APIs now. The end user interacts with the user interface, but the entire backend runs on APIs. Even when one application needs to interact with another, we use APIs. It's an API-driven world, and Apache JMeter supports API testing.

We had some challenges testing HTTP/2 APIs, which are becoming more prevalent with advancements like 5G. So, we added another plugin to help with HTTP/2 API load testing. Apache JMeter, with additional plugins, now supports HTTP/2, which is critical as everyone moves from HTTP/1 to HTTP/2.

We used many features, and we like all of them. It's hard to say which one is better than the other. The ability to simulate heavy loads from multiple users is definitely a standout. We can increase the number of threads, ramp up, ramp down, and run stable load tests. We've validated all these use cases.

The tool's reports are user-friendly and self-explanatory. It has good visualization aspects as well. 

Performance and stability are key industry requirements. Often, functionality testing is prioritized, but performance and stability are crucial once the product is in production.

To the best of my knowledge, the documentation could be improved. It should be enhanced to better support newcomers. Currently, only people with some experience can easily understand the content. Including more sample programs, applications, and use cases would help many more people adapt to using the solution.

I have been using the product for a few years.  

I rate the product's stability a nine out of ten. 

The scalability can be viewed from one instance and multiple instances. We haven't explored the multiple instances part, so I can't speak to that. However, with a single instance, we've been able to get good performance, explore all the features, and cater to our use cases.

I haven't contacted the tech support yet. We search the internet or call experts for help. 

The tool's deployment is straightforward. You need to follow the user documentation to deploy it. 

The solution can be deployed with the help of in-house engineers. 

The tool is open-source. 

I rate the overall product an eight out of ten. I recommend it wherever I go. 

There is room for improvement in the scripting concepts. The scripting and even the results and reports were very elaborative and informative in LoadRunner, but not in JMeter because everything has to be done manually. 

And, whichever metric we need, we need to add it manually and start monitoring it, but not in LoadRunner. It was a very elaborate report. A lot more information, but not in JMeter.

I have been using it for four to five months. I have been with the organization for just four to five months.

It is scalable. It is cloud-based. Whenever, based on the requirements, we can scale it to whatever extent we need. But with respect to LoadRunner and NeoLoad, since they are all paid ones, we had to follow a procedure even if we had to scale for certain protocols or with respect to users. We had to pay the cost.

There are around seven to eight members using this tool.

I have switched over to a new company where they used JMeter. Earlier, we used Micro Focus LoadRunner.

More than NeoLoad, I prefer LoadRunner the most because I have had experience from the past 13 to 14 years, majorly on LoadRunner. 

Any of the customers would be very easily convinced with the LoadRunner or the NeoLoad reports more than the JMeter reports. And even interpretation of the results, everything would be very much comfortable and customer-friendly with respect to LoadRunner and the other tools, but not with JMeter.

If I had to compare with respect to JMeter and other tools, the script creation, user-friendliness, handling of the tools, customization of scripts - everything is very much easy. Even for training, it would be very easy with LoadRunner more than JMeter.

And documentation, materials, support, technical support, installation, everything - whatever the support- also looks pretty good in LoadRunner or NeoLoad, not in JMeter. Since it's open source, everything has to be done on your own. And the training of freshers and juniors would be more comfortable with LoadRunner than JMeter.

It is free.

I propose they use Micro Focus LoadRunner or NeoLoad. I have even put forward the proposal here [in my current company] as well.

Overall, I would rate it a six out of ten. 

I consider Apache JMeter to be a fundamental tool in the industry for performance testing. Its primary advantage lies in being free, making it accessible to everyone. The platform boasts a wide range of plugins, regularly updated, and has a substantial community. You can find information on almost any topic in the community forums or Q&A sites related to code.

Apache JMeter is well-known and widely used among developers, particularly on popular developer forums. While it may not have the most user-friendly interface, it offers strong support through official manuals and various articles from companies providing load testing services. 

The tool is free, has a substantial community, and serves as a fundamental choice for testers, especially those new to performance testing. While other tools like K6 may be more developer-oriented, JMeter's affordability and accessibility make it suitable for those without extensive performance testing experience.

Given that Apache JMeter is a free and open-source tool, documentation improvement may not be a major concern, as it is mostly contributed on a voluntary basis. The essential information is already available. However, in terms of the interface, there are occasional bugs, and the tool may not address them as quickly as some users would like. Fixing defects and bugs might take a considerable amount of time, with users sometimes having to wait for several months or even a year for the next release to address specific issues.

I have worked with Apache JMeter for years. 

In terms of stability, there have been some instances of unknown bugs, but these are documented on the official pages and tracked in bug repositories where users can find descriptions and potential workarounds. Users with less experience may encounter unexpected behavior, but with online resources, such as Google, they can understand and address the issues. Some known problems, like internal loop issues when launching from the MacOS terminal, can affect stability, but they are not critical and usually have workarounds. While these issues may slightly impact the user experience, they do not significantly detract from it. On a scale of ten, the overall user experience with JMeter might be rated around seven or eight.

Scalability is possible for both small and large companies. In smaller companies, JMeter can be scaled across multiple machines, utilizing them as load generators. For more complex network setups, collaboration with the DevOps or system administration teams may be required to handle firewall configurations. In large enterprises, options like Docker Swarm or Kubernetes can be employed. Additionally, using JMeter images or containers within these frameworks allows for quick scalability.

While I haven't personally engaged in direct interaction with support, I have encountered challenges and utilized forums and official support channels to address and resolve those issues. So, yes, I've had experiences leveraging these resources for problem-solving.

A few years ago, I found Apache JMeter to be a reliable tool, and while it may have changed since then, I haven't used it recently for a direct comparison. Around five years ago, I had a positive experience with Neotys, which was an excellent tool, albeit expensive. However, as its pricing is now contact-based, I'm not sure about the current costs. Additionally, I've recently explored K6, which seems promising. K6 is actively developed and evolving rapidly. It caters more to a coding-centric experience, making it favorable for developers who appreciate JavaScript-based coding without extensive installations. This tool might see significant growth in functionality in the coming years.

If someone is completely new to Apache JMeter, it might take around one hour to half an hour to set it up initially. This includes spending time reading manuals, watching YouTube videos, and getting familiar with the tool. For those with some experience, the setup process could take as little as ten minutes. This involves downloading and installing JMeter, configuring Java if necessary, and adjusting path variables. The overall time may vary based on the machine's readiness and the user's familiarity with the setup process.

One piece of advice I often provide to those venturing into performance testing with Apache JMeter is to carefully consider the expected load. Due to its utilization of the Java Virtual Machine, JMeter can be memory-intensive. For extensive testing scenarios with a high volume of virtual users and transactions, it's crucial to meticulously configure JMeter, considering each element in the scenario. However, for simpler yet intensive testing needs, individuals might find less resource-intensive tools like Gatling or Locust more suitable.

If it were a commercial tool, I'd rate it an eight, but given that it's a free and non-commercial tool, I'd lean more towards a nine. While it's not perfect, I believe it's one of the best options available for now.

We have multiple use cases. We have APIs integrated for functionality. We're using JMeter for performance testing those APIs.

There are about 80 people working on this project, and about 12 people are using JMeter for performance testing.

Approximately 10% of people are using JMeter in my organization, and some people are using PureLoad, which is a paid tool.

We're using version 4. The solution is deployed on an Azure public cloud.

The reporting features are really good. There's a lot less latency than other solutions. We configure our API script and execute it through JMeter, get a response time over there, and compare that response time with the Azure cloud response time. The latency is low. JMeter is optimized very well. 

Another valuable feature is that we can distribute our load in different formats, like a responsive load. Then, we can distribute our load in a different manner by using plugins.

We decided to use JMeter because it's open source, and it's a very stable product. There are many plugins that are easily available to configure multiple things.

JMeter is lagging when it comes to GUI performance testing because we need to install some third-party plugins for recording the GUI script, and the performance isn't very reliable. I think it should be improved. The API is pretty optimized, but the GUI isn't.

I use JMeter for API and stress testing, and I use a different tool for GUI testing.

It's pretty stable.

My server is capable of processing 60,000 API requests in one minute. I'm putting 1.2 million API requests per minute on my server because I have configured some scaling rules in the Azure environment. After reaching the optimized level of 60,000 requests, it automatically scales out by one load in the Azure cloud. JMeter generates that load with the specific time we have provided in our script and configuration.

I haven't contacted the official JMeter support channel because if I'm facing any issues, I just Google it. I have found a lot of solutions there because it's open source and multiple people can give their feedback and answer queries. 

The reporting is better in PureLoad because it's a licensed project, but it's okay if the entire report is embedded in Excel format.

There are multiple formats, like tree format and CSV format. In CSV format, you can download your reports. By using some formulas in Excel, you can prepare a similar report. There's automation in PureLoad, but it's not really required in my projects.

Setup isn't complicated. I would rate the setup as eight out of ten.

The speed of setup will depend on your internet speed, but deployment usually takes one to two hours to complete. If you've already written the script, you can easily upload those scripts in JMeter and trigger them. It will take one to two hours to set up all the configurations for JMeter.

The solution is open source.

I would rate Apache JMeter as nine out of ten. There are a lot of features. In terms of stress testing and performance testing, it's really good. There are many plugins available that are compatible with JMeter. You can start your load according to your requirement. JMeter isn't very complex to understand. It's user-friendly and the test results are also available in different varieties, including start, view, trees, and tables.

My advice is that you need to understand the requirements for your project and what needs to be done in terms of performance testing. You also need to think about which plugins serve your purpose. If the plugins and reporting are there, then you should definitely work with JMeter. It's a really good tool with no cost.

You can easily find errors and add or drag in the problem. There are also browser plugins, which support multiple tests and protocol services. In my project, I'm testing MQTT services, which is message queuing telemetry transport. The notification service we're using in our application is related to that. I have tested that particular functionality with JMeter as well because of the security protocol.

I use Apache JMeter primarily for performance testing projects. It is a day-in, day-out tool where we run performance test executions to create a production-like load on systems. We analyze the results and share recommendations with customers. We use it for load testing, stress testing, and endurance testing on systems.

Apache JMeter helps us meet our requirements for performance testing by allowing us to create scripts and run them. It is part of our daily routine, and it provides us the capability to test using different protocols like gRPC, which is essential for our operations.

The most valuable features of Apache JMeter include SCTP sampler, throughput controllers, stepping up thread group, parallel controller, timers, and the ability to use gRPC protocol. These features meet our requirements and allow us to effectively create and run our performance testing scripts.

Apache JMeter has room for improvement in handling larger infrastructures as it consumes a lot of CPU and memory. It requires integration with other tools for live metrics, which is time-consuming. 

Also, the failure response times are calculated in the overall response time analysis, which should be separate. Better script maintenance and integration with ALM or repository tools would be beneficial.

I have been using Apache JMeter for about 14 years.

Apache JMeter is generally stable, with a high stability rating of nine out of ten. Any instability could impact timelines, project deadlines, releases, and revenues.

While Apache JMeter can scale to the required number of user loads, it requires a lot of manual work and larger infrastructure, which are challenges to its scalability.

There is no dedicated support team for Apache JMeter as it is an open-source tool. We rely on community support, which is not enough and needs to be improved.

Positive

I previously used LoadRunner. We switched due to customer preference for a commercial tool.

The initial setup of Apache JMeter is rated between eight and nine out of ten. If you have knowledge, it's an easy setup.

No specific team is required to maintain Apache JMeter. Performance test engineers familiar with the tool can maintain it.

Apache JMeter is an open-source tool, so there are no costs associated with its setup, pricing, or licensing.

We evaluated NeoLoad and found LoadRunner to be more realistic than NeoLoad and Apache JMeter.

For those looking into open source, JMeter is an excellent tool and should be the first option. For commercial needs, BlazeMeter is a good choice, or LoadRunner is a good choice for a commercial setup.

I'd rate the solution ten out of ten.

Load testing is something that we used to do on Apache JMeter. We have regular releases every two weeks with varying features and modules. For major releases, where most of the EPS are modified or new features are introduced with new pages, we perform a performance test once every three to four months. We have a fixed schedule for performance testing before the sale, such as Thanksgiving and Black Friday, to ensure stability and performance during the sales period.

It is an open-source tool that is easy to use. It can be easily integrated with multiple tools, including Selenium. The tool also provides a recording and playback feature, along with the ability for modification and parameterization. Since it is an open-source tool, it can be easily integrated with many other tools, such as BlazeMeter, making the integration process very helpful.

The UI of the solution needs to be better. The UI takes up a lot of our bandwidth. So, we always run on the command line. Hence, improving the UI is needed. If it can be more lightweight, the editing can also be made easier.

I have been using Apache JMeter for four to five years.

Apache JMeter is a stable tool. Around 10,000-12,000 users are using the tool. One can increase its usage, but we haven't done so since we will need multiple machines to be connected to a network to generate the load. So, we haven't exceeded its use beyond 10,000 users.

Apache JMeter is a scalable tool.

We haven't used the solution's technical support.

We used other solutions in the past, but they were costly since they require a license, whereas Apache JMeter is free. Hence, we prefer Apace JMeter.

The solution's initial setup process was straightforward since setup can be done by opening a JAR file. It can be deployed in half an hour. Experienced people can deploy it in 15-20 mins, and newer ones may take up to an hour.

Also, we don't deploy on any server. Normally, the tests are on local ones.

For deployment and maintenance, you need knowledge of scripting and APIs. But otherwise, maintenance should be easy. Once you record and have the script ready, until and unless there are modifications to the application, maintaining it should not be much hassle.

The implementation was done in-house.

There is no investment as such. Only the resourcing part is there in the tool.

Apache JMeter is a free tool.

I recommend Apache JMeter to others who want to use it. I rate the overall solution an eight out of ten.

We use the solution for performance and security testing.

The solution's most valuable feature is its ability to install and automate functions with ease.

They should improve the solution on its UI front.

 We have been using the solution for six years.

I rate the solution's stability as a seven or eight.

We are an enterprise business using the solution. It flips a bit whenever we add more than 10,000 virtual users to the solution. It becomes impossible to get the expected result. We have to use distributed testing to deal with the issue. I rate the solution's scalability as a six.

We check with the solution's community support forum in case of any queries. It is very active.

We tried out solutions such as LoadRunner and NeoLoad. As these were commercial tools, we settled for JMeter. Also, the reviews from those who have used the solution helped us switch to it.

I rate the solution's initial setup as an eight. It is easy.

Regarding deployment, you have to download the installation file and save it in the system. If it has specific prerequisites, such as installing Java, you need to ensure it is compatible with JMeter's current version.

The solution is free of cost as it is open source.

The solution works well for small or medium applications but not with 10,000 or more footfall. I rate the solution as a seven.