[python_concurrent_cpu_wall] Add new check (#134)

Author: KowalskiThomas

scenarios/python_concurrent_cpu_wall_3.11/Dockerfile

@@ -0,0 +1,17 @@
+ARG BASE_IMAGE="prof-python-3.11"
+FROM $BASE_IMAGE
+
+COPY ./scenarios/python_concurrent_cpu_wall_3.11/main.py \
+    ./scenarios/python_concurrent_cpu_wall_3.11/requirements.txt \
+    /app/
+RUN chmod 644 /app/*
+
+WORKDIR /app
+
+RUN pip install -r requirements.txt
+
+ENV EXECUTION_TIME_SEC="30"
+
+ENV DD_PROFILING_ENABLED="true"
+
+CMD python main.py

scenarios/python_concurrent_cpu_wall_3.11/README.md

@@ -0,0 +1,23 @@
+# python_concurrent_cpu_wall_3.11
+
+Verifies per-thread CPU-vs-wall attribution for threads that are on-CPU and
+off-CPU *at the same time*. Unlike `python_spiky_3.11` (single thread that
+alternates between bursts and sleeps sequentially), this runs two threads
+concurrently for the full duration:
+
+- **busy**: burns CPU in `busy_loop`
+- **idle**: loops over short `time.sleep` calls in `idle_wait`
+
+This exercises the sampler reading each thread's own CPU clock
+(`clock_gettime(cpu_clock_id)`) independently, and the "wall is guaranteed, CPU
+is optional" semantics: a sleeping thread still produces wall-time samples but
+~0 CPU.
+
+## Expected behavior
+
+- **cpu-time**: almost all CPU is in `busy_loop` (label `thread name: busy`);
+  the idle thread contributes ~0.
+- **wall-time**: `busy_loop` and `idle_wait` contribute the *same* amount
+  (~33% each, the remaining third being the MainThread blocked in `join`),
+  confirming that wall time is attributed equally to the on-CPU and the
+  sleeping thread.

scenarios/python_concurrent_cpu_wall_3.11/expected_profile.json

@@ -0,0 +1,48 @@
+{
+  "test_name": "python_concurrent_cpu_wall",
+  "stacks": [
+    {
+      "profile-type": "cpu-time",
+      "stack-content": [
+        {
+          "regular_expression": ".*busy_loop",
+          "percent": 95,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": ["busy"]
+            }
+          ]
+        },
+        {
+          "regular_expression": ".*busy_loop",
+          "percent": 0,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": ["idle"]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "wall-time",
+      "stack-content": [
+        {
+          "regular_expression": ".*busy_loop",
+          "percent": 33,
+          "error_margin": 12
+        },
+        {
+          "regular_expression": ".*idle_wait",
+          "percent": 33,
+          "error_margin": 12
+        }
+      ]
+    }
+  ],
+  "scale_by_duration": false
+}

scenarios/python_concurrent_cpu_wall_3.11/main.py

@@ -0,0 +1,32 @@
+import os
+import threading
+from time import sleep, time
+
+
+def busy_loop(end: float) -> None:
+    x = 0
+    while time() < end:
+        for i in range(10000):
+            x += i
+
+
+def idle_wait(end: float) -> None:
+    while time() < end:
+        sleep(0.05)
+
+
+if __name__ == "__main__":
+    from ddtrace.profiling import Profiler
+
+    prof = Profiler()
+    prof.start()
+
+    execution_time = float(os.environ.get("EXECUTION_TIME_SEC", "30"))
+    end = time() + execution_time
+
+    busy = threading.Thread(target=busy_loop, args=(end,), name="busy")
+    idle = threading.Thread(target=idle_wait, args=(end,), name="idle")
+    busy.start()
+    idle.start()
+    busy.join()
+    idle.join()

scenarios/python_concurrent_cpu_wall_3.11/requirements.txt

@@ -0,0 +1 @@
+ddtrace