NBomber

https://nbomber.com/docs/
Admin
NBomber is a powerful and flexible load testing framework designed to generate detailed performance...
Tokens:91,857
Snippets:1,240
Trust Score:7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Scenario Initialization Example

Source: https://nbomber.com/docs/nbomber/scenario?sp_open_privacyCenter=true

Basic usage of the WithInit method to perform setup tasks before the load test begins.

```csharp
var scenario = Scenario.Create("scenario_with_init", async context =>  
{  
    await Task.Delay(1_000);  
    return Response.Ok();  
})  
.WithInit(context =>  
{  
    // You can do here any initialization logic: populate the database, etc.  
    context.Logger.Information("MY INIT");  
    return Task.CompletedTask;  
});
```

--------------------------------

### Basic HTTP Scenario

Source: https://nbomber.com/docs/protocols/http/http-client

A simple example demonstrating how to create an HTTP client and send a GET request within an NBomber scenario.

```csharp
var httpClient = Http.CreateDefaultClient();  
  
var scenario = Scenario.Create("http_scenario", async context =>  
{     
    var request =  
        Http.CreateRequest("GET", "https://nbomber.com")  
            .WithHeader("Content-Type", "application/json")  
            .WithBody(new StringContent("{ some JSON }", Encoding.UTF8, "application/json"));  
  
    var response = await Http.Send(httpClient, request);  
  
    return response;  
});
```

--------------------------------

### Run Execution Examples

Source: https://nbomber.com/docs/nbomber/nbomber-runner

Examples showing basic test execution and execution with CLI arguments passed from the Main method.

```csharp
// basic run  
NBomberRunner  
    .RegisterScenarios(scenario)  
    .Run();  
  
// run with CLI arguments  
static void Main(string[] args)  
{  
    var scenario = Scenario.Create("scenario", ...);  
  
    NBomberRunner  
        .RegisterScenarios(scenario)  
        .Run(args);  
}
```

--------------------------------

### Install TimescaleDB

Source: https://nbomber.com/docs/nbomber-studio/installation/kubernetes

Create the namespace and deploy the TimescaleDB instance with a specified password.

```bash
kubectl create namespace nbomber-studio  
  
helm install nbomber-timescale timescale/timescale \  
  --namespace nbomber-studio \  
  --set postgresql.password=nb_studio_db  
```

--------------------------------

### Start NBomber Studio containers

Source: https://nbomber.com/docs/nbomber-studio/installation/docker

Run this command in the directory containing the docker-compose.yaml file to start the services.

```bash
docker compose up -d  
```

--------------------------------

### Install NBomber.MQTT package

Source: https://nbomber.com/docs/protocols/mqtt?sp_open_privacyCenter=true

Command to install the required NuGet package for MQTT support.

```bash
dotnet add package NBomber.MQTT
```

--------------------------------

### ThresholdSetting JSON Examples

Source: https://nbomber.com/docs/nbomber/asserts_and_thresholds?sp_open_privacyCenter=true

Basic examples of defining threshold settings within a JSON configuration.

```json
{ "OkLatency": "max < 100" },  
{ "OkLatency": "p75 < 80" },  
{ "StepName": "step_1", "OkLatency": "p75 < 80", "AbortWhenErrorCount": 42 },  
{ "StepName": "step_1", "OkLatency": "p75 < 80", "StartCheckAfter": "00:00:20" },  
```

--------------------------------

### Example Infrastructure Configuration File

Source: https://nbomber.com/docs/nbomber/json-config

A sample JSON file structure for configuring Serilog, PingPlugin, and InfluxDBSink.

```json
{
    "Serilog": {  
        "WriteTo": [{  
            "Name": "Elasticsearch",  
            "Args": {  
                "nodeUris": "http://localhost:9200",  
                "indexFormat": "nbomber-index-{0:yyyy.MM}"  
            }  
        }]  
    },  
  
    "PingPlugin": {  
        "Hosts": ["jsonplaceholder.typicode.com"],  
        "BufferSizeBytes": 32,  
        "Ttl": 128,  
        "DontFragment": false,  
        "Timeout": 1000  
    },  
      
    "InfluxDBSink": {  
      "Url": "http://localhost:8086",  
      "Database": "nbomber",  
      "UserName": "",  
      "Password": "",  
      "Token": "",  
      "CustomTags": [{"Key": "environment", "Value": "linux"}]  
    }  
}
```

--------------------------------

### Install NBomber.WebSockets

Source: https://nbomber.com/docs/protocols/websockets

Command to add the experimental WebSocket plugin to your project.

```bash
dotnet add package NBomber.WebSockets
```

--------------------------------

### Install NBomber.AMQP package

Source: https://nbomber.com/docs/protocols/amqp

Use the dotnet CLI to add the experimental AMQP plugin to your project.

```bash
dotnet add package NBomber.AMQP
```

--------------------------------

