 | |
Gatling reports screenshot
| |
| Type of business | Private |
|---|---|
Type of site | Open-source load and performance testing for web applications |
| Available in | English |
| Founded | July 1, 2015; 9 years ago (2015-07-01) |
| Headquarters | Bagneux, France |
| Area served | Worldwide |
| Founder(s) | Stéphane Landelle (CTO) |
| Industry | Software |
| Products | Gatling, Gatling Enterprise (Frontline) |
| URL | gatling |
| Launched | 13 January 2012; 12 years ago (2012-01-13) |
| Current status | Active |
| Written in | Scala, Java, JavaScript |
Gatling is a load- and performance-testing framework based on Scala, Akka and Netty. The first stable release was published on January 13, 2012. In 2015, Gatling's founder, Stéphane Landelle, created a company (named "Gatling Corp"), dedicated to the development of the open-source project. According to Gatling Corp's official website, Gatling was downloaded more than 20,000,000 times (2024). In June 2016, Gatling officially presented Gatling FrontLine (now Gatling Enterprise), Gatling's Enterprise Version with additional features.[1]
The software is designed to be used as a load testing tool for analyzing and measuring the performance of a variety of services, with a focus on web applications, APIs, and microservices.
Gatling was mentioned twice in ThoughtWorks Technology Radar, in 2013 and 2014,[2] "as a tool worth trying",[2] with an emphasis on "the interesting premise of treating your performance tests as production code".[2]
The latest minor release is Gatling 3.11, published on April 23, 2024.[3]
Gatling Corp develops the open-source performance testing tool for web applications, Gatling, and its enterprise version, Gatling Enterprise. The Project's aims include:
//Java
public class ComputerDatabaseSimulation extends Simulation {
HttpProtocolBuilder httpProtocol =
http.baseUrl("https://computer-database.gatling.io")
.acceptHeader("application/json")
.contentTypeHeader("application/json");
ScenarioBuilder myFirstScenario = scenario("My First Scenario")
.exec(http("Request 1")
.get("/computers/"));
{
setUp(
myFirstScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
}
}
//JavaScript
export default simulation((setUp) => {
const httpProtocol =
http.baseUrl("https://computer-database.gatling.io")
.acceptHeader("application/json")
.contentTypeHeader("application/json");
const myScenario = scenario("My Scenario")
.exec(http("Request 1")
.get("/computers/"));
setUp(
myScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
});
//Java
ScenarioBuilder myFirstScenario = scenario("My First Scenario")
.exec(http("Request 1")
.get("/computers/"));
{
setUp(
myFirstScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
}
//JavaScript
const myScenario = scenario("My Scenario")
.exec(http("Request 1")
.get("/computers/"));
setUp(
myScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
});
//Java
.exec(http("Request 1")
.get("/computers/"));
//JavaScript
.exec(http("Request 1")
.get("/computers/"));
//Java
setUp(
myFirstScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
//JavaScript
setUp(
myScenario.injectOpen(constantUsersPerSec(2).during(60))
).protocols(httpProtocol);
Gatling implemented a fully new architecture for a performance testing tool, in order to be more resource efficient.[8] It makes it possible to simulate a high number of requests per second with a single machine.[9]
Gatling comes with a recorder to bootstrap a simulation.
Gatling is provided with a simple[10] and lightweight[2] Domain-specific language, in which simulations and scenarios are coded. This allows users to add custom behavior through many hooks.[11] This makes simulation scripts readable and easy to maintain.[12]
In 2024 Gatling introduced a new DSL (SDK) for JavaScript and TypeScript.[13] The JavaScript and TypeScript SDK uses GraalVM to translate JavaScript code to Java and execute load tests on a JVM. The addition of JavaScript and TypeScript support makes Gatling the first polyglot load testing tool in the market.
This is an example of what Gatling's Domain-specific language looks like (see also § Terminology):
val scn = scenario("BasicSimulation")
.exec(http("request_1")
.get("/"))
.pause(5)
At the end of each test, Gatling generates an HTML report. Reports include:[14]
It officially supports the following protocols:
Gatling documentation states that it is protocol agnostic, which makes it possible to implement other protocols' support.[15] Here is a non-exhaustive list of community protocols support:
Gatling comes out with official and community plugins. It integrates with:
Here is a non-exhaustive list of community plugins:
Automation with Gatling is related to its simulations' maintainability.[16] The integration with other developer tools, especially in the DevOps lifecycle, makes it possible to industrialize performance tests, that is to say to fully automate the execution of performance testing campaigns in the software development process.
| Version[17] | Release date |
|---|---|
| 3.11.1 | 25 April 2024 |
| 3.10.3 | 21 December 2023 |
| 3.9.5 | 10 May 2023 |
| 3.0.0 | 23 October 2018 |
| 2.3.0 | 30 August 2017 |
| 2.2.0 | 15 April 2016 |
| 2.1.0 | 15 December 2014 |
| 2.0.0 | 6 October 2014 |
| 1.5.0 | 6 May 2013 |
| 1.4.0 | 20 December 2012 |
| 1.3.0 | 19 September 2012 |
| 1.2.0 | 31 May 2012 |
| 1.1.0 | 26 March 2012 |
| 1.0.0 | 13 January 2012 |
Gatling is published under Apache License 2.0,[18]apermissive free software license written by the Apache Software Foundation (ASF).[19]
The source code is accessible on GitHub.
Gatling Enterprise is the commercial version of Gatling. Gatling Enterprise is proprietary software. It is distributed by Gatling Corp.
Gatling started as an open-source project in 2012. 3 years later, in 2015, its founder, Stéphane Landelle, created a dedicated company named "Gatling Corp".
Gatling was designed by Stéphane Landelle when he was the Chief Technology Officer (CTO) of a French IT consulting firm, eBusiness Information.
In 2015, a dedicated company was created. It provides Gatling's users with professional services and, since 2016, with an Enterprise Version of Gatling, Gatling FrontLine.
The company is based in Bagneux, France, near Paris.
Gatling Corp is a member of Systematic Paris-Region, an Île-de-France business cluster created in 2005,[20] devoted to complex systems and ICT.[21] Systematic Paris-Region gathers large groups, SMEs, universities and research labs to promote digital innovation. Gatling is a member of Systematic's Open Source Working Group and was elected member of Systematic's board of directors, as a representative of SMEs, in November 2016.
The company took part in some events, like the Paris Open Source Summit (POSS, 2015, 2016 and 2017 editions), Liferay's 2016 Symposium, Java User Group (JUG)'s meetings, the Paris Gatling User Group and the New York Gatling User Group.
"Simulation" is the actual test. It is a Scala class that extends Gatling's io.gatling.core.scenario.Simulation class. Simulation has a HTTP Protocol object instantiated and configured with proper values as URL, request header parameters, authentication, caching, etc. Simulation has one or more "Scenario".
Scenario is a series of HTTP Requests with different action (POST/GET) and request parameters. Scenario is the actual user execution path. It is configured with load users count and ramp up pattern. This is done in the Simulation's "setUp" method. Several scenarios can form one simulation.
Gatling consumes fewer system resources to run a load test than other options.
It is capable of creating an immense amount of traffic from a single node.
It is an easy-to-install tool where simulations and scenarios are coded in a simple domain-specific language (DSL).
You can thus generate readable and easy to maintain performance test code.
As the core engine is actually protocol agnostic, it is perfectly possible to implement support for other protocols.
The language, Scala, and Gatling's DSL are pretty focused on facilitating the maintainability of the tests, which is ideal if you are focusing on continuous integration
The 'BSD-like' licenses such as the BSD, MIT, and Apache licenses are extremely permissive, requiring little more than attributing the original portions of the licensed code to the original developers in your own code and/or documentation.
