Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

6.1 KB
Raw Blame
import type * as Browser from "@sentry/browser";
import type { init } from "@sentry/browser";
import type { Me } from "./shell-state";
import { parseDeepLink, UI_BASE } from "./deep-link.ts";
import { finishTiming, traceStatus, type TimingResult } from "../../chassis/src/timing.ts";
import { errDetail, swallow } from "../../chassis/src/errors.ts";

const MAX_TIMINGS_PER_PAGE = 200;
const API_RESOURCES = new Set([
  "approvals",
  "blobs",
  "channel-header-pin",
  "composio",
  "connectors",
  "contexts",
  "crons",
  "deliveries",
  "deployments",
  "directory",
  "files",
  "inbox",
  "keychain",
  "loops",
  "memory",
  "playgrounds",
  "projects",
  "resources",
  "runs",
  "runtime-config",
  "scope-resources",
  "search",
  "sessions",
  "skills",
  "slack-installation",
  "suggested-activities",
  "surface-config",
  "turn",
  "ui-state",
  "user-model-auth",
  "webhooks",
]);
let client: ReturnType<typeof init>;
let sdk: typeof Browser | undefined;
let generation = 0;
let timingBudget = 0;
let largestContentfulPaint: number | undefined;
let pageLoadReported = false;

function timing(op: string, name: string, startMs: number, result: TimingResult): void {
  if (!client || !sdk || timingBudget <= 0) return;
  timingBudget--;
  try {
    sdk.getCurrentScope().setPropagationContext({ traceId: hex(16), sampleRand: Math.random() });
    const span = sdk.startInactiveSpan({ op, name, startTime: startMs, attributes: { "sentry.source": "route" } });
    finishTiming(sdk, span, result);
  } catch {
    return;
  }
}

function hex(bytes: number): string {
  return Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (b) => b.toString(16).padStart(2, "0")).join("");
}

export function apiRouteName(pathname: string): string {
  const segments = pathname.split("/").filter(Boolean);
  const api = segments.indexOf("api");
  const resource = segments[api + 1];
  if (api < 0 || !resource || !API_RESOURCES.has(resource)) return "/*";
  return `/api/${resource}${segments.length > api + 2 ? "/*" : ""}`;
}

export function reportRequestTiming(url: string, method: string, startMs: number, status: number | null): void {
  if (!client) return;
  let target: URL;
  try {
    target = new URL(url, window.location.origin);
  } catch {
    return;
  }
  if (target.origin !== window.location.origin) return;
  timing("http.client", `${/^[A-Z]{3,7}$/.test(method) ? method : "GET"} ${apiRouteName(target.pathname)}`, startMs, {
    status: status === null ? "internal_error" : traceStatus(status),
    data: { url: target.href, http_status: status === null ? "network" : String(status) },
  });
}

function reportPageLoad(): void {
  try {
    const navigation = performance.getEntriesByType("navigation")[0] as PerformanceNavigationTiming | undefined;
    if (!navigation?.loadEventEnd) return;
    const paint = (name: string) => performance.getEntriesByName(name)[0]?.startTime;
    const { view } = parseDeepLink(UI_BASE, window.location.pathname, "");
    timing("pageload", "pageload", performance.timeOrigin, {
      status: "ok",
      endMs: performance.timeOrigin + navigation.loadEventEnd,
      data: { page: view ?? "other", url: navigation.name },
      measurements: {
        ttfb: navigation.responseStart,
        dom_content_loaded: navigation.domContentLoadedEventEnd,
        load: navigation.loadEventEnd,
        fcp: paint("first-contentful-paint"),
        lcp: largestContentfulPaint,
      },
    });
  } catch {
    return;
  }
}

function startTiming(rate: number): void {
  timingBudget = rate > 0 ? MAX_TIMINGS_PER_PAGE : 0;
  if (!timingBudget || pageLoadReported) return;
  pageLoadReported = true;
  try {
    new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) largestContentfulPaint = entry.startTime;
    }).observe({ type: "largest-contentful-paint", buffered: true });
  } catch {
    largestContentfulPaint = undefined;
  }
  try {
    const report = () => setTimeout(reportPageLoad, 500);
    if (document.readyState === "complete") report();
    else window.addEventListener("load", report, { once: true });
  } catch {
    return;
  }
}

export function reportHandledError(context: string, error: unknown): void {
  console.warn(`[handled] ${context}: ${errDetail(error)}`);
  if (!client || !sdk) return;
  sdk.captureException(error, { tags: { error_code: context }, fingerprint: ["{{ default }}", context] });
}

export function stopBrowserErrors(): void {
  generation++;
  timingBudget = 0;
  if (client) client.getOptions().enabled = false;
  client = undefined;
}

export async function initializeBrowserErrors(me: Me): Promise<void> {
  stopBrowserErrors();
  if (!me.browserErrors?.dsn || me.impersonatedBy) return;
  const current = generation;
  const { dsn, release, tracesSampleRate } = me.browserErrors;
  const rate = tracesSampleRate && tracesSampleRate > 0 && tracesSampleRate <= 1 ? tracesSampleRate : 0;
  try {
    const browser = await import("@sentry/browser");
    if (current !== generation) return;
    sdk = browser;
    client = browser.init({
      dsn,
      release,
      defaultIntegrations: false,
      integrations: [
        browser.globalHandlersIntegration(),
        browser.linkedErrorsIntegration(),
        browser.extraErrorDataIntegration({ depth: 8 }),
      ],
      attachStacktrace: true,
      sendClientReports: false,
      enableLogs: false,
      tracesSampleRate: rate,
      tracePropagationTargets: [],
      initialScope: { tags: { service: "web-ui-browser", org: me.org }, user: { username: me.user } },
      beforeSend: (event, hint) => {
        const error = hint.originalException;
        return current !== generation ||
          (error instanceof Error &&
            (error.name === "AbortError" ||
              (error.name === "TypeError" &&
                ["Failed to fetch", "NetworkError when attempting to fetch resource.", "Load failed"].includes(
                  error.message,
                ))))
          ? null
          : event;
      },
      beforeSendTransaction: (event) => (current === generation ? event : null),
    });
  } catch (error) {
    swallow("browser error reporting initialization", error);
    if (current === generation) client = undefined;
  }
  if (client) startTiming(rate);
}