Online Traffic Replay in Python Automated Testing: Recording, Tagging, Load Testing, and Platform Selection

In automated testing, online traffic replay is a key technique that simulates real user requests to reproduce production scenarios and verify system performance and stability.

1. Recording Traffic

To capture live traffic, use a Python proxy tool such as Mitmproxy to intercept and log requests. The following script records each request’s URL, method, headers, and body into a traffic.log file.

import mitmproxy
import json
class FlowRecorder:
    def __init__(self):
        self.traffic = []
    def request(self, flow):
        request_info = {
            "url": flow.request.url,
            "method": flow.request.method,
            "headers": dict(flow.request.headers),
            "body": flow.request.text,
        }
        self.traffic.append(request_info)
    def response(self, flow):
        pass
    def done(self):
        with open("traffic.log", "w") as file:
            file.write(json.dumps(self.traffic))
addons = [FlowRecorder()]
if __name__ == "__main__":
    mitmproxy.options.Options(addons=addons).run()

Running this script with Mitmproxy records the traffic and saves it to traffic.log .

2. Tagging Traffic

To differentiate request types during replay, add a custom tag field to each recorded entry. The code below reads the log, inserts a "tag" attribute, and writes the updated data back.

import json
traffic_file = "traffic.log"
with open(traffic_file, "r") as file:
    content = file.read()
    traffic_data = json.loads(content)
for request in traffic_data:
    # 添加标记字段
    request["tag"] = "user_request"
with open(traffic_file, "w") as file:
    file.write(json.dumps(traffic_data))

This adds a "tag" field to every request in traffic.log .

3. Load Testing the Traffic

Before replay, use a load‑testing tool such as Locust to simulate high‑concurrency scenarios. The example defines a TrafficUser class that reads the recorded traffic and issues each request to the target system.

from locust import HttpUser, task, between
import json
traffic_file = "traffic.log"
class TrafficUser(HttpUser):
    wait_time = between(1, 2)
    @task
    def replay_traffic(self):
        with open(traffic_file, "r") as file:
            content = file.read()
            traffic_data = json.loads(content)
        for request in traffic_data:
            self.client.request(
                method=request["method"],
                url=request["url"],
                headers=request["headers"],
                data=request["body"],
            )

This Locust script replays each recorded request, allowing you to assess performance under load.

4. Initiating Load Tests and Choosing a Platform

Load tests can be run on self‑built environments using Python’s multithreading/multiprocessing or on cloud‑based platforms that provide scalable resources and reporting, such as LoadRunner or BlazeMeter. Choose the approach that fits your budget and requirements.

Conclusion

By recording traffic, tagging requests, performing load testing, and selecting an appropriate testing platform, you can effectively implement online traffic replay in Python automated testing to validate system performance and stability.