Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

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.rego
index 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_usage
default allow = false
allow {
- 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.rego
index 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.go
index 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.go
index 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.txt
index 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 = deny
diff --git a/libs/fleet/backend/go.mod b/libs/fleet/backend/go.mod
index 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 // indirect
github.com/spf13/cast v1.10.0 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
+ go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.28.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
+ go.opentelemetry.io/otel/sdk/metric v1.28.0 // indirect
go.opentelemetry.io/proto/otlp v1.3.1 // indirect
go.uber.org/mock v0.6.0 // indirect
go.yaml.in/yaml/v3 v3.0.4 // indirect
diff --git a/libs/fleet/backend/go.sum b/libs/fleet/backend/go.sum
index 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:4K4tsIX
go.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:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6b
go.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.go
index d4a9155a3e..5960fd5207 100644
--- a/libs/fleet/backend/handlers/usage.go
+++ b/libs/fleet/backend/handlers/usage.go
@@ -1,7 +1,9 @@
package handlers
import (
+ "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.go
new file mode 100644
index 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.go
index 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.go
index 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, nil
diff --git a/libs/fleet/backend/telemetry/telemetry.go b/libs/fleet/backend/telemetry/telemetry.go
index be967e1b83..f28aa5de89 100644
--- a/libs/fleet/backend/telemetry/telemetry.go
+++ b/libs/fleet/backend/telemetry/telemetry.go
@@ -2,14 +2,18 @@ package telemetry
import (
"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 error
once.Do(func() {
- shutdownErr = provider.Shutdown(ctx)
+ shutdownErr = errors.Join(metricProvider.Shutdown(ctx), traceProvider.Shutdown(ctx))
})
return shutdownErr
}, nil
diff --git a/libs/fleet/backend/telemetry/telemetry_test.go b/libs/fleet/backend/telemetry/telemetry_test.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 EventStore
allocations AllocationClient
clock 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() t
if 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.ts
new file mode 100644
index 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.tsx
index 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.tsx
index 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.ts
index 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,
}