Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
perf(usage): halve dashboard and partition fetch latency (#7146)
r33drichardsacd3f0c854c8
diff --git a/libs/fleet/backend/auth/authz_usage.rego b/libs/fleet/backend/auth/authz_usage.regoindex 68bcc21ee9..4bd3c8d8cc 100644--- a/libs/fleet/backend/auth/authz_usage.rego+++ b/libs/fleet/backend/auth/authz_usage.rego@@ -3,7 +3,19 @@ package authz_usagedefault allow = falseallow {- startswith(input.route, "/api/usage/")+ input.route == "/api/usage/overview"input.method == "GET"input.user.azp == "cyclops-cs-spa"}++allow {+ input.route == "/api/usage/pool"+ input.method == "GET"+ input.user.azp == "cyclops-cs-spa"+}++allow {+ input.route == "/api/usage/browser-timings"+ input.method == "POST"+ input.user.azp == "cyclops-cs-spa"+}diff --git a/libs/fleet/backend/auth/authz_usage_test.rego b/libs/fleet/backend/auth/authz_usage_test.regoindex 31e9deaf79..93b5d56e34 100644--- a/libs/fleet/backend/auth/authz_usage_test.rego+++ b/libs/fleet/backend/auth/authz_usage_test.rego@@ -9,3 +9,5 @@ route_allow if { authz_base.allow; authz_usage.allow }test_spa_get_allowed if { route_allow with input as {"route":"/api/usage/overview","method":"GET","path":"/api/usage/overview","params":{},"user":{"sub":"user-1","azp":"cyclops-cs-spa","namespace":"","email":""}} }test_spa_post_denied if { not route_allow with input as {"route":"/api/usage/overview","method":"POST","path":"/api/usage/overview","params":{},"user":{"sub":"user-1","azp":"cyclops-cs-spa","namespace":"","email":""}} }test_cli_get_denied if { not route_allow with input as {"route":"/api/usage/overview","method":"GET","path":"/api/usage/overview","params":{},"user":{"sub":"user-1","azp":"cua-cli","namespace":"","email":""}} }++test_spa_browser_timings_post_allowed if { route_allow with input as {"route":"/api/usage/browser-timings","method":"POST","path":"/api/usage/browser-timings","params":{},"user":{"sub":"user-1","azp":"cyclops-cs-spa","namespace":"","email":""}} }diff --git a/libs/fleet/backend/auth/policy_characterization_test.go b/libs/fleet/backend/auth/policy_characterization_test.goindex eb02b64e0c..80e3e41445 100644--- a/libs/fleet/backend/auth/policy_characterization_test.go+++ b/libs/fleet/backend/auth/policy_characterization_test.go@@ -161,6 +161,7 @@ func characterizationCases() map[string][]routeCase {simple("/api/state/query", "/api/state/query")simple("/api/usage/overview", "/api/usage/overview")simple("/api/usage/pool", "/api/usage/pool")+ simple("/api/usage/browser-timings", "/api/usage/browser-timings")simple("/api/chat/conversations", "/api/chat/conversations")simple("/api/billing/summary", "/api/billing/summary")simple("/api/billing/usage", "/api/billing/usage")diff --git a/libs/fleet/backend/auth/policy_routes.go b/libs/fleet/backend/auth/policy_routes.goindex 5d46e519c9..15fe2bde0c 100644--- a/libs/fleet/backend/auth/policy_routes.go+++ b/libs/fleet/backend/auth/policy_routes.go@@ -276,10 +276,11 @@ var surfacePolicies = map[string]surfacePolicy{// memoized per surface: the three billing routes share one module, one tree,// and one compiled plan.var routeSurfaces = map[string]string{- "/api/config": "config",- "/api/state/query": "state-query",- "/api/usage/overview": "usage",- "/api/usage/pool": "usage",+ "/api/config": "config",+ "/api/state/query": "state-query",+ "/api/usage/overview": "usage",+ "/api/usage/pool": "usage",+ "/api/usage/browser-timings": "usage","/api/chat/conversations": "chat","/api/chat/conversations/{id}": "chat",diff --git a/libs/fleet/backend/auth/testdata/route-authorization-table.txt b/libs/fleet/backend/auth/testdata/route-authorization-table.txtindex b5ec4f3605..5526cbf1a8 100644--- a/libs/fleet/backend/auth/testdata/route-authorization-table.txt+++ b/libs/fleet/backend/auth/testdata/route-authorization-table.txt@@ -3078,6 +3078,61 @@/api/svc/{namespace}/{service}/{path...} | unreachable-ns | QUERY | spa = error/api/svc/{namespace}/{service}/{path...} | unreachable-ns | QUERY | user-key = error/api/svc/{namespace}/{service}/{path...} | unreachable-ns | QUERY | user-key-verified = error+/api/usage/browser-timings | plain | DELETE | admin-spa = deny+/api/usage/browser-timings | plain | DELETE | cua-cli = deny+/api/usage/browser-timings | plain | DELETE | dcr-client = deny+/api/usage/browser-timings | plain | DELETE | empty-sub = deny+/api/usage/browser-timings | plain | DELETE | github-oidc = deny+/api/usage/browser-timings | plain | DELETE | oauth2-proxy = deny+/api/usage/browser-timings | plain | DELETE | per-key-other-ns = deny+/api/usage/browser-timings | plain | DELETE | per-key-owned-ns = deny+/api/usage/browser-timings | plain | DELETE | spa = deny+/api/usage/browser-timings | plain | DELETE | user-key = deny+/api/usage/browser-timings | plain | DELETE | user-key-verified = deny+/api/usage/browser-timings | plain | GET | admin-spa = deny+/api/usage/browser-timings | plain | GET | cua-cli = deny+/api/usage/browser-timings | plain | GET | dcr-client = deny+/api/usage/browser-timings | plain | GET | empty-sub = deny+/api/usage/browser-timings | plain | GET | github-oidc = deny+/api/usage/browser-timings | plain | GET | oauth2-proxy = deny+/api/usage/browser-timings | plain | GET | per-key-other-ns = deny+/api/usage/browser-timings | plain | GET | per-key-owned-ns = deny+/api/usage/browser-timings | plain | GET | spa = deny+/api/usage/browser-timings | plain | GET | user-key = deny+/api/usage/browser-timings | plain | GET | user-key-verified = deny+/api/usage/browser-timings | plain | PATCH | admin-spa = deny+/api/usage/browser-timings | plain | PATCH | cua-cli = deny+/api/usage/browser-timings | plain | PATCH | dcr-client = deny+/api/usage/browser-timings | plain | PATCH | empty-sub = deny+/api/usage/browser-timings | plain | PATCH | github-oidc = deny+/api/usage/browser-timings | plain | PATCH | oauth2-proxy = deny+/api/usage/browser-timings | plain | PATCH | per-key-other-ns = deny+/api/usage/browser-timings | plain | PATCH | per-key-owned-ns = deny+/api/usage/browser-timings | plain | PATCH | spa = deny+/api/usage/browser-timings | plain | PATCH | user-key = deny+/api/usage/browser-timings | plain | PATCH | user-key-verified = deny+/api/usage/browser-timings | plain | POST | admin-spa = allow+/api/usage/browser-timings | plain | POST | cua-cli = deny+/api/usage/browser-timings | plain | POST | dcr-client = deny+/api/usage/browser-timings | plain | POST | empty-sub = deny+/api/usage/browser-timings | plain | POST | github-oidc = deny+/api/usage/browser-timings | plain | POST | oauth2-proxy = deny+/api/usage/browser-timings | plain | POST | per-key-other-ns = deny+/api/usage/browser-timings | plain | POST | per-key-owned-ns = deny+/api/usage/browser-timings | plain | POST | spa = allow+/api/usage/browser-timings | plain | POST | user-key = deny+/api/usage/browser-timings | plain | POST | user-key-verified = deny+/api/usage/browser-timings | plain | QUERY | admin-spa = deny+/api/usage/browser-timings | plain | QUERY | cua-cli = deny+/api/usage/browser-timings | plain | QUERY | dcr-client = deny+/api/usage/browser-timings | plain | QUERY | empty-sub = deny+/api/usage/browser-timings | plain | QUERY | github-oidc = deny+/api/usage/browser-timings | plain | QUERY | oauth2-proxy = deny+/api/usage/browser-timings | plain | QUERY | per-key-other-ns = deny+/api/usage/browser-timings | plain | QUERY | per-key-owned-ns = deny+/api/usage/browser-timings | plain | QUERY | spa = deny+/api/usage/browser-timings | plain | QUERY | user-key = deny+/api/usage/browser-timings | plain | QUERY | user-key-verified = deny/api/usage/overview | plain | DELETE | admin-spa = deny/api/usage/overview | plain | DELETE | cua-cli = deny/api/usage/overview | plain | DELETE | dcr-client = denydiff --git a/libs/fleet/backend/go.mod b/libs/fleet/backend/go.modindex 7fd5fcefb1..b382a2f385 100644--- a/libs/fleet/backend/go.mod+++ b/libs/fleet/backend/go.mod@@ -50,7 +50,9 @@ require (github.com/spf13/afero v1.15.0 // indirectgithub.com/spf13/cast v1.10.0 // indirectgithub.com/subosito/gotenv v1.6.0 // indirect+ go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.28.0 // indirectgo.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect+ go.opentelemetry.io/otel/sdk/metric v1.28.0 // indirectgo.opentelemetry.io/proto/otlp v1.3.1 // indirectgo.uber.org/mock v0.6.0 // indirectgo.yaml.in/yaml/v3 v3.0.4 // indirectdiff --git a/libs/fleet/backend/go.sum b/libs/fleet/backend/go.sumindex 2806be8909..fc042865d0 100644--- a/libs/fleet/backend/go.sum+++ b/libs/fleet/backend/go.sum@@ -237,6 +237,8 @@ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXgo.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.28.0 h1:aLmmtjRke7LPDQ3lvpFz+kNEH43faFhzW7v8BFIEydg=+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.28.0/go.mod h1:TC1pyCt6G9Sjb4bQpShH+P5R53pO6ZuGnHuuln9xMeE=go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 h1:R3X6ZXmNPRR8ul6i3WgFURCHzaXjHdm0karRG/+dj3s=@@ -247,6 +249,8 @@ go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bgo.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=+go.opentelemetry.io/otel/sdk/metric v1.28.0 h1:OkuaKgKrgAbYrrY0t92c+cC+2F6hsFNnCQArXCKlg08=+go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg=go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=diff --git a/libs/fleet/backend/handlers/usage.go b/libs/fleet/backend/handlers/usage.goindex d4a9155a3e..5960fd5207 100644--- a/libs/fleet/backend/handlers/usage.go+++ b/libs/fleet/backend/handlers/usage.go@@ -1,7 +1,9 @@package handlersimport (+ "encoding/json""errors"+ "io""log/slog""net/http""regexp"@@ -33,6 +35,18 @@ const (UsageIntervalDay = usage.IntervalDay)+type usageBrowserTimings struct {+ InitialLoadMS float64 `json:"initial_load_ms"`+ DashboardReadyMS float64 `json:"dashboard_ready_ms"`+}++func (timings usageBrowserTimings) valid() bool {+ const maxDurationMS = 120_000+ return timings.InitialLoadMS >= 0 && timings.InitialLoadMS <= maxDurationMS &&+ timings.DashboardReadyMS >= 0 && timings.DashboardReadyMS <= maxDurationMS &&+ timings.DashboardReadyMS >= timings.InitialLoadMS+}+var usagePoolID = regexp.MustCompile(`^[A-Za-z0-9](?:[A-Za-z0-9._:-]{0,126}[A-Za-z0-9])?$`)func parseUsageTimeframe(raw string) (UsageTimeframe, UsageInterval, bool) {@@ -155,3 +169,25 @@ func (h Handlers) GetUsagePoolDetail(w http.ResponseWriter, r *http.Request) {func markUsageHandlerError(span trace.Span, description string) {span.SetStatus(codes.Error, description)}++func (h Handlers) RecordUsageBrowserTimings(w http.ResponseWriter, r *http.Request) {+ ctx, span := handlerTracer().Start(r.Context(), "usage.browser_timings")+ defer span.End()+ r = r.WithContext(ctx)+ w.Header().Set("Cache-Control", "private, no-store")+ query, _, ok := h.authorizeUsage(w, r)+ if !ok {+ return+ }++ decoder := json.NewDecoder(io.LimitReader(r.Body, 4<<10))+ decoder.DisallowUnknownFields()+ var timings usageBrowserTimings+ if err := decoder.Decode(&timings); err != nil || !timings.valid() {+ writeErr(w, http.StatusBadRequest, "invalid usage browser timings")+ return+ }+ recordUsageBrowserTimings(ctx, query.Timeframe, timings)+ span.SetAttributes(attribute.String("usage.timeframe", string(query.Timeframe)))+ w.WriteHeader(http.StatusNoContent)+}diff --git a/libs/fleet/backend/handlers/usage_metrics.go b/libs/fleet/backend/handlers/usage_metrics.gonew file mode 100644index 0000000000..2356c1a7c7--- /dev/null+++ b/libs/fleet/backend/handlers/usage_metrics.go@@ -0,0 +1,37 @@+package handlers++import (+ "context"+ "sync"+ "time"++ "go.opentelemetry.io/otel"+ "go.opentelemetry.io/otel/attribute"+ "go.opentelemetry.io/otel/metric"+)++var (+ usageBrowserMetricsOnce sync.Once+ usageBrowserDuration metric.Float64Histogram+)++func initUsageBrowserMetrics() {+ usageBrowserDuration, _ = otel.Meter("cyclops-cs-backend/handlers").Float64Histogram(+ "cyclops.usage.browser.duration",+ metric.WithDescription("Browser-observed Usage dashboard phase duration."),+ metric.WithUnit("s"),+ )+}++func recordUsageBrowserTimings(ctx context.Context, timeframe UsageTimeframe, timings usageBrowserTimings) {+ usageBrowserMetricsOnce.Do(initUsageBrowserMetrics)+ for phase, duration := range map[string]time.Duration{+ "initial_load": time.Duration(timings.InitialLoadMS * float64(time.Millisecond)),+ "dashboard_ready": time.Duration(timings.DashboardReadyMS * float64(time.Millisecond)),+ } {+ usageBrowserDuration.Record(ctx, duration.Seconds(), metric.WithAttributes(+ attribute.String("usage.timeframe", string(timeframe)),+ attribute.String("usage.browser.phase", phase),+ ))+ }+}diff --git a/libs/fleet/backend/handlers/usage_test.go b/libs/fleet/backend/handlers/usage_test.goindex 0802d3f9e5..abc325c2c3 100644--- a/libs/fleet/backend/handlers/usage_test.go+++ b/libs/fleet/backend/handlers/usage_test.go@@ -7,6 +7,7 @@ import ("errors""net/http""net/http/httptest"+ "strings""testing""go.opentelemetry.io/otel"@@ -81,6 +82,29 @@ func TestUsagePoolValidationAndInterval(t *testing.T) {}}+func TestRecordUsageBrowserTimingsValidatesPayload(t *testing.T) {+ handler := uh(&fakeUsageProvider{}, true, false)+ request := withUser(+ httptest.NewRequest(http.MethodPost, "/api/usage/browser-timings?timeframe=24h", strings.NewReader(`{"initial_load_ms":120,"dashboard_ready_ms":140}`)),+ &auth.User{ID: "user"},+ )+ response := httptest.NewRecorder()+ handler.RecordUsageBrowserTimings(response, request)+ if response.Code != http.StatusNoContent {+ t.Fatalf("status = %d, want %d", response.Code, http.StatusNoContent)+ }++ request = withUser(+ httptest.NewRequest(http.MethodPost, "/api/usage/browser-timings?timeframe=24h", strings.NewReader(`{"initial_load_ms":120,"dashboard_ready_ms":10}`)),+ &auth.User{ID: "user"},+ )+ response = httptest.NewRecorder()+ handler.RecordUsageBrowserTimings(response, request)+ if response.Code != http.StatusBadRequest {+ t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest)+ }+}+func TestUsageProviderErrorsAreRedacted(t *testing.T) {t.Run("mandatory source failure", func(t *testing.T) {p := &fakeUsageProvider{overviewErr: errors.New("postgres://[email protected]: source unavailable")}diff --git a/libs/fleet/backend/main.go b/libs/fleet/backend/main.goindex f52576269d..6240db0409 100644--- a/libs/fleet/backend/main.go+++ b/libs/fleet/backend/main.go@@ -152,6 +152,7 @@ func setupRouter(c handlers.Handlers) http.Handler {withAuthenticatedMiddlewares("/api/state/query", c.QueryState))r.Handle("GET /api/usage/overview", withAuthenticatedMiddlewares("/api/usage/overview", c.GetUsageOverview))r.Handle("GET /api/usage/pool", withAuthenticatedMiddlewares("/api/usage/pool", c.GetUsagePoolDetail))+ r.Handle("POST /api/usage/browser-timings", withAuthenticatedMiddlewares("/api/usage/browser-timings", c.RecordUsageBrowserTimings))r.Handle("GET /api/admin/feature-flags", withAuthenticatedMiddlewares("/api/admin/feature-flags", c.ListFeatureFlags))r.Handle("POST /api/admin/feature-flags", withAuthenticatedMiddlewares("/api/admin/feature-flags", c.CreateFeatureFlag))r.Handle("PUT /api/admin/feature-flags/{key}", withAuthenticatedMiddlewares("/api/admin/feature-flags/{key}", c.UpdateFeatureFlag))@@ -261,7 +262,7 @@ func initializeTelemetry(ctx context.Context, cfg config.TelemetryConfiguration)ResourceAttrs: cfg.ResourceAttrs,})if err != nil {- slog.Warn("otel: init failed; tracing disabled", "err", err)+ slog.Warn("otel: init failed; telemetry disabled", "err", err)return func(context.Context) error { return nil }, err}return shutdown, nildiff --git a/libs/fleet/backend/telemetry/telemetry.go b/libs/fleet/backend/telemetry/telemetry.goindex be967e1b83..f28aa5de89 100644--- a/libs/fleet/backend/telemetry/telemetry.go+++ b/libs/fleet/backend/telemetry/telemetry.go@@ -2,14 +2,18 @@ package telemetryimport ("context"+ "errors""fmt""strings""sync"+ "time""go.opentelemetry.io/otel""go.opentelemetry.io/otel/attribute"+ "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp""go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp""go.opentelemetry.io/otel/propagation"+ sdkmetric "go.opentelemetry.io/otel/sdk/metric""go.opentelemetry.io/otel/sdk/resource"sdktrace "go.opentelemetry.io/otel/sdk/trace"semconv "go.opentelemetry.io/otel/semconv/v1.26.0"@@ -40,16 +44,26 @@ func Init(ctx context.Context, cfg Config) (func(context.Context) error, error)return nil, fmt.Errorf("build resource: %w", err)}- exporter, err := otlptracehttp.New(ctx, otlptracehttp.WithEndpointURL(cfg.Endpoint))+ traceExporter, err := otlptracehttp.New(ctx, otlptracehttp.WithEndpointURL(cfg.Endpoint))if err != nil {return nil, fmt.Errorf("create otlp http trace exporter: %w", err)}- provider := sdktrace.NewTracerProvider(- sdktrace.WithBatcher(exporter),+ traceProvider := sdktrace.NewTracerProvider(+ sdktrace.WithBatcher(traceExporter),sdktrace.WithResource(res),)- otel.SetTracerProvider(provider)+ metricExporter, err := otlpmetrichttp.New(ctx, otlpmetrichttp.WithEndpointURL(cfg.Endpoint))+ if err != nil {+ _ = traceProvider.Shutdown(ctx)+ return nil, fmt.Errorf("create otlp http metric exporter: %w", err)+ }+ metricProvider := sdkmetric.NewMeterProvider(+ sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExporter, sdkmetric.WithInterval(15*time.Second))),+ sdkmetric.WithResource(res),+ )+ otel.SetTracerProvider(traceProvider)+ otel.SetMeterProvider(metricProvider)otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{},propagation.Baggage{},@@ -59,7 +73,7 @@ func Init(ctx context.Context, cfg Config) (func(context.Context) error, error)return func(ctx context.Context) error {var shutdownErr erroronce.Do(func() {- shutdownErr = provider.Shutdown(ctx)+ shutdownErr = errors.Join(metricProvider.Shutdown(ctx), traceProvider.Shutdown(ctx))})return shutdownErr}, nildiff --git a/libs/fleet/backend/telemetry/telemetry_test.go b/libs/fleet/backend/telemetry/telemetry_test.goindex eef9f5d814..5046eef70a 100644--- a/libs/fleet/backend/telemetry/telemetry_test.go+++ b/libs/fleet/backend/telemetry/telemetry_test.go@@ -14,9 +14,8 @@ import (func TestInit_ExportsSpansOverOTLPHTTP(t *testing.T) {var (- mu sync.Mutex- requestPath string- bodySize int+ mu sync.Mutex+ bodySizes = map[string]int{})srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {@@ -25,8 +24,7 @@ func TestInit_ExportsSpansOverOTLPHTTP(t *testing.T) {t.Fatalf("read body: %v", err)}mu.Lock()- requestPath = r.URL.Path- bodySize = len(body)+ bodySizes[r.URL.Path] = len(body)mu.Unlock()w.WriteHeader(http.StatusAccepted)}))@@ -53,6 +51,11 @@ func TestInit_ExportsSpansOverOTLPHTTP(t *testing.T) {_, span := otel.Tracer("test").Start(ctx, "backend.request")span.End()+ counter, err := otel.Meter("test").Int64Counter("test.requests")+ if err != nil {+ t.Fatalf("create counter: %v", err)+ }+ counter.Add(ctx, 1)if err := shutdown(context.Background()); err != nil {t.Fatalf("shutdown() error = %v", err)@@ -61,10 +64,9 @@ func TestInit_ExportsSpansOverOTLPHTTP(t *testing.T) {mu.Lock()defer mu.Unlock()- if requestPath != "/v1/traces" {- t.Fatalf("request path = %q, want %q", requestPath, "/v1/traces")- }- if bodySize == 0 {- t.Fatalf("body size = %d, want > 0", bodySize)+ for _, path := range []string{"/v1/traces", "/v1/metrics"} {+ if bodySizes[path] == 0 {+ t.Fatalf("body size for %s = %d, want > 0; requests = %#v", path, bodySizes[path], bodySizes)+ }}}diff --git a/libs/fleet/backend/usage/cache_test.go b/libs/fleet/backend/usage/cache_test.gonew file mode 100644index 0000000000..c6191b49a6--- /dev/null+++ b/libs/fleet/backend/usage/cache_test.go@@ -0,0 +1,127 @@+package usage++import (+ "context"+ "errors"+ "sync"+ "sync/atomic"+ "testing"+ "time"+)++func cachedProviderFixture(now *time.Time) (*provider, *fakeEventStore, *fakeAllocationClient) {+ events := &fakeEventStore{events: []SandboxEvent{{+ EventID: mustUUID("00000000-0000-0000-0000-000000000091"), Namespace: "ns-a",+ SandboxName: "sandbox-a", SandboxUID: "uid-a", PoolName: "pool-a",+ Runtime: "kubevirt", VMName: "vm-a", EventType: "Added",+ ObservedAt: now.Add(-25 * time.Hour),+ }}}+ allocations := &fakeAllocationClient{asOf: now.UTC().Truncate(time.Hour), allocations: []Allocation{{+ Start: now.UTC().Truncate(time.Hour).Add(-time.Hour), End: now.UTC().Truncate(time.Hour),+ Namespace: "ns-a", Pod: "virt-launcher-vm-a-abc", Minutes: 60,+ CPUUsageAverage: 1, CPURequestAverage: 2,+ RAMUsageAverageBytes: gibibyte, RAMRequestAverageBytes: 2 * gibibyte,+ }}}+ return NewProvider(events, allocations, func() time.Time { return *now }), events, allocations+}++func TestProviderCachesOverviewForPoolDetail(t *testing.T) {+ now := time.Date(2026, 8, 22, 4, 30, 0, 0, time.UTC)+ provider, events, allocations := cachedProviderFixture(&now)+ query := Query{ActorSubject: "alice", Subject: "alice", Timeframe: Timeframe24H}++ overview, err := provider.Overview(context.Background(), query)+ if err != nil || len(overview.Pools) != 1 {+ t.Fatalf("Overview() = %#v, %v", overview, err)+ }+ if _, err := provider.PoolDetail(context.Background(), PoolQuery{Query: query, PoolID: overview.Pools[0].ID, Interval: IntervalHour}); err != nil {+ t.Fatal(err)+ }+ if events.calls != 1 || allocations.calls != 1 {+ t.Fatalf("source calls = events %d allocations %d, want 1 each", events.calls, allocations.calls)+ }+}++func TestProviderCacheSeparatesSubjectsAndHourCutoffs(t *testing.T) {+ now := time.Date(2026, 8, 22, 4, 30, 0, 0, time.UTC)+ provider, _, allocations := cachedProviderFixture(&now)++ for _, subject := range []string{"alice", "bob"} {+ if _, err := provider.Overview(context.Background(), Query{Subject: subject, Timeframe: Timeframe24H}); err != nil {+ t.Fatal(err)+ }+ }+ now = now.Add(time.Hour)+ if _, err := provider.Overview(context.Background(), Query{Subject: "alice", Timeframe: Timeframe24H}); err != nil {+ t.Fatal(err)+ }+ if allocations.calls != 3 {+ t.Fatalf("allocation calls = %d, want 3", allocations.calls)+ }+}++func TestProviderCacheExpiresAndDoesNotCacheErrors(t *testing.T) {+ now := time.Date(2026, 8, 22, 4, 30, 0, 0, time.UTC)+ provider, _, allocations := cachedProviderFixture(&now)+ provider.cacheTTL = time.Minute+ query := Query{Subject: "alice", Timeframe: Timeframe24H}++ allocations.err = errors.New("temporary")+ if _, err := provider.Overview(context.Background(), query); err == nil {+ t.Fatal("Overview() error = nil")+ }+ allocations.err = nil+ if _, err := provider.Overview(context.Background(), query); err != nil {+ t.Fatal(err)+ }+ now = now.Add(2 * time.Minute)+ if _, err := provider.Overview(context.Background(), query); err != nil {+ t.Fatal(err)+ }+ if allocations.calls != 3 {+ t.Fatalf("allocation calls = %d, want 3", allocations.calls)+ }+}++type singleflightAllocationClient struct {+ calls atomic.Int64+}++func (client *singleflightAllocationClient) Allocations(_ context.Context, start, end time.Time, _ time.Duration, _ []string) ([]Allocation, time.Time, bool, error) {+ client.calls.Add(1)+ time.Sleep(25 * time.Millisecond)+ return []Allocation{{+ Start: end.Add(-time.Hour), End: end, Namespace: "ns-a", Pod: "virt-launcher-vm-a-abc",+ Minutes: 60, CPUUsageAverage: 1, CPURequestAverage: 2,+ RAMUsageAverageBytes: gibibyte, RAMRequestAverageBytes: 2 * gibibyte,+ }}, end, false, nil+}++func TestProviderSingleflightsConcurrentLoads(t *testing.T) {+ now := time.Date(2026, 8, 22, 4, 30, 0, 0, time.UTC)+ events := benchmarkEventStore{}+ allocations := &singleflightAllocationClient{}+ provider := NewProvider(events, allocations, func() time.Time { return now })+ query := Query{Subject: "alice", Timeframe: Timeframe24H}++ var group sync.WaitGroup+ errorsSeen := make(chan error, 8)+ for index := 0; index < 8; index++ {+ group.Add(1)+ go func() {+ defer group.Done()+ _, err := provider.Overview(context.Background(), query)+ errorsSeen <- err+ }()+ }+ group.Wait()+ close(errorsSeen)+ for err := range errorsSeen {+ if err != nil {+ t.Fatal(err)+ }+ }+ if calls := allocations.calls.Load(); calls != 1 {+ t.Fatalf("allocation calls = %d, want 1", calls)+ }+}diff --git a/libs/fleet/backend/usage/metrics.go b/libs/fleet/backend/usage/metrics.gonew file mode 100644index 0000000000..59b681e76e--- /dev/null+++ b/libs/fleet/backend/usage/metrics.go@@ -0,0 +1,50 @@+package usage++import (+ "context"+ "sync"+ "time"++ "go.opentelemetry.io/otel"+ "go.opentelemetry.io/otel/attribute"+ "go.opentelemetry.io/otel/metric"+)++var (+ usageMetricsOnce sync.Once+ cacheRequests metric.Int64Counter+ loadDuration metric.Float64Histogram+)++func initUsageMetrics() {+ meter := otel.Meter("cyclops-cs-backend/usage")+ cacheRequests, _ = meter.Int64Counter(+ "cyclops.usage.cache.requests",+ metric.WithDescription("Usage provider cache lookups by outcome."),+ )+ loadDuration, _ = meter.Float64Histogram(+ "cyclops.usage.load.duration",+ metric.WithDescription("Duration of uncached Usage provider loads."),+ metric.WithUnit("s"),+ )+}++func recordUsageCache(ctx context.Context, timeframe Timeframe, outcome string) {+ usageMetricsOnce.Do(initUsageMetrics)+ cacheRequests.Add(ctx, 1, metric.WithAttributes(+ attribute.String("usage.timeframe", string(timeframe)),+ attribute.String("usage.cache.outcome", outcome),+ ))+}++func recordUsageLoad(ctx context.Context, timeframe Timeframe, duration time.Duration, err error) {+ usageMetricsOnce.Do(initUsageMetrics)+ outcome := "success"+ if err != nil {+ outcome = "error"+ }+ loadDuration.Record(ctx, duration.Seconds(), metric.WithAttributes(+ attribute.String("usage.timeframe", string(timeframe)),+ attribute.String("usage.load.outcome", outcome),+ ))+}diff --git a/libs/fleet/backend/usage/performance_test.go b/libs/fleet/backend/usage/performance_test.gonew file mode 100644index 0000000000..4a39f6931f--- /dev/null+++ b/libs/fleet/backend/usage/performance_test.go@@ -0,0 +1,45 @@+package usage++import (+ "context"+ "testing"+ "time"+)++type benchmarkEventStore struct{}++func (benchmarkEventStore) Events(_ context.Context, _ string, start, end time.Time) ([]SandboxEvent, error) {+ return []SandboxEvent{{EventID: mustUUID("00000000-0000-0000-0000-000000000099"), SandboxName: "sandbox-a", Namespace: "ns-a", SandboxUID: "uid-a", PoolName: "pool-a", Runtime: "kubevirt", VMName: "vm-a", EventType: "Added", ObservedAt: start.Add(-time.Hour)}}, nil+}++type benchmarkAllocationClient struct {+ delay time.Duration+ calls int+}++func (client *benchmarkAllocationClient) Allocations(_ context.Context, start, end time.Time, _ time.Duration, _ []string) ([]Allocation, time.Time, bool, error) {+ client.calls+++ time.Sleep(client.delay)+ return []Allocation{{Start: end.Add(-time.Hour), End: end, Namespace: "ns-a", Pod: "virt-launcher-vm-a-abc", Minutes: 60, CPUUsageAverage: 1, CPURequestAverage: 2, RAMUsageAverageBytes: gibibyte, RAMRequestAverageBytes: 2 * gibibyte}}, end, false, nil+}++func BenchmarkDashboardLoad(benchmark *testing.B) {+ now := time.Date(2026, 8, 22, 4, 30, 0, 0, time.UTC)+ query := Query{ActorSubject: "user", Subject: "user", Timeframe: Timeframe24H}++ benchmark.ReportAllocs()+ benchmark.ResetTimer()+ for index := 0; index < benchmark.N; index++ {+ allocations := &benchmarkAllocationClient{delay: 20 * time.Millisecond}+ provider := NewProvider(benchmarkEventStore{}, allocations, func() time.Time { return now })+ before := allocations.calls+ overview, err := provider.Overview(context.Background(), query)+ if err != nil || len(overview.Pools) == 0 {+ benchmark.Fatalf("Overview() = %v, %v", overview, err)+ }+ if _, err := provider.PoolDetail(context.Background(), PoolQuery{Query: query, PoolID: overview.Pools[0].ID, Interval: IntervalHour}); err != nil {+ benchmark.Fatal(err)+ }+ benchmark.ReportMetric(float64(allocations.calls-before), "allocation_queries/op")+ }+}diff --git a/libs/fleet/backend/usage/provider.go b/libs/fleet/backend/usage/provider.goindex 10460b2fca..5a35f25e20 100644--- a/libs/fleet/backend/usage/provider.go+++ b/libs/fleet/backend/usage/provider.go@@ -7,11 +7,13 @@ import ("regexp""sort""strings"+ "sync""time""cyclops-cs-backend/identity""go.opentelemetry.io/otel/attribute""go.opentelemetry.io/otel/trace"+ "golang.org/x/sync/singleflight")var (@@ -19,10 +21,30 @@ var (dns1123Label = regexp.MustCompile(`^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$`))+const (+ defaultUsageCacheTTL = 2 * time.Minute+ maxUsageCacheEntries = 256+)+type provider struct {events EventStoreallocations AllocationClientclock func() time.Time+ cacheTTL time.Duration+ cacheMu sync.Mutex+ cache map[usageCacheKey]usageCacheEntry+ loads singleflight.Group+}++type usageCacheKey struct {+ subject string+ timeframe Timeframe+ cutoff time.Time+}++type usageCacheEntry struct {+ data usageData+ expiresAt time.Time}type liveSegment struct {@@ -39,7 +61,10 @@ func NewProvider(events EventStore, allocations AllocationClient, clock func() tif clock == nil {clock = time.Now}- return &provider{events: events, allocations: allocations, clock: clock}+ return &provider{+ events: events, allocations: allocations, clock: clock,+ cacheTTL: defaultUsageCacheTTL, cache: make(map[usageCacheKey]usageCacheEntry),+ }}func (p *provider) Overview(ctx context.Context, query Query) (OverviewResponse, error) {@@ -47,32 +72,40 @@ func (p *provider) Overview(ctx context.Context, query Query) (OverviewResponse,if err != nil {return OverviewResponse{}, err}+ return buildOverview(data), nil+}++func buildOverview(data usageData) OverviewResponse {response := OverviewResponse{DataAsOf: data.asOf, Partial: data.partial, Pools: make([]PoolSummary, 0)}for _, pool := range data.pools {response.Pools = append(response.Pools, PoolSummary{ID: pool.id, Name: pool.name, CPU: MetricTotals{Consumed: pool.cpuConsumed, Provisioned: pool.cpuProvisioned}, Memory: MetricTotals{Consumed: pool.memoryConsumed, Provisioned: pool.memoryProvisioned}, CostUSD: pool.costUSD})}- return response, nil+ return response}func (p *provider) PoolDetail(ctx context.Context, query PoolQuery) (PoolDetailResponse, error) {- namespace, poolName, ok := parsePoolID(query.PoolID)- if !ok {- return PoolDetailResponse{}, fmt.Errorf("invalid pool ID")- }data, err := p.load(ctx, query.Query)if err != nil {return PoolDetailResponse{}, err}- step, err := intervalDuration(query.Interval)+ return buildPoolDetail(ctx, data, query.PoolID, query.Interval)+}++func buildPoolDetail(ctx context.Context, data usageData, poolID string, interval Interval) (PoolDetailResponse, error) {+ namespace, poolName, ok := parsePoolID(poolID)+ if !ok {+ return PoolDetailResponse{}, fmt.Errorf("invalid pool ID")+ }+ step, err := intervalDuration(interval)if err != nil {return PoolDetailResponse{}, err}- pool, ok := findPool(data.pools, query.PoolID)+ pool, ok := findPool(data.pools, poolID)if !ok {- return PoolDetailResponse{}, fmt.Errorf("%w: %s", ErrPoolNotFound, query.PoolID)+ return PoolDetailResponse{}, fmt.Errorf("%w: %s", ErrPoolNotFound, poolID)}_, bucketSpan := usageTracer().Start(ctx, "usage.buckets.build", trace.WithAttributes(- attribute.String("usage.interval", string(query.Interval)),+ attribute.String("usage.interval", string(interval)),))response := PoolDetailResponse{DataAsOf: data.asOf, Partial: data.partial, Pool: PoolIdentity{ID: pool.id, Name: pool.name}, Buckets: make([]Bucket, 0)}for start := data.start; start.Before(data.end); start = start.Add(step) {@@ -111,6 +144,8 @@ type bucketKey struct {}func (p *provider) load(ctx context.Context, query Query) (usageData, error) {+ now := p.clock().UTC()+ key := usageCacheKey{subject: query.Subject, timeframe: query.Timeframe, cutoff: now.Truncate(time.Hour)}ctx, span := usageTracer().Start(ctx, "usage.load", trace.WithAttributes(attribute.String("usage.timeframe", string(query.Timeframe)),attribute.Bool("usage.admin", query.Admin),@@ -118,12 +153,46 @@ func (p *provider) load(ctx context.Context, query Query) (usageData, error) {))defer span.End()+ if cached, ok := p.cached(key, now); ok {+ span.SetAttributes(attribute.Bool("usage.cache.hit", true))+ recordUsageCache(ctx, query.Timeframe, "hit")+ return cached, nil+ }+ span.SetAttributes(attribute.Bool("usage.cache.hit", false))++ loaded, err, shared := p.loads.Do(cacheFlightKey(key), func() (any, error) {+ if cached, ok := p.cached(key, p.clock().UTC()); ok {+ return cached, nil+ }+ data, loadErr := p.loadUncached(ctx, query, now)+ if loadErr == nil {+ p.storeCached(key, data, p.clock().UTC())+ }+ return data, loadErr+ })+ cacheOutcome := "miss"+ if shared {+ cacheOutcome = "shared"+ }+ recordUsageCache(ctx, query.Timeframe, cacheOutcome)+ if err != nil {+ return usageData{}, err+ }+ return loaded.(usageData), nil+}++func (p *provider) loadUncached(ctx context.Context, query Query, now time.Time) (data usageData, err error) {+ ctx, span := usageTracer().Start(ctx, "usage.load.uncached")+ defer span.End()+ started := time.Now()+ defer func() { recordUsageLoad(ctx, query.Timeframe, time.Since(started), err) }()+if p.events == nil || p.allocations == nil {- err := fmt.Errorf("usage provider is not configured")+ err = fmt.Errorf("usage provider is not configured")markUsageSpanError(span, "usage provider unavailable")return usageData{}, err}- start, end, step, err := usageWindow(query.Timeframe, p.clock())+ start, end, step, err := usageWindow(query.Timeframe, now)if err != nil {markUsageSpanError(span, "invalid usage window")return usageData{}, err@@ -152,7 +221,7 @@ func (p *provider) load(ctx context.Context, query Query) (usageData, error) {)segmentsSpan.End()- data := usageData{start: start, end: end, asOf: end, partial: partial, pools: make([]usageTotals, 0), buckets: make(map[bucketKey]usageTotals)}+ data = usageData{start: start, end: end, asOf: end, partial: partial, pools: make([]usageTotals, 0), buckets: make(map[bucketKey]usageTotals)}if len(segments) == 0 || len(namespaces) == 0 {span.SetAttributes(attribute.Int("usage.pool_count", 0),@@ -221,6 +290,52 @@ func (p *provider) load(ctx context.Context, query Query) (usageData, error) {return data, nil}+func cacheFlightKey(key usageCacheKey) string {+ return key.subject + "\x00" + string(key.timeframe) + "\x00" + key.cutoff.Format(time.RFC3339)+}++func (p *provider) cached(key usageCacheKey, now time.Time) (usageData, bool) {+ if p.cacheTTL <= 0 {+ return usageData{}, false+ }+ p.cacheMu.Lock()+ defer p.cacheMu.Unlock()+ entry, ok := p.cache[key]+ if !ok {+ return usageData{}, false+ }+ if !now.Before(entry.expiresAt) {+ delete(p.cache, key)+ return usageData{}, false+ }+ return entry.data, true+}++func (p *provider) storeCached(key usageCacheKey, data usageData, now time.Time) {+ if p.cacheTTL <= 0 {+ return+ }+ p.cacheMu.Lock()+ defer p.cacheMu.Unlock()+ if len(p.cache) >= maxUsageCacheEntries {+ var oldestKey usageCacheKey+ var oldestExpiry time.Time+ for candidate, entry := range p.cache {+ if !now.Before(entry.expiresAt) {+ delete(p.cache, candidate)+ continue+ }+ if oldestExpiry.IsZero() || entry.expiresAt.Before(oldestExpiry) {+ oldestKey, oldestExpiry = candidate, entry.expiresAt+ }+ }+ if len(p.cache) >= maxUsageCacheEntries && !oldestExpiry.IsZero() {+ delete(p.cache, oldestKey)+ }+ }+ p.cache[key] = usageCacheEntry{data: data, expiresAt: now.Add(p.cacheTTL)}+}+func usageWindow(timeframe Timeframe, now time.Time) (time.Time, time.Time, time.Duration, error) {cutoff := now.UTC().Truncate(time.Hour)switch timeframe {diff --git a/libs/fleet/e2e/usage.performance.spec.ts b/libs/fleet/e2e/usage.performance.spec.tsnew file mode 100644index 0000000000..5c82dcd036--- /dev/null+++ b/libs/fleet/e2e/usage.performance.spec.ts@@ -0,0 +1,50 @@+import { expect, test, type Page, type Route } from "@playwright/test"+import { mockAuth } from "./fixtures/mock-api"++const overview = {+ data_as_of: "2026-08-22T04:00:00Z",+ partial: false,+ pools: [+ {+ id: "ns-a:pool-a",+ name: "Pool A",+ cpu: { consumed: 12, provisioned: 24 },+ memory: { consumed: 48, provisioned: 96 },+ cost_usd: 2.75,+ },+ ],+}++async function delayedJSON(route: Route, body: unknown) {+ await new Promise((resolve) => setTimeout(resolve, 200))+ await route.fulfill({ json: body })+}++test("measures Usage dashboard ready time", async ({ page }) => {+ const visualPreview = process.env.CYCLOPS_BROWSER_VISUAL_PREVIEW === "true"+ if (!visualPreview) await mockAuth(page, { admin: false, usage: true })+ let usageRequests = 0+ let browserTimings: Record<string, number> | null = null+ await page.route("**/api/usage/overview**", async (route) => {+ usageRequests+++ await delayedJSON(route, overview)+ })+ await page.route("**/api/usage/browser-timings**", async (route) => {+ browserTimings = route.request().postDataJSON() as Record<string, number>+ await route.fulfill({ status: 204 })+ })++ const started = performance.now()+ await page.goto(visualPreview ? "/usage?cua-visual-preview" : "/usage")+ await expect(+ page.getByRole("heading", { name: "Cost by pool" }),+ ).toBeVisible()+ const readyMS = performance.now() - started+ await expect.poll(() => browserTimings).not.toBeNull()++ console.log(`METRIC browser_ready_ms=${readyMS.toFixed(3)}`)+ console.log(`METRIC browser_usage_requests=${usageRequests}`)+ expect(usageRequests).toBe(1)+ expect(browserTimings?.initial_load_ms).toBeGreaterThanOrEqual(200)+ expect(browserTimings?.dashboard_ready_ms).toBeGreaterThanOrEqual(200)+})diff --git a/libs/fleet/src/components/FeatureFlagContext.tsx b/libs/fleet/src/components/FeatureFlagContext.tsxindex 4e5040aa2d..7496171b23 100644--- a/libs/fleet/src/components/FeatureFlagContext.tsx+++ b/libs/fleet/src/components/FeatureFlagContext.tsx@@ -33,7 +33,7 @@ export function FeatureFlagProvider({ children }: { children: ReactNode }) {const visualPreview = isLocalVisualPreview()const [value, setValue] = useState<Omit<FeatureFlagContextValue, "refresh">>({...(visualPreview- ? { ...DEFAULT_FLAGS, billing: true, chat: true }+ ? { ...DEFAULT_FLAGS, billing: true, chat: true, usage: true }: DEFAULT_FLAGS),resolved: visualPreview,})diff --git a/libs/fleet/src/pages/BillingUsage.tsx b/libs/fleet/src/pages/BillingUsage.tsxindex 678ab069ce..b8e2a7ea20 100644--- a/libs/fleet/src/pages/BillingUsage.tsx+++ b/libs/fleet/src/pages/BillingUsage.tsx@@ -1,5 +1,5 @@import Select from "@cloudscape-design/components/select"-import { useCallback, useEffect, useMemo, useState } from "react"+import { useCallback, useEffect, useMemo, useRef, useState } from "react"import { CuaButton } from "../components/CuaButton"import { PageEmpty, PageError } from "../components/PageState"import { PageShell } from "../components/PageShell"@@ -42,12 +42,27 @@ export function BillingUsagePage() {const [overview, setOverview] = useState<UsageOverviewResponse | null>(null)const [loading, setLoading] = useState(true)const [error, setError] = useState(false)+ const loadStarted = useRef(0)const load = useCallback(async () => {+ loadStarted.current = performance.now()setLoading(true)setError(false)try {- setOverview(await usageApi.overview(timeframe))+ const value = await usageApi.overview(timeframe)+ const initialLoadMS = performance.now() - loadStarted.current+ setOverview(value)+ requestAnimationFrame(() => {+ requestAnimationFrame(() => {+ performance.mark("usage-dashboard-ready")+ void usageApi+ .recordBrowserTimings(timeframe, {+ initial_load_ms: initialLoadMS,+ dashboard_ready_ms: performance.now() - loadStarted.current,+ })+ .catch(() => undefined)+ })+ })} catch {setOverview(null)setError(true)diff --git a/libs/fleet/src/sdk/usage.ts b/libs/fleet/src/sdk/usage.tsindex 254d677de8..761681ef9e 100644--- a/libs/fleet/src/sdk/usage.ts+++ b/libs/fleet/src/sdk/usage.ts@@ -38,6 +38,11 @@ export interface UsagePoolDetailResponse {buckets: UsageBucket[]}+export interface UsageBrowserTimings {+ initial_load_ms: number+ dashboard_ready_ms: number+}+const previewPools: UsagePoolSummary[] = [{id: "preview:browser-agent-fleet",@@ -159,6 +164,23 @@ function params(timeframe: UsageTimeframe, subject?: string) {return query}+async function recordBrowserTimings(+ timeframe: UsageTimeframe,+ timings: UsageBrowserTimings,+): Promise<void> {+ if (isLocalVisualPreview()) return+ const token = await getToken()+ await fetch(`/api/usage/browser-timings?${params(timeframe)}`, {+ method: "POST",+ headers: {+ Authorization: token ? `Bearer ${token}` : "",+ "Content-Type": "application/json",+ },+ body: JSON.stringify(timings),+ keepalive: true,+ })+}+export const usageApi = {overview: (timeframe: UsageTimeframe, subject?: string) =>isLocalVisualPreview()@@ -173,4 +195,5 @@ export const usageApi = {query.set("pool", poolId)return request<UsagePoolDetailResponse>("/api/usage/pool", query)},+ recordBrowserTimings,}