Setup Load Test

What is Load Testing?

Load testing is a critical discipline in performance engineering that involves simulating realistic user traffic and conditions to evaluate how an application behaves under stress. Its primary goal is to determine the system's capacity, identify performance bottlenecks, and ensure the application remains stable and responsive as user demand increases.

Significance of Load Testing:

1. Capacity Planning: Determine the maximum number of users your system can handle before performance degrades.

2. Bottleneck Identification: Pinpoint specific components (database queries, API endpoints, server resources) that slow down under load.

3. Scalability Validation: Confirm that your infrastructure scales effectively to meet peak demand.

4. Risk Mitigation: Proactively fix performance issues before they lead to production outages or poor user experience.

PerfAgents streamlines this process by enabling you to leverage industry-standard JMeter load tests while seamlessly scaling load generation across distributed cloud infrastructure.

Create Your First Load Test

After selecting a project, you can configure and execute your first load test. Navigate to Create Load Test from the Left Navigation. The load test creation process is structured into three main configuration sections:

Section 1: Test Configuration

This section defines the identity and script for your load test.

Field	Description	Example
Test Name (Required)	A descriptive name for the test.	Homepage Load Test – Q1
Description (Optional)	Explain the purpose of this test.	“Simulate 500 concurrent users during peak sale.”
Tags (Optional)	Add tags separated by spaces or commas for filtering.	homepage, q1, critical

Upload JMX File

• PerfAgents uses JMeter (`.jmx`) files for load test execution.

• Drag and drop your `.jmx` file or click browse.

• Once uploaded, the file appears under “Uploaded JMX File”.

Supporting Files (Optional)

Upload any necessary files for your test, such as CSV data files, configuration files, or other resources.

Test Variables

Define key-value pairs to override variables in the JMX file, enabling execution for different configurations without modifying the script.

Name	Value
base_url	https://staging.example.com

Section 2: Load Configuration

The Load Configuration section dynamically renders thread group controls based on the uploaded JMX file. Upon uploading a JMeter script, PerfAgents automatically detects the thread groups and generates customized configuration panels based on their specific types. For multi-thread JMeter scripts PerfAgents parses all thread groups within the file and displays dedicated configuration panels for each one. This ensures complete transparency and granular control over every execution unit within your test plan.

Thread Group–Wise Configuration Rendering

When a JMX file is uploaded:

• PerfAgents detects all thread groups defined in the test plan.

• Each thread group is displayed as an independent configuration block.

• Configurations are auto-mapped based on the type of thread group.

• Users can view/modify load parameters without editing the original JMX file.

Each thread group is clearly segmented and labeled for visibility and control.

Supported Thread Group Types

PerfAgents supports multiple JMeter thread group types and renders configuration options specific to each type.

Standard Test Plan Thread Group

The Standard Test Plan Thread Group represents the traditional JMeter thread group model. It is designed for straightforward, time-based load execution where traffic follows a predictable ramp-up, steady-state duration, and optional loop behavior. This configuration is best suited for simple and controlled load testing scenarios where complex traffic staging is not required.

Configurable Parameters

1. Virtual Users: Defines the total number of concurrent threads (virtual users) that will execute the test plan. This represents the peak concurrency level during the test execution. Users are introduced progressively based on the ramp-up configuration.

2. Duration: Specifies how long the thread group will remain active once execution begins. This allows you to define a time-bound test window (e.g., 2 minutes, 15 minutes, 30 minutes, etc.), ensuring predictable execution control.

3. Ramp-Up Time: Determines how long it takes to reach the configured number of virtual users. Instead of starting all threads instantly, users are distributed evenly across the ramp-up period. For example:

   1. 100 users with a 100-second ramp-up → 1 user starts per second.

   This helps prevent artificial traffic spikes and simulates gradual traffic growth.

4. Start-Up Delay: Defines a delay before the thread group begins execution. This is useful when:

   1. Coordinating with other thread groups

   2. Sequencing traffic

   3. Allowing setup tasks to complete before load injection begins

5. Loop Count (Including Infinite Option): Specifies how many times each virtual user executes the test script during the active duration. Options include:

   1. Fixed loop count (e.g., run 5 times)

   2. Infinite loop (executes continuously until duration ends)

   The infinite option is typically used for time-based tests where sustained load is required without limiting iteration count.

Visualization Support

PerfAgents enhances the standard thread group configuration with real-time validation and visualization:

1. Live Thread Curve Preview: A dynamic graph displays how virtual users will increase over time based on the configured ramp-up and duration. This allows you to:

   1. Validate concurrency growth

   2. Identify unintended spikes

   3. Confirm steady-state behavior

2. Peak Users Display: Automatically calculates and displays the maximum number of concurrent users defined in the configuration. This helps verify infrastructure capacity planning before execution.

3. Total Duration Summary: Displays the total calculated test runtime including ramp-up and steady-state periods. This ensures clarity around actual execution time before the test is launched.

Ultimate Thread Group (UTG)