### Install NBomber Converter CLI

Source: https://nbomber.com/docs/plugins/converter/overview

Install the converter tool globally via the .NET CLI.

```bash
dotnet tool install -g nbomber.converter.tool
```

```bash
dotnet tool install -g nbomber.converter.tool --version 0.1.1
```

--------------------------------

### Run NBomber Cluster in Local Dev Mode

Source: https://nbomber.com/docs/cluster/run-cluster-cli?sp_open_privacyCenter=true

Example commands to start multiple NBomber processes in a local development cluster without requiring a license key.

```bash
# to start NBomber process 1  
dotnet my-nbomber-test.dll --cluster-local-dev=true --cluster-id=default --cluster-agents-count=2 --cluster-nats-url=nats://localhost  
  
# to start NBomber process 2  
dotnet my-nbomber-test.dll --cluster-local-dev=true --cluster-id=default --cluster-agents-count=2 --cluster-nats-url=nats://localhost  
  
# to start NBomber process 3  
dotnet my-nbomber-test.dll --cluster-local-dev=true --cluster-id=default --cluster-agents-count=2 --cluster-nats-url=nats://localhost
```

--------------------------------

### Verify Kubernetes Prerequisites

Source: https://nbomber.com/docs/nbomber-studio/installation/kubernetes

Check cluster connectivity, Helm installation, and storage configuration before proceeding with the installation.

```bash
kubectl cluster-info  
helm version  
kubectl get storageclass  
```

--------------------------------

### Install xUnit Dependencies

Source: https://nbomber.com/docs/nbomber/asserts_and_thresholds?sp_open_privacyCenter=true

Required dotnet commands to set up xUnit for NBomber assertions.

```bash
dotnet add package xunit  
dotnet add package xunit.runner.visualstudio  
dotnet add package Microsoft.NET.Test.Sdk  
```

--------------------------------

### Install NBomber Studio

Source: https://nbomber.com/docs/nbomber-studio/installation/kubernetes

Deploy NBomber Studio using the Helm chart and provide the database connection string.

```bash
helm install nbomber-studio nbomber-studio/nbomber-studio \  
  --namespace nbomber-studio \  
  --set config.secret.enabled=true \  
  --set-string "config.secret.data.PostgreSql.ConnectionString=Host=nbomber-timescale.nbomber-studio.svc.cluster.local;Port=5432;Username=nb_studio_db;Password=nb_studio_db;Database=nb_studio_db"  
```

--------------------------------

### Run

Source: https://nbomber.com/docs/nbomber/nbomber-runner

Starts the load test execution and returns the final statistics.

```APIDOC
## Run()

### Description
Starts the load test execution. It returns NodeStats containing the final statistics of the test run.

### Signatures
`public NodeStats Run()`
`public NodeStats Run(string[] args)`

### Parameters
- **args** (string[]) - Optional - CLI arguments to override test settings.
```

--------------------------------

### Full NBomberRunner Configuration Example

Source: https://nbomber.com/docs/nbomber/nbomber-runner

Demonstrates chaining multiple configuration methods to set up a comprehensive load test execution.

```csharp
NBomberRunner  
    .RegisterScenarios(scenario)  
    .LoadConfig("config.json")  
    .WithTestSuite("my test suite")  
    .WithTestName("my test name")  
    .WithLicense("Your_License_Key")  
    .WithReportFileName("my_report")  
    .WithReportFolder("report_folder")  
    .WithReportFormats(ReportFormat.Txt, ReportFormat.Html)  
    .WithReportingInterval(TimeSpan.FromSeconds(5))  
    .WithMinimumLogLevel(LogEventLevel.Debug)  
    .DisplayConsoleMetrics(true)  
    .Run();
```

--------------------------------

### Install NBomber.Data package

Source: https://nbomber.com/docs/nbomber/data

Command to add the NBomber.Data NuGet package to your project.

```bash
dotnet add package NBomber.Data
```

--------------------------------

### CLI Configuration Arguments

Source: https://nbomber.com/docs/nbomber-studio/config?sp_open_privacyCenter=true

Examples of using the --config or -c command-line arguments to load single or multiple configuration files.

```bash
# Single config file
--config /path/to/config.json

# Short form
-c /path/to/config.json

# Multiple config files (later files override earlier ones)
--config /path/to/base-config.json --config /path/to/secrets.json
```

--------------------------------

### LoadConfig Usage Examples

Source: https://nbomber.com/docs/nbomber/nbomber-runner

Demonstrates loading configuration from a local file, a remote URL, or a raw JSON string.

```csharp
// from local file  
NBomberRunner  
    .RegisterScenarios(scenario)  
    .LoadConfig("config.json")  
    .Run();  
  
// from URL  
NBomberRunner  
    .RegisterScenarios(scenario)  
    .LoadConfig("https://my-test-host.com/config.json")  
    .Run();  
  
// from JSON content  
NBomberRunner  
    .RegisterScenarios(scenario)  
    .LoadConfig("{ \"TestSuite\": \"my-suite\" }")  
    .Run();
```

