@openhoo/hoopilot 2.1.5 → 2.1.6

package/dist/index.d.ts

@@ -12,7 +12,7 @@ declare class MetricsRegistry {
         now?: () => number;
     });
     /** Mark a request as started; pair with exactly one {@link observe}. */
-    startRequest(): void;
+    startRequest(route?: string): void;
     /** Record a completed request and clear its in-flight slot. */
     observe(observation: RequestObservation): void;
     /**
@@ -35,7 +35,7 @@ declare class MetricsRegistry {
      */
     recordGithubRateLimit(rateLimit: GithubRateLimit | undefined): void;
     /** A JSON-friendly view of the current counters. */
-    snapshot(now?: () => number): MetricsSnapshot;
+    snapshot(nowOrOptions?: (() => number) | MetricsSnapshotOptions): MetricsSnapshot;
     /** Render the Prometheus text exposition format (version 0.0.4). */
     renderPrometheus(now?: () => number): string;
 }
@@ -243,6 +243,12 @@ interface MetricsSnapshot {
     };
     uptimeSeconds: number;
 }
+/** Options for deriving a JSON metrics snapshot without changing raw counters. */
+interface MetricsSnapshotOptions {
+    excludeRoutes?: readonly string[];
+    excludeUpstreamPaths?: readonly string[];
+    now?: () => number;
+}
 /** JSON body returned by the proxy's `/v1/usage` route. */
 interface UsageResponseBody {
     copilot: CopilotUsage | null;

package/dist/index.js

@@ -2630,6 +2630,7 @@ var MetricsRegistry = class {
   #inFlight = 0;
   #requests = /* @__PURE__ */ new Map();
   #durations = /* @__PURE__ */ new Map();
+  #inFlightByRoute = /* @__PURE__ */ new Map();
   #tokens = /* @__PURE__ */ new Map();
   #upstream = /* @__PURE__ */ new Map();
   #copilotQuota;
@@ -2639,14 +2640,23 @@ var MetricsRegistry = class {
     this.#startedAtMs = (options.now ?? Date.now)();
   }
   /** Mark a request as started; pair with exactly one {@link observe}. */
-  startRequest() {
+  startRequest(route) {
     this.#inFlight += 1;
+    if (route) {
+      this.#inFlightByRoute.set(route, (this.#inFlightByRoute.get(route) ?? 0) + 1);
+    }
   }
   /** Record a completed request and clear its in-flight slot. */
   observe(observation) {
     if (this.#inFlight > 0) {
       this.#inFlight -= 1;
     }
+    const inFlightForRoute = this.#inFlightByRoute.get(observation.route) ?? 0;
+    if (inFlightForRoute > 1) {
+      this.#inFlightByRoute.set(observation.route, inFlightForRoute - 1);
+    } else if (inFlightForRoute === 1) {
+      this.#inFlightByRoute.delete(observation.route);
+    }
     const key = labelKey(observation.route, observation.method, String(observation.status));
     this.#requests.set(key, (this.#requests.get(key) ?? 0) + 1);
     this.#observeDuration(observation.route, observation.durationMs / 1e3);
@@ -2731,12 +2741,19 @@ var MetricsRegistry = class {
     this.#durations.set(route, entry);
   }
   /** A JSON-friendly view of the current counters. */
-  snapshot(now = Date.now) {
+  snapshot(nowOrOptions = Date.now) {
+    const options = typeof nowOrOptions === "function" ? { now: nowOrOptions } : nowOrOptions;
+    const now = options.now ?? Date.now;
+    const excludeRoutes = new Set(options.excludeRoutes ?? []);
+    const excludeUpstreamPaths = new Set(options.excludeUpstreamPaths ?? []);
     const byRoute = {};
     const byStatus = {};
     let requestsTotal = 0;
     for (const [key, count] of this.#requests) {
       const [route = "", , status = ""] = key.split(LABEL_SEPARATOR);
+      if (excludeRoutes.has(route)) {
+        continue;
+      }
       byRoute[route] = (byRoute[route] ?? 0) + count;
       byStatus[status] = (byStatus[status] ?? 0) + count;
       requestsTotal += count;
@@ -2754,8 +2771,12 @@ var MetricsRegistry = class {
     let upstreamTotal = 0;
     let upstreamErrors = 0;
     for (const [key, count] of this.#upstream) {
+      const [path = "", outcome = ""] = key.split(LABEL_SEPARATOR);
+      if (excludeUpstreamPaths.has(path)) {
+        continue;
+      }
       upstreamTotal += count;
-      if (key.endsWith(`${LABEL_SEPARATOR}error`)) {
+      if (outcome === "error") {
         upstreamErrors += count;
       }
     }
@@ -2765,8 +2786,8 @@ var MetricsRegistry = class {
     }
     return {
       githubRateLimit,
-      inFlight: this.#inFlight,
-      latency: this.#latencySnapshot(),
+      inFlight: this.#filteredInFlight(excludeRoutes),
+      latency: this.#latencySnapshot(excludeRoutes),
       requests: { byRoute, byStatus, total: requestsTotal },
       startedAt: new Date(this.#startedAtMs).toISOString(),
       tokens: { byModel, extraction: { ...this.#extraction }, ...tokenTotals },
@@ -2774,15 +2795,30 @@ var MetricsRegistry = class {
       uptimeSeconds: Math.max(0, Math.round((now() - this.#startedAtMs) / 1e3))
     };
   }
+  #filteredInFlight(excludeRoutes) {
+    if (excludeRoutes.size === 0) {
+      return this.#inFlight;
+    }
+    let excluded = 0;
+    for (const [route, count] of this.#inFlightByRoute) {
+      if (excludeRoutes.has(route)) {
+        excluded += count;
+      }
+    }
+    return Math.max(0, this.#inFlight - excluded);
+  }
   // Summarize the duration histogram into a JSON latency view: per-route count and
   // exact average, plus overall average and estimated p50/p95. The percentiles come
   // from the buckets aggregated across routes, so they share /metrics' resolution.
-  #latencySnapshot() {
+  #latencySnapshot(excludeRoutes = /* @__PURE__ */ new Set()) {
     const byRoute = {};
     const aggregateBuckets = new Array(DURATION_BUCKETS_SECONDS.length).fill(0);
     let totalCount = 0;
     let totalSum = 0;
     for (const [route, entry] of this.#durations) {
+      if (excludeRoutes.has(route)) {
+        continue;
+      }
       byRoute[route] = {
         avgMs: entry.count > 0 ? round2(entry.sum / entry.count * 1e3) : 0,
         count: entry.count
@@ -3813,10 +3849,10 @@ footer.foot .end { margin-left:auto; }
     pollGen += 1; var myGen = pollGen;
     if (inflightFetch){ try { inflightFetch.abort(); } catch (e) {} }
     var ctrl = new AbortController(); inflightFetch = ctrl;
-    var to = setTimeout(function(){ try { ctrl.abort(); } catch (e) {} }, 3000);
+    var to = setTimeout(function(){ try { ctrl.abort(); } catch (e) {} }, Math.max(10000, intervalMs * 2));
     var headers = { "accept":"application/json" };
     if (apiKey) headers["x-api-key"] = apiKey;
-    fetch("/v1/usage", { headers: headers, signal: ctrl.signal, cache:"no-store" }).then(function(res){
+    fetch("/v1/usage?view=dashboard", { headers: headers, signal: ctrl.signal, cache:"no-store" }).then(function(res){
       clearTimeout(to);
       if (myGen !== pollGen) return null;
       if (res.status === 401 || res.status === 403){ inflightFetch = null; showAuth(!!apiKey); return null; }
@@ -4127,6 +4163,15 @@ var MAX_REQUEST_BODY_BYTES = 16 * 1024 * 1024;
 var REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 var REQUEST_TOO_LARGE_MESSAGE = `Request body must be ${MAX_REQUEST_BODY_BYTES} bytes or smaller.`;
 var USAGE_CACHE_TTL_MS = 6e4;
+var DASHBOARD_USAGE_VIEW = "dashboard";
+var DASHBOARD_EXCLUDED_ROUTES = [
+  "cors.preflight",
+  "dashboard",
+  "health",
+  "metrics",
+  "usage"
+];
+var DASHBOARD_EXCLUDED_UPSTREAM_PATHS = ["/copilot_internal/user"];
 var RequestBodyTooLargeError = class extends Error {
   constructor() {
     super(REQUEST_TOO_LARGE_MESSAGE);
@@ -4179,7 +4224,7 @@ function createHoopilotHandler(options = {}) {
       requestId,
       route
     });
-    metrics.startRequest();
+    metrics.startRequest(route);
     const origin = request.headers.get("origin")?.trim() || void 0;
     const corsOrigin = resolveCorsAllowOrigin(origin, allowedOrigins);
     const inner = normalizeInnerRequest(request, apiPath, url);
@@ -4302,7 +4347,7 @@ function buildApp(deps) {
     }
     logger.error({ err: errorDetails(error), event: "http.request.failed" }, "request failed");
     return jsonError(500, "internal_error", message);
-  }).get("/", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/healthz", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/metrics", () => metricsResponse(metrics)).get("/v1/usage", ({ request }) => handleUsage(metrics, readUsage, request.signal)).get(
+  }).get("/", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/healthz", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/metrics", () => metricsResponse(metrics)).get("/v1/usage", ({ request }) => handleUsage(metrics, readUsage, request)).get(
     "/v1/models",
     ({ request }) => handleModels(client, metrics, request.signal, loggerFor(request))
   ).get("/v1/responses", () => websocketUnsupportedResponse()).post(
@@ -5060,9 +5105,13 @@ function dashboardResponse() {
     status: 200
   });
 }
-async function handleUsage(metrics, readUsage, signal) {
-  const { copilot, error } = await readUsage(signal);
-  const proxy = metrics.snapshot();
+async function handleUsage(metrics, readUsage, request) {
+  const view = new URL(request.url).searchParams.get("view");
+  const { copilot, error } = await readUsage(request.signal);
+  const proxy = view === DASHBOARD_USAGE_VIEW ? metrics.snapshot({
+    excludeRoutes: DASHBOARD_EXCLUDED_ROUTES,
+    excludeUpstreamPaths: DASHBOARD_EXCLUDED_UPSTREAM_PATHS
+  }) : metrics.snapshot();
   const body = {
     copilot: copilot ?? null,
     object: "usage",
@@ -5079,25 +5128,30 @@ function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_
   let cache;
   return async (signal) => {
     if (cache && now() - cache.atMs < ttlMs) {
-      return { copilot: cache.value };
+      return cache.result;
     }
     try {
       const upstream = await client.usage(signal);
       metrics.recordUpstream(usagePath, upstream.ok);
       metrics.recordGithubRateLimit(parseRateLimitHeaders(upstream.headers, now()));
       if (!upstream.ok) {
-        return { error: `GitHub Copilot usage request failed with ${upstream.status}.` };
+        const result2 = { error: `GitHub Copilot usage request failed with ${upstream.status}.` };
+        cache = { atMs: now(), result: result2 };
+        return result2;
       }
       const value = normalizeCopilotUsage(await upstream.json().catch(() => ({})));
-      cache = { atMs: now(), value };
+      const result = { copilot: value };
+      cache = { atMs: now(), result };
       metrics.recordCopilotQuota(value);
-      return { copilot: value };
+      return result;
     } catch (error) {
       if (error instanceof CopilotAuthError) {
         return { error: error.message };
       }
       metrics.recordUpstream(usagePath, false);
-      return { error: errorMessage(error) };
+      const result = { error: errorMessage(error) };
+      cache = { atMs: now(), result };
+      return result;
     }
   };
 }