Checkpoint Lab — Configuration Elements, Variables, Properties, and Environment Control

1. Checkpoint assumptions and hard ceilings

2. Workspace

jmeter-ch06-checkpoint/
├── fixtures/
│   └── config_fixture.py
├── config/
│   ├── lab-a.properties
│   └── lab-b.properties
├── plans/
│   ├── config-debug.jmx
│   └── config-load.jmx
├── evidence/
│   ├── resolution-a.txt
│   ├── resolution-b.txt
│   ├── predictions.txt
│   ├── jmx-sha256.txt
│   └── validity.txt
└── results/
    ├── run-a/
    ├── run-b/
    └── broken/

3. Start and preflight both fixtures

python fixtures/config_fixture.py --port 8000 --name LAB-A --log results/run-a/server-events.jsonl
python fixtures/config_fixture.py --port 8001 --name LAB-B --log results/run-b/server-events.jsonl

curl --fail --silent http://127.0.0.1:8000/health
curl --fail --silent http://127.0.0.1:8001/health

Record the returned server names so the configuration files can be verified independently of JMeter.

4. Property profiles

config/lab-a.properties:

# Non-secret local configuration A
lab.host=127.0.0.1
lab.port=8000
lab.name=LAB-A
load.threads=2
load.duration=3
run.label=properties-a
global.mode=project-file
lab.data.path=fixtures/data/config-a.csv

config/lab-b.properties:

# Non-secret local configuration B
lab.host=127.0.0.1
lab.port=8001
lab.name=LAB-B
load.threads=1
load.duration=4
run.label=properties-b
global.mode=project-file
lab.data.path=fixtures/data/config-b.csv

5. One JMX contract

The plan must use:

HOST      = ${__P(lab.host,127.0.0.1)}
PORT      = ${__P(lab.port,8000)}
DATA_PATH = ${__P(lab.data.path,fixtures/data/default.csv)}

Thread Group:
  Number of Threads = ${__P(load.threads,1)}
  Loop Count = 100
  Lifetime enabled
  Duration = ${__P(load.duration,3)}

Headers:
  X-Run-Label   = ${__P(run.label,default-run)}
  X-Global-Mode = ${__P(global.mode,default-mode)}

Sampler:
/config?thread=${__threadNum}&data_path=${DATA_PATH}&run=${__P(run.label,default-run)}

Save the load JMX once, calculate its SHA-256, and keep the same file for A and B:

# Bash
sha256sum plans/config-load.jmx > evidence/jmx-sha256.txt

# PowerShell
Get-FileHash plans\config-load.jmx -Algorithm SHA256 |
  Format-List | Out-File evidence\jmx-sha256.txt

6. Write predictions before any run

Add one more prediction: a response-derived THREAD_ECHO variable will differ by JMeter thread, while run.label remains the same for every thread inside that run.

7. Authoring-only variable/property proof

Use the debug copy at 2 threads × 1 loop. Add the same extractor from Lesson 2 to create THREAD_ECHO. Add a verification sampler:

/verify?thread_var=${THREAD_ECHO}&thread_func=${__threadNum}&run=${__P(run.label,default-run)}

Use Debug Sampler/View Results Tree once to inspect thread variables and selected properties. Expected: each thread's THREAD_ECHO matches its own __threadNum, while run.label is shared. Then disable diagnostics for load runs.

8. Run LAB-A

jmeter -n   -t plans/config-load.jmx   -q config/lab-a.properties   -Dlab.jvm.tag=JVM-A   -l results/run-a/results.jtl   -j results/run-a/jmeter.log

Verify server A receives events and server B does not receive this run's requests. Preserve /stats from both endpoints.

9. Run LAB-B with the exact same JMX

jmeter -n   -t plans/config-load.jmx   -q config/lab-b.properties   -Dlab.jvm.tag=JVM-B   -l results/run-b/results.jtl   -j results/run-b/jmeter.log

Recalculate the JMX SHA-256 and verify it has not changed. The resolved target/workload should change because the external properties changed—not because the JMX was edited.

10. Build the property-resolution evidence table

11. Deliberately break the variable/property mapping

Create a copy only for the diagnostic failure, plans/broken-port.jmx. Change HTTP Defaults port from ${PORT} to ${LAB_PORT}. Keep the launch input -q config/lab-b.properties, which defines JMeter property lab.port=8001 but does not define variable LAB_PORT.

Prediction: ${LAB_PORT} remains unresolved because it is a missing variable. Preserve the failing JMX/JTL/log. Do not “fix” the property file by adding an unrelated LAB_PORT variable concept.

12. Diagnose and restore the intended ownership

Read the JMX and input table:

• property exists: lab.port=8001;
• startup variable exists: PORT=${__P(lab.port,8000)};
• missing variable: LAB_PORT.

The least destructive correction is to restore HTTP Defaults to ${PORT} (or use ${__P(lab.port,8000)} directly). Rerun LAB-B into a new result directory; preserve the broken evidence.

13. One intentional -J override

Run A once more with the same profile and only this additional non-secret override:

-Jrun.label=checkpoint-cli-override

The target, users, duration, and data path remain from the A file while the run label changes. Record the resolved value and exact command.

14. Explain the distributed property boundary

If this plan later runs remotely, a controller-only -Jrun.label=... is not a contract for remote engine properties. The remote samplers need the relevant JMeter properties provisioned/sent, commonly via -G. Data files, Java -D system properties, plugins, and OS environment state still require separate engine provisioning.

No remote engine is started in this checkpoint.

15. Verification checklist

• JMX SHA-256 is identical for A and B normal runs.
• LAB-A receives only the A normal run; LAB-B receives only B normal run.
• Resolved thread count/duration match the selected property file.
• Run label/global mode/data-path query/header values match the property resolution table.
• Bounded debug evidence shows response-derived variable isolation by thread.
• run.label is shared within one JMeter process as expected.
• The broken ${LAB_PORT} failure is preserved and correctly attributed to variable/property mismatch.
• JTL and jmeter.log are unique per run.
• No real secrets, public targets, remote ports, or distribution-property edits were introduced.

16. Required evidence packet

17. Validity statement

18. Cleanup

1. Stop both local fixture processes.
2. Keep A/B/broken artifacts until review is complete.
3. Disable/remove Debug Sampler from load profiles.
4. Do not copy property dumps into tickets if they might contain real secret values in future environments.
5. No production target, real credential, remote engine, RMI port, database, container, plugin, or system-wide JVM/OS setting was changed.

19. What Chapter 06 adds to the operating model

The performance-test operating model now has a configuration provenance contract: committed JMX logic, selected non-secret profile, explicit CLI overrides, Java/JMeter property boundaries, thread-local runtime values, target allow-list, and the resolved run manifest are separately reviewable.

Chapter 07 builds on this configuration control to parameterize timers, think time, pacing, and throughput targets safely without confusing a timer property with achieved request rate or server latency.

Knowledge check

Official references and version notes

• Functions and Variables — current variable syntax, undefined-variable behavior, __P, __property, __setProperty, and thread-local versus global-property rules.
• Elements of a Test Plan — User Defined Variables startup processing and variable-copy behavior per thread.
• Getting Started — -J, -G, -D, -q, property-file loading, command-line processing order, GUI versus CLI guidance, and jmeter.log behavior.
• Properties Reference — current guidance for setting JMeter properties through user.properties rather than modifying distribution defaults.
• Apache JMeter downloads — current production release and Java requirement.