--------------------------------

### Configure NBomber Studio with Docker

Source: https://nbomber.com/docs/nbomber-studio/config

Examples of mounting configuration files into a Docker container and passing them via the command directive.

```yaml
services:  
  nbomber-studio:  
    image: nbomberdocker/nbomber-studio:latest  
    ports:  
      - "5333:8080"  
    volumes:  
      - ./config.json:/app/config.json  
    command: ["--config", "/app/config.json"]
```

```yaml
services:  
  nbomber-studio:  
    image: nbomberdocker/nbomber-studio:latest  
    ports:  
      - "5333:8080"  
    volumes:  
      - ./config.json:/app/config.json  
      - ./secrets.json:/app/secrets.json  
    command: ["--config", "/app/config.json", "--config", "/app/secrets.json"]
```

--------------------------------

### Start Grafana and InfluxDB services

Source: https://nbomber.com/docs/reporting/realtime/grafana?sp_open_privacyCenter=true

Executes the docker-compose configuration to launch the monitoring stack.

```bash
docker compose up -d
```

--------------------------------

### Install NBomber.WebBrowser package

Source: https://nbomber.com/docs/protocols/webbrowser

Use this command to add the experimental WebBrowser package to your .NET project.

```bash
dotnet add package NBomber.WebBrowser
```

--------------------------------

### Configure InfluxDB Sink

Source: https://nbomber.com/docs/reporting/realtime/influx-db?sp_open_privacyCenter=true

Examples for initializing InfluxDB clients for different versions to be used with the InfluxDBSink.

```csharp
var influxDbSink = new InfluxDBSink(  
    new InfluxDBClient("http://localhost:8086", "username", "password", "database", retentionPolicy: "autogen")  
);  
```

```csharp
var influxOpt = new InfluxDBClientOptions("http://localhost:8086");  
influxOpt.Org = "Org";  
influxOpt.Bucket = "nbomber";  
influxOpt.Token = "Token"  
  
var influxDbSink = new InfluxDBSink(  
    new InfluxDBClient(influxOpt)  
);  
```

--------------------------------

### Install TimescaleDB Sink Package

Source: https://nbomber.com/docs/reporting/realtime/timescale

Use the .NET CLI to add the NBomber.Sinks.Timescale package to your project.

```bash
dotnet add package NBomber.Sinks.Timescale
```

--------------------------------

### Install NBomber.Http package

Source: https://nbomber.com/docs/getting-started/hello_world_tutorial

Use the .NET CLI to add the necessary HTTP plugin dependency to your project.

```bash
dotnet add package NBomber.Http
```

--------------------------------

### Install NBomber.RestSharp package

Source: https://nbomber.com/docs/protocols/http/restsharp?sp_open_privacyCenter=true

Use the .NET CLI to add the required dependency to your project.

```bash
dotnet add package NBomber.RestSharp
```

--------------------------------

### Run Method Signatures

Source: https://nbomber.com/docs/nbomber/nbomber-runner

Method signatures for starting the load test execution, with or without CLI arguments.

```csharp
public NodeStats Run()  
public NodeStats Run(string[] args)
```

--------------------------------

### Create an HTTP load test

Source: https://nbomber.com/docs/getting-started/hello_world_tutorial

Implement a scenario that performs HTTP GET requests.

```csharp
using System;
using System.Threading.Tasks;
using System.Net.Http;
using NBomber.CSharp;

namespace MyLoadTest
{
    class Program
    {
        static void Main(string[] args)
        {     
            var httpClient = Http.CreateDefaultClient();

            var scenario = Scenario.Create("hello_world_scenario", async context =>
            {
                var response = await httpClient.GetAsync("https://nbomber.com");

                return response.IsSuccessStatusCode
                    ? Response.Ok()
                    : Response.Fail();
            })
            .WithoutWarmUp()
            .WithLoadSimulations(
                Simulation.Inject(rate: 10,
                                  interval: TimeSpan.FromSeconds(1),
                                  during: TimeSpan.FromSeconds(30))
            );

            NBomberRunner
                .RegisterScenarios(scenario)
                .Run();
        }
    }
}
```

--------------------------------

### Modeling a User Workflow

Source: https://nbomber.com/docs/nbomber/scenario?sp_open_privacyCenter=true

An example of modeling a multi-step user workflow within a scenario.

```csharp
var scenario = Scenario.Create("my e-commerce scenario", async context =>  
{  
    await Login();          
    await OpenHomePage();       
    await Logout();  
  
    return Response.Ok();          
});
```

--------------------------------

### Install OpenTelemetry Sink via NuGet

Source: https://nbomber.com/docs/reporting/realtime/opentelemetry

