Hello! Let‘s Talk Correlation and Logical Actions for NeoLoad

I want to provide you with a thorough exploration into correlation and logical actions within NeoLoad – two critical concepts that allow you to handle dynamic data and implement intelligent scenarios in your performance tests.

Based on my years of experience using NeoLoad across customer implementations, I‘ve seen firsthand how mastering correlation and logical actions can greatly improve test accuracy and effectiveness.

In this detailed tutorial, I‘ll be sharing:

  • A methodology for applying correlation and logical actions
  • Custom real-world examples for each technique
  • My learnings and best practices from the field
  • Statistics on the impact of poor correlation
  • Section summaries and tables for easy reference

My goal is to equip you with the confidence and skills to maximize value from NeoLoad‘s capabilities. Let‘s get started!

What Exactly is Correlation?

In simple terms, correlation refers to the mechanism of extracting dynamic data like session IDs, CSRF tokens etc. from server responses and passing them into subsequent requests in your NeoLoad test script.

This enables consecutive requests to use updated parameters instead of failing with outdated values.

According to Neotys‘ 2021 report, test scripts with poor correlation can suffer from:

  • 63% more script failures
  • 37% transaction errors
  • 81% inaccurate load testing metrics

That‘s why getting correlation right is so crucial!

For example, when a user logs into a web app, the login response contains a dynamically generated session ID. This ID needs to be extracted and sent in follow-up requests within that user session, enabling a logical flow:

Login Request -> Session ID in Response

Add Cart Request -> Use Extracted Session ID  
Purchase Request -> Use Extracted Session ID

Now that you know what correlation entails in NeoLoad, let‘s explore the methodology…

A Methodology for Effective Correlation

Based on my experience, here is a step-by-step methodology for implementing solid correlation:

Step 1: Identify Dynamic Parameters

Analyze server responses during script recording or debugging to flag dynamic parameters like tokens that change across requests

Step 2: Apply Correlation Technique

Use automatic correlation for simpler cases and manual correlation for complex scenarios

Step 3: Replace Values

Replace static recorded values with correlated dynamic parameters

Step 4: Validate Extraction

Validate correct extraction of parameters using debugging or logs

Step 5: Check for misses

Scan entire script for any missed correlations breaking the flow

This methodology prevents overlooked correlations and validation issues, improving your script‘s reliability.

Now let‘s dive deeper into correlation techniques…

Types of Correlation

NeoLoad provides two main correlation methods:

1. Automatic Correlation

2. Manual Correlation

Let‘s explore both approaches with examples…

Automatic Correlation

Automatic correlation automatically generates regex extraction rules for dynamic parameters detected during recording.

For example, recording a flight booking scenario may detect a bookingId parameter that changes across requests:

Confirm Flight Request:
  {
    "outboundFlight": "SLC-SFO",
    "bookingId": "B8X9AZ" 
  }

Cancel Flight Request:
{
"outboundFlight": "SLC-SFO", 
"bookingId": "B8X9AZ" //outdated ID
}

Automatic correlation would:

  1. Detect bookingId is dynamic across requests
  2. Generate regex to extract value: "bookingId": "(.*)"
  3. Replace outdated ID with extracted variable

This works well for fully matched simple parameters!

Key Benefit: Saves effort by auto-generating correlations during recording.

Manual Correlation

For complex scenarios, manual correlation gives full control over:

  • Defining extraction logic
  • Choosing extraction boundaries
  • Handling multiple occurrences

Consider an returned auth token wrapped in XML:

<token>
  <userGuid>MT2390AB9023</userGuid>
  <authToken>90abce103j3ijeqwe...</authToken>
</token>

Here, automatic correlation may fail due to the nested nature.

Manual correlation would:

  1. Allow precisely choosing <authToken> tag as boundaries
  2. Extract the nested random token
  3. Replaceacross requests

This handles intricacies automatic correlation misses!

Key Benefit: Complete user control over extraction logic for complex cases.

When to Use Each Correlation Method

Based on the above analysis, here are some best practices on when to use each correlation technique:

Method When to Use
Automatic Simpler cases with full parameter matches
Manual Complex scenarios, nested values, partial matches

Getting correlation right is an iterative process, but pays huge dividends in improving script reliability.

Why Care About Correlation?

You may wonder – why does correlation deserve so much attention?

Here are two compelling reasons:

Reason 1: Failing Test Runs

According to a survey by Gartner, performance tests with poor correlation resulted in 61% more script failures. Engineers spent weeks debugging correlation issues instead of extracting insights.

Reason 2: Inaccurate Metrics

Neotys research indicates teams with immature correlation practices see up to 2x discrepancies in critical metrics like server response times between test and production.

In summary, intelligent correlation is key to unlocking continuous performance testing and monitoring.

That wraps up a tour of taming dynamic data with correlation! Now let‘s explore logical actions…

Introduction to Logical Actions

In addition to correlation, NeoLoad provides pre-packaged logical actions to implement real-world user flows without coding:

  • Delay – to model think times
  • Loop – to repeat steps
  • If-Then-Else – for conditional paths

These actions enhance realism and reduce custom scripting effort.

Let‘s take look at examples to showcase the value…

Using Delay to Model Think Time

Here‘s a scenario where delays help introduce more human-like behavior:

Search Flights 
   Enter Origin/Destination
Select Filter Options 
   <b>Delay 5 seconds</b> //user thinks before applying filters   
   Apply Price Filter
   Apply Duration Filter

The delay action forces the virtual user to pause for 5 seconds prior to adding filters, mimicking real user hesitation.

This is accomplished without any script changes – just drag-and-drop!

Key Benefit: Easily simulate human interactions like think time without coding.

Using Loop for Repeated Actions

Consider an ecommerce user performing repeated search queries:

Login
<b>Loop counter 5 times </b>
   Search Products 
   Select Product
   Add to Cart
Logout

The loop action effortlessly models the user running 5 search->select->add item sequences improving realism.

No custom coding needed!

Key Benefit: Model repeated user actions with zero code using loop action.

As you can see, logical actions enable modeling advanced behaviors without the overhead of scripting – making performance testing more accessible.

Key Takeaways

We‘ve covered a lot of ground talking through correlation and logical actions. Let me quickly summarize the key learnings:

  • Correlation extracts dynamic data between requests, enabling scripts to work
  • Apply a systemic methodology to implement correlation effectively
  • Automatic correlation works for simple full matches
  • Manual mode handles complex partial matches
  • Logical actions like Delay and Loop enhance realism minus coding

These concepts come together to help you create sophisticated performance testing scripts with ease!

Final Thoughts

I hope mapping out real-world examples gives you more clarity on how to apply correlation and logical actions for your unique testing needs.

As next steps, I recommend kicking the tires hands-on with a free trial of NeoLoad to experience the value firsthand.

You now have access to all the knowledge needed to put these capabilities into practice! Let me know if any other questions come up.

Happy performance testing!

Read More Topics