diff --git a/README.md b/README.md
index 12010cc..0f6af9e 100644
--- a/README.md
+++ b/README.md
@@ -127,6 +127,7 @@ See cephtrace in action troubleshooting real performance issues.
 | **DWARF Files** | Managing debug information for tracing | [Guide](doc/dwarf-json-files.md) |
 
 ### 📊 Analysis & Tools
+- **[Visualizing Trace Output](doc/visualizing-output.md)** - One-screen terminal summary (latency histogram, where the time goes), or a self-contained interactive HTML report, from any capture
 - **[Analyzing Radostrace Logs](doc/analyze-radostrace.md)** - Extract insights from client traces
 - **[Analyzing Osdtrace Logs](doc/analyze-osdtrace.md)** - Deep-dive into OSD performance data
 
diff --git a/doc/analyze-osdtrace.md b/doc/analyze-osdtrace.md
index edcaa3c..5bf3c65 100644
--- a/doc/analyze-osdtrace.md
+++ b/doc/analyze-osdtrace.md
@@ -1,5 +1,9 @@
 # Osdtrace Analysis Tool
 
+> For a quick visual overview (where latency is spent, distribution shape,
+> per-OSD outliers) before diving into the numbers, see
+> [Visualizing trace output](visualizing-output.md).
+
 The `analyze_osdtrace_output.py` script provides automated statistical analysis of osdtrace log files with fio-style latency distribution output.
 
 ## Overview
diff --git a/doc/analyze-radostrace.md b/doc/analyze-radostrace.md
index d875c80..fce6f74 100644
--- a/doc/analyze-radostrace.md
+++ b/doc/analyze-radostrace.md
@@ -1,5 +1,9 @@
 # Radostrace Analysis Tool
 
+> For a quick visual overview (latency histogram, read/write split, slow-OSD
+> hint) before diving into the numbers, see
+> [Visualizing trace output](visualizing-output.md).
+
 The `analyze_radostrace_output.py` script provides automated analysis of radostrace log files to identify problematic OSDs involved in high-latency operations.
 
 ## Overview
diff --git a/doc/images/report-osdtrace.png b/doc/images/report-osdtrace.png
new file mode 100644
index 0000000..5a7b5ad
Binary files /dev/null and b/doc/images/report-osdtrace.png differ
diff --git a/doc/images/report-radostrace.png b/doc/images/report-radostrace.png
new file mode 100644
index 0000000..0d97f2c
Binary files /dev/null and b/doc/images/report-radostrace.png differ
diff --git a/doc/visualizing-output.md b/doc/visualizing-output.md
new file mode 100644
index 0000000..ff4b8b5
--- /dev/null
+++ b/doc/visualizing-output.md
@@ -0,0 +1,136 @@
+# Visualizing trace output
+
+`radostrace` and `osdtrace` stream one line per IO - thousands of rows in a
+typical capture. `tools/cephtrace_report.py` turns a capture into a
+**one-screen visual summary** that answers the three questions you usually have
+at a glance: *is it slow, what's slow, and where is the time going.*
+
+It has no flags to remember - point it at a log (or pipe one in) and it
+auto-detects which tool produced it.
+
+```bash
+# osdtrace
+sudo ./osdtrace --id 0 -t 30 > osd.log
+./tools/cephtrace_report.py osd.log
+
+# radostrace (also reads the CSV that `radostrace -o` writes)
+sudo ./radostrace -p <pid> -t 30 | ./tools/cephtrace_report.py
+```
+
+## osdtrace example
+
+Real output from a ~116k-op capture (a single OSD under a 4 KiB write+read
+workload):
+
+```
+osdtrace summary - 115829 OSD ops
+  op_r 86926   op_w 28903
+
+where the time goes   (share of total latency, avg 4.1ms/op)
+     messenger  ▏                                        0%
+         queue  ███▋                                     9%
+           osd  ▉                                        2%
+     bluestore  ████████████████▌                        41%
+     +kv_commit ██████████████▊                          37%  (rocksdb commit)
+
+op latency distribution   p50 4.0ms   p95 9.5ms   p99 11.3ms   max 30.1ms
+     <250us  ████████████                             11896
+     <500us  ██████████▌                              10420
+       <1ms  ███████████████▊                         15594
+       <2ms  █████████████▋                           13440
+       <4ms  ██████▊                                  6647
+       <8ms  ████████████████████████████████████████ 39612
+      <16ms  ██████████████████▍                      18164
+      <32ms                                           56
+
+slowest ops
+     30.1ms  op_w     osd.0 pg 2.12 4.0K
+     28.0ms  op_w     osd.0 pg 2.e 4.0K
+
+  -> deeper: ./tools/analyze_osdtrace_output.py <log> [-i | -f kv_commit | -o <osd>]
+```
+
+The **where the time goes** block is the headline: it turns osdtrace's dense
+per-stage numbers into an instant "your latency is RocksDB commit, not network
+or queueing." Because the stages overlap (`op_lat` is not their sum), the
+shares are of total latency and need not add up to 100% - the point is which
+stage dominates.
+
+When a capture spans **more than one OSD**, an extra **per-OSD p95 latency**
+block is drawn (highest p95 first), so an outlier OSD stands out immediately -
+the single-OSD capture above omits it.
+
+## radostrace example
+
+```
+radostrace summary - 353 client ops
+    reads      152  ██████████████████████████████▎          43%
+    writes     201  ████████████████████████████████████████ 56%
+
+latency distribution   p50 3.5ms   p95 15.6ms   p99 19.4ms   max 19.7ms
+       <1ms  ███████████████▋                         36
+       <8ms  ████████████████████████████████████████ 92
+      <16ms  █████████████████████████████▋           68
+
+OSDs in the acting set of the slowest 17 ops
+    osd.0    ████████████████████████ 17
+
+  -> deeper: ./tools/analyze_radostrace_output.py <log> <osd_tree> [threshold_us]
+```
+
+The **OSDs in the acting set of the slowest ops** block is a quick culprit
+pointer; for the full iterative ranking mapped to physical hosts, use the
+analyzer it points to.
+
+## Interactive HTML report
+
+For a richer, shareable view, add `--html <file>` to write a **self-contained**
+HTML report instead of terminal text:
+
+```bash
+./tools/cephtrace_report.py --html report.html osd.log
+# wrote report.html (osdtrace, 115829 ops)
+```
+
+Open it in any browser, or attach it to a ticket - it is a single file with no
+external dependencies (no CDN, works offline). It shows everything the terminal
+view does plus things a terminal can't:
+
+![osdtrace HTML report](images/report-osdtrace.png)
+
+- **Latency over the capture** - p95 per slice in arrival order, so a workload
+  that degrades over time (or runs in bursts) is visible as a shape.
+- **Interactive**: hover any bar for exact counts/latencies; click a column
+  header to sort the per-OSD / per-pool and slowest-ops tables; click a row in
+  the per-group table to **filter the histogram to that OSD or pool** (and
+  "show all" to reset).
+
+The radostrace report is the same layout with a read/write split, per-pool
+breakdown, and the object name on each slowest op:
+
+![radostrace HTML report](images/report-radostrace.png)
+
+The report embeds only **precomputed aggregates** (histograms, per-slice
+percentiles, per-group stats, the 50 slowest ops), so even a multi-hundred-
+thousand-op capture produces a ~20 KB file.
+
+## Relationship to the analyzers
+
+This tool is the visual *glance*. It deliberately reuses the existing parsers
+(`analyze_osdtrace_output.parse_line` and `analyze_radostrace_output`'s format
+detection) rather than maintaining a second one. When you need the numbers,
+not the shape, use the detailed analyzers:
+
+- [Analyzing osdtrace logs](analyze-osdtrace.md) - fio-style percentile tables,
+  per-stage contribution (`-i`), per-OSD / per-field filtering
+- [Analyzing radostrace logs](analyze-radostrace.md) - iterative culprit-OSD
+  ranking mapped to hosts via `ceph osd tree`
+
+## Notes
+
+- Pure Python 3 standard library - no dependencies to install.
+- The bars use Unicode block characters; any modern terminal renders them.
+  Section headings are bold only when writing to a terminal, so piping or
+  redirecting to a file stays clean.
+- Reads either the default space-separated output or the CSV produced by
+  `radostrace -o`.
diff --git a/tests/test_cephtrace_report.py b/tests/test_cephtrace_report.py
new file mode 100644
index 0000000..2f98f86
--- /dev/null
+++ b/tests/test_cephtrace_report.py
@@ -0,0 +1,169 @@
+"""
+Smoke tests for cephtrace_report.py.
+
+These run against the small committed sample logs in tools/sample-logs/ so
+they are offline and fast.  The module is imported directly (tox sets
+PYTHONPATH=tools); cephtrace_report has a hyphen-free name precisely so it is
+importable here.
+"""
+import json
+import os
+import re
+import runpy
+import sys
+
+import pytest
+
+import cephtrace_report  # pylint: disable=E0401
+
+SAMPLES = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "tools", "sample-logs",
+)
+OSD_LOG = os.path.join(SAMPLES, "osdtrace_data.log")
+RADOS_LOG = os.path.join(SAMPLES, "radostrace_data.log")
+RADOS_CSV = os.path.join(SAMPLES, "radostrace_data.csv")
+
+
+def _run(path, capsys):
+    """Run the tool's main() against a file path and return stdout."""
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", path]
+    try:
+        rc = cephtrace_report.main()
+    finally:
+        sys.argv = argv
+    return rc, capsys.readouterr().out
+
+
+def test_osdtrace_report(capsys):
+    """osdtrace sample renders every headline section and the op types."""
+    rc, out = _run(OSD_LOG, capsys)
+    assert rc == 0
+    assert "osdtrace summary - 11 OSD ops" in out
+    for token in ("op_r", "op_w", "subop_w"):
+        assert token in out
+    assert "where the time goes" in out
+    assert "op latency distribution" in out
+    # bluestore dominates this write-heavy sample; kv_commit must surface
+    assert "kv_commit" in out
+    # two distinct OSDs in the sample -> per-OSD section is drawn
+    assert "per-OSD p95 latency" in out
+    assert "slowest ops" in out
+    assert "analyze_osdtrace_output.py" in out
+
+
+def test_radostrace_space_report(capsys):
+    """Space-formatted radostrace sample renders the client-side sections."""
+    rc, out = _run(RADOS_LOG, capsys)
+    assert rc == 0
+    assert "radostrace summary" in out
+    assert "reads" in out and "writes" in out
+    assert "latency distribution" in out
+    assert "slowest ops" in out
+    assert "analyze_radostrace_output.py" in out
+
+
+def test_radostrace_csv_report(capsys):
+    """CSV-formatted (radostrace -o) sample is detected and rendered."""
+    rc, out = _run(RADOS_CSV, capsys)
+    assert rc == 0
+    assert "radostrace summary" in out
+    assert "latency distribution" in out
+
+
+def _embedded_json(html):
+    """Pull the embedded payload back out of a generated report."""
+    match = re.search(r"const DATA = (\{.*?\});", html, re.S)
+    return json.loads(match.group(1))
+
+
+def test_html_osdtrace(tmp_path, capsys):
+    """--html on osdtrace writes a self-contained report with valid payload."""
+    out = tmp_path / "osd.html"
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", "--html", str(out), OSD_LOG]
+    try:
+        rc = cephtrace_report.main()
+    finally:
+        sys.argv = argv
+    assert rc == 0
+    assert f"wrote {out}" in capsys.readouterr().out
+    html = out.read_text(encoding="utf-8")
+    # self-contained: placeholder substituted, no external script/style refs
+    assert "__CEPHTRACE_DATA__" not in html
+    assert "<script src" not in html and "http" not in html.split("foot")[0]
+    payload = _embedded_json(html)
+    assert payload["kind"] == "osdtrace"
+    assert payload["summary"]["ops"] == 11
+    # two OSDs in the sample -> per-group histograms for cross-filtering
+    assert payload["groupLabel"] == "OSD"
+    assert sorted(payload["histGroups"]) == ["0", "2"]
+    assert len(payload["histOverall"]) == len(payload["histLabels"])
+    assert payload["stages"] and payload["kvCommit"] > 0
+    assert payload["timeline"] and payload["slowest"]
+
+
+def test_html_radostrace(tmp_path):
+    """--html on radostrace (CSV input) writes a valid pool-keyed report."""
+    out = tmp_path / "rados.html"
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", "--html", str(out), RADOS_CSV]
+    try:
+        rc = cephtrace_report.main()
+    finally:
+        sys.argv = argv
+    assert rc == 0
+    payload = _embedded_json(out.read_text(encoding="utf-8"))
+    assert payload["kind"] == "radostrace"
+    assert payload["groupLabel"] == "Pool"
+    assert "reads" in payload["summary"] and "writes" in payload["summary"]
+    assert payload["slowest"][0]["lat"] >= payload["slowest"][-1]["lat"]
+
+
+def test_html_requires_filename(capsys):
+    """--html with no following filename fails with rc=2."""
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", "--html"]
+    try:
+        rc = cephtrace_report.main()
+    finally:
+        sys.argv = argv
+    assert rc == 2
+    assert "requires an output filename" in capsys.readouterr().err
+
+
+def test_no_rows_returns_error(tmp_path, capsys):
+    """A file with no recognizable trace rows fails cleanly (rc=1)."""
+    junk = tmp_path / "junk.log"
+    junk.write_text("hello\nworld\n", encoding="utf-8")
+    rc, _ = _run(str(junk), capsys)
+    assert rc == 1
+
+
+def test_help_runs(capsys):
+    """--help prints the module docstring and exits 0."""
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", "--help"]
+    try:
+        rc = cephtrace_report.main()
+    finally:
+        sys.argv = argv
+    assert rc == 0
+    assert "one-screen visual summary" in capsys.readouterr().out
+
+
+def test_runs_as_script():
+    """The committed osdtrace sample runs end-to-end as a script (no import
+    side-effects, exit code 0)."""
+    argv = sys.argv
+    sys.argv = ["cephtrace_report.py", OSD_LOG]
+    try:
+        with pytest.raises(SystemExit) as exc:
+            runpy.run_path(
+                os.path.join(SAMPLES, "..", "cephtrace_report.py"),
+                run_name="__main__",
+            )
+        assert exc.value.code == 0
+    finally:
+        sys.argv = argv
diff --git a/tools/cephtrace_report.py b/tools/cephtrace_report.py
new file mode 100755
index 0000000..9bff99b
--- /dev/null
+++ b/tools/cephtrace_report.py
@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+"""
+cephtrace_report - a one-screen visual summary of radostrace / osdtrace output.
+
+This is the "is it slow, what's slow, where's the time going" glance: it draws
+bar charts and a latency histogram so the shape of a capture is understandable
+at sight, with no flags to remember.
+
+It complements - it does not replace - the two detailed analyzers:
+  * analyze_osdtrace_output.py   fio-style percentile tables, per-stage
+                                 contribution (-i), per-OSD/field filtering
+  * analyze_radostrace_output.py iterative culprit-OSD ranking mapped to hosts
+
+To avoid a second, divergent parser, the osdtrace path reuses
+analyze_osdtrace_output.parse_line, and the radostrace path reuses
+analyze_radostrace_output.detect_file_format and the same column layout.
+
+Usage:
+    radostrace -t 30 > rados.log && ./tools/cephtrace_report.py rados.log
+    sudo ./osdtrace --id 0 -t 30 | ./tools/cephtrace_report.py
+
+    # write a self-contained, interactive HTML report instead of terminal text
+    ./tools/cephtrace_report.py --html report.html osd.log
+"""
+import csv
+import json
+import os
+import re
+import shutil
+import sys
+from collections import Counter, defaultdict
+
+# Reuse the existing, battle-tested parsers from the sibling analyzers rather
+# than maintain a second one that could drift.  They live in this directory,
+# so put it on the path first; pylint can't follow that runtime edit, hence
+# the targeted disables.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+# pylint: disable=wrong-import-position,import-error
+from analyze_osdtrace_output import parse_line as parse_osd_line  # noqa: E402
+from analyze_radostrace_output import detect_file_format  # noqa: E402
+# pylint: enable=wrong-import-position,import-error
+
+# 1/8th-width cells give smooth, sub-character-resolution bars.
+_CELLS = " ▏▎▍▌▋▊▉█"
+
+# Log-scale latency buckets (microseconds), shared by the terminal histogram
+# and the HTML report so both tell the same story.
+_HIST_EDGES = [250, 500, 1000, 2000, 4000, 8000, 16000, 32000, 64000, 1e18]
+_HIST_NAMES = ["<250us", "<500us", "<1ms", "<2ms", "<4ms", "<8ms", "<16ms",
+               "<32ms", "<64ms", ">=64ms"]
+
+
+def _bucketize(lats):
+    """Count latencies into the shared log-scale buckets."""
+    buckets = [0] * len(_HIST_EDGES)
+    for value in lats:
+        for i, edge in enumerate(_HIST_EDGES):
+            if value < edge:
+                buckets[i] += 1
+                break
+    return buckets
+
+
+def _bar(frac, width):
+    """Render a proportional unicode bar padded to ``width`` columns."""
+    frac = 0.0 if frac < 0 else 1.0 if frac > 1 else frac
+    full = int(frac * width)
+    rem = int(round((frac * width - full) * 8))
+    return ("█" * full + (_CELLS[rem] if rem else "")).ljust(width)
+
+
+def _pct(sorted_vals, percentile):
+    """Linear-interpolated percentile of an already-sorted list."""
+    if not sorted_vals:
+        return 0
+    pos = (len(sorted_vals) - 1) * percentile / 100.0
+    low = int(pos)
+    if low + 1 >= len(sorted_vals):
+        return sorted_vals[low]
+    return sorted_vals[low] + (sorted_vals[low + 1] - sorted_vals[low]) * (
+        pos - low)
+
+
+def _us(value):
+    """Human-readable latency from a microsecond value."""
+    value = float(value)
+    if value < 1000:
+        return f"{value:.0f}us"
+    if value < 1_000_000:
+        return f"{value / 1000:.1f}ms"
+    return f"{value / 1_000_000:.2f}s"
+
+
+def _hsize(value):
+    """Human-readable byte size."""
+    value = float(value)
+    for unit in ("B", "K", "M", "G"):
+        if value < 1024:
+            fmt = "{:.0f}{}" if unit == "B" else "{:.1f}{}"
+            return fmt.format(value, unit)
+        value /= 1024
+    return f"{value:.1f}T"
+
+
+def _heading(text):
+    """Print a section heading, bold only when writing to a terminal."""
+    print(f"\n\033[1m{text}\033[0m" if sys.stdout.isatty() else f"\n{text}")
+
+
+def _bar_width(term_width):
+    """Bar column count that leaves room for labels at this terminal width."""
+    return max(16, min(40, term_width - 34))
+
+
+def latency_histogram(lats, bar_w, label):
+    """Draw a log-scale latency histogram plus a p50/p95/p99/max line.
+
+    The percentile *tables* already live in the analyzers; what they lack is
+    the distribution *shape*, which is what this renders.
+    """
+    buckets = _bucketize(lats)
+    ordered = sorted(lats)
+    _heading(f"{label} distribution   "
+             f"p50 {_us(_pct(ordered, 50))}   p95 {_us(_pct(ordered, 95))}   "
+             f"p99 {_us(_pct(ordered, 99))}   max {_us(ordered[-1])}")
+    peak = max(buckets) or 1
+    for name, count in zip(_HIST_NAMES, buckets):
+        if count:
+            print(f"    {name:>7}  {_bar(count / peak, bar_w)} {count}")
+
+
+# ---------------------------------------------------------------------------
+# osdtrace
+# ---------------------------------------------------------------------------
+
+def _osd_where_time_goes(rows, bar_w):
+    """Aggregate share of total latency per stage (stages overlap, so the
+    shares need not sum to 100% - this shows which stage dominates)."""
+    total = sum(r["lat"] for r in rows) or 1
+    stage_of = {
+        "messenger": lambda r: (r["throttle_lat"] + r["recv_lat"]
+                                + r["dispatch_lat"]),
+        "queue": lambda r: r["queue_lat"],
+        "osd": lambda r: r["osd_lat"],
+        "bluestore": lambda r: r["bluestore_lat"],
+    }
+    _heading("where the time goes   (share of total latency, "
+             f"avg {_us(total / len(rows))}/op)")
+    for stage, func in stage_of.items():
+        frac = sum(func(r) for r in rows) / total
+        print(f"    {stage:>10}  {_bar(frac, bar_w)} {100 * frac:.0f}%")
+    kv_commit = sum(r["bluestore_details"].get("kv_commit", 0) for r in rows)
+    if kv_commit:
+        print(f"     +kv_commit {_bar(kv_commit / total, bar_w)} "
+              f"{100 * kv_commit / total:.0f}%  (rocksdb commit)")
+
+
+def _osd_per_osd_p95(rows, bar_w):
+    """Per-OSD p95 latency bars - only meaningful with >1 OSD captured."""
+    by_osd = defaultdict(list)
+    for row in rows:
+        by_osd[row["osd"]].append(row["lat"])
+    if len(by_osd) <= 1:
+        return
+    _heading("per-OSD p95 latency")
+    ranked = sorted(by_osd.items(),
+                    key=lambda kv: -_pct(sorted(kv[1]), 95))[:8]
+    top = _pct(sorted(ranked[0][1]), 95) or 1
+    for osd, lats in ranked:
+        p95 = _pct(sorted(lats), 95)
+        print(f"    osd.{osd:<5} {_bar(p95 / top, bar_w)} "
+              f"{_us(p95)}  ({len(lats)} ops)")
+
+
+def report_osdtrace(rows, width):
+    """Print the full osdtrace visual summary."""
+    bar_w = _bar_width(width)
+    bytype = Counter(r["op"] for r in rows)
+    _heading(f"osdtrace summary - {len(rows)} OSD ops")
+    print("  " + "   ".join(f"{t} {c}" for t, c in bytype.most_common()))
+
+    _osd_where_time_goes(rows, bar_w)
+    latency_histogram([r["lat"] for r in rows], bar_w, "op latency")
+    _osd_per_osd_p95(rows, bar_w)
+
+    _heading("slowest ops")
+    for row in sorted(rows, key=lambda r: -r["lat"])[:5]:
+        print(f"    {_us(row['lat']):>7}  {row['op']:<8} osd.{row['osd']} "
+              f"pg {row['pg']} {_hsize(row['size'])}")
+
+    print("\n  -> deeper: ./tools/analyze_osdtrace_output.py <log> "
+          "[-i | -f kv_commit | -o <osd>]")
+
+
+# ---------------------------------------------------------------------------
+# radostrace
+# ---------------------------------------------------------------------------
+
+# Column layout shared with analyze_radostrace_output.py (space and CSV):
+#   0 pid  1 client  2 tid  3 pool  4 pg  5 acting  6 WR  7 size  8 latency
+#   9.. object + [ops]
+def _parse_radostrace(lines, is_csv):
+    """Parse radostrace rows into dicts: wr, size, lat, pool, obj, acting."""
+    rows = []
+    if is_csv:
+        for row in csv.reader(lines):
+            if len(row) < 10 or not row[8].isdigit():
+                continue
+            obj = row[9] + (" " + row[10] if len(row) > 10 and row[10] else "")
+            rows.append({"wr": row[6], "size": int(row[7]),
+                         "lat": int(row[8]), "pool": row[3], "obj": obj,
+                         "acting": [int(x) for x in re.findall(r"\d+",
+                                                               row[5])]})
+        return rows
+    for line in lines:
+        if not line.strip() or line.startswith(("Execution", "Version")):
+            continue
+        parts = line.split()
+        if len(parts) < 10 or not parts[8].isdigit():
+            continue
+        rows.append({"wr": parts[6], "size": int(parts[7]),
+                     "lat": int(parts[8]), "pool": parts[3],
+                     "obj": " ".join(parts[9:]),
+                     "acting": [int(x) for x in re.findall(r"\d+", parts[5])]})
+    return rows
+
+
+def _rados_pools(rows, bar_w):
+    """Ops-per-pool bars - only shown for multi-pool captures (RGW etc.)."""
+    pools = Counter(r["pool"] for r in rows)
+    if len(pools) <= 1:
+        return
+    _heading("ops per pool")
+    pmax = pools.most_common(1)[0][1]
+    for pool, count in pools.most_common(6):
+        print(f"    pool {pool:<5} {_bar(count / pmax, bar_w)} {count}")
+
+
+def _rados_slow_osds(rows, bar_w):
+    """OSDs in the acting set of the slowest ops - a quick culprit pointer
+    (the radostrace analyzer does the full iterative, host-mapped ranking)."""
+    cut = max(1, len(rows) // 20)
+    slow = sorted(rows, key=lambda r: -r["lat"])[:cut]
+    culprit = Counter(osd for r in slow for osd in r["acting"])
+    if not culprit:
+        return
+    _heading(f"OSDs in the acting set of the slowest {cut} ops")
+    cmax = culprit.most_common(1)[0][1]
+    for osd, count in culprit.most_common(6):
+        print(f"    osd.{osd:<5} {_bar(count / cmax, bar_w)} {count}")
+
+
+def report_radostrace(rows, width):
+    """Print the full radostrace visual summary."""
+    bar_w = _bar_width(width)
+    total = len(rows)
+    reads = sum(1 for r in rows if r["wr"] == "R")
+    writes = sum(1 for r in rows if r["wr"] == "W")
+    _heading(f"radostrace summary - {total} client ops")
+    rmax = max(reads, writes) or 1
+    print(f"    reads   {reads:>6}  {_bar(reads / rmax, bar_w)} "
+          f"{100 * reads // total}%")
+    print(f"    writes  {writes:>6}  {_bar(writes / rmax, bar_w)} "
+          f"{100 * writes // total}%")
+
+    latency_histogram([r["lat"] for r in rows], bar_w, "latency")
+    _rados_pools(rows, bar_w)
+    _rados_slow_osds(rows, bar_w)
+
+    _heading("slowest ops")
+    for row in sorted(rows, key=lambda r: -r["lat"])[:5]:
+        print(f"    {_us(row['lat']):>7}  {row['wr']}  "
+              f"{row['obj'][:max(20, width - 18)]}")
+
+    print("\n  -> deeper: ./tools/analyze_radostrace_output.py <log> "
+          "<osd_tree> [threshold_us]")
+
+
+# ---------------------------------------------------------------------------
+
+def _is_osdtrace(lines):
+    """True when the input looks like osdtrace ('osd <n> pg ...') output."""
+    return any(re.match(r"osd\s+\d+\s+pg\s", ln) for ln in lines)
+
+
+def _load(lines, is_csv):
+    """Parse buffered lines into ('osdtrace'|'radostrace', rows)."""
+    if _is_osdtrace(lines):
+        rows = [d[0] for d in (parse_osd_line(ln) for ln in lines) if d]
+        return "osdtrace", rows
+    return "radostrace", _parse_radostrace(lines, is_csv)
+
+
+# ---------------------------------------------------------------------------
+# HTML report (self-contained; aggregates precomputed here, rendered by the
+# JS in report_template.html over the embedded JSON payload).
+# ---------------------------------------------------------------------------
+
+def _timeline(rows, slices=60):
+    """p50/p95 per equal slice of the capture, in arrival order."""
+    if len(rows) < slices:
+        slices = max(1, len(rows))
+    step = len(rows) / slices
+    out = []
+    for i in range(slices):
+        chunk = rows[int(i * step):int((i + 1) * step)]
+        lats = sorted(r["lat"] for r in chunk)
+        if lats:
+            out.append({"p50": round(_pct(lats, 50)),
+                        "p95": round(_pct(lats, 95)), "n": len(lats)})
+    return out
+
+
+def _group_stats(groups):
+    """Per-group {id, count, p50, p95, max} + per-group histograms."""
+    table, hists = [], {}
+    for gid, lats in groups.items():
+        ordered = sorted(lats)
+        table.append({"id": gid, "count": len(ordered),
+                      "p50": round(_pct(ordered, 50)),
+                      "p95": round(_pct(ordered, 95)), "max": ordered[-1]})
+        hists[str(gid)] = _bucketize(ordered)
+    table.sort(key=lambda g: -g["p95"])
+    return table, hists
+
+
+def _build_payload(kind, rows):
+    """Compact JSON-able aggregates for the HTML template."""
+    lats = sorted(r["lat"] for r in rows)
+    summary = {"ops": len(rows), "p50": _us(_pct(lats, 50)),
+               "p95": _us(_pct(lats, 95)), "p99": _us(_pct(lats, 99)),
+               "max": _us(lats[-1])}
+    payload = {"kind": kind, "summary": summary,
+               "histLabels": _HIST_NAMES,
+               "histOverall": _bucketize(r["lat"] for r in rows),
+               "timeline": _timeline(rows)}
+
+    if kind == "osdtrace":
+        bytype = Counter(r["op"] for r in rows)
+        summary["byType"] = bytype.most_common()
+        total = sum(r["lat"] for r in rows) or 1
+        stage = {
+            "messenger": sum(r["throttle_lat"] + r["recv_lat"]
+                             + r["dispatch_lat"] for r in rows),
+            "queue": sum(r["queue_lat"] for r in rows),
+            "osd": sum(r["osd_lat"] for r in rows),
+            "bluestore": sum(r["bluestore_lat"] for r in rows),
+        }
+        payload["stages"] = [[k, round(100 * v / total)]
+                             for k, v in stage.items()]
+        kv_commit = sum(r["bluestore_details"].get("kv_commit", 0)
+                        for r in rows)
+        payload["kvCommit"] = round(100 * kv_commit / total)
+        groups = defaultdict(list)
+        for row in rows:
+            groups[row["osd"]].append(row["lat"])
+        payload["groupLabel"] = "OSD"
+        payload["groups"], payload["histGroups"] = _group_stats(groups)
+        payload["slowest"] = [
+            {"lat": r["lat"], "op": r["op"], "osd": r["osd"], "pg": r["pg"],
+             "size": _hsize(r["size"])}
+            for r in sorted(rows, key=lambda r: -r["lat"])[:50]]
+    else:
+        summary["reads"] = sum(1 for r in rows if r["wr"] == "R")
+        summary["writes"] = sum(1 for r in rows if r["wr"] == "W")
+        summary["byType"] = [["read", summary["reads"]],
+                             ["write", summary["writes"]]]
+        groups = defaultdict(list)
+        for row in rows:
+            groups[row["pool"]].append(row["lat"])
+        payload["groupLabel"] = "Pool"
+        payload["groups"], payload["histGroups"] = _group_stats(groups)
+        payload["slowest"] = [
+            {"lat": r["lat"], "wr": r["wr"], "pool": r["pool"],
+             "obj": r["obj"]}
+            for r in sorted(rows, key=lambda r: -r["lat"])[:50]]
+    return payload
+
+
+def _write_html(payload, out_path):
+    """Inline the payload into the template and write a standalone .html."""
+    template = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                            "report_template.html")
+    with open(template, encoding="utf-8") as handle:
+        html = handle.read()
+    # Compact, and neutralize any "</script>" that could ride in on an object
+    # name by escaping "<".
+    blob = json.dumps(payload, separators=(",", ":")).replace("<", "\\u003c")
+    with open(out_path, "w", encoding="utf-8") as handle:
+        handle.write(html.replace("__CEPHTRACE_DATA__", blob))
+
+
+def main():
+    """Read a file arg or stdin, detect the tool, print or write a report."""
+    if "-h" in sys.argv or "--help" in sys.argv:
+        print(__doc__)
+        return 0
+    argv = sys.argv[1:]
+    html_out = None
+    if "--html" in argv:
+        idx = argv.index("--html")
+        if idx + 1 >= len(argv):
+            print("--html requires an output filename", file=sys.stderr)
+            return 2
+        html_out = argv[idx + 1]
+        del argv[idx:idx + 2]
+    positional = [a for a in argv if not a.startswith("-")]
+
+    if positional:
+        path = positional[0]
+        with open(path, encoding="utf-8", errors="replace") as handle:
+            lines = handle.readlines()
+        is_csv = detect_file_format(path) == "csv"
+    else:
+        lines = sys.stdin.readlines()
+        is_csv = any("," in ln for ln in lines[:5] if ln.strip())
+
+    kind, rows = _load(lines, is_csv)
+    if not rows:
+        print(f"no {kind} rows recognized", file=sys.stderr)
+        return 1
+
+    if html_out:
+        _write_html(_build_payload(kind, rows), html_out)
+        print(f"wrote {html_out} ({kind}, {len(rows)} ops)")
+        return 0
+
+    width = shutil.get_terminal_size((90, 24)).columns
+    if kind == "osdtrace":
+        report_osdtrace(rows, width)
+    else:
+        report_radostrace(rows, width)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/report_template.html b/tools/report_template.html
new file mode 100644
index 0000000..c32bbbc
--- /dev/null
+++ b/tools/report_template.html
@@ -0,0 +1,364 @@
+<!DOCTYPE html>
+<!--
+  cephtrace report - self-contained, no external dependencies.
+  Generated by tools/cephtrace_report.py --html.  The placeholder below is
+  replaced with a compact JSON payload of precomputed aggregates; all
+  rendering and interactivity is vanilla JS over that payload.
+-->
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>cephtrace report</title>
+<style>
+  :root {
+    --bg: #f6f7f9; --card: #ffffff; --ink: #1f2933; --muted: #7b8794;
+    --line: #e4e7eb; --accent: #2f6f9f; --accent2: #4a9fd4;
+    --warn: #d9822b; --bad: #c0392b; --good: #3a9d6b;
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; background: var(--bg); color: var(--ink);
+    font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+          Helvetica, Arial, sans-serif;
+  }
+  .wrap { max-width: 980px; margin: 0 auto; padding: 24px 18px 60px; }
+  h1 { font-size: 20px; margin: 0 0 2px; }
+  .sub { color: var(--muted); margin: 0 0 22px; font-size: 13px; }
+  .card {
+    background: var(--card); border: 1px solid var(--line);
+    border-radius: 10px; padding: 18px 20px; margin: 0 0 18px;
+  }
+  .card h2 { font-size: 14px; margin: 0 0 14px; font-weight: 600; }
+  .card h2 .hint { color: var(--muted); font-weight: 400; }
+  .stats { display: flex; flex-wrap: wrap; gap: 14px; }
+  .stat {
+    flex: 1 1 110px; background: var(--card); border: 1px solid var(--line);
+    border-radius: 10px; padding: 12px 14px;
+  }
+  .stat .v { font-size: 22px; font-weight: 650; letter-spacing: -0.5px; }
+  .stat .k { color: var(--muted); font-size: 12px; text-transform: uppercase;
+             letter-spacing: 0.4px; }
+  /* horizontal stage bars */
+  .hbar { display: grid; grid-template-columns: 110px 1fr 48px;
+          align-items: center; gap: 10px; margin: 6px 0; }
+  .hbar .lab { color: var(--muted); text-align: right; font-size: 13px; }
+  .hbar .track { background: var(--bg); border-radius: 6px; height: 18px;
+                 overflow: hidden; }
+  .hbar .fill { height: 100%; background: var(--accent); border-radius: 6px; }
+  .hbar .pc { font-variant-numeric: tabular-nums; font-size: 13px; }
+  /* vertical bar charts (histogram, timeline).  align-items:stretch (the
+     default) makes every .col fill the 150px height, so the bars' percentage
+     heights resolve against a definite parent. */
+  .vbars { display: flex; align-items: stretch; gap: 3px; height: 150px;
+           border-bottom: 1px solid var(--line); }
+  .vbars .col { flex: 1 1 0; display: flex; flex-direction: column;
+                justify-content: flex-end; min-width: 0; cursor: default; }
+  .vbars .b { background: var(--accent); border-radius: 3px 3px 0 0;
+              transition: opacity .1s; min-height: 1px; }
+  .vbars .col:hover .b { opacity: .65; }
+  .axis { display: flex; gap: 3px; margin-top: 4px; }
+  .axis span { flex: 1 1 0; text-align: center; color: var(--muted);
+               font-size: 10px; overflow: hidden; white-space: nowrap; }
+  table { width: 100%; border-collapse: collapse; font-size: 13px; }
+  th, td { text-align: right; padding: 6px 10px;
+           border-bottom: 1px solid var(--line); white-space: nowrap; }
+  th:first-child, td:first-child { text-align: left; }
+  td.obj { text-align: left; font-family: ui-monospace, SFMono-Regular,
+           Menlo, monospace; font-size: 12px; max-width: 0; width: 99%;
+           overflow: hidden; text-overflow: ellipsis; }
+  th { color: var(--muted); font-weight: 600; cursor: pointer;
+       user-select: none; }
+  th.sorted::after { content: " \25BE"; }
+  th.asc::after { content: " \25B4"; }
+  tbody tr.sel { background: #eaf2f8; }
+  tbody tr.click { cursor: pointer; }
+  tbody tr.click:hover { background: #f0f4f8; }
+  .pill { display: inline-block; padding: 1px 7px; border-radius: 10px;
+          font-size: 11px; font-weight: 600; }
+  .pill.r { background: #e7f1fb; color: var(--accent); }
+  .pill.w { background: #fbeee2; color: var(--warn); }
+  .filterbar { color: var(--muted); font-size: 13px; margin: 0 0 10px; }
+  .filterbar b { color: var(--ink); }
+  .filterbar button { font: inherit; color: var(--accent);
+    background: none; border: none; cursor: pointer; padding: 0;
+    text-decoration: underline; }
+  #tip { position: fixed; pointer-events: none; z-index: 10; opacity: 0;
+    background: #1f2933; color: #fff; padding: 5px 9px; border-radius: 6px;
+    font-size: 12px; transition: opacity .08s; white-space: nowrap; }
+  .foot { color: var(--muted); font-size: 12px; margin-top: 26px; }
+  .foot code { background: var(--card); border: 1px solid var(--line);
+               border-radius: 4px; padding: 1px 5px; }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <h1 id="title">cephtrace report</h1>
+  <p class="sub" id="subtitle"></p>
+
+  <div class="stats" id="stats"></div>
+
+  <div class="card" id="stagesCard" hidden>
+    <h2>Where the time goes
+      <span class="hint">- share of total latency (stages overlap)</span></h2>
+    <div id="stages"></div>
+  </div>
+
+  <div class="card">
+    <h2 id="histTitle">Latency distribution</h2>
+    <p class="filterbar" id="histFilter" hidden></p>
+    <div class="vbars" id="hist"></div>
+    <div class="axis" id="histAxis"></div>
+  </div>
+
+  <div class="card">
+    <h2>Latency over the capture
+      <span class="hint">- p95 per slice, in arrival order &rarr;</span></h2>
+    <div class="vbars" id="timeline"></div>
+  </div>
+
+  <div class="card" id="groupCard">
+    <h2 id="groupTitle"></h2>
+    <p class="filterbar"><span id="groupHint"></span></p>
+    <table id="groupTable"></table>
+  </div>
+
+  <div class="card">
+    <h2>Slowest ops</h2>
+    <table id="slowTable"></table>
+  </div>
+
+  <p class="foot" id="foot"></p>
+</div>
+
+<div id="tip"></div>
+
+<script>
+const DATA = __CEPHTRACE_DATA__;
+
+const tip = document.getElementById("tip");
+function showTip(e, html) {
+  tip.innerHTML = html; tip.style.opacity = 1;
+  tip.style.left = (e.clientX + 12) + "px";
+  tip.style.top = (e.clientY + 12) + "px";
+}
+function hideTip() { tip.style.opacity = 0; }
+
+function el(tag, attrs, kids) {
+  const n = document.createElement(tag);
+  for (const k in (attrs || {})) {
+    if (k === "class") n.className = attrs[k];
+    else if (k === "html") n.innerHTML = attrs[k];
+    else n.setAttribute(k, attrs[k]);
+  }
+  (kids || []).forEach(c => n.appendChild(
+    typeof c === "string" ? document.createTextNode(c) : c));
+  return n;
+}
+
+// color a histogram bucket by how slow it is
+function bucketColor(label) {
+  if (label.indexOf("ms") < 0) return "var(--accent)";        // sub-ms
+  const ms = parseFloat(label.replace(/[<>=]/g, ""));
+  if (ms >= 64) return "var(--bad)";
+  if (ms >= 16) return "var(--warn)";
+  return "var(--accent2)";
+}
+
+function renderStats() {
+  const s = DATA.summary, box = document.getElementById("stats");
+  const cards = [["ops", s.ops.toLocaleString()],
+                 ["p50", s.p50], ["p95", s.p95],
+                 ["p99", s.p99], ["max", s.max]];
+  if (DATA.kind === "radostrace")
+    cards.splice(1, 0, ["read / write", s.reads + " / " + s.writes]);
+  cards.forEach(([k, v]) => box.appendChild(
+    el("div", {class: "stat"},
+       [el("div", {class: "v"}, [String(v)]),
+        el("div", {class: "k"}, [k])])));
+}
+
+function renderStages() {
+  if (DATA.kind !== "osdtrace") return;
+  document.getElementById("stagesCard").hidden = false;
+  const host = document.getElementById("stages");
+  const rows = DATA.stages.slice();
+  if (DATA.kvCommit) rows.push(["+kv_commit (rocksdb)", DATA.kvCommit, 1]);
+  rows.forEach(([name, pc, sub]) => {
+    const fill = el("div", {class: "fill"});
+    fill.style.width = Math.max(1, pc) + "%";
+    if (sub) fill.style.background = "var(--good)";
+    host.appendChild(el("div", {class: "hbar"},
+      [el("div", {class: "lab"}, [name]),
+       el("div", {class: "track"}, [fill]),
+       el("div", {class: "pc"}, [pc + "%"])]));
+  });
+}
+
+let histGroup = null;  // null = all
+
+function renderHist() {
+  const counts = histGroup === null ? DATA.histOverall
+                                    : DATA.histGroups[histGroup];
+  const host = document.getElementById("hist");
+  const axis = document.getElementById("histAxis");
+  host.innerHTML = ""; axis.innerHTML = "";
+  const peak = Math.max(1, ...counts);
+  DATA.histLabels.forEach((label, i) => {
+    const bar = el("div", {class: "b"});
+    bar.style.height = (100 * counts[i] / peak) + "%";
+    bar.style.background = bucketColor(label);
+    const col = el("div", {class: "col"}, [bar]);
+    col.onmousemove = e => showTip(e,
+      "<b>" + counts[i].toLocaleString() + "</b> ops " + label);
+    col.onmouseleave = hideTip;
+    host.appendChild(col);
+    axis.appendChild(el("span", {title: label}, [label]));
+  });
+  const fb = document.getElementById("histFilter");
+  if (histGroup === null) { fb.hidden = true; }
+  else {
+    fb.hidden = false; fb.innerHTML = "";
+    fb.appendChild(document.createTextNode(
+      "filtered to " + DATA.groupLabel.toLowerCase() + " "));
+    fb.appendChild(el("b", {}, [labelFor(histGroup)]));
+    fb.appendChild(document.createTextNode(" · "));
+    const btn = el("button", {}, ["show all"]);
+    btn.onclick = () => setGroup(null);
+    fb.appendChild(btn);
+  }
+}
+
+function labelFor(id) {
+  return (DATA.groupLabel === "OSD" ? "osd." : "pool ") + id;
+}
+
+function setGroup(id) {
+  histGroup = id;
+  document.getElementById("histTitle").textContent =
+    "Latency distribution" + (id === null ? "" : " - " + labelFor(id));
+  renderHist();
+  document.querySelectorAll("#groupTable tbody tr").forEach(tr =>
+    tr.classList.toggle("sel", tr.dataset.id === String(id)));
+}
+
+function renderTimeline() {
+  const host = document.getElementById("timeline");
+  const peak = Math.max(1, ...DATA.timeline.map(s => s.p95));
+  DATA.timeline.forEach((s, i) => {
+    const bar = el("div", {class: "b"});
+    bar.style.height = (100 * s.p95 / peak) + "%";
+    bar.style.background = "var(--accent)";
+    const col = el("div", {class: "col"}, [bar]);
+    col.onmousemove = e => showTip(e,
+      "slice " + (i + 1) + "/" + DATA.timeline.length +
+      "<br>p95 <b>" + fmtUs(s.p95) + "</b> · p50 " + fmtUs(s.p50) +
+      " · " + s.n + " ops");
+    col.onmouseleave = hideTip;
+    host.appendChild(col);
+  });
+}
+
+function fmtUs(v) {
+  if (v < 1000) return Math.round(v) + "us";
+  if (v < 1e6) return (v / 1000).toFixed(1) + "ms";
+  return (v / 1e6).toFixed(2) + "s";
+}
+
+// generic sortable table
+function makeTable(node, cols, rows, opts) {
+  opts = opts || {};
+  let sortIdx = opts.sort == null ? 1 : opts.sort, asc = false;
+  function draw() {
+    node.innerHTML = "";
+    const thead = el("tr", {});
+    cols.forEach((c, i) => {
+      const th = el("th", {}, [c.h]);
+      if (i === sortIdx) th.classList.add(asc ? "asc" : "sorted");
+      th.onclick = () => {
+        if (i === sortIdx) asc = !asc; else { sortIdx = i; asc = false; }
+        draw();
+      };
+      thead.appendChild(th);
+    });
+    node.appendChild(el("thead", {}, [thead]));
+    const body = el("tbody", {});
+    const sorted = rows.slice().sort((a, b) => {
+      const x = a[cols[sortIdx].k], y = b[cols[sortIdx].k];
+      const d = (typeof x === "number" && typeof y === "number")
+                ? x - y : String(x).localeCompare(String(y));
+      return asc ? d : -d;
+    });
+    sorted.forEach(r => {
+      const tr = el("tr", {});
+      if (opts.id) { tr.dataset.id = r[opts.id]; tr.classList.add("click"); }
+      cols.forEach(c => {
+        const td = el("td", c.cls ? {class: c.cls} : {});
+        td.innerHTML = c.fmt ? c.fmt(r[c.k], r) : r[c.k];
+        tr.appendChild(td);
+      });
+      if (opts.onclick) tr.onclick = () => opts.onclick(r);
+      body.appendChild(tr);
+    });
+    node.appendChild(body);
+  }
+  draw();
+}
+
+function renderGroups() {
+  document.getElementById("groupTitle").textContent =
+    "Per-" + DATA.groupLabel + " latency";
+  document.getElementById("groupHint").textContent =
+    "click a row to filter the histogram above";
+  const cols = [
+    {h: DATA.groupLabel, k: "label"},
+    {h: "ops", k: "count", fmt: v => v.toLocaleString()},
+    {h: "p50", k: "p50", fmt: fmtUs},
+    {h: "p95", k: "p95", fmt: fmtUs},
+    {h: "max", k: "max", fmt: fmtUs},
+  ];
+  DATA.groups.forEach(g => { g.label = labelFor(g.id); });
+  makeTable(document.getElementById("groupTable"), cols, DATA.groups,
+    {sort: 3, id: "id", onclick: g => setGroup(g.id)});
+}
+
+function renderSlowest() {
+  let cols;
+  if (DATA.kind === "osdtrace") {
+    cols = [
+      {h: "latency", k: "lat", fmt: fmtUs},
+      {h: "type", k: "op"},
+      {h: "osd", k: "osd", fmt: v => "osd." + v},
+      {h: "pg", k: "pg"}, {h: "size", k: "size"},
+    ];
+  } else {
+    cols = [
+      {h: "latency", k: "lat", fmt: fmtUs},
+      {h: "rw", k: "wr", fmt: v => '<span class="pill ' +
+        v.toLowerCase() + '">' + v + "</span>"},
+      {h: "pool", k: "pool"},
+      {h: "object", k: "obj", cls: "obj"},
+    ];
+  }
+  makeTable(document.getElementById("slowTable"), cols, DATA.slowest,
+            {sort: 0});
+}
+
+document.getElementById("title").textContent =
+  DATA.kind + " report";
+document.getElementById("subtitle").textContent =
+  DATA.summary.ops.toLocaleString() + " ops · " +
+  DATA.summary.byType.map(t => t[0] + " " + t[1]).join("  ·  ");
+document.getElementById("foot").innerHTML =
+  "Generated by <code>cephtrace_report.py --html</code> · " +
+  "no external dependencies · for the numbers, see the matching analyzer.";
+
+renderStats();
+renderStages();
+renderHist();
+renderTimeline();
+renderGroups();
+renderSlowest();
+</script>
+</body>
+</html>
diff --git a/tools/sample-logs/osdtrace_data.log b/tools/sample-logs/osdtrace_data.log
new file mode 100644
index 0000000..9bec46c
--- /dev/null
+++ b/tools/sample-logs/osdtrace_data.log
@@ -0,0 +1,11 @@
+osd 0 pg 2.1d op_r size 24 client 14164 tid 1 throttle_lat 2 recv_lat 12 dispatch_lat 20 queue_lat 84 osd_lat 69 bluestore_lat 33 op_lat 220
+osd 0 pg 2.d op_r size 4096 client 14164 tid 2 throttle_lat 2 recv_lat 13 dispatch_lat 19 queue_lat 105 osd_lat 133 bluestore_lat 510 op_lat 782
+osd 0 pg 2.a op_r size 4096 client 14164 tid 5 throttle_lat 0 recv_lat 4 dispatch_lat 4 queue_lat 350 osd_lat 87 bluestore_lat 224 op_lat 670
+osd 0 pg 2.1d op_r size 4096 client 14164 tid 3 throttle_lat 1 recv_lat 52 dispatch_lat 6 queue_lat 118 osd_lat 87 bluestore_lat 826 op_lat 1091
+osd 0 pg 2.d op_w size 4096 client 14160 tid 1 throttle_lat 2 recv_lat 14 dispatch_lat 39 queue_lat 176 osd_lat 304 peers [(-1, 0), (-1, 0)] bluestore_lat 4363 (prepare 132 aio_wait 0 (aio_size 0) seq_wait 13 kv_commit 4217) op_lat 4975
+osd 0 pg 2.1d op_w size 4096 client 14160 tid 2 throttle_lat 0 recv_lat 21 dispatch_lat 6 queue_lat 141 osd_lat 230 peers [(-1, 0), (-1, 0)] bluestore_lat 4342 (prepare 87 aio_wait 0 (aio_size 0) seq_wait 12 kv_commit 4241) op_lat 4862
+osd 0 pg 2.1b op_w size 4096 client 14160 tid 3 throttle_lat 0 recv_lat 9 dispatch_lat 5 queue_lat 412 osd_lat 121 peers [(-1, 0), (-1, 0)] bluestore_lat 8309 (prepare 79 aio_wait 0 (aio_size 0) seq_wait 14 kv_commit 8214) op_lat 9012
+osd 0 pg 2.a op_w size 4096 client 14160 tid 4 throttle_lat 0 recv_lat 8 dispatch_lat 5 queue_lat 229 osd_lat 126 peers [(-1, 0), (-1, 0)] bluestore_lat 8207 (prepare 76 aio_wait 0 (aio_size 0) seq_wait 14 kv_commit 8116) op_lat 8659
+osd 2 pg 4.a subop_w size 4461 client 34161 tid 14 throttle_lat 2 recv_lat 53 dispatch_lat 38 queue_lat 389 osd_lat 116 bluestore_lat 8041 (prepare 107 aio_wait 0 (aio_size 0) seq_wait 19 kv_commit 7914) subop_lat 8714
+osd 2 pg 4.c subop_w size 4460 client 34161 tid 2 throttle_lat 1 recv_lat 24 dispatch_lat 7 queue_lat 321 osd_lat 106 bluestore_lat 8214 (prepare 253 aio_wait 0 (aio_size 0) seq_wait 21 kv_commit 7940) subop_lat 8822
+osd 2 pg 4.c subop_w size 4461 client 34161 tid 11 throttle_lat 1 recv_lat 15 dispatch_lat 12 queue_lat 79 osd_lat 136 bluestore_lat 7499 (prepare 389 aio_wait 0 (aio_size 0) seq_wait 20 kv_commit 7089) subop_lat 8619