Use the .NET CLI to add the experimental OpenTelemetry sink package to your project.

```bash
dotnet add package NBomber.Sinks.OpenTelemetry
```

--------------------------------

### Basic WebSocket PUSH with callback

Source: https://nbomber.com/docs/best-practices/testing-push

Demonstrates a standard WebSocket client setup using a callback function to handle incoming messages.

```csharp
var client = new WebsocketClient(url);  
  
await client.Connect();  
  
await client.Send("message 1");  
  
client.MessageReceived.Subscribe(msg => Console.WriteLine(msg)); // callback function  
  
await client.Send("message 2");  
```

--------------------------------

### Install Datadog Sink Package

Source: https://nbomber.com/docs/reporting/realtime/datadog

Use the .NET CLI to add the required Datadog sink package to your project.

```bash
dotnet add package NBomber.Sinks.Datadog
```

--------------------------------

### Install Serilog Elasticsearch sink

Source: https://nbomber.com/docs/nbomber/logger

Use the .NET CLI to add the required NuGet package for Elasticsearch logging support.

```bash
dotnet add package Serilog.Sinks.Elasticsearch
```

--------------------------------

### Configure NBomber with JSON

Source: https://nbomber.com/docs/nbomber/json-config

A complete JSON configuration example for defining test suites, scenarios, load simulations, and custom settings.

```json
{
  "TestSuite": "gitter.io",
  "TestName": "test_http_api",

  "TargetScenarios": ["test_youtube"],

  "GlobalSettings": {

    "ScenariosSettings": [
      {
          "ScenarioName": "test_youtube",
          "WarmUpDuration": "00:00:02",

          "LoadSimulationsSettings": [
              { "RampingInject": [50, "00:00:01", "00:00:30"] },
              { "Inject": [50, "00:00:01", "00:01:00"] },
              { "RampingInject": [0, "00:00:01", "00:00:30"] }
          ],

          "CustomSettings": {
              "MyTestField": "localhost",
              "MyPauseMs": 100
          },

          "MaxFailCount": 500,

          "Weight": 10
      }
    ],

    "GlobalCustomSettings": {
        "ConnectionString": "my_db_connection_string"
    },

    "ReportFileName": "custom_report_name",
    "ReportFolder": "./my_reports",
    "ReportFormats": ["Html", "Txt"],
    "ReportingInterval": "00:00:30",

    "DisplayConsoleMetrics": true
  }
}
```

--------------------------------

### Defining a Scenario with Multiple Steps

Source: https://nbomber.com/docs/nbomber/scenario/step

Example of a workflow scenario consisting of login, home page access, and logout steps.

```csharp
var scenario = Scenario.Create("my e-commerce scenario", async context =>  
{  
    var step1 = await Step.Run("login", context, async () =>  
    {  
        await Task.Delay(1_000);  
        return Response.Ok();  
    });  
  
    var step2 = await Step.Run("open_home_page", context, async () =>  
    {  
        await Task.Delay(1_000);  
        return Response.Ok();  
    });      
  
    var step3 = await Step.Run("logout", context, async () =>  
    {  
        await Task.Delay(1_000);  
        return Response.Ok();  
    });  
  
    return Response.Ok();          
});
```

--------------------------------

### Create a Scenario

Source: https://nbomber.com/docs/nbomber/scenario

Defines the method signature for creating a scenario and provides an example of modeling a multi-step user workflow.

```csharp
public static ScenarioProps Create(string name, Func<IScenarioContext, Task<IResponse>> run)
```

```csharp
var scenario = Scenario.Create("my e-commerce scenario", async context =>  
{  
    await Login();          
    await OpenHomePage();       
    await Logout();  
  
    return Response.Ok();          
});
```

--------------------------------

### Get elapsed scenario time

Source: https://nbomber.com/docs/nbomber/scenario/scenario-context

Use GetScenarioTimerTime to retrieve the duration since the scenario started, useful for conditional logic based on test duration.

```csharp
var scenario = Scenario.Create("timer_example", async context =>  
{  
    var elapsed = context.GetScenarioTimerTime();  
  
    if (elapsed > TimeSpan.FromMinutes(5))  
    {  
        context.Logger.Information("Test running for over 5 minutes, elapsed: {0}", elapsed);  
    }  
  
    return Response.Ok();  
});
```

--------------------------------

### Basic RestSharp client usage in NBomber

Source: https://nbomber.com/docs/protocols/http/restsharp?sp_open_privacyCenter=true

Demonstrates initializing a client and executing PUT and GET requests using the RestSharp plugin.

```csharp
var options = new RestClientOptions($"http://localhost:60529");  
var client = RestClientBuilder.CreateDefaultClient(options);  
  
var request = new RestRequest("api/users/{id}");  
request.AddParameter("id", userId, ParameterType.UrlSegment);  
  
// PUT  
var response = await client.SendPut(request);  
  
// GET  
var response = await client.SendGet<User>(request);
```