The Ultimate Thread Group (UTG) is designed for advanced traffic modeling and complex load simulation scenarios. Unlike standard thread groups that follow a simple ramp-up and duration model, UTG allows you to define multiple staged schedules within a single thread group. This makes it ideal for replicating real-world production traffic patterns where user load fluctuates over time.

Configurable Parameters

Each row in the UTG schedule represents a separate execution stage. You can define multiple rows to simulate phased traffic behavior.

1. Start Threads Count: Defines the number of virtual users that will begin execution during that specific stage. This allows you to incrementally increase or decrease the active user count across different time windows.

2. Initial Delay (sec): Specifies how long the thread group should wait before initiating that particular stage. This helps in:

   • Delaying load injection

   • Sequencing traffic waves

   • Staggering execution across multiple schedules

3. Startup Time (sec): Determines how long it takes for the defined threads to ramp up to their full count. Instead of launching all threads instantly, they are gradually introduced over the configured duration. This prevents sudden load spikes unless intentionally configured.

4. Hold Load For (sec): Defines how long the threads remain active at peak concurrency during that stage. This parameter is used to simulate steady-state traffic where user activity remains constant for a defined period.

5. Shutdown Time: Controls how long it takes for the active threads to ramp down and terminate. Similar to ramp-up, threads do not stop abruptly unless configured to do so. This allows smoother load drop-offs.

Visualization Support

PerfAgents provides visual validation of your UTG configuration:

1. Thread Schedule Table: Displays each configured stage with its respective timing and concurrency values.

2. Thread Count Over Time Graph: Generates a real-time visualization of expected active threads based on your UTG schedule. This helps you:

   • Validate ramp patterns before execution

   • Identify potential unintended spikes

   • Confirm peak concurrency behavior

3. Peak Thread Indication: Automatically highlights the maximum concurrent thread count derived from the defined schedules. This ensures infrastructure sizing aligns with your expected peak load.

SetUp Thread Group

The SetUp Thread Group is executed before the main load test begins. It is designed to prepare the system and environment so that the actual load phase runs under realistic and controlled conditions. Unlike the primary load thread groups, the SetUp Thread Group does not represent production traffic. Instead, it ensures that prerequisites are completed prior to load injection.

Configurable Parameters

1. Virtual Users: Defines how many threads will execute the setup logic. Typically, this number is smaller than the main load group unless large-scale preparation is required.

2. Duration: Specifies how long the setup logic should run. This ensures the preparation phase completes within a defined time window.

3. Ramp-Up Time: Controls how gradually setup threads are introduced. This can be useful when:

   1. Initializing large datasets

   2. Avoiding sudden backend spikes during setup

4. Start-Up Delay: Defines the amount of time the thread group waits before it begins execution. In simple terms, it introduces a controlled pause between the test launch and when this specific thread group starts running.

5. Loop Count (Including Infinite Option): Defines how many times each setup thread executes its assigned flow. This can be:

   1. Fixed (e.g., create 100 users)

   2. Infinite (until duration completes)

TearDown Thread Group

The TearDown Thread Group is executed after the main load test completes. It is designed to handle post-test cleanup and environment restoration tasks. Unlike the primary thread groups that generate load, the TearDown Thread Group ensures that the system is returned to a stable and controlled state once testing finishes.

Configurable Parameters

1. Virtual Users: Defines how many threads will execute cleanup tasks. Typically, this is lower than the main load unless large-scale cleanup is required.

2. Duration: Specifies how long the teardown logic will run. This ensures cleanup completes within a controlled time window.

3. Ramp-Up Time: Determines how gradually teardown threads are introduced. Useful when cleanup actions involve backend processing and should not cause abrupt load spikes.

4. Start-Up Delay: Defines how long the TearDown Thread Group waits before beginning execution after the main load test completes. This allows you to introduce a controlled pause between the end of the load phase and the start of cleanup operations.

5. Loop Count (Including Infinite Option): Specifies how many times each thread executes the teardown script. Can be:

   1. Fixed (e.g., delete 100 records)

   2. Infinite (runs until duration ends)

Section 3: Load Generator Configuration

This section allows you to select the region where the load test will be executed and define how the virtual users configured in the Load Configuration section should be distributed across those regions.

You can distribute these users using either of the following allocation modes:

• Traffic %: Distribute the total virtual users across regions based on a percentage allocation.

• Fixed VUs: Assign a specific number of virtual users to each selected region.

The system automatically calculates the Peak VUs, Total VUs, and Computed Engines based on the selected regions and configured allocation.

Region Availability

The available regions depend on the subscription plan:

US East (Ohio)	✅	✅	✅
Canada (Central)	✅	✅	✅
Europe (Ireland)	❌	✅	✅
US West (Oregon)	❌	✅	✅
US East (N. Virginia)	❌	✅	✅
Asia Pacific (Tokyo)	❌	✅	✅
Asia Pacific (Singapore)	❌	✅	✅
Europe (London)	❌	✅	✅
Europe (Frankfurt)	❌	❌	✅
Asia Pacific (Sydney)	❌	❌	✅
Asia Pacific (Mumbai)	❌	❌	✅

Note: Free Plan supports single-region load testing in US East (Ohio) only.

