gh-154060: Show replay duration and rate

Author: pablogsal

Lib/profiling/sampling/binary_reader.py

@@ -125,6 +125,8 @@ def convert_binary_to_format(input_file, output_file, output_format,
 
         # Replay samples through collector
         count = reader.replay_samples(collector, progress_callback)
+        if hasattr(collector, "set_replay_stats"):
+            collector.set_replay_stats(info)
 
         # Export to target format
         collector.export(output_file)

Lib/profiling/sampling/cli.py

@@ -776,6 +776,8 @@ def progress_callback(current, total):
             )
 
     count = reader.replay_samples(collector, progress_callback)
+    if hasattr(collector, "set_replay_stats"):
+        collector.set_replay_stats(info)
     print()
 
     if args.format == "pstats":

Lib/profiling/sampling/stack_collector.py

@@ -78,6 +78,7 @@ def __init__(self, *args, **kwargs):
         self._string_table = StringTable()
         self._module_cache = {}
         self._all_threads = set()
+        self._last_replay_timestamp_us = None
 
         # Thread status statistics (similar to LiveStatsCollector)
         self.thread_status_counts = {
@@ -97,6 +98,13 @@ def collect(self, stack_frames, timestamps_us=None):
         """Override to track thread status statistics before processing frames."""
         # Weight is number of timestamps (samples with identical stack)
         weight = len(timestamps_us) if timestamps_us else 1
+        if timestamps_us:
+            last_timestamp_us = max(timestamps_us)
+            if (
+                self._last_replay_timestamp_us is None
+                or last_timestamp_us > self._last_replay_timestamp_us
+            ):
+                self._last_replay_timestamp_us = last_timestamp_us
 
         # Increment sample count by weight
         self._sample_count += weight
@@ -142,6 +150,27 @@ def set_stats(self, sample_interval_usec, duration_sec, sample_rate,
             "mode": mode
         }
 
+    def set_replay_stats(self, info):
+        """Set the statistics that can be reconstructed during replay."""
+        if self._last_replay_timestamp_us is None:
+            return
+
+        interval = info["sample_interval_us"]
+        if interval <= 0:
+            return
+        duration_us = max(
+            interval,
+            self._last_replay_timestamp_us - info["start_time_us"] + interval,
+        )
+        self.set_stats(
+            interval,
+            duration_us / 1_000_000,
+            1_000_000 / interval,
+            error_rate=None,
+            missed_samples=None,
+            mode=None,
+        )
+
     def export(self, filename):
         flamegraph_data = self._convert_to_flamegraph_format()
 

Lib/test/test_profiling/test_sampling_profiler/test_binary_format.py

@@ -1580,6 +1580,34 @@ def test_timestamp_preservation_with_rle(self):
         self.assertEqual(ts_collector.all_timestamps, expected_timestamps)
 
 
+class TestBinaryReplayToFlamegraph(BinaryFormatTestBase):
+    def test_replay_includes_reconstructed_stats(self):
+        frames = [
+            make_frame("hot.py", 99, "hot_func"),
+            make_frame("main.py", 1, "main"),
+        ]
+        samples = [
+            [
+                make_interpreter(
+                    0,
+                    [make_thread(1, frames, THREAD_STATUS_HAS_GIL)],
+                )
+            ]
+            for _ in range(5)
+        ]
+        bin_path = self.create_binary_file(samples, interval=2000)
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as file:
+            html_path = file.name
+        self.temp_files.append(html_path)
+
+        convert_binary_to_format(bin_path, html_path, "flamegraph")
+
+        with open(html_path, encoding="utf-8") as file:
+            content = file.read()
+        self.assertIn('"duration_sec":', content)
+        self.assertIn('"sample_rate": 500.0', content)
+
+
 class TestBinaryReplayToJsonl(BinaryFormatTestBase):
     """Tests for binary -> JSONL replay via convert_binary_to_format."""
 

Lib/test/test_profiling/test_sampling_profiler/test_collectors.py

@@ -1156,6 +1156,26 @@ def test_flamegraph_collector_stats_accumulation(self):
         collector.collect(stack_frames_gc)
         self.assertEqual(collector.samples_with_gc_frames, 2)
 
+    def test_flamegraph_collector_reconstructs_replay_stats(self):
+        """Replay duration and configured rate come from binary metadata."""
+        collector = FlamegraphCollector(1000)
+        frames = [
+            MockInterpreterInfo(0, [
+                MockThreadInfo(1, [MockFrameInfo("file.py", 10, "func")])
+            ])
+        ]
+        collector.collect(frames, timestamps_us=[1_001_000, 1_002_000])
+
+        collector.set_replay_stats({
+            "start_time_us": 1_000_000,
+            "sample_interval_us": 1000,
+        })
+
+        self.assertAlmostEqual(collector.stats["duration_sec"], 0.003)
+        self.assertAlmostEqual(collector.stats["sample_rate"], 1000.0)
+        self.assertIsNone(collector.stats["error_rate"])
+        self.assertIsNone(collector.stats["missed_samples"])
+
     def test_flamegraph_collector_per_thread_stats(self):
         """Test per-thread statistics tracking in FlamegraphCollector."""
         collector = FlamegraphCollector(sample_interval_usec=1000)

Misc/NEWS.d/next/Library/2026-07-19-12-10-00.gh-issue-154060.cR6tYn.rst

@@ -0,0 +1,2 @@
+Show the reconstructed duration and configured sampling rate in replayed
+Tachyon flamegraphs.