--------------------------------

### Configure initialization and cleanup for an empty scenario

Source: https://nbomber.com/docs/nbomber/scenario?sp_open_privacyCenter=true

Use WithInit and WithClean to define setup and teardown logic for a scenario that does not perform load testing.

```csharp
var initDbScn =   
  Scenario  
      .Empty("populate_database_scenario")  
      .WithInit(async context =>  
      {  
          // here we can populate our DB  
          await Task.Delay(5000);  
      })  
      .WithClean(async context =>  
      {  
          // here we can do a cleanup for our DB  
          await Task.Delay(5000);  
      });
```

--------------------------------

### Initializing and Populating ClientPool

Source: https://nbomber.com/docs/nbomber/client-pool

Demonstrates initializing a ClientPool and populating it with clients during the Scenario Init phase.

```csharp
var clientPool = new ClientPool<WebsocketClient>();  
  
var scenario = Scenario.Create("scenario", async context =>   
{   
    ...   
})  
.WithInit(async context =>  
{  
    for (var i = 0; i < 10; i++)  
    {  
        var client = new WebsocketClient(url);      
        await client.Connect();  
  
        clientPool.AddClient(client);  
    }      
});
```

--------------------------------

### Pass configuration via CLI arguments

Source: https://nbomber.com/docs/nbomber-studio/config

Examples of using the --config or -c flags to provide one or more configuration files to the application.

```bash
# Single config file  
--config /path/to/config.json  
  
# Short form  
-c /path/to/config.json  
  
# Multiple config files (later files override earlier ones)  
--config /path/to/base-config.json --config /path/to/secrets.json
```

--------------------------------

### Implement Uniform Distribution Scenario

Source: https://nbomber.com/docs/nbomber/dynamic-workloads

Demonstrates using System.Random via IScenarioContext to switch between steps based on a uniform distribution.

```csharp
var scenario = Scenario.Create("home_page", async context =>  
{  
    // context.Random: System.Random  
    var stepNumber = context.Random.Next(minValue: 1, maxValue: 11);  
      
    switch (stepNumber)  
    {  
        case 1: // run step 1  
            Step.Run("step_1", ...);  
            break;  
  
        case 2: // run step 2  
            Step.Run("step_2", ...);  
            break;  
          
        ...  
    }  
});  
```

--------------------------------

### Add NBomber package

Source: https://nbomber.com/docs/getting-started/installation

Installs the NBomber NuGet package into the current project.

```bash
dotnet add package NBomber
```

--------------------------------

### Define NBomber Scenario

Source: https://nbomber.com/docs/nbomber-studio/loadtests-in-k8s/docker

Example of creating a scenario named 'my_scenario' in C#.

```csharp
var scenario = Scenario.Create("my_scenario", async context => ...)
```

--------------------------------

### Applying CustomSettings in Init

Source: https://nbomber.com/docs/nbomber/scenario?sp_open_privacyCenter=true

Retrieving and applying custom configuration settings during the initialization phase.

```csharp
var scenario = Scenario.Create("scenario_with_init", async context =>  
{  
    await Task.Delay(1_000);  
    return Response.Ok();  
})  
.WithInit(context =>  
{  
    var customSettings = context.CustomSettings.Get<CustomScenarioSettings>();  
  
    context.Logger.Information(  
        "test init received CustomSettings.TestField '{TestField}'",  
        customSettings.TestField  
    );  
});
```

--------------------------------

### Creating a client for every turn

Source: https://nbomber.com/docs/nbomber/client-pool

This approach initializes, connects, and disconnects a new client instance for every single scenario iteration.

```csharp
var scenario = Scenario.Create("scenario", async context =>  
{  
    using var client = new WebsocketClient(url);  
      
    await client.Connect();  
  
    await client.Send("message");  
  
    await client.Disconnect();  
});
```

--------------------------------

### Send WebSocket Data

Source: https://nbomber.com/docs/protocols/websockets

Method signatures and examples for sending text or binary payloads.

```csharp
public ValueTask Send(string text, CancellationToken cancellationToken = default);  
  
public ValueTask Send(ReadOnlyMemory<byte> payload, CancellationToken cancellationToken = default);
```

```csharp
var step = await Step.Run("send", context, async () =>  
{  
    string command = "ping";      
    await websocket.Send(command);  
  
    return Response.Ok(sizeBytes: command.Length);  
});
```

```csharp
var step = await Step.Run("send", context, async () =>  
{  
    byte[] data = Encoding.UTF8.GetBytes("pong");  
    await websocket.Send(data);  
      
    return Response.Ok(sizeBytes: data.Length);  
});
```

--------------------------------

### Create a new console project

Source: https://nbomber.com/docs/getting-started/installation

Initializes a new C# console application project using the .NET CLI.