Configure Regions

1. Select the required regions where the load test should be executed.

2. Choose the allocation method from the dropdown:

   1. Traffic %

   2. Fixed VUs

3. Configure the allocation for each selected region.

4. The system automatically calculates the resulting Peak VUs, Total VUs, and Computed Engines.

5. Use Distribute evenly to distribute the configured load evenly across the selected regions when required.

6. Click Add Region to include additional regions.

Final Step: Create Load Test

After configuring all sections, click Create Load Test. The test will appear under “All Tests” section, ready for execution.

UI Automation in Load Testing

PerfAgents offers an advanced UI Automation feature that allows you to execute automated UI scripts alongside your load tests. This ensures that while your system is under stress, you can also validate the end-to-end user experience and UI responsiveness.

UI Script Upload

Once you have configured your basic load settings, you can navigate to the UI Automation tab to manage your automated scripts.

1. Upload UI Script Files:

   1. Drag and drop or browse your UI script files (supports .js and .ts formats).

   2. Maximum file size: 100 MB.

2. UI Script Type: Select the automation framework. Currently, PerfAgents provides robust support for Playwright.

3. Download Template: A convenient option to download a sample script template to ensure your automation follows the required structure.

Trigger Configuration

The trigger configuration defines how and when your UI scripts are executed during the load test.

Configuration	Description
Trigger Type	Define the basis for execution (e.g., Thread Count, Time Based).
Peak Thread Count	It defines the peak load threshold at which the first UI script execution is initiated when Trigger Type is Thread Count.
Trigger After	It specifies the elapsed time after which the first UI script execution is triggered when the Trigger Type is set to Time Based.
Iterations	Set how many times the UI script should repeat.
Intervals (seconds)	Define the delay between subsequent UI script executions.

Visual Execution Preview: The real-time graph on the right provides a visual representation of the Virtual Users (Threads) over the Elapsed Time, helping you correlate UI automation triggers with the overall load profile.

By integrating UI Automation, you can capture logs, and performance metrics from a real browser perspective while the backend is under heavy load.

APM Integrations

PerfAgents supports integration with external Application Performance Monitoring (APM) platforms, enabling users to correlate server-side infrastructure metrics with load testing results. By combining application performance and infrastructure monitoring within a single dashboard, teams can identify bottlenecks more effectively and understand system behavior under load.

Supported Integrations

PerfAgents currently supports the following APM platforms:

1. AWS CloudWatch

2. Datadog

3. Azure Monitor

4. Dynatrace

These integrations can be configured during load test creation and reused across multiple test executions.

Configuring an APM Integration

Step 1: Navigate to APM Integration

While creating a load test:

1. Upload a valid JMX file.

2. Open the APM Integration section from the left panel.

Once a JMX file is uploaded, the APM Integration module becomes available for configuration.

Step 2: Select an APM Provider

Choose the monitoring platform you want to connect. Available options include:

1. AWS CloudWatch

2. Datadog

3. Azure Monitor

4. Dynatrace

Click “Config” on the desired integration card.

Step 3: Create or Select an Existing Key

Users can now either:

• Create a new integration key

• Reuse an existing configured key

Creating a new Integration Key

APM Provider	Required Fields
AWS CloudWatch	Key Name, IAM Access Key ID, IAM Secret Access Key
Datadog	Key Name, Datadog URL, API Key, Application Key
Azure Monitor	Key Name, Client ID, Client Secret, Tenant ID, Subscription ID
Dynatrace	Key Name, Dynatrace URL, API Token

Step 4: Test the Connection

After entering the required credentials:

1. Click Test Connection.

2. The Platform validates the provided credentials.

3. Connection status is displayed immediately.

Successful validation confirms that PerfAgents can access monitoring data from the selected platform.

Step 5: Save the Integration

Once connectivity is verified:

1. Save the integration.

2. The configured key becomes available for future use.

3. Users can manage integrations from the Settings section.

Step 6: Create an APM Profile

After successfully configuring and validating an APM integration, create a monitoring profile that defines the infrastructure resources and server-side metrics to be tracked during load test execution. Click Next to navigate to the Create Profile section. The profile configuration fields vary depending on the selected APM integration:

APM Provider	Profile Configuration Fields
AWS CloudWatch	Profile Name, Region, Namespace, Resources, Metrics
Datadog	Profile Name, Host, Entity
Azure Monitor	Profile Name, Region, Namespace, Resources, Metrics
Dynatrace	Profile Name, Entity Type, Entity, Metrics

After configuring the required fields, click Integrate.

Step 7: Applying a Profile to a Load Test

After a profile is created, it appears under the Available Profiles section for the selected APM integration. To associate a profile with the current load test:

1. Select the desired profile using the checkbox.

2. Click Apply.

3. The selected profile is linked to the load test configuration.

Multiple saved profiles may be available depending on the configured APM provider.

Once applied, PerfAgents continuously collects the selected server-side metrics during test execution and displays them alongside client-side performance data within the Real-Time Load Test Dashboard and Timeline Report, enabling comprehensive infrastructure and application performance analysis.