Apache JMeter Reviews

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

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. 

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 primarily use it for conducting different types of performance testing, such as load testing, spike testing, and endurance testing.

JMeter is basically the art of the entire performance testing process. We generate load on our application using JMeter and then monitor various metrics like CPU with different monitoring tools. It's the essential foundation for our performance testing.

JMeter is doing some good things with upcoming releases, but the main area for improvement is the extensions available. 

Another area of improvement is the reporting part, specifically regarding report generation. 

There are certain things like we can't merge custom metrics into the JMeter reports. We're limited to JMeter metrics, and other server metrics can't be integrated with JMeter dashboard. This forces us to rely on another tool. 

We should be able to add or custom-configure server details directly in JMeter reports.

We have been using it for three years.

I would rate the stability a nine out of ten.  It's generally quite stable, it hardly has crashes or issues.

Scalability is good for my use cases, but to generate a large load, you must go into distribution mode, which is more complex to configure and requires powerful machines. So, while it's fine for my needs, but the scalability wouldn't be a perfect ten. I would rate it a seven out of ten, as there are some limitations for large-scale testing.

I'm the one who uses it most extensively. And the other we have four to five people are using it just for their local testing. It's development testing kind of stuff.  

It's an open-source community. So we can post our queries there. We generally get good responses from the forums. So it's good enough.

I used another tool like HP LoadRunner. And now it's offered by some different companies, ownership-wise, but it was long back. 

I would rate my experience with the initial setup an eight out of ten, where one is difficult, and ten is easy. Even for new users, the installation is straightforward based on the documentation. 

However, customizing and building something extra can be complex. But overall, it's easy enough to download and start working with.

Our main system is on the cloud, so we primarily use JMeter on the cloud. However, some use cases require on-premises deployment, and we use it there as well.

One person is enough for deployment. The deployment won't take much time. It is very fast, typically within five minutes.

We use the open-source version. 

I'll definitely advise that you should at least give it a try. If it serves your initial needs and meets your expectations, you should go for it. 

It's quite an old and up-to-mark tool with a proven track record in the industry, and there's a strong community behind it. So it's definitely worth giving a shot.

Overall, I would rate the solution an eight out of ten. 

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.

JMeter is used by a team of four performance engineers. We monitor tasks on the API level, so all of the requests are hitting individually.

JMeter has helped us streamline our applications by identifying multiple bottlenecks in our systems and exercising tasks against APIs.

JMeter is a free tool with a large user population, which comes in handy because we have a vast knowledge base to tap into when needed. It's also easier to hire consultants who know JMeter.

JMeter's reporting is extremely rudimentary. The fundamental reporting mechanisms need to be drastically improved. It doesn't utilize an automatic session management mechanism or methods other tools use like parsing cookies and variables. Everything needs to be done manually. There's no automation.

We've been using JMeter for the past three years.

JMeter never crashed on us. It's highly stable.

JMeter is highly scalable.

There is no technical support for JMeter.

We previously used LoadRunner, but we switched because the organization had an accumulated knowledge of JMeter. Nobody really knew LoadRunner. However, the biggest advantage is that it's free, and we didn't have to invest in acquiring a performance testing solution.

JMeter is simple to install. We did it in-house, and it takes a day or two to deploy it to the cloud. There's no maintenance required. 

We looked at a number of different tools.

I rate JMeter five out of 10. You need knowledgeable employees to work with the tool because it's difficult to learn. There is a steep learning curve, so you shouldn't expect an entry-level engineer to pick up the tool quickly and become proficient. It takes a considerable amount of time.

We utilize it solely for load testing and performance testing. 

JMeter is user-friendly, and that's a notable advantage of JVTech. It's straightforward and easy to use, unlike some other load testing tools, making it very easy to understand.                

I have been using Apache JMeter for the past 4 to 5 years. 

The last time I used it, there were some APIs that I tested, and they were running well before. We didn't make any changes to them, but when I tried to check them again recently, they didn't go through. It seemed like an issue at the integration level. I'm currently working on getting half an automation, where I'll have separate linear and rest. But that's the situation so far.