```bash
dotnet new console -n [project_name] -lang ["C#"]
```

--------------------------------

### Access custom settings in C#

Source: https://nbomber.com/docs/nbomber/json-config

Demonstrates how to define classes for custom settings and retrieve them within the ScenarioInit handler.

```csharp
public class CustomScenarioSettings
{
    public string MyTestField { get; set; }
    public int MyPauseMs { get; set; }
}

public class GlobalScenarioSettings
{
    public string ConnectionString { get; set; }
}

public class JSONConfigExample
{
    CustomScenarioSettings _customSettings = new();

    public void Run()
    {
        var scenario = Scenario.Create("my_scenario", async context =>
        {
            var step = await Step.Run("step", context, async () =>
            {
                await Task.Delay(_customSettings.MyPauseMs);

                context.Logger.Debug(
                    "step received CustomSettings.MyTestField '{0}'",
                    _customSettings.MyTestField
                );

                return Response.Ok();
            });

            return Response.Ok();
        })
        .WithInit(context =>
        {
            // On Scenario Init, the corresponding CustomSettings defined in JSON Config
            // will be passed and loaded here.
            _customSettings = context.CustomSettings.Get<CustomScenarioSettings>();

            context.Logger.Information(
                "test init received CustomSettings.MyTestField '{0}'",
                _customSettings.MyTestField
            );

            // if you want some settings to be shared globally among all scenarios
            // you can use GlobalCustomSettings for this
            var globalSettings = context.GlobalCustomSettings.Get<GlobalScenarioSettings>();
            context.Logger.Information(
                "test init received GlobalSettings.ConnectionString '{0}'",
                globalSettings.ConnectionString
            );

            return Task.CompletedTask;
        })
        .WithLoadSimulations(
            Simulation.Inject(rate: 50,
                              interval: TimeSpan.FromSeconds(1),
                              during: TimeSpan.FromMinutes(1))
        )
        .WithWarmUpDuration(TimeSpan.FromSeconds(10))
        .WithMaxFailCount(1_000)
        .WithWeight(10);

        NBomberRunner
            .RegisterScenarios(scenario)
            .LoadConfig("./Features/CustomSettings/config.json")
            .WithTestSuite("my test suite")
            .WithTestName("my test name")
            .WithReportFileName("my_report")
            .WithReportFolder("report_folder")
            .WithReportFormats(ReportFormat.Txt, ReportFormat.Html)
            .WithReportingInterval(TimeSpan.FromSeconds(10))
            .DisplayConsoleMetrics(true)
            .Run();
    }
}
```

--------------------------------

### HTTP Trace Log Output

Source: https://nbomber.com/docs/protocols/http/http-client

Example of the log output generated when HTTP tracing is enabled.

```text
2024-04-06 10:56:11.090 +03:00 [DBG] [ThreadId:7] HTTP Request:  
 TraceId: 30774c79337a4d3e9c6fa897bdb87ad1  
 Method: GET  
 RequestUri: "https://jsonplaceholder.typicode.com/todos/1"  
 HttpVersion: 1.1  
 Headers: Content-Type: application/json  
 Content:   
  
2024-04-06 10:56:11.994 +03:00 [DBG] [ThreadId:9] HTTP Response:  
 TraceId: 30774c79337a4d3e9c6fa897bdb87ad1  
 HttpVersion: 1.1  
 StatusCode: "OK"  
 ReasonPhrase: OK  
 Headers: Date: Sat, 06 Apr 2024 07:56:10 GMT, Connection: keep-alive, Report-To: {"group":"heroku-nel","max_age":3600,"endpoints":[{"url":"https://nel.heroku.com/reports?ts=1712102103&sid=e11707d5-02a7-43ef-b45e-2cf4d2036f7d&s=NEDTWuReF%2Ftx6jFV3Ve%2FTGNlbenGGlra6iQD4Wu%2BL1k%3D"}]}, Reporting-Endpoints: heroku-nel=https://nel.heroku.com/reports?ts=1712102103&sid=e11707d5-02a7-43ef-b45e-2cf4d2036f7d&s=NEDTWuReF%2Ftx6jFV3Ve%2FTGNlbenGGlra6iQD4Wu%2BL1k%3D, Nel: {"report_to":"heroku-nel","max_age":3600,"success_fraction":0.005,"failure_fraction":0.05,"response_headers":["Via"]}, X-Powered-By: Express, X-Ratelimit-Limit: 1000, X-Ratelimit-Remaining: 999, X-Ratelimit-Reset: 1712102115, Vary: Origin, Accept-Encoding, Access-Control-Allow-Credentials: true, Cache-Control: max-age=43200, Pragma: no-cache, X-Content-Type-Options: nosniff, ETag: W/"53-hfEnumeNh6YirfjyjaujcOPPT+s", Via: 1.1 vegur, CF-Cache-Status: HIT, Age: 23727, Accept-Ranges: bytes, Server: cloudflare, CF-RAY: 8700384848945b45-VIE, Alt-Svc: h3=":443"  
 Content: {  
  "userId": 1,  
  "id": 1,  
  "title": "delectus aut autem",  
  "completed": false  
}  
```

--------------------------------

### Navigate to project directory

Source: https://nbomber.com/docs/getting-started/installation

Changes the current working directory to the newly created project folder.

```bash
cd [project_name]
```

--------------------------------

### Configure Ramping Constant Load Simulation

Source: https://nbomber.com/docs/nbomber/load-simulation

Demonstrates how to use RampingConstant to scale the number of concurrent scenario instances over time. This example shows a two-stage ramp-up and ramp-down process.

```csharp
Scenario.Create("scenario", async context =>  
{  
    await Task.Delay(1_000);  
    return Response.Ok();  
})  
.WithLoadSimulations(  
    // ramp up from 0 to 50 copies      
    // duration: 30 seconds (it executes from [00:00:00] to [00:00:30])  
    Simulation.RampingConstant(copies: 50, during: TimeSpan.FromSeconds(30)),  
  
    // ramp down from 50 to 20 copies  
    // duration: 30 seconds (it executes from [00:00:30] to [00:01:00])  
    Simulation.RampingConstant(copies: 20, during: TimeSpan.FromSeconds(30))  
);
```

--------------------------------

### Set Max Fail Count in Scenario

Source: https://nbomber.com/docs/nbomber/scenario?sp_open_privacyCenter=true

Example of applying a custom failure threshold to a scenario.

```csharp
var scenario = Scenario.Create("scenario", async context =>  
{  
    await Task.Delay(1_000);  
    return Response.Ok();  
})  
.WithMaxFailCount(10);
```

--------------------------------

### Defining Thresholds with Bytes

Source: https://nbomber.com/docs/nbomber/asserts_and_thresholds?sp_open_privacyCenter=true

Example of using the Bytes helper to define a data transfer threshold.

```csharp
// all data transfers should be bigger than 10GB  
Assert.True(stats.Ok.DataTransfer.AllBytes > Bytes.FromGb(10));  
```

--------------------------------

### Apply license via CLI arguments

Source: https://nbomber.com/docs/getting-started/license

Pass the license key as a command-line argument when executing the project DLL.

```bash
YourProject.dll --license=Your_License_Key  
```

--------------------------------

### Apply license via NBomberRunner

Source: https://nbomber.com/docs/getting-started/license

Use the WithLicense method directly on the NBomberRunner instance to apply your license key.

```csharp
NBomberRunner  
    .RegisterScenarios(scenario1)  
	    .WithLicense("Your_License_Key")  
    .Run();  
```

--------------------------------

### Basic Assertions Example

Source: https://nbomber.com/docs/nbomber/asserts_and_thresholds?sp_open_privacyCenter=true

Using xUnit assertions to validate latency statistics after a test run.

```csharp
Assert.True(stepStats.Ok.Latency.Percent99 > 0);  
Assert.False(stepStats.Ok.Latency.Percent99 > 1_000);  
```

--------------------------------

### Run Coordinator via Code

Source: https://nbomber.com/docs/cluster/run-cluster-json?sp_open_privacyCenter=true

Configures and starts the Coordinator programmatically using the NBomberRunner API.

```csharp
var scenario1 = Scenario.Create("scenario_1", async context => { ... });
var scenario2 = Scenario.Create("scenario_2", async context => { ... });
var scenario3 = Scenario.Create("scenario_3", async context => { ... });

NBomberRunner
    .RegisterScenarios(scenario1, scenario2, scenario3)
    .LoadConfig("manualcluster-config.json")
    .WithNodeType(NodeType.Coordinator)
    .WithAgentsCount(50)
    .Run(args);
```

--------------------------------

### Run Coordinator via CLI

Source: https://nbomber.com/docs/cluster/run-cluster-json?sp_open_privacyCenter=true

Starts an NBomber process as the Coordinator using command-line arguments.

```bash
MyLoadTest.dll --config="manualcluster-config.json" --cluster-node-type=coordinator --license=YOUR_LICENSE_KEY
```

--------------------------------

### Run Agent via Code

Source: https://nbomber.com/docs/cluster/run-cluster-json?sp_open_privacyCenter=true

Configures and starts an Agent programmatically using the NBomberRunner API.

```csharp
var scenario1 = Scenario.Create("scenario_1", async context => { ... });
var scenario2 = Scenario.Create("scenario_2", async context => { ... });
var scenario3 = Scenario.Create("scenario_3", async context => { ... });

NBomberRunner
    .RegisterScenarios(scenario1, scenario2, scenario3)
    .LoadConfig("manualcluster-config.json")
    .WithAgentGroup("my_group")
    .WithNodeType(NodeType.Agent)
    .Run(args);
```

--------------------------------

### Random DataFeed Usage

Source: https://nbomber.com/docs/nbomber/data

Example of using a Random DataFeed to retrieve non-sequential values within a scenario.

```csharp
var id = new[] { 10, 11, 12, 13, 14 };  
  
// here we create Random DataFeed   
// that randomly picks an item per GetNextItem() invocation.  
var myDataFeed = DataFeed.Random(users);  
  
var scenario = Scenario.Create("scenario", async ctx =>  
{  
    // then in Scenario you can get RANDOM values from the DataFeed  
  
    var number = myDataFeed.GetNextItem(ctx.ScenarioInfo); // 10      
    number = myDataFeed.GetNextItem(ctx.ScenarioInfo);     // 10  
    number = myDataFeed.GetNextItem(ctx.ScenarioInfo);     // 14     
    number = myDataFeed.GetNextItem(ctx.ScenarioInfo);     // 13     
    number = myDataFeed.GetNextItem(ctx.ScenarioInfo);     // 11         
    number = myDataFeed.GetNextItem(ctx.ScenarioInfo);     // 12         
  
    return Response.Ok();  
})
```

--------------------------------

### Implement MQTT Ping Pong Scenario

Source: https://nbomber.com/docs/protocols/mqtt?sp_open_privacyCenter=true

Demonstrates a basic MQTT scenario where a client connects, subscribes to a unique topic, performs a publish-receive cycle, and disconnects.

```csharp
var payload = Data.GenerateRandomBytes(200);  
  
var scenario = Scenario.Create("mqtt_scenario", async ctx =>  
{  
    var topic = $"/clients/{ctx.ScenarioInfo.InstanceId}";  
    using var mqttClient = new MqttClient(new MqttClientFactory().CreateMqttClient());  
  
    var connect = await Step.Run("connect", ctx, async () =>  
    {  
        var options = new MqttClientOptionsBuilder()  
            .WithTcpServer("localhost")  
            .Build();  
  
        return await mqttClient.Connect(options);  
    });  
  
    var subscribe = await Step.Run("subscribe", ctx, async () =>  
    {  
        var response = await mqttClient.Subscribe(topic);  
        return response;  
    });  
  
    var publish = await Step.Run("publish", ctx, async () =>  
    {  
        var msg = new MqttApplicationMessageBuilder()  
            .WithTopic(topic)  
            .WithPayload(payload)  
            .Build();  
  
        return await mqttClient.Publish(msg);  
    });  
  
    var receive = await Step.Run("receive", ctx, async () =>  
    {  
        // pass the ScenarioCancellationToken to stop waiting for a response if the scenario finish event is triggered  
        var response = await mqttClient.Receive(ctx.ScenarioCancellationToken);  
        return response;  
    });  
  
    var disconnect = await Step.Run("disconnect", ctx, async () =>  
    {  
        var response = await mqttClient.Disconnect();  
        return response;  
    });  
  
    return Response.Ok();  
})  
```

--------------------------------

### Agent Group Configuration Block

Source: https://nbomber.com/docs/cluster/run-cluster-json

Example of defining multiple agent groups with specific target scenarios.

```json
"Agent": {  
    "AgentGroups": [  
        { "AgentGroup": "1", "TargetScenarios": ["scenario_1"] },  
        { "AgentGroup": "2", "TargetScenarios": ["scenario_2"] },  
        { "AgentGroup": "my_group", "TargetScenarios": ["scenario_3"] }  
    ],  
    "AgentsCount": 1  
}
```

--------------------------------

### Delayed Runtime Threshold Check

Source: https://nbomber.com/docs/nbomber/asserts_and_thresholds?sp_open_privacyCenter=true

Delaying the start of threshold evaluation to allow for system stabilization during ramp-up.

```csharp
Threshold.Create(scenarioStats =>   
    scenarioStats.Fail.Request.Percent < 10,   
    startCheckAfter: TimeSpan.FromSeconds(10) // Threshold check will be delayed on 10 sec  
)  
```

--------------------------------

### Manage NATS Container Lifecycle

Source: https://nbomber.com/docs/cluster/install-nats?sp_open_privacyCenter=true

Commands to start and stop the NATS container using Docker Compose.

```bash
docker compose up -d  
```

```bash
docker compose down  
```

--------------------------------

### Register DatadogSink in NBomberRunner

Source: https://nbomber.com/docs/reporting/realtime/datadog

Load the infrastructure configuration and register the Datadog sink during the NBomber runner setup.

```csharp
var datadog = new DatadogSink();  
  
var scenario = Scenario.Create("scenario", async context => { ... });  
  
NBomberRunner  
    .RegisterScenarios(scenario)      
    .WithReportingInterval(TimeSpan.FromSeconds(5))  
    .WithReportingSinks(datadog)  
    .LoadInfraConfig("infra-config.json");
```
Tokens:
Raw