In a Gatling simulation, what does calling exponentialPauses() on setUp change about every pause(2) in the scenario, and how do you exempt a single one of them?

A Gatling simulation has a run-wide **pause type** that decides how the numbers written in the scenario's `pause(...)` calls are turned into actual waits. The scenario says *how long*; the pause type says *how that length is interpreted*. ## What changes when the type changes The built-in default is constant: the wait is precisely the duration you wrote. Declare something else on `setUp` and the same literal becomes a parameter of a distribution instead. | declared on `setUp` | what `pause(2)` becomes | |---|---| | nothing (the default) | exactly 2 s | | `constantPauses()` | exactly 2 s, stated explicitly | | `exponentialPauses()` | a draw from an exponential distribution with **mean** 2 s | | `uniformPauses(20.0)` | uniform, 2 s ± 20% | | `uniformPauses(Duration.ofMillis(500))` | uniform, 2 s ± 500 ms | | `normalPausesWithPercentageDuration(20.0)` | normal, mean 2 s, standard deviation 20% of the mean | | `normalPausesWithStdDevDuration(Duration.ofMillis(500))` | normal, mean 2 s, standard deviation 500 ms | | `customPauses(session -> 5L)` | 5 **milliseconds** — the declared 2 s is discarded | | `disablePauses()` | no wait at all | Three of those rows hide a trap: * **The `Double` arguments are percentages, not fractions.** Gatling divides them by 100 internally, so `uniformPauses(0.5)` means ± 0.5 %, not ± 50 %. If you want half the mean either side, write `uniformPauses(50.0)`. * **`customPauses` ignores the declared duration entirely** and its function returns **milliseconds**. `customPauses(session -> 5L)` makes every pause in the run five milliseconds long, regardless of what each call declared. * **Normal draws are clamped at zero**, so a wide standard deviation produces a pile-up at zero rather than negative waits. Note also that the two-argument `pause(1, 4)` composes with the type rather than replacing it: Gatling first draws a duration uniformly between the bounds, then feeds *that* value to the pause type as its mean. ## Exempting a single call Every `pause(...)` overload takes an optional last argument that Gatling's own source calls `force`, and it overrides whatever the population resolved to: ```java setUp(scn.injectOpen(atOnceUsers(10))) .exponentialPauses(); // ...inside the scenario, one wait that must stay exact: pause(Duration.ofSeconds(2), constantPauses) ``` The values you can pass are DSL constants and factory methods with their own names — and those names are **not** the same as the `setUp` method names, which is a genuine source of confusion: * on `setUp`: `disablePauses()`, `constantPauses()`, `exponentialPauses()`, `uniformPauses(...)`, `normalPausesWithStdDevDuration(...)`, `normalPausesWithPercentageDuration(...)`, `customPauses(...)`, or `pauses(type)`. An injected population carries that same list **minus the two `normalPauses*` methods**, which exist only on `SetUp` in both the Scala DSL and the Java API — per population a normal distribution is reachable only through the generic escape hatch, `pauses(normalPausesWithStdDevDuration(...))`; * as a `force` value: `disabledPauses`, `constantPauses`, `exponentialPauses`, `uniformPausesPlusOrMinusPercentage(...)`, `uniformPausesPlusOrMinusDuration(...)`, `normalPausesWithStdDevDuration(...)`, `normalPausesWithPercentageDuration(...)`, `customPauses(...)`. So the uniform type is `uniformPauses(20.0)` in one place and `uniformPausesPlusOrMinusPercentage(20.0)` in the other, and "disabled" is a method called `disablePauses()` in one and a value called `disabledPauses` in the other. The names are identical in the Java API and in Scala; Kotlin uses the Java ones. ## Where the type is resolved Gatling settles the type once, while it builds each population, in this order: 1. a `force` argument on the individual `pause(...)` call, if there is one; 2. the type declared on that injected population, e.g. `scn.injectOpen(...).exponentialPauses()`; 3. the type declared on `setUp`; 4. the built-in default, constant. (A `throttle` declared on the run or on a population also forces that population's type to disabled — `throttle` is a different subject, owned by the injection side of the DSL, and is mentioned here only because it lands in this same slot.) Two consequences follow. First, one `setUp` can hold populations with different policies, because most of the pause methods exist on an injected population as well as on `setUp`; a population's setting **replaces** the run-wide one rather than blending with it. Second, because the whole decision happens at build time, `disablePauses()` costs nothing at run time: a disabled pause is not turned into an action at all, so the chain is wired straight through to the next step rather than executing a check that skips a wait. ## What the policy does not touch The pause type is read in exactly one place in Gatling's source — the builder for the `pause` action. `pace` and `rendezVous` are built without ever consulting it. So `disablePauses()` removes every `pause` from the run and leaves every `pace` interval and every `rendezVous` barrier intact. If you are using `disablePauses()` as a "remove all waiting" switch, it is not one. Finally, there is no configuration key for any of this: nothing in `gatling.conf` sets the pause type. It is declared in the simulation's code or not at all.