I prefer tools that I can easily teach people within twenty minutes, and JMeter falls into that category. It's part of the tools I use to help others learn load testing. While JMeter can be a bit tricky, I find it easy to grasp and teach. It's user-friendly, and I can quickly introduce someone to it. It's a tool that I can easily exchange with others, and I aim to achieve proficiency in it soon because of its simplicity and ease of use.

We have a Neotys slave server configuration where we have one server that caters to three servers, and we test most of the load on Apache JMeter, particularly for a hundred users. We test the load for web applications, services, and the rest of the APIs, though our current setup for Apache JMeter isn't that big.

Initially, Apache JMeter had a complex configuration; its UI was tricky and required a lot of resources. Creating scripts and running tests on Apache JMeter was always confusing, but nowadays, with more documentation and UI enhancements, Apache JMeter has improved. Previously, recording and creating scripts was tricky, and you had to do it manually. Now there's a recording facility in Apache JMeter that lets you create and modify scripts and test faster, which helped improve my organization.

To me, what's most valuable in Apache JMeter is that it's a lightweight tool for application testing. It's the best load-testing tool for my company because Apache JMeter simulates your application during testing. Apache JMeter also creates threads with good server utilization. Apache JMeter allows you to focus on analyzing the situation, looking into measurements, response time, and client-server responses, which I find valuable.

Both scalability and stability could be improved in Apache JMeter.

What I'd like to see in Apache JMeter in the future is ease of use in terms of scripting. A recording capability similar to what LoadRunner offers, where you can record scripts, make some modifications, then the script will be ready, is another advanced feature I'd like Apache JMeter to have. The two features would make it easier for new users to learn how to use Apache JMeter and help users utilize the tool more quickly.

I've been using Apache JMeter for more than six or seven years.

Apache JMeter isn't as stable because it sometimes crashes when you're running a test. The performance of Apache JMeter could be improved because testing on it isn't always as smooth sailing.

The tool is partially stable. You can't expect Apache JMeter to run well for enterprise-level, high-load applications. It's a good tool for more straightforward or lightweight web applications but not for CRM-type applications.

Scalability-wise, Apache JMeter could be improved because if you try to implement it on multi-servers, the threads running on the tool don't hold up well.

We used LoadRunner before using Apache JMeter. As Apache JMeter is open source, and we only needed to test lightweight applications, we were pretty sure we wanted to go with Apache JMeter.

Apache JMeter is an open-source tool that you can install directly from the web with binary files, so setting it up on one to two machines is easy. The setup could be tricky if you hook Apache JMeter to three or more different machines, and it's also tricky when you execute it after.

We implemented Apache JMeter in-house.

I've seen ROI from Apache JMeter, mainly because it doesn't cost much to maintain, and we can use it on a few lightweight applications.

We didn't pay licensing fees for Apache JMeter because it's an open-source tool. We only paid for the machines where we installed Apache JMeter modules.

I have experience with Apache JMeter, with version 5.5. as the most recent version I've used.

Apache JMeter is deployed on-premises, but my company did a POC with Apache JMeter and BlazeMeter. BlazeMeter is a CA proprietor tool where you can hook up Apache JMeter scripts. BlazeMeter is a cloud-based tool where you can run tests with the help of Apache JMeter scripts.

At the moment, only two people use Apache JMeter within my company. Two people can handle the deployment of Apache JMeter, while only one person is required to maintain it.

My advice to people looking into implementing Apache JMeter is to make the decision based on the application portfolio. For example, if it's more diverse, then using Apache JMeter could be tricky, but if you're only testing lightweight applications, Apache JMeter will be a viable solution.

Apache JMeter requires minimal investment, yet it has some returns, and it's a good tool, so I'm rating it as seven out of ten.

I use JMeter for concurrency and some backend services. We are also using JMeter to apply our tests within our framework by sending some requests to JMeter to assess our application's performance. My company is developing software based on data analytics that produces insights and graphs like Tableau or Power BI. We use JMeter to test the graphs, how the tables are rendered, and how long it takes to render some applications. 

For instance, we have a problem with one of our clients that use some complex scenarios or queries that take too much time to retrieve from the application or render to the end user. We ran a couple of tests on the application using JMeter and spotted the service or request that was taking too much time.We alerted the developers about this, and they took the appropriate action to fix this problem. Afterward, we run another cycle of JMeter to ensure everything is working as expected.

There are two modules. The analytics module is the interface for the stakeholders and company decision-makers. The number of users isn't that big, unlike the retail applications websites. It's 500 users at most. The other module is deals with data volume. We are currently doing some POCs to check whether we will benefit from JMeter in this area because it's not a concurrency issue. It's a data volume issue.

We have a hybrid deployment because we are using JMeter to assess the performance of our products. If the product is deployed on the cloud, we use JMeter on the cloud. If it's on-prem, we are using it on-prem. At my previous company, we mainly used JMeter on-prem.

I expect that we will continue to rely more on JMeter, and we have multiple DevOps pipelines using JMeter to test another module in our application.

I use all the tools, but one feature that stands out is JMeter's ability to test when services are sending a particular kind of request. We are using specific ports to send queries, and assess the performance based on the time it takes these queries to respond. You can use it with stuff other than the web performance.

The UI needs some work. The first time I used JMeter, I couldn't record the full scenario to mimic the user experience. Since then, they have introduced some plugins and a third-party tool called BlazeMeter. It's working on this, actually.

It's an excellent plugin that you can use to record the scenario from Google Chrome, and it integrates easily into JMeter. They could also make it easier to generate the built-in report. Now, you run the tests and generate the charts in a separate column. The graphs and charts that display the test metrics could be better.

I worked with another tool called Web Performance Tester, and its interface is better than JMeter's. They have intuitive graphs while you are running the tests, so you can see how things are going. It shows you the number of concurrent users logged into the system, the number of failures, response times, etc.

I worked in performance testing from 2011 until 2019. I was working with another tool, but in the last few years, I started using JMeter for a couple of projects.

It's hard to say definitively. When there's something wrong with JMeter, we're unsure whether it's something in the device because there are lots of requests coming from the machine. Maybe we didn't use it that many times from our local server. There are some bottlenecks, but in many cases, we only need to restart JMeter, and it works fine.

JMeter is scalable. I did a test using it in a distributed environment with more than one client. We used JMeter to load from the server and also the plugin tool. It works fairly well in a complex environment. I still need to research the maximum concurrent JMeter can handle. Is it 1 billion or 10 million? 

In my work experience, I need to load maybe 1 million users. For example, most of my work is on the backend of e-commerce websites with a maximum of 1,000 users. We have many clients, but the load is not that big. 

I don't think JMeter has technical support because it's an open-source application, but there is support for third-party apps that use JMeter. For instance, BlazeMeter has good technical support.

I have more experience in a tool called Web Performance Tester, but it has some limitations. For example, it doesn't support some forms. A long time ago, their support was better, but lately, their support hasn't been so good. They always ask us to switch to the consultancy service and they don't give us the solution. If we face problems, they always tell us, "Okay. You can consult us." This is not a good practice, actually.

Also, Web Performance Tester isn't well-known, so some of our clients aren't confident in it because it doesn't have a reputation.  They were more familiar with JMeter, and it's something I've used.  However, I have no problem with Web Performance Tester. It's hard to compare the two tools because it's not apples to apples. 

I joined this company in October, and they had just started using JMeter. Previously, they were using a tool that they had developed in-house. They found that JMeter has more capabilities and specificity than the tools they were using.

Setting up JMeter is straightforward. It doesn't need an installation like other tools. There is a batch file for Windows. Around four people in my organization are responsible for maintaining and managing JMeter.

JMeter is a free open-source tool. There are some third-party tools built on top of JMeter that have a license or something like BlazeMeter. I think you can also purchase some additional services.

I rate Apache JMeter eight out of 10.  Before using JMeter, you should find some tutorials because you need to be trained to use it. It's not a plug-and-play tool. This is what I did. Spend some time researching JMeter's capabilities. We met a lot of people who knew about JMeter, but when you tell them that it can do something, they're not aware of it. 

For instance, through taking some courses, we learned that JMeter has distributed performance capabilities. Some people still know that you can't make these recordable scenarios. This information hasn't reached everyone in the IT market.