Gatling is an open-source load and performance testing tool used to assess the performance and scalability of web applications, APIs, and servers which uses Scala, Akka and Netty as a technology stack and as its backbone. The first Gatling release was in January 2012. Since then, Gatling has had a couple of major releases almost each year, as well as a pretty extensive popularity growth across the performance engineering community. It is designed to simulate a large number of concurrent users accessing the application or system and measure how it performs under different loads. Gatling is commonly used by developers, testers, and performance engineers to identify performance bottlenecks, analyze response times, and ensure that an application can handle its expected user load without degrading the user experience. Key features of Gatling include:

1. Scalable Load Generation: Gatling can generate a significant load on the application by simulating thousands of virtual users concurrently. This capability allows testers to determine the application’s maximum capacity and its ability to handle peak loads.
2. Realistic User Simulation: Gatling allows testers to create realistic scenarios by defining user behavior and interactions, such as browsing pages, submitting forms, and making API requests. This realistic simulation helps in understanding how the application behaves under different user patterns.
3. Domain-Specific Language (DSL): Gatling uses a DSL written in Scala, a programming language, to define test scenarios. This DSL provides an expressive and flexible way to create complex and dynamic test scripts.
4. Detailed Test Reports: After executing tests, Gatling generates comprehensive test reports with detailed statistics, response times, error rates, and various performance metrics. These reports help in identifying performance issues and analyzing the overall test results.
5. Protocol Support: Gatling supports various protocols such as HTTP, HTTPS, WebSockets, JMS, FTP, and more, allowing testers to evaluate a wide range of applications and services.
6. Scripting and Code Reusability: Test scripts in Gatling are written as code, which allows for scripting and code reusability. Testers can create modular scripts and reuse them in multiple scenarios.
7. Integration with CI/CD: Gatling can be easily integrated into Continuous Integration and Continuous Deployment (CI/CD) pipelines, enabling automated performance testing as part of the development workflow.

Gatling is a command line tool, i.e it has no GUI or Web UI, which implies a certain level of technical knowledge for its users.

1. Gatling Works Everywhere

 Gatling is written in Scala, which allows you to run it on any system. That’s why you will never hit any trouble by using different local machines and cloud servers to run and create your tests.

2. Create Gatling Tests as Code

For many developers, it is a huge benefit if they can write performance tests as source code, as Gatling enables. This allows us to store tests under version control systems that enhance developers’ collaboration, keep historical changes clear and prevent us from losing the work we have done. Also you can use any popular code IDE application for writing script.

3.Gatling has Detailed Metrics Dashboards Out of the Box

Gatling created detailed metrics dashboard that you can see after tests execution without having to add any additional plugins. The report is stored as an HTML file, which can be easily saved for some future analyses and metrics comparison. 

4.Gatling is Powerful!

it’s worth saying that all performance tools should be powerful by the nature of their purpose .But Gatling definitely has an advantage over many other frameworks (like JMeter), because it uses advanced architecture and the Akka toolkit, which is based on the actor model that is distributed and fully asynchronous by design. It uses scala for scripting which a powerfull language.Gatling doesn’t allocate a separate thread for each user. Instead, all multithreading is done via messages between actors (universal primitives of concurrent computation), which allow to simulate a list of users by using just one thread.Gatling handles the load better than JMeter and can help you save CPU and RAM, which will help you simulate a bit more users.

5. Gatling has Capable Assertions

Gatling has an integrated assertions API, which gives you a full arsenal to perform functional assertions. This API allows you to run different types of functional checks along with your performance testing.

6.Gatling Uses Human Readable Tests

Gatling tests are very elegant, because Gatling defines a domain-specific language that allows writing very clear and human readable tests. This is important because it helps teammates work together on the same scenarios without spending time on additional knowledge transfer. Below is the Gatling script:

7.Gatling has Inbuilt Integration with Continuous Integration Pipelines

Gatling performance tool can be fully executed by using the command line, making it compatible with any Continuous Integration platform. You will be doubly happy if you use Jenkins continuous integration service, because you can use the pretty useful Jenkins Gatling plugin, which lets you to keep track performance metrics trends in the main screen of the test build plan.

Gatling Cons:

– Not for beginners – The larger number of prerequisites and high technical skills that are needed make it hard to use for beginner as Scala, requires coding skills.

– Poor level of information during execution time

– Few protocols supported: HTTP, WebSockets, Server-sent events, JMS

– Doesn’t have host monitoring integrations (third-party applications can be used) or you can use the Gatling Frontline, which is the commercial version of the Gatling open source framework. 

– No distributed testing – Using the free version, the load distribution (running a higher load from a farm of load generator machines) is not so intuitive like other open source tools.

Reference:

https://gatling.io/docs/2.3/