Skip to content
Python
21.9 KB
Raw Blame
import { esc, duration, count } from "./observability-data.js";
const id = (s) => encodeURIComponent(s);
const path = (q) =>
  `/v1/sessions/${id(q.sessionId)}/observability/${id(q.turnId)}`;
/** Transport stays in the trusted application; the component never stores credentials. */
export function serviceTracingAdapter(request) {
  const get = (p, signal) => request(p, signal);
  return {
    search: async (q, signal) =>
      get(
        "/v1/observability/runs?" +
          new URLSearchParams({
            q: q.q || "",
            limit: "25",
            ...(q.after ? { after: q.after } : {}),
          }),
        signal,
      ),
    // The existing run directory is authorized and cursor-bound. Exact matching is
    // essential: its text search can also match another session's partial ID.
    turns: async (q, signal) => {
      const p = await get(
        "/v1/observability/runs?" +
          new URLSearchParams({
            q: q.sessionId,
            limit: "100",
            ...(q.after ? { after: q.after } : {}),
          }),
        signal,
      );
      return {
        turns: p.runs.filter((r) => r.session_id === q.sessionId),
        next_cursor: p.next_cursor,
      };
    },
    timeline: (q, signal) =>
      get(
        path(q) +
          "/timeline?" +
          new URLSearchParams({
            limit: "100",
            after: String(q.after ?? 0),
            ...(q.through != null ? { through: String(q.through) } : {}),
          }),
        signal,
      ),
    summary: (q, signal) => get(path(q) + "/summary", signal),
    children: (q, signal) => get(path(q) + "/children", signal),
  };
}
const svg = (kind) => {
  const shapes = {
    model: '<path d="m12 3 3 6 6 3-6 3-3 6-3-6-6-3 6-3Z"/>',
    tool: '<path d="m8 5-5 7 5 7M16 5l5 7-5 7M14 4l-4 16"/>',
    agent:
      '<rect x="4" y="5" width="16" height="14" rx="4"/><path d="M9 10h.01M15 10h.01M9 14h6M12 2v3"/>',
    chevron: '<path d="m9 5 7 7-7 7"/>',
  };
  return `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${shapes[kind] || shapes.agent}</svg>`;
};
const kind = (s) =>
  s.operation.startsWith("model.")
    ? "model"
    : s.operation.startsWith("tool.")
      ? "tool"
      : "agent";
const name = (s) =>
  (s.tool && s.tool.replaceAll("__", " · ").replaceAll("_", " ")) ||
  (s.model && s.operation === "model.attempt" && `Model · ${s.model}`) ||
  {
    "agent.execute": "Execution segment",
    "model.requested": "Request started",
    "policy.review": "Policy check",
    "approval.wait": "Approval wait",
    "question.wait": "Question wait",
    "environment.operation": "Prepare environment",
  }[s.operation] ||
  s.operation;
const key = (s) => s.trace_id + "/" + s.span_id;
const reason = (e) =>
  e?.status === 403
    ? "You cannot read this session."
    : e?.status === 404
      ? "This recording is no longer available."
      : e?.status === 503
        ? "Recording is disabled or unavailable."
        : e?.status === 429
          ? "Recording readers are busy. Try Refresh."
          : "Unable to load recording. Try Refresh.";
const button = (action, text, extra = "") =>
  `<button type="button" data-tr="${action}" ${extra}>${text}</button>`;
const scope = (r) => ({ sessionId: r.session_id, turnId: r.turn_id });
/** Session-oriented trace browser. No evaluations or combined team view. */
export function mountSessionTracing(
  root,
  { adapter, initialRun = null, onOverview } = {},
) {
  if (!adapter) throw Error("A tracing adapter is required");
  const lifetime = new AbortController(),
    signal = lifetime.signal;
  let disposed = false,
    searchGen = 0,
    sessionGen = 0,
    detailGen = 0,
    timer;
  let results = [],
    nextSearch = null,
    searchText = "",
    session = null,
    turns = [],
    nextTurns = null,
    history = [],
    cache = new Map(),
    selected = null,
    details = null,
    mode = "tree",
    tab = "preview",
    pending = false;
  root.classList.add("ow-session-tracing");
  root.innerHTML = `<div class="tr-heading"><div><h1>Tracing</h1><p>Follow a session, one turn at a time.</p></div><div>${onOverview ? button("overview", "Usage overview ↗") : ""}${button("refresh", "Refresh")}</div></div><div class="tr-toolbar"><input type="search" aria-label="Search sessions" placeholder="Search session name or ID…" maxlength="200"><span class="tr-directory-state" role="status"></span></div><div class="tr-workbench"><aside class="tr-directory"><div class="tr-panehead">Sessions</div><div class="tr-results"></div><div class="tr-directory-footer"></div></aside><section class="tr-execution"><div class="tr-panehead"><span>Execution</span><div class="tr-segment" role="group" aria-label="Execution view">${button("tree", "Tree", 'aria-pressed="true"')}${button("waterfall", "Waterfall", 'aria-pressed="false"')}</div></div><div class="tr-context"></div><div class="tr-turns"></div></section><section class="tr-inspector"><div class="tr-panehead">Step details</div><div class="tr-details"></div></section></div>`;
  const $ = (s) => root.querySelector(s);
  const query = () => $(".tr-toolbar input").value;
  function sessions() {
    const map = new Map();
    for (const r of results)
      if (!map.has(r.session_id)) map.set(r.session_id, r);
    return [...map.values()];
  }
  function directory() {
    const rs = sessions();
    $(".tr-results").innerHTML =
      rs
        .map(
          (r) =>
            `<button class="tr-session ${session?.session_id === r.session_id ? "selected" : ""}" data-tr="session" data-tr-session="${esc(r.session_id)}"><strong>${esc(r.name || r.agent || r.session_id)}</strong><span><i class="tr-status">${esc(r.status || "Unknown")}</i><small>${r.created_ms ? esc(new Date(r.created_ms).toLocaleDateString()) : ""}</small></span><code>${esc(r.session_id)}</code></button>`,
        )
        .join("") ||
      '<p class="tr-note">No matching sessions on this page.</p>';
    $(".tr-directory-footer").innerHTML = nextSearch
      ? button("more-search", "More sessions")
      : "";
  }
  async function search(more = false) {
    const gen = ++searchGen,
      q = searchText;
    $(".tr-directory-state").textContent = "Searching…";
    try {
      const page = await adapter.search(
        { q, after: more ? nextSearch : undefined },
        signal,
      );
      if (disposed || gen !== searchGen) return;
      results = (more ? [...results, ...page.runs] : page.runs).slice(0, 1000);
      nextSearch = results.length < 1000 ? page.next_cursor : null;
      $(".tr-directory-state").textContent =
        `${sessions().length} sessions loaded${nextSearch ? " · more available" : ""}`;
      directory();
      if (!session && results.length) await openSession(results[0]);
    } catch (e) {
      if (disposed || gen !== searchGen) return;
      results = [];
      nextSearch = null;
      directory();
      $(".tr-directory-state").textContent = reason(e);
    }
  }
  function crumb() {
    return `<div class="tr-breadcrumb">${button("home", "Sessions")}${history.length ? `<span>›</span>${button("back", esc(history.at(-1).session.name || history.at(-1).session.agent || "Parent agent"))}<span>›</span>${button("back", esc(history.at(-1).parentTurn))}` : ""}<span>›</span><strong>${esc(session?.name || session?.agent || "Session")}</strong></div>`;
  }
  function context() {
    if (!session) return;
    $(".tr-context").innerHTML =
      crumb() +
      `<h2>${esc(session.name || session.agent || session.session_id)}</h2><div class="tr-chips"><span>${esc(session.status || "Unknown")}</span><span>${turns.length} ${turns.length === 1 ? "turn" : "turns"} loaded${nextTurns ? " · more available" : ""}</span><code>${esc(session.session_id)}</code></div>`;
  }
  const visibleSteps = (c) =>
    (c.steps || []).filter((s) => s.operation !== "model.requested");
  function body(t, c) {
    if (c.error) return `<p class="tr-error" role="status">${esc(c.error)}</p>`;
    if (c.loading)
      return '<p class="tr-note" role="status">Loading recording…</p>';
    const ss = visibleSteps(c),
      known = ss.filter(
        (s) => Number.isFinite(s.started_ms) && Number.isFinite(s.duration_us),
      ),
      start = known.length ? Math.min(...known.map((s) => s.started_ms)) : 0,
      end = known.length
        ? Math.max(...known.map((s) => s.started_ms + s.duration_us / 1000))
        : 1,
      range = Math.max(1, end - start),
      summary = c.summary;
    const total = summary?.usage;
    const tokens =
      total?.input?.total != null && total?.output?.total != null
        ? `${count(total.input.total + total.output.total)}${total.input.unknown || total.output.unknown ? " + unknown" : ""}`
        : "Not reported";
    let html = `<div class="tr-turn-metrics"><span>${esc(duration(summary?.wall_elapsed_us))} elapsed</span><span>${tokens} tokens</span><span>${ss.length} steps loaded</span></div>`;
    if (mode === "waterfall")
      html += `<div class="tr-axis">${[0, 1, 2, 3, 4].map((i) => `<span>${i ? esc(duration(((range * i) / 4) * 1000)) : "0 s"}</span>`).join("")}</div>`;
    // Indentation follows recorded parent IDs only. Missing parents are roots;
    // cycles are bounded and labelled, never silently invented.
    const map = new Map(ss.map((s) => [key(s), s]));
    const depth = (s) => {
      let n = 0,
        p = s,
        seen = new Set([key(s)]);
      while (n < 6) {
        const parent = map.get(p.parent_trace_id + "/" + p.parent_span_id);
        if (!parent || seen.has(key(parent))) break;
        seen.add(key(parent));
        n++;
        p = parent;
      }
      return n;
    };
    for (const s of ss) {
      const d = depth(s),
        k = kind(s),
        timing =
          Number.isFinite(s.started_ms) && Number.isFinite(s.duration_us);
      html += `<button class="tr-step tr-${k} ${selected?.step && key(selected.step) === key(s) ? "selected" : ""} ${mode === "waterfall" ? "tr-waterfall" : ""}" data-tr="step" data-turn="${esc(t.turn_id)}" data-step="${esc(key(s))}" data-depth="${d}"><span class="tr-step-name">${svg(k)}<span>${esc(name(s))}</span></span>${mode === "tree" ? `<span class="tr-duration">${esc(duration(s.duration_us))}</span>` : `<span class="tr-track">${timing ? `<i data-left="${Math.min(99, Math.max(0, ((s.started_ms - start) / range) * 100))}" data-width="${Math.min(100, (s.duration_us / 1000 / range) * 100)}" class="${s.outcome === "error" ? "tr-failed" : ""}"></i>` : "<small>Unknown timing</small>"}</span>`}<span class="tr-outcome ${s.outcome === "error" ? "tr-error" : ""}">${esc(s.outcome || "Unknown")}</span></button>`;
    }
    if (c.next != null)
      html +=
        c.steps.length < 1000
          ? button(
              "more-steps",
              "Load more steps",
              `data-turn="${esc(t.turn_id)}"`,
            )
          : '<p class="tr-note">Showing 1,000 steps. Narrow the query through the SDK to inspect further records.</p>';
    if (!ss.length)
      html += '<p class="tr-note">No recorded steps for this turn.</p>';
    html += `<div class="tr-children">${(c.children || []).map((child, i) => `<div><span>${svg("agent")}${esc(child.agent_id)} <small>${esc(child.phase)}</small></span>${child.child_turn_id ? button("child", `Open session ↗`, `data-turn="${esc(t.turn_id)}" data-child="${i}" aria-label="Open ${esc(child.agent_id)} session"`) : "<small>Initial turn unavailable</small>"}</div>`).join("")}</div>`;
    if (c.childError)
      html +=
        '<p class="tr-note">Child links are unavailable for this turn.</p>';
    const cov = summary?.coverage;
    if (
      cov?.scan_truncated ||
      cov?.hierarchy_incomplete ||
      cov?.unknown_outcome_steps ||
      cov?.unknown_timing_steps
    )
      html +=
        '<p class="tr-note">Partial coverage: some timing, hierarchy or outcomes are incomplete. Recording is best effort.</p>';
    return html;
  }
  function render() {
    context();
    directory();
    $(".tr-turns").innerHTML =
      turns
        .map((t) => {
          const c = cache.get(t.turn_id);
          return `<section class="tr-turn"><button data-tr="turn" data-turn="${esc(t.turn_id)}" class="tr-turn-heading" aria-expanded="${!!c?.open}"><span class="tr-chevron ${c?.open ? "open" : ""}">${svg("chevron")}</span><span><b>${esc(t.label || "Turn · " + t.turn_id.slice(0, 14) + "…")}</b><small>${esc(t.status || "Status not reported")}</small></span></button>${c?.open ? `<div class="tr-calls">${body(t, c)}</div>` : ""}</section>`;
        })
        .join("") +
      (nextTurns != null ? button("more-turns", "Load more turns") : "") +
      (pending ? '<p class="tr-note" role="status">Loading turns…</p>' : "");
    root
      .querySelectorAll(".tr-segment button")
      .forEach((b) =>
        b.setAttribute("aria-pressed", String(b.dataset.tr === mode)),
      );
    for (const el of root.querySelectorAll("[data-depth]"))
      el.style.setProperty("--indent", el.dataset.depth);
    for (const el of root.querySelectorAll("[data-left]")) {
      el.style.left = el.dataset.left + "%";
      el.style.width = el.dataset.width + "%";
    }
  }
  async function loadTurns(more = false, target) {
    if (more && pending) return;
    const gen = sessionGen,
      sid = session.session_id;
    pending = true;
    render();
    try {
      const p = await adapter.turns(
        { sessionId: sid, after: more ? nextTurns : undefined },
        signal,
      );
      if (disposed || gen !== sessionGen) return;
      const incoming = p.turns.filter((t) => t.session_id === sid);
      if (!more && incoming[0])
        session = { ...session, status: incoming[0].status };
      const unique = new Map(
        (more ? [...turns, ...incoming] : incoming).map((t) => [t.turn_id, t]),
      );
      turns = [...unique.values()];
      turns = turns.slice(0, 1000);
      nextTurns = turns.length < 1000 ? p.next_cursor : null;
      pending = false;
      if (target && !turns.some((t) => t.turn_id === target.turn_id))
        turns.unshift({ ...target, session_id: sid });
      render();
      if (!more && turns.length) {
        const t = turns.find((t) => t.turn_id === target?.turn_id) || turns[0];
        await loadTurn(t);
      }
    } catch (e) {
      if (disposed || gen !== sessionGen) return;
      pending = false;
      turns = [];
      nextTurns = null;
      render();
      $(".tr-turns").innerHTML =
        `<p class="tr-error" role="status">${esc(reason(e))}</p>`;
    }
  }
  async function openSession(r, target) {
    sessionGen++;
    detailGen++;
    session = r;
    turns = [];
    cache = new Map();
    selected = null;
    details = null;
    nextTurns = null;
    $(".tr-details").innerHTML =
      '<p class="tr-note">Select a model or tool call.</p>';
    await loadTurns(false, target || r);
  }
  async function loadTurn(t, more = false) {
    const gen = sessionGen,
      old = cache.get(t.turn_id) || {},
      q = scope(t);
    const c = { ...old, open: true, loading: true };
    cache.set(t.turn_id, c);
    render();
    try {
      const [page, s, child] = await Promise.all([
        adapter.timeline(
          {
            ...q,
            after: more ? old.next : undefined,
            through: more ? old.through : undefined,
            limit: 100,
          },
          signal,
        ),
        more
          ? Promise.resolve({ summary: old.summary })
          : adapter.summary(q, signal),
        more
          ? Promise.resolve({ children: old.children })
          : adapter.children
            ? adapter
                .children(q, signal)
                .catch(() => ({ children: [], unavailable: true }))
            : Promise.resolve({ children: [] }),
      ]);
      if (disposed || gen !== sessionGen || cache.get(t.turn_id) !== c) return;
      const steps = [
        ...(more ? old.steps || [] : []),
        ...page.page.steps.map((x) => x.step),
      ];
      Object.assign(c, {
        steps: steps.slice(0, 1000),
        next: page.page.next,
        through: page.page.through,
        summary: s.summary,
        children: child.children,
        childError: child.unavailable,
        loading: false,
        error: null,
      });
      render();
    } catch (e) {
      if (disposed || gen !== sessionGen) return;
      Object.assign(c, {
        loading: false,
        error: reason(e),
        steps: [],
        children: [],
      });
      if (selected?.turn.turn_id === t.turn_id) {
        selected = null;
        details = null;
        detailGen++;
        $(".tr-details").innerHTML =
          '<p class="tr-note">Selected recording is unavailable.</p>';
      }
      render();
    }
  }
  function inspector() {
    const s = selected?.step;
    if (!s) return;
    const payload = (v) =>
      v === undefined || v === null
        ? '<div class="tr-empty">Content was not captured or is not available to this viewer.</div>'
        : `<pre>${esc(typeof v === "string" ? v : JSON.stringify(v, null, 2))}</pre>`;
    $(".tr-details").innerHTML =
      `<div class="tr-detail-title"><small>${esc(s.operation)}</small><h2>${esc(name(s))}</h2><div class="tr-chips"><span>${esc(s.outcome)}</span><span>${esc(duration(s.duration_us))}</span></div></div><div class="tr-tabs" role="group" aria-label="Step detail view">${["preview", "attributes", "json"].map((x) => button(x, x === "json" ? "JSON" : x[0].toUpperCase() + x.slice(1), `aria-pressed="${tab === x}"`)).join("")}</div><div class="tr-detail-body">${
        tab === "json"
          ? `<pre>${esc(JSON.stringify(s, null, 2))}</pre>`
          : tab === "attributes"
            ? `<dl>${Object.entries(s)
                .filter(([, v]) => v != null)
                .map(
                  ([k, v]) =>
                    `<dt>${esc(k)}</dt><dd>${esc(typeof v === "object" ? JSON.stringify(v) : v)}</dd>`,
                )
                .join("")}</dl>`
            : `<h3>Input</h3>${payload(details?.input)}<h3>Output</h3>${payload(details?.output)}${details?.error ? `<p class="tr-note">${esc(details.error)}</p>` : ""}<h3>Execution</h3><dl><dt>Duration</dt><dd>${esc(duration(s.duration_us))}</dd><dt>First output</dt><dd>${esc(duration(s.first_output_us))}</dd><dt>Model</dt><dd>${esc(s.model || "—")}</dd><dt>Token usage</dt><dd>${s.usage ? esc(JSON.stringify(s.usage)) : "Not reported"}</dd><dt>Span</dt><dd>${esc(s.span_id)}</dd></dl>`
      }</div>`;
  }
  async function select(t, s) {
    selected = { turn: t, step: s };
    details = null;
    tab = "preview";
    const gen = ++detailGen,
      sessionVersion = sessionGen;
    render();
    inspector();
    if (adapter.stepDetails) {
      try {
        const value = await adapter.stepDetails(
          { ...scope(t), traceId: s.trace_id, spanId: s.span_id },
          signal,
        );
        if (disposed || gen !== detailGen || sessionVersion !== sessionGen)
          return;
        details = value;
        inspector();
      } catch (e) {
        if (!disposed && gen === detailGen) {
          details = { error: reason(e) };
          inspector();
        }
      }
    }
  }
  async function click(e) {
    const b = e.target.closest("button[data-tr]");
    if (!b || !root.contains(b)) return;
    const action = b.dataset.tr,
      t = turns.find((t) => t.turn_id === b.dataset.turn);
    if (action === "session") {
      history = [];
      await openSession(
        results.find((r) => r.session_id === b.dataset.trSession),
      );
    } else if (action === "turn") {
      const c = cache.get(t.turn_id);
      if (c?.open) {
        c.open = false;
        render();
      } else if (c?.steps) {
        c.open = true;
        render();
      } else await loadTurn(t);
    } else if (action === "more-steps") await loadTurn(t, true);
    else if (action === "step") {
      const s = cache
        .get(t.turn_id)
        ?.steps.find((s) => key(s) === b.dataset.step);
      if (s) await select(t, s);
    } else if (action === "child") {
      const c = cache.get(t.turn_id).children[Number(b.dataset.child)];
      history.push({
        session,
        turns,
        nextTurns,
        cache,
        selected,
        details,
        tab,
        mode,
        parentTurn: t.label || "Turn · " + t.turn_id.slice(0, 14) + "…",
        scroll: $(".tr-execution").scrollTop,
      });
      await openSession(
        {
          session_id: c.child_session_id,
          turn_id: c.child_turn_id,
          name: c.agent_id,
          status: c.phase,
        },
        { session_id: c.child_session_id, turn_id: c.child_turn_id },
      );
      $(".tr-execution").scrollTop = 0;
    } else if (action === "back") {
      const h = history.pop();
      if (h) {
        sessionGen++;
        detailGen++;
        ({ session, turns, nextTurns, cache, selected, details, tab, mode } =
          h);
        pending = false;
        render();
        $(".tr-execution").scrollTop = h.scroll;
        inspector();
      }
    } else if (action === "home") {
      history = [];
      if (results[0]) await openSession(results[0]);
    } else if (["tree", "waterfall"].includes(action)) {
      mode = action;
      render();
    } else if (["preview", "attributes", "json"].includes(action)) {
      tab = action;
      inspector();
    } else if (action === "more-search") await search(true);
    else if (action === "more-turns") await loadTurns(true);
    else if (action === "refresh") {
      if (session) await openSession(session, selected?.turn);
      else await search();
    } else if (action === "overview") onOverview?.();
  }
  root.addEventListener("click", click, { signal });
  $(".tr-toolbar input").addEventListener(
    "input",
    () => {
      clearTimeout(timer);
      searchText = query();
      searchGen++;
      timer = setTimeout(() => search(), 250);
    },
    { signal },
  );
  if (initialRun) openSession(initialRun);
  if (adapter.search) search();
  else $(".tr-toolbar").hidden = true;
  return {
    refresh: () => (session ? openSession(session) : search()),
    dispose() {
      disposed = true;
      searchGen++;
      sessionGen++;
      detailGen++;
      clearTimeout(timer);
      lifetime.abort();
      root.replaceChildren();
      root.classList.remove("ow-session-tracing");
    },
  };
}