Skip to content

The only tool you need to know what is happening and how to fix it.

multi instance progress

ddux01177377ead9
diff --git a/backend/app/controllers/metrics.controller.go b/backend/app/controllers/metrics.controller.go
new file mode 100644
index 00000000..6f77ced9
--- /dev/null
+++ b/backend/app/controllers/metrics.controller.go
@@ -0,0 +1,249 @@
+package controllers
+
+import (
+ "backend/app/models"
+ "backend/app/repositories"
+ "net/http"
+ "time"
+
+ "github.com/gin-gonic/gin"
+)
+
+type metricsController struct{}
+
+// Response types for split endpoints
+type ApplicationMetricsResponse struct {
+ Metrics []models.DashboardMetric `json:"metrics"`
+ AvailableServers []string `json:"availableServers"`
+ LastUpdated time.Time `json:"lastUpdated"`
+}
+
+type StatsMetricsResponse struct {
+ Metrics []models.DashboardMetric `json:"metrics"`
+ LastUpdated time.Time `json:"lastUpdated"`
+}
+
+type ServerMetricsResponse struct {
+ Metrics []models.DashboardMetric `json:"metrics"`
+ AvailableServers []string `json:"availableServers"`
+ LastUpdated time.Time `json:"lastUpdated"`
+}
+
+// GetApplicationMetrics returns Go application metrics (Go Routines, Heap Objects, GC Cycles, GC Pause)
+// Always returns ALL servers' data - ignores server selector
+func (m metricsController) GetApplicationMetrics(c *gin.Context) {
+ projectId := c.Query("projectId")
+ now := time.Now()
+ start, end := parseTimeRange(c, now)
+
+ // Calculate previous period for comparison
+ duration := end.Sub(start)
+ prevStart := start.Add(-duration)
+ prevEnd := start
+
+ // Calculate aggregation interval based on time range
+ intervalMinutes := calculateIntervalMinutes(duration)
+
+ // Get available servers in the time range
+ availableServers, err := repositories.MetricRecordRepository.GetDistinctServers(c, projectId, start, end)
+ if err != nil {
+ availableServers = []string{}
+ }
+
+ // Always pass empty slice to get ALL servers
+ var emptyServers []string
+
+ metrics := make([]models.DashboardMetric, 0, 4)
+
+ // 1. Go Routines
+ goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
+
+ // 2. Heap Objects
+ heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
+
+ // 3. GC Cycles (Num GC)
+ numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("num_gc", "GC Cycles", "", numGCPerServer, numGCPrev, "num_gc"))
+
+ // 4. GC Pause Total (convert from nanoseconds to milliseconds)
+ gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ // Convert nanoseconds to milliseconds for each server's data
+ for serverName, points := range gcPausePerServer {
+ for i := range points {
+ gcPausePerServer[serverName][i].Value = points[i].Value / 1_000_000
+ }
+ }
+ gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
+ gcPausePrev := gcPausePrevRaw / 1_000_000
+ metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
+
+ c.JSON(http.StatusOK, ApplicationMetricsResponse{
+ Metrics: metrics,
+ AvailableServers: availableServers,
+ LastUpdated: now,
+ })
+}
+
+// GetStatsMetrics returns request/exception stats (Requests, Exceptions, Avg Response Time, Error Rate)
+// These are NOT per-server metrics
+func (m metricsController) GetStatsMetrics(c *gin.Context) {
+ projectId := c.Query("projectId")
+ now := time.Now()
+ start, end := parseTimeRange(c, now)
+
+ // Calculate previous period for comparison
+ duration := end.Sub(start)
+ prevStart := start.Add(-duration)
+ prevEnd := start
+
+ // Calculate aggregation interval based on time range
+ intervalMinutes := calculateIntervalMinutes(duration)
+
+ metrics := make([]models.DashboardMetric, 0, 4)
+
+ // 1. Requests count
+ requestsTrend, err := repositories.TransactionRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
+ if err != nil {
+ panic(err)
+ }
+ requestsCurrent, _ := repositories.TransactionRepository.CountBetween(c, projectId, start, end)
+ requestsPrev, _ := repositories.TransactionRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ metrics = append(metrics, buildMetric("requests", "Requests", float64(requestsCurrent), "count", requestsTrend, float64(requestsPrev), "requests"))
+
+ // 2. Exceptions count
+ exceptionsTrend, err := repositories.ExceptionStackTraceRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
+ if err != nil {
+ panic(err)
+ }
+ exceptionsCurrent, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, start, end)
+ exceptionsPrev, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ metrics = append(metrics, buildMetric("exceptions", "Exceptions", float64(exceptionsCurrent), "count", exceptionsTrend, float64(exceptionsPrev), "exceptions"))
+
+ // 3. Average Response Time
+ avgDurationTrend, err := repositories.TransactionRepository.AvgDurationByInterval(c, projectId, start, end, intervalMinutes)
+ if err != nil {
+ panic(err)
+ }
+ avgDurationCurrent := getLastValue(avgDurationTrend)
+ avgDurationPrevTrend, _ := repositories.TransactionRepository.AvgDurationByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
+ avgDurationPrev := getAverageValue(avgDurationPrevTrend)
+ metrics = append(metrics, buildMetric("avg_response_time", "Avg Response Time", avgDurationCurrent, "ms", avgDurationTrend, avgDurationPrev, "response_time"))
+
+ // 4. Error Rate
+ errorRateTrend, err := repositories.TransactionRepository.ErrorRateByInterval(c, projectId, start, end, intervalMinutes)
+ if err != nil {
+ panic(err)
+ }
+ errorRateCurrent := getLastValue(errorRateTrend)
+ errorRatePrevTrend, _ := repositories.TransactionRepository.ErrorRateByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
+ errorRatePrev := getAverageValue(errorRatePrevTrend)
+ metrics = append(metrics, buildMetric("error_rate", "Error Rate", errorRateCurrent, "%", errorRateTrend, errorRatePrev, "error_rate"))
+
+ c.JSON(http.StatusOK, StatsMetricsResponse{
+ Metrics: metrics,
+ LastUpdated: now,
+ })
+}
+
+// GetServerMetrics returns server resource metrics (CPU Usage, Memory Usage, Total Memory)
+// Always returns ALL servers' data - ignores server selector
+func (m metricsController) GetServerMetrics(c *gin.Context) {
+ projectId := c.Query("projectId")
+ now := time.Now()
+ start, end := parseTimeRange(c, now)
+
+ // Calculate previous period for comparison
+ duration := end.Sub(start)
+ prevStart := start.Add(-duration)
+ prevEnd := start
+
+ // Calculate aggregation interval based on time range
+ intervalMinutes := calculateIntervalMinutes(duration)
+
+ // Get available servers in the time range
+ availableServers, err := repositories.MetricRecordRepository.GetDistinctServers(c, projectId, start, end)
+ if err != nil {
+ availableServers = []string{}
+ }
+
+ // Always pass empty slice to get ALL servers
+ var emptyServers []string
+
+ metrics := make([]models.DashboardMetric, 0, 3)
+
+ // 1. CPU Usage
+ cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
+
+ // 2. Memory Usage (MB)
+ memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("memory_usage", "Memory Usage", "MB", memPerServer, memPrev, "memory"))
+
+ // 3. Total System Memory (MB)
+ memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, emptyServers)
+ if err != nil {
+ panic(err)
+ }
+ memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
+ metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
+
+ c.JSON(http.StatusOK, ServerMetricsResponse{
+ Metrics: metrics,
+ AvailableServers: availableServers,
+ LastUpdated: now,
+ })
+}
+
+// parseTimeRange extracts fromDate and toDate from query params, defaults to last 24h
+func parseTimeRange(c *gin.Context, now time.Time) (start, end time.Time) {
+ // Parse fromDate parameter
+ if fromDateStr := c.Query("fromDate"); fromDateStr != "" {
+ if parsed, err := time.Parse(time.RFC3339, fromDateStr); err == nil {
+ start = parsed
+ } else {
+ start = now.Add(-24 * time.Hour)
+ }
+ } else {
+ start = now.Add(-24 * time.Hour)
+ }
+
+ // Parse toDate parameter
+ if toDateStr := c.Query("toDate"); toDateStr != "" {
+ if parsed, err := time.Parse(time.RFC3339, toDateStr); err == nil {
+ end = parsed
+ } else {
+ end = now
+ }
+ } else {
+ end = now
+ }
+
+ return start, end
+}
+
+var MetricsController = metricsController{}
diff --git a/backend/app/controllers/routes.go b/backend/app/controllers/routes.go
index a651074f..c0d28706 100644
--- a/backend/app/controllers/routes.go
+++ b/backend/app/controllers/routes.go
@@ -36,6 +36,11 @@ func RegisterControllers(router *gin.RouterGroup) {
router.GET("/dashboard", middleware.UseAppAuth, DashboardController.GetDashboard)
router.GET("/dashboard/overview", middleware.UseAppAuth, DashboardController.GetDashboardOverview)
+ // Metrics endpoints (split by category)
+ router.GET("/metrics/application", middleware.UseAppAuth, MetricsController.GetApplicationMetrics)
+ router.GET("/metrics/stats", middleware.UseAppAuth, MetricsController.GetStatsMetrics)
+ router.GET("/metrics/server", middleware.UseAppAuth, MetricsController.GetServerMetrics)
+
router.POST("/transactions", middleware.UseAppAuth, TransactionController.FindAllTransactions)
router.POST("/transactions/grouped", middleware.UseAppAuth, TransactionController.FindGroupedByEndpoint)
router.POST("/transactions/endpoint", middleware.UseAppAuth, TransactionController.FindByEndpoint)
diff --git a/frontend/src/lib/components/dashboard/metric-card.svelte b/frontend/src/lib/components/dashboard/metric-card.svelte
index 4a57ec2a..b026556e 100644
--- a/frontend/src/lib/components/dashboard/metric-card.svelte
+++ b/frontend/src/lib/components/dashboard/metric-card.svelte
@@ -208,13 +208,13 @@
});
</script>
-<Card.Root class="gap-3">
+<Card.Root class="gap-3 pb-0">
<Card.Header class="pb-2">
<Card.Title class="text-sm font-medium">
{metric.name}
</Card.Title>
</Card.Header>
- <Card.Content class="pt-0">
+ <Card.Content class="p-1 pt-0 pl-3">
<!-- Large Value Display -->
@@ -284,7 +284,7 @@
seriesLayout="stack"
props={{
xAxis: {
- format: () => ""
+ format: () => "",
},
yAxis: {
format: (a: number) => a > 999 ? (a/1000).toFixed(0) + "k" : `${a}`,
diff --git a/frontend/src/lib/components/dashboard/metrics-tab-content.svelte b/frontend/src/lib/components/dashboard/metrics-tab-content.svelte
new file mode 100644
index 00000000..72b2dd72
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/metrics-tab-content.svelte
@@ -0,0 +1,125 @@
+<script lang="ts">
+ import { LoadingCircle } from '$lib/components/ui/loading-circle';
+ import { ErrorDisplay } from '$lib/components/ui/error-display';
+ import MetricCard from './metric-card.svelte';
+ import type { DashboardMetric, ServerMetricTrend, MetricTrendPoint } from '$lib/types/dashboard';
+
+ let {
+ metrics = null,
+ loading = false,
+ error = '',
+ errorTitle = 'Failed to Load Metrics',
+ onRetry,
+ timeDomain = null,
+ onRangeSelect,
+ serverColorMap = {},
+ selectedServers = [],
+ availableServers = []
+ } = $props<{
+ metrics: DashboardMetric[] | null;
+ loading: boolean;
+ error: string;
+ errorTitle?: string;
+ onRetry: () => void;
+ timeDomain: [Date, Date] | null;
+ onRangeSelect?: (from: Date, to: Date) => void;
+ serverColorMap: Record<string, string>;
+ selectedServers: string[];
+ availableServers: string[];
+ }>();
+
+ // Marker for "none selected" state (must match server-filter.svelte)
+ const NONE_SELECTED = '__none__';
+
+ // Client-side filtering: Filter metrics by selected servers
+ function filterMetricsByServer(metricsToFilter: DashboardMetric[]): DashboardMetric[] {
+ // Check for "none selected" state
+ const isNoneSelected = selectedServers.length === 1 && selectedServers[0] === NONE_SELECTED;
+
+ // If no servers selected or all servers selected, show all data
+ if (!isNoneSelected && (selectedServers.length === 0 || selectedServers.length === availableServers.length)) {
+ return metricsToFilter;
+ }
+
+ return metricsToFilter.map(metric => {
+ // If metric doesn't have server breakdown, return as-is
+ if (!metric.servers || metric.servers.length === 0) {
+ return metric;
+ }
+
+ // Filter to only selected servers
+ const filteredServers = metric.servers.filter(
+ s => selectedServers.includes(s.serverName)
+ );
+
+ // Recalculate aggregate value from filtered servers
+ const newValue = filteredServers.length > 0
+ ? filteredServers.reduce((sum, s) => sum + s.value, 0) / filteredServers.length
+ : 0;
+
+ // Recalculate aggregate trend from filtered servers
+ const newTrend = recalculateAggregateTrend(filteredServers);
+
+ return {
+ ...metric,
+ servers: filteredServers,
+ value: newValue,
+ trend: newTrend
+ };
+ });
+ }
+
+ // Helper to recalculate aggregate trend from filtered server data
+ function recalculateAggregateTrend(servers: ServerMetricTrend[]): MetricTrendPoint[] {
+ if (servers.length === 0) return [];
+
+ const timestampValues = new Map<number, number[]>();
+ for (const server of servers) {
+ for (const point of server.trend) {
+ const ts = point.timestamp.getTime();
+ if (!timestampValues.has(ts)) timestampValues.set(ts, []);
+ timestampValues.get(ts)!.push(point.value);
+ }
+ }
+
+ return Array.from(timestampValues.entries())
+ .sort(([a], [b]) => a - b)
+ .map(([ts, values]) => ({
+ timestamp: new Date(ts),
+ value: values.reduce((a, b) => a + b, 0) / values.length
+ }));
+ }
+
+ // Derived filtered metrics
+ const filteredMetrics = $derived(
+ metrics ? filterMetricsByServer(metrics) : []
+ );
+</script>
+
+{#if error && !loading}
+ <ErrorDisplay
+ status={400}
+ title={errorTitle}
+ description={error}
+ {onRetry}
+ />
+{:else if loading}
+ <div class="flex items-center justify-center py-20">
+ <LoadingCircle size="xlg" />
+ </div>
+{:else if filteredMetrics.length > 0}
+ <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3">
+ {#each filteredMetrics as metric (metric.id)}
+ <MetricCard
+ {metric}
+ {timeDomain}
+ {onRangeSelect}
+ {serverColorMap}
+ />
+ {/each}
+ </div>
+{:else}
+ <div class="flex items-center justify-center py-20 text-muted-foreground">
+ No metrics data available
+ </div>
+{/if}
diff --git a/frontend/src/lib/components/dashboard/server-filter.svelte b/frontend/src/lib/components/dashboard/server-filter.svelte
index 36ec8480..7cb0dc3e 100644
--- a/frontend/src/lib/components/dashboard/server-filter.svelte
+++ b/frontend/src/lib/components/dashboard/server-filter.svelte
@@ -1,8 +1,10 @@
<script lang="ts">
import { Button } from '$lib/components/ui/button';
import * as Popover from '$lib/components/ui/popover';
- import { Checkbox } from '$lib/components/ui/checkbox';
- import { Server, ChevronDown } from 'lucide-svelte';
+ import { Input } from '$lib/components/ui/input';
+ import { Separator } from '$lib/components/ui/separator';
+ import { Badge } from '$lib/components/ui/badge';
+ import { CirclePlus, Check } from 'lucide-svelte';
interface Props {
availableServers: string[];
@@ -19,135 +21,192 @@
}: Props = $props();
let isOpen = $state(false);
- let tempSelectedServers = $state<Set<string>>(new Set(selectedServers));
+ let searchQuery = $state('');
- // Sync temp state when popover opens
- $effect(() => {
- if (isOpen) {
- tempSelectedServers = new Set(selectedServers);
- }
- });
+ // Filter servers based on search
+ const filteredServers = $derived(
+ [...availableServers]
+ .sort()
+ .filter(s => s.toLowerCase().includes(searchQuery.toLowerCase()))
+ );
+
+ // Marker for "none selected" state
+ const NONE_SELECTED = '__none__';
- // Computed states
- const allSelected = $derived(tempSelectedServers.size === availableServers.length);
- const noneSelected = $derived(tempSelectedServers.size === 0);
+ // Check if in "none selected" state
+ const isNoneSelected = $derived(
+ selectedServers.length === 1 && selectedServers[0] === NONE_SELECTED
+ );
- // Display label for the trigger button
- const displayLabel = $derived(() => {
+ // Get the list of servers to display in the legend
+ const displayServers = $derived(() => {
+ if (isNoneSelected) return [];
+ // If empty (all selected) or all explicitly selected, show all available servers
if (selectedServers.length === 0 || selectedServers.length === availableServers.length) {
- return 'All servers';
+ return [...availableServers].sort();
}
- if (selectedServers.length === 1) {
- return selectedServers[0];
- }
- return `${selectedServers.length} servers`;
+ // Otherwise show the selected ones
+ return [...selectedServers].sort();
});
- function toggleServer(serverName: string) {
- const newSet = new Set(tempSelectedServers);
- if (newSet.has(serverName)) {
- newSet.delete(serverName);
- } else {
- newSet.add(serverName);
- }
- tempSelectedServers = newSet;
+ // Has active filters (some but not all selected, or none selected)
+ const hasActiveFilters = $derived(
+ isNoneSelected || (selectedServers.length > 0 && selectedServers.length < availableServers.length)
+ );
+
+ function isSelected(serverName: string): boolean {
+ // None selected state
+ if (isNoneSelected) return false;
+ // If no servers selected, treat as "all selected"
+ if (selectedServers.length === 0) return true;
+ return selectedServers.includes(serverName);
}
function selectAll() {
- tempSelectedServers = new Set(availableServers);
+ selectedServers = [];
+ onSelectionChange?.([]);
}
- function clearAll() {
- tempSelectedServers = new Set();
+ function selectNone() {
+ selectedServers = [NONE_SELECTED];
+ onSelectionChange?.([NONE_SELECTED]);
}
- function arraysEqual(a: string[], b: string[]): boolean {
- if (a.length !== b.length) return false;
- const sortedA = [...a].sort();
- const sortedB = [...b].sort();
- return sortedA.every((v, i) => v === sortedB[i]);
- }
+ function toggleServer(serverName: string) {
+ let newSelection: string[];
- function applySelection() {
- const newSelection = Array.from(tempSelectedServers);
- if (!arraysEqual(newSelection, selectedServers)) {
- selectedServers = newSelection;
- onSelectionChange?.(newSelection);
+ if (isNoneSelected) {
+ // None selected - clicking one selects just that one
+ newSelection = [serverName];
+ } else if (selectedServers.length === 0) {
+ // Currently "all selected" - clicking one deselects it (select all except this one)
+ newSelection = availableServers.filter(s => s !== serverName);
+ } else if (selectedServers.includes(serverName)) {
+ // Remove from selection
+ newSelection = selectedServers.filter(s => s !== serverName);
+ // If removing last one, go to none selected state
+ if (newSelection.length === 0) {
+ newSelection = [NONE_SELECTED];
+ }
+ } else {
+ // Add to selection
+ newSelection = [...selectedServers, serverName];
+ // If all are now selected, reset to empty (all selected state)
+ if (newSelection.length === availableServers.length) {
+ newSelection = [];
+ }
}
+
+ selectedServers = newSelection;
+ onSelectionChange?.(newSelection);
}
+ function clearFilters() {
+ selectedServers = [];
+ onSelectionChange?.([]);
+ }
+
+ // Reset search when popover closes
function handleOpenChange(open: boolean) {
if (!open) {
- // Apply selection when closing (only if changed)
- applySelection();
+ searchQuery = '';
}
isOpen = open;
}
-
- function isSelected(serverName: string): boolean {
- return tempSelectedServers.has(serverName);
- }
</script>
<Popover.Root bind:open={isOpen} onOpenChange={handleOpenChange}>
<Popover.Trigger>
- <Button variant="outline" class="h-9 justify-between gap-2 font-normal">
- <span class="flex items-center gap-2">
- <Server class="h-4 w-4 text-muted-foreground" />
- <span class="truncate">{displayLabel()}</span>
- </span>
- <ChevronDown class="h-4 w-4 text-muted-foreground" />
+ <Button variant="outline" size="sm" class="h-auto min-h-8 border-dashed py-1.5">
+ <CirclePlus class="mr-2 h-4 w-4 flex-shrink-0" />
+ <span class="flex-shrink-0">Servers</span>
+ {#if displayServers().length > 0}
+ <Separator orientation="vertical" class="mx-2 h-4" />
+ <div class="flex flex-wrap gap-1">
+ {#each displayServers() as server}
+ {@const color = serverColorMap[server] || '#888888'}
+ <Badge variant="secondary" class="rounded-sm px-1.5 py-0 font-normal flex items-center gap-1">
+ <span
+ class="h-2 w-2 rounded-full flex-shrink-0"
+ style="background-color: {color};"
+ ></span>
+ <span class="truncate max-w-[80px]">{server}</span>
+ </Badge>
+ {/each}
+ </div>
+ {:else if isNoneSelected}
+ <Separator orientation="vertical" class="mx-2 h-4" />
+ <span class="text-muted-foreground text-xs">None selected</span>
+ {/if}
</Button>
</Popover.Trigger>
- <Popover.Content class="w-[220px] p-0" align="start">
- <div class="p-3 border-b">
- <div class="flex items-center justify-between">
- <span class="text-sm font-medium">Servers</span>
- <div class="flex items-center gap-2">
- <button
- class="text-xs text-primary hover:underline disabled:text-muted-foreground disabled:no-underline"
- onclick={selectAll}
- disabled={allSelected}
- >
- All
- </button>
- <span class="text-muted-foreground">|</span>
- <button
- class="text-xs text-primary hover:underline disabled:text-muted-foreground disabled:no-underline"
- onclick={clearAll}
- disabled={noneSelected}
- >
- Clear
- </button>
- </div>
- </div>
+
+ <Popover.Content class="w-[200px] p-0" align="start">
+ <!-- Search Input -->
+ <div class="p-2">
+ <Input
+ placeholder="Servers"
+ bind:value={searchQuery}
+ class="h-8"
+ />
</div>
- <div class="max-h-[280px] overflow-y-auto py-2">
- {#each [...availableServers].sort() as serverName}
+
+ <!-- Quick Actions -->
+ {#if availableServers.length > 0}
+ <div class="flex items-center justify-between border-t px-2 py-1.5">
+ <button
+ class="text-xs text-muted-foreground hover:text-foreground"
+ onclick={selectAll}
+ >
+ Select all
+ </button>
+ <button
+ class="text-xs text-muted-foreground hover:text-foreground"
+ onclick={selectNone}
+ >
+ Deselect all
+ </button>
+ </div>
+ {/if}
+
+ <!-- Server List -->
+ <div class="max-h-[200px] overflow-y-auto">
+ {#each filteredServers as serverName}
{@const color = serverColorMap[serverName] || '#888888'}
+ {@const selected = isSelected(serverName)}
<button
- class="w-full px-3 py-1.5 text-left text-sm hover:bg-muted/50 flex items-center gap-3 transition-colors"
+ class="relative flex w-full cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none hover:bg-accent hover:text-accent-foreground"
onclick={() => toggleServer(serverName)}
>
- <Checkbox
- checked={isSelected(serverName)}
- aria-label={`Select ${serverName}`}
- />
+ <div class="flex h-4 w-4 items-center justify-center rounded-sm border border-primary {selected ? 'bg-primary text-primary-foreground' : 'opacity-50'}">
+ {#if selected}
+ <Check class="h-3 w-3" />
+ {/if}
+ </div>
<span
- class="w-3 h-3 rounded-full flex-shrink-0"
+ class="h-2 w-2 rounded-full flex-shrink-0"
style="background-color: {color};"
></span>
- <span class="truncate">{serverName}</span>
+ <span class="flex-1 truncate text-left">{serverName}</span>
</button>
{/each}
+
+ {#if filteredServers.length === 0}
+ <div class="py-6 text-center text-sm text-muted-foreground">
+ No servers found.
+ </div>
+ {/if}
</div>
- <div class="p-3 border-t">
- <Button size="sm" class="w-full" onclick={() => {
- applySelection();
- isOpen = false;
- }}>
- Apply
- </Button>
- </div>
+
+ <!-- Clear Filters -->
+ {#if hasActiveFilters}
+ <Separator />
+ <button
+ class="w-full py-2 text-center text-sm hover:bg-accent"
+ onclick={clearFilters}
+ >
+ Clear filters
+ </button>
+ {/if}
</Popover.Content>
</Popover.Root>
diff --git a/frontend/src/lib/components/ui/tabs/index.ts b/frontend/src/lib/components/ui/tabs/index.ts
new file mode 100644
index 00000000..0084e101
--- /dev/null
+++ b/frontend/src/lib/components/ui/tabs/index.ts
@@ -0,0 +1,16 @@
+import Root from "./tabs.svelte";
+import List from "./tabs-list.svelte";
+import Trigger from "./tabs-trigger.svelte";
+import Content from "./tabs-content.svelte";
+
+export {
+ Root,
+ List,
+ Trigger,
+ Content,
+ //
+ Root as Tabs,
+ List as TabsList,
+ Trigger as TabsTrigger,
+ Content as TabsContent,
+};
diff --git a/frontend/src/lib/components/ui/tabs/tabs-content.svelte b/frontend/src/lib/components/ui/tabs/tabs-content.svelte
new file mode 100644
index 00000000..e7bfed33
--- /dev/null
+++ b/frontend/src/lib/components/ui/tabs/tabs-content.svelte
@@ -0,0 +1,22 @@
+<script lang="ts">
+ import { Tabs as TabsPrimitive } from "bits-ui";
+ import { cn, type WithoutChild } from "$lib/utils.js";
+
+ let {
+ ref = $bindable(null),
+ class: className,
+ children,
+ ...restProps
+ }: WithoutChild<TabsPrimitive.ContentProps> = $props();
+</script>
+
+<TabsPrimitive.Content
+ bind:ref
+ class={cn(
+ "ring-offset-background focus-visible:ring-ring mt-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2",
+ className
+ )}
+ {...restProps}
+>
+ {@render children?.()}
+</TabsPrimitive.Content>
diff --git a/frontend/src/lib/components/ui/tabs/tabs-list.svelte b/frontend/src/lib/components/ui/tabs/tabs-list.svelte
new file mode 100644
index 00000000..2fcb3348
--- /dev/null
+++ b/frontend/src/lib/components/ui/tabs/tabs-list.svelte
@@ -0,0 +1,22 @@
+<script lang="ts">
+ import { Tabs as TabsPrimitive } from "bits-ui";
+ import { cn, type WithoutChild } from "$lib/utils.js";
+
+ let {
+ ref = $bindable(null),
+ class: className,
+ children,
+ ...restProps
+ }: WithoutChild<TabsPrimitive.ListProps> = $props();
+</script>
+
+<TabsPrimitive.List
+ bind:ref
+ class={cn(
+ "bg-muted text-muted-foreground inline-flex h-9 items-center justify-center rounded-lg p-1",
+ className
+ )}
+ {...restProps}
+>
+ {@render children?.()}
+</TabsPrimitive.List>
diff --git a/frontend/src/lib/components/ui/tabs/tabs-trigger.svelte b/frontend/src/lib/components/ui/tabs/tabs-trigger.svelte
new file mode 100644
index 00000000..3c32ccf8
--- /dev/null
+++ b/frontend/src/lib/components/ui/tabs/tabs-trigger.svelte
@@ -0,0 +1,22 @@
+<script lang="ts">
+ import { Tabs as TabsPrimitive } from "bits-ui";
+ import { cn, type WithoutChild } from "$lib/utils.js";
+
+ let {
+ ref = $bindable(null),
+ class: className,
+ children,
+ ...restProps
+ }: WithoutChild<TabsPrimitive.TriggerProps> = $props();
+</script>
+
+<TabsPrimitive.Trigger
+ bind:ref
+ class={cn(
+ "ring-offset-background focus-visible:ring-ring data-[state=active]:bg-background data-[state=active]:text-foreground inline-flex items-center justify-center whitespace-nowrap rounded-md px-3 py-1 text-sm font-medium transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow",
+ className
+ )}
+ {...restProps}
+>
+ {@render children?.()}
+</TabsPrimitive.Trigger>
diff --git a/frontend/src/lib/components/ui/tabs/tabs.svelte b/frontend/src/lib/components/ui/tabs/tabs.svelte
new file mode 100644
index 00000000..1db821c5
--- /dev/null
+++ b/frontend/src/lib/components/ui/tabs/tabs.svelte
@@ -0,0 +1,10 @@
+<script lang="ts">
+ import { Tabs as TabsPrimitive } from "bits-ui";
+
+ let {
+ value = $bindable(),
+ ...restProps
+ }: TabsPrimitive.RootProps = $props();
+</script>
+
+<TabsPrimitive.Root bind:value {...restProps} />
diff --git a/frontend/src/lib/types/dashboard.ts b/frontend/src/lib/types/dashboard.ts
index 2a51fadd..624558d8 100644
--- a/frontend/src/lib/types/dashboard.ts
+++ b/frontend/src/lib/types/dashboard.ts
@@ -17,7 +17,6 @@ export type DashboardMetric = {
value: number;
unit: string;
trend: MetricTrendPoint[];
- change24h: number; // Percentage change (e.g., 5.2 or -3.1)
status: MetricStatus;
formatValue?: (value: number) => string;
servers?: ServerMetricTrend[]; // Per-server breakdown for multi-server metrics
@@ -28,3 +27,26 @@ export type DashboardData = {
lastUpdated: Date;
availableServers?: string[]; // List of servers with data in the time range
};
+
+// Tab types for split metrics endpoints
+export type MetricsTab = 'application' | 'stats' | 'server';
+
+// Response type for /api/metrics/application
+export type ApplicationMetricsData = {
+ metrics: DashboardMetric[];
+ availableServers: string[];
+ lastUpdated: Date;
+};
+
+// Response type for /api/metrics/stats
+export type StatsMetricsData = {
+ metrics: DashboardMetric[];
+ lastUpdated: Date;
+};
+
+// Response type for /api/metrics/server
+export type ServerMetricsData = {
+ metrics: DashboardMetric[];
+ availableServers: string[];
+ lastUpdated: Date;
+};
diff --git a/frontend/src/lib/utils/mock-dashboard-data.ts b/frontend/src/lib/utils/mock-dashboard-data.ts
deleted file mode 100644
index b708d15e..00000000
--- a/frontend/src/lib/utils/mock-dashboard-data.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import type { DashboardData, MetricTrendPoint, MetricStatus } from '$lib/types/dashboard';
-
-function generateTrendData(
- baseValue: number,
- points: number = 12,
- variance: number = 0.1
-): MetricTrendPoint[] {
- const now = Date.now();
- const interval = 60000; // 1 minute intervals
-
- return Array.from({ length: points }, (_, i) => ({
- timestamp: new Date(now - (points - i - 1) * interval),
- value: baseValue + (Math.random() - 0.5) * baseValue * variance
- }));
-}
-
-function determineStatus(
- value: number,
- thresholds: { warning: number; critical: number },
- inverted: boolean = false
-): MetricStatus {
- if (inverted) {
- if (value < thresholds.critical) return 'critical';
- if (value < thresholds.warning) return 'warning';
- return 'healthy';
- } else {
- if (value > thresholds.critical) return 'critical';
- if (value > thresholds.warning) return 'warning';
- return 'healthy';
- }
-}
-
-export function generateMockDashboardData(): DashboardData {
- const cpuValue = 45 + Math.random() * 20; // 45-65%
- const memoryValue = 512 + Math.random() * 256; // 512-768 MB
- const goRoutinesValue = 150 + Math.random() * 100; // 150-250
- const heapObjectsValue = 25000 + Math.random() * 10000; // 25k-35k
- const errorRateValue = 0.5 + Math.random() * 2; // 0.5-2.5%
- const p95LatencyValue = 120 + Math.random() * 80; // 120-200ms
- const throughputValue = 850 + Math.random() * 300; // 850-1150 req/s
- const apdexValue = 0.85 + Math.random() * 0.1; // 0.85-0.95
-
- return {
- metrics: [
- {
- id: 'cpu',
- name: 'CPU Usage',
- value: cpuValue,
- unit: '%',
- trend: generateTrendData(cpuValue, 12),
- change24h: -2.3 + Math.random() * 4, // -2.3 to 1.7
- status: determineStatus(cpuValue, { warning: 70, critical: 90 }),
- formatValue: (v) => v.toFixed(1)
- },
- {
- id: 'memory',
- name: 'Memory',
- value: memoryValue,
- unit: 'MB',
- trend: generateTrendData(memoryValue, 12),
- change24h: 5.8 + Math.random() * 4 - 2, // 3.8 to 7.8
- status: determineStatus(memoryValue, { warning: 700, critical: 900 }),
- formatValue: (v) => Math.round(v).toString()
- },
- {
- id: 'goroutines',
- name: 'Go Routines',
- value: goRoutinesValue,
- unit: '',
- trend: generateTrendData(goRoutinesValue, 12),
- change24h: 12.4 + Math.random() * 4 - 2, // 10.4 to 14.4
- status: determineStatus(goRoutinesValue, { warning: 300, critical: 500 }),
- formatValue: (v) => Math.round(v).toString()
- },
- {
- id: 'heap',
- name: 'Heap Objects',
- value: heapObjectsValue,
- unit: '',
- trend: generateTrendData(heapObjectsValue, 12),
- change24h: -1.2 + Math.random() * 4 - 2, // -3.2 to 0.8
- status: determineStatus(heapObjectsValue, { warning: 40000, critical: 60000 }),
- formatValue: (v) => (v / 1000).toFixed(1) + 'k'
- },
- {
- id: 'error-rate',
- name: 'Error Rate',
- value: errorRateValue,
- unit: '%',
- trend: generateTrendData(errorRateValue, 12),
- change24h: -15.3 + Math.random() * 10, // -15.3 to -5.3
- status: determineStatus(errorRateValue, { warning: 2, critical: 5 }),
- formatValue: (v) => v.toFixed(2)
- },
- {
- id: 'p95-latency',
- name: 'P95 Latency',
- value: p95LatencyValue,
- unit: 'ms',
- trend: generateTrendData(p95LatencyValue, 12),
- change24h: 3.7 + Math.random() * 4 - 2, // 1.7 to 5.7
- status: determineStatus(p95LatencyValue, { warning: 200, critical: 500 }),
- formatValue: (v) => Math.round(v).toString()
- },
- {
- id: 'throughput',
- name: 'Throughput',
- value: throughputValue,
- unit: 'req/s',
- trend: generateTrendData(throughputValue, 12),
- change24h: 8.2 + Math.random() * 4 - 2, // 6.2 to 10.2
- status: determineStatus(throughputValue, { warning: 500, critical: 300 }, true),
- formatValue: (v) => Math.round(v).toString()
- },
- {
- id: 'apdex',
- name: 'Apdex Score',
- value: apdexValue,
- unit: '',
- trend: generateTrendData(apdexValue, 12, 0.05),
- change24h: 1.8 + Math.random() * 2 - 1, // 0.8 to 2.8
- status: determineStatus(apdexValue, { warning: 0.7, critical: 0.5 }, true),
- formatValue: (v) => v.toFixed(3)
- }
- ],
- lastUpdated: new Date()
- };
-}
diff --git a/frontend/src/routes/metrics/+page.svelte b/frontend/src/routes/metrics/+page.svelte
index 4af5792b..0fbc720d 100644
--- a/frontend/src/routes/metrics/+page.svelte
+++ b/frontend/src/routes/metrics/+page.svelte
@@ -2,19 +2,20 @@
import { onMount } from 'svelte';
import { browser } from '$app/environment';
import { Button } from '$lib/components/ui/button';
- import { LoadingCircle } from '$lib/components/ui/loading-circle';
- import { RefreshCw } from 'lucide-svelte';
- import MetricCard from '$lib/components/dashboard/metric-card.svelte';
+ import { RefreshCw, Code } from 'lucide-svelte';
import ServerFilter from '$lib/components/dashboard/server-filter.svelte';
+ import MetricsTabContent from '$lib/components/dashboard/metrics-tab-content.svelte';
+ import * as Tabs from '$lib/components/ui/tabs';
import type {
- DashboardData,
DashboardMetric,
ServerMetricTrend,
- MetricTrendPoint
+ MetricTrendPoint,
+ MetricsTab,
+ ApplicationMetricsData,
+ StatsMetricsData,
+ ServerMetricsData
} from '$lib/types/dashboard';
- import { Card, CardContent } from '$lib/components/ui/card';
import { api } from '$lib/api';
- import { ErrorDisplay } from '$lib/components/ui/error-display';
import { projectsState } from '$lib/state/projects.svelte';
import { getTimezone } from '$lib/state/timezone.svelte';
import { getNow, parseISO, toUTCISO, calendarDateTimeToLuxon, formatDateTime } from '$lib/utils/formatters';
@@ -24,17 +25,37 @@
const timezone = $derived(getTimezone());
- let dashboardData = $state<DashboardData | null>(null);
- let loading = $state(true);
- let error = $state('');
- let errorStatus = $state<number>(0);
+ // Tab state
+ let activeTab = $state<MetricsTab>('application');
- // Server filtering state
- let availableServers = $state<string[]>([]);
+ // Per-tab data (null = not loaded yet)
+ let applicationData = $state<ApplicationMetricsData | null>(null);
+ let statsData = $state<StatsMetricsData | null>(null);
+ let serverData = $state<ServerMetricsData | null>(null);
+
+ // Per-tab loading states
+ let loadingApplication = $state(false);
+ let loadingStats = $state(false);
+ let loadingServer = $state(false);
+
+ // Per-tab error states
+ let errorApplication = $state('');
+ let errorStats = $state('');
+ let errorServer = $state('');
+
+ // Server filtering state (client-side only)
let selectedServers = $state<string[]>([]);
+ // Merge available servers from all endpoints
+ const availableServers = $derived(() => {
+ const servers = new Set<string>();
+ applicationData?.availableServers?.forEach(s => servers.add(s));
+ serverData?.availableServers?.forEach(s => servers.add(s));
+ return Array.from(servers).sort();
+ });
+
// Compute server color map for consistent colors across all charts
- const serverColorMap = $derived(getServerColorMap(availableServers));
+ const serverColorMap = $derived(getServerColorMap(availableServers()));
// Preset definitions (must match TimeRangePicker)
const presetMinutes: Record<string, number> = {
@@ -52,7 +73,7 @@
// Calculate time range from preset
function getTimeRangeFromPresetLocal(presetValue: string): { from: Date; to: Date } {
- const minutes = presetMinutes[presetValue] || 360; // Default to 6h
+ const minutes = presetMinutes[presetValue] || 360;
const now = getNow(timezone);
const from = now.minus({ minutes });
return { from: from.toJSDate(), to: now.toJSDate() };
@@ -64,33 +85,34 @@
from: Date | null;
to: Date | null;
servers: string[];
+ tab: MetricsTab;
} {
- if (!browser) return { preset: '6h', from: null, to: null, servers: [] };
+ if (!browser) return { preset: '6h', from: null, to: null, servers: [], tab: 'application' };
const params = new URLSearchParams(window.location.search);
const presetParam = params.get('preset');
const fromParam = params.get('from');
const toParam = params.get('to');
const serversParam = params.get('servers');
+ const tabParam = params.get('tab') as MetricsTab | null;
- // Parse servers from URL
const servers = serversParam ? serversParam.split(',').filter((s) => s.length > 0) : [];
+ const tab: MetricsTab = tabParam && ['application', 'stats', 'server'].includes(tabParam)
+ ? tabParam
+ : 'application';
- // If preset is specified, use it
if (presetParam && presetMinutes[presetParam]) {
- return { preset: presetParam, from: null, to: null, servers };
+ return { preset: presetParam, from: null, to: null, servers, tab };
}
- // If custom from/to specified
if (fromParam && toParam) {
const fromDt = parseISO(fromParam, timezone);
const toDt = parseISO(toParam, timezone);
if (fromDt.isValid && toDt.isValid) {
- return { preset: null, from: fromDt.toJSDate(), to: toDt.toJSDate(), servers };
+ return { preset: null, from: fromDt.toJSDate(), to: toDt.toJSDate(), servers, tab };
}
}
- // Default to 6h preset
- return { preset: '6h', from: null, to: null, servers };
+ return { preset: '6h', from: null, to: null, servers, tab };
}
function dateToCalendarDate(date: Date): CalendarDate {
@@ -114,23 +136,24 @@
let toTime = $state(dateToTimeString(initialRange.to));
let sharedTimeDomain = $state<[Date, Date] | null>(null);
- // Update URL with current time range and server selection
+ // Initialize tab from URL
+ activeTab = initialUrlParams.tab;
+
+ // Update URL with current state
function updateUrl(pushState = true) {
if (!browser) return;
const params = new URLSearchParams();
+ params.set('tab', activeTab);
if (selectedPreset) {
- // Store preset in URL
params.set('preset', selectedPreset);
} else {
- // Store custom from/to in URL
params.set('from', getFromDateTimeUTC());
params.set('to', getToDateTimeUTC());
}
- // Store server selection in URL (only if not all servers selected)
- if (selectedServers.length > 0 && selectedServers.length < availableServers.length) {
+ if (selectedServers.length > 0 && selectedServers.length < availableServers().length) {
params.set('servers', selectedServers.join(','));
}
@@ -162,13 +185,14 @@
toTime = dateToTimeString(urlParams.to);
}
- // Update selected servers from URL
selectedServers = urlParams.servers;
+ activeTab = urlParams.tab;
- loadDashboard(false); // Don't push to history on popstate
+ // Clear cached data and reload active tab
+ clearAllData();
+ loadActiveTab(false);
}
- // Combine date and time into UTC ISO datetime string
function getFromDateTimeUTC(): string {
const [hour, minute] = (fromTime || '00:00').split(':').map(Number);
const dt = calendarDateTimeToLuxon({ year: fromDate.year, month: fromDate.month, day: fromDate.day, hour, minute }, timezone);
@@ -181,6 +205,149 @@
return toUTCISO(dt);
}
+ // Clear all cached data
+ function clearAllData() {
+ applicationData = null;
+ statsData = null;
+ serverData = null;
+ }
+
+ // Transform API response timestamps to Date objects
+ function transformMetrics(metrics: any[]): DashboardMetric[] {
+ if (!metrics || !Array.isArray(metrics)) return [];
+ return metrics.map((m: any) => ({
+ id: m.id,
+ name: m.name,
+ value: m.value,
+ unit: m.unit,
+ trend: (m.trend || []).map((t: any) => ({
+ timestamp: new Date(t.timestamp),
+ value: t.value
+ })),
+ status: m.status,
+ servers: m.servers?.map(
+ (s: any): ServerMetricTrend => ({
+ serverName: s.serverName,
+ value: s.value,
+ trend: (s.trend || []).map(
+ (t: any): MetricTrendPoint => ({
+ timestamp: new Date(t.timestamp),
+ value: t.value
+ })
+ )
+ })
+ )
+ }));
+ }
+
+ // Load Application metrics
+ async function loadApplicationMetrics() {
+ loadingApplication = true;
+ errorApplication = '';
+
+ try {
+ const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
+ const response = await api.get(`/metrics/application?${queryParams}`, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+
+ applicationData = {
+ metrics: transformMetrics(response.metrics),
+ availableServers: response.availableServers || [],
+ lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date()
+ };
+ } catch (e: any) {
+ errorApplication = e.message || 'Failed to load application metrics';
+ console.error(e);
+ } finally {
+ loadingApplication = false;
+ }
+ }
+
+ // Load Stats metrics
+ async function loadStatsMetrics() {
+ loadingStats = true;
+ errorStats = '';
+
+ try {
+ const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
+ const response = await api.get(`/metrics/stats?${queryParams}`, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+
+ statsData = {
+ metrics: transformMetrics(response.metrics),
+ lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date()
+ };
+ } catch (e: any) {
+ errorStats = e.message || 'Failed to load stats metrics';
+ console.error(e);
+ } finally {
+ loadingStats = false;
+ }
+ }
+
+ // Load Server metrics
+ async function loadServerMetrics() {
+ loadingServer = true;
+ errorServer = '';
+
+ try {
+ const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
+ const response = await api.get(`/metrics/server?${queryParams}`, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+
+ serverData = {
+ metrics: transformMetrics(response.metrics),
+ availableServers: response.availableServers || [],
+ lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date()
+ };
+ } catch (e: any) {
+ errorServer = e.message || 'Failed to load server metrics';
+ console.error(e);
+ } finally {
+ loadingServer = false;
+ }
+ }
+
+ // Load only the active tab's data (lazy loading)
+ function loadActiveTab(pushToHistory = true) {
+ if (pushToHistory) updateUrl(true);
+
+ // Update shared time domain
+ sharedTimeDomain = [new Date(getFromDateTimeUTC()), new Date(getToDateTimeUTC())];
+
+ switch (activeTab) {
+ case 'application':
+ if (!applicationData) loadApplicationMetrics();
+ break;
+ case 'stats':
+ if (!statsData) loadStatsMetrics();
+ break;
+ case 'server':
+ if (!serverData) loadServerMetrics();
+ break;
+ }
+ }
+
+ // Force reload (for refresh button & time range change)
+ function reloadActiveTab() {
+ updateUrl(true);
+ sharedTimeDomain = [new Date(getFromDateTimeUTC()), new Date(getToDateTimeUTC())];
+
+ // Clear all cached data when time range changes
+ clearAllData();
+
+ // Load the active tab
+ switch (activeTab) {
+ case 'application': loadApplicationMetrics(); break;
+ case 'stats': loadStatsMetrics(); break;
+ case 'server': loadServerMetrics(); break;
+ }
+ }
+
+ // Handle time range change
function handleTimeRangeChange(
from: { date: CalendarDate; time: string },
to: { date: CalendarDate; time: string },
@@ -191,137 +358,72 @@
toDate = to.date;
toTime = to.time;
selectedPreset = preset;
- loadDashboard();
+ reloadActiveTab();
+ }
+
+ // Handle tab change - lazy load if data not loaded
+ function handleTabChange(tab: string) {
+ activeTab = tab as MetricsTab;
+ loadActiveTab(false);
+ updateUrl(false);
}
+ // Client-side server filtering - NO API call needed
function handleServerSelectionChange(servers: string[]) {
selectedServers = servers;
- loadDashboard();
+ updateUrl(false);
}
// Handle drag-to-zoom selection from chart overlay
function handleChartRangeSelect(from: Date, to: Date) {
- selectedPreset = null; // Chart selection is always custom
+ selectedPreset = null;
fromDate = new CalendarDate(from.getFullYear(), from.getMonth() + 1, from.getDate());
fromTime = `${String(from.getHours()).padStart(2, '0')}:${String(from.getMinutes()).padStart(2, '0')}`;
toDate = new CalendarDate(to.getFullYear(), to.getMonth() + 1, to.getDate());
toTime = `${String(to.getHours()).padStart(2, '0')}:${String(to.getMinutes()).padStart(2, '0')}`;
- loadDashboard();
+ reloadActiveTab();
}
- async function loadDashboard(pushToHistory = true) {
- loading = true;
- error = '';
- errorStatus = 0;
-
- // Update URL with current time range
- updateUrl(pushToHistory);
-
- try {
- const fromDateTimeUTC = getFromDateTimeUTC();
- const toDateTimeUTC = getToDateTimeUTC();
-
- // Store shared time domain for charts
- sharedTimeDomain = [new Date(fromDateTimeUTC), new Date(toDateTimeUTC)];
-
- // Build query params for date range and server selection
- let queryParams = `fromDate=${fromDateTimeUTC}&toDate=${toDateTimeUTC}`;
- if (selectedServers.length > 0 && selectedServers.length < availableServers.length) {
- queryParams += `&servers=${selectedServers.join(',')}`;
- }
-
- const response = await api.get(`/dashboard?${queryParams}`, {
- projectId: projectsState.currentProjectId ?? undefined
- });
+ // Get last updated time for current tab
+ const lastUpdated = $derived(() => {
+ switch (activeTab) {
+ case 'application': return applicationData?.lastUpdated;
+ case 'stats': return statsData?.lastUpdated;
+ case 'server': return serverData?.lastUpdated;
+ default: return undefined;
+ }
+ });
- // Update available servers from API response
- if (response.availableServers) {
- availableServers = response.availableServers;
- }
+ const lastUpdatedFormatted = $derived(
+ lastUpdated()
+ ? formatDateTime(lastUpdated()!, { timezone, format: 'time' })
+ : ''
+ );
- // Transform the API response to match the DashboardData type
- // Convert timestamp strings to Date objects
- // Handle case where metrics might be null/undefined (no data)
- const metrics: DashboardMetric[] =
- response.metrics && Array.isArray(response.metrics)
- ? response.metrics.map((m: any) => ({
- id: m.id,
- name: m.name,
- value: m.value,
- unit: m.unit,
- trend: (m.trend || []).map((t: any) => ({
- timestamp: new Date(t.timestamp),
- value: t.value
- })),
- change24h: m.change24h,
- status: m.status,
- // Include per-server data if available
- servers: m.servers?.map(
- (s: any): ServerMetricTrend => ({
- serverName: s.serverName,
- value: s.value,
- trend: (s.trend || []).map(
- (t: any): MetricTrendPoint => ({
- timestamp: new Date(t.timestamp),
- value: t.value
- })
- )
- })
- )
- }))
- : [];
-
- dashboardData = {
- metrics,
- lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date(),
- availableServers: response.availableServers || []
- };
- } catch (e: any) {
- errorStatus = e.status || 0;
- error = e.message || 'Failed to load dashboard data';
- console.error(e);
- } finally {
- loading = false;
+ // Check if current tab is loading
+ const isCurrentTabLoading = $derived(() => {
+ switch (activeTab) {
+ case 'application': return loadingApplication;
+ case 'stats': return loadingStats;
+ case 'server': return loadingServer;
+ default: return false;
}
- }
+ });
onMount(() => {
- // On initial load, use replaceState to set URL without creating history entry
- loadDashboard(false);
+ // Only load the active tab on mount (lazy loading)
+ loadActiveTab(false);
- // Listen for browser back/forward navigation
window.addEventListener('popstate', handlePopState);
-
- return () => {
- window.removeEventListener('popstate', handlePopState);
- };
+ return () => window.removeEventListener('popstate', handlePopState);
});
-
- const lastUpdatedFormatted = $derived(
- dashboardData?.lastUpdated
- ? formatDateTime(dashboardData.lastUpdated, { timezone, format: 'time' })
- : ''
- );
</script>
<div class="space-y-4">
<!-- Header -->
<div class="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
- <div>
- <h2 class="text-2xl font-bold tracking-tight">Metrics</h2>
- {#if dashboardData}
- <p class="mt-1 text-sm text-muted-foreground">Last updated: {lastUpdatedFormatted}</p>
- {/if}
- </div>
+ <h2 class="text-2xl font-bold tracking-tight">Metrics</h2>
<div class="flex items-center gap-2">
- {#if availableServers.length > 1}
- <ServerFilter
- {availableServers}
- bind:selectedServers
- onSelectionChange={handleServerSelectionChange}
- {serverColorMap}
- />
- {/if}
<TimeRangePicker
bind:fromDate
bind:toDate
@@ -330,44 +432,99 @@
bind:preset={selectedPreset}
onApply={handleTimeRangeChange}
/>
- <Button variant="outline" size="sm" onclick={() => loadDashboard()} disabled={loading}>
- <RefreshCw class="h-4 w-4 {loading ? 'animate-spin' : ''}" />
+ <Button variant="outline" size="sm" onclick={() => reloadActiveTab()} disabled={isCurrentTabLoading()}>
+ <RefreshCw class="h-4 w-4 {isCurrentTabLoading() ? 'animate-spin' : ''}" />
</Button>
</div>
</div>
- {#if error && !loading}
- <ErrorDisplay
- status={errorStatus === 404
- ? 404
- : errorStatus === 400
- ? 400
- : errorStatus === 422
- ? 422
- : 400}
- title="Failed to Load Metrics"
- description={error}
- onRetry={() => loadDashboard()}
- />
- {/if}
-
- <!-- Metrics Grid -->
- {#if !error}
- <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4">
- {#if loading}
- <div class="col-span-full flex items-center justify-center py-20">
- <LoadingCircle size="xlg" />
- </div>
- {:else if dashboardData}
- {#each dashboardData.metrics as metric (metric.id)}
- <MetricCard
- {metric}
- timeDomain={sharedTimeDomain}
- onRangeSelect={handleChartRangeSelect}
+ <!-- Tabs -->
+ <Tabs.Root bind:value={activeTab} onValueChange={handleTabChange}>
+ <div class="flex flex-wrap items-center justify-between gap-2">
+ <div class="flex flex-wrap items-center gap-2">
+ <Tabs.List>
+ <Tabs.Trigger value="application">Application</Tabs.Trigger>
+ <Tabs.Trigger value="stats">Stats</Tabs.Trigger>
+ <Tabs.Trigger value="server">CPU / Mem</Tabs.Trigger>
+ <Tabs.Trigger value="custom">Custom</Tabs.Trigger>
+ </Tabs.List>
+
+ {#if availableServers().length > 1}
+ <ServerFilter
+ availableServers={availableServers()}
+ bind:selectedServers
+ onSelectionChange={handleServerSelectionChange}
{serverColorMap}
/>
- {/each}
+ {/if}
+ </div>
+
+ {#if lastUpdated()}
+ <span class="text-sm text-muted-foreground whitespace-nowrap">
+ Updated: {lastUpdatedFormatted}
+ </span>
{/if}
</div>
- {/if}
+
+ <!-- Application Tab -->
+ <Tabs.Content value="application">
+ <MetricsTabContent
+ metrics={applicationData?.metrics ?? null}
+ loading={loadingApplication}
+ error={errorApplication}
+ errorTitle="Failed to Load Application Metrics"
+ onRetry={() => loadApplicationMetrics()}
+ timeDomain={sharedTimeDomain}
+ onRangeSelect={handleChartRangeSelect}
+ {serverColorMap}
+ {selectedServers}
+ availableServers={availableServers()}
+ />
+ </Tabs.Content>
+
+ <!-- Stats Tab -->
+ <Tabs.Content value="stats">
+ <MetricsTabContent
+ metrics={statsData?.metrics ?? null}
+ loading={loadingStats}
+ error={errorStats}
+ errorTitle="Failed to Load Stats Metrics"
+ onRetry={() => loadStatsMetrics()}
+ timeDomain={sharedTimeDomain}
+ onRangeSelect={handleChartRangeSelect}
+ {serverColorMap}
+ {selectedServers}
+ availableServers={availableServers()}
+ />
+ </Tabs.Content>
+
+ <!-- Server Tab -->
+ <Tabs.Content value="server">
+ <MetricsTabContent
+ metrics={serverData?.metrics ?? null}
+ loading={loadingServer}
+ error={errorServer}
+ errorTitle="Failed to Load Server Metrics"
+ onRetry={() => loadServerMetrics()}
+ timeDomain={sharedTimeDomain}
+ onRangeSelect={handleChartRangeSelect}
+ {serverColorMap}
+ {selectedServers}
+ availableServers={availableServers()}
+ />
+ </Tabs.Content>
+
+ <!-- Custom Tab -->
+ <Tabs.Content value="custom">
+ <div class="flex flex-col items-center justify-center py-8 text-center">
+ <div class="bg-muted mb-4 rounded-full p-3">
+ <Code class="text-muted-foreground h-6 w-6" />
+ </div>
+ <h3 class="mb-2 text-lg font-semibold">Custom Metrics not supported</h3>
+ <p class="text-muted-foreground mb-4 max-w-md text-sm">
+ Custom Metrics are not currently supported, but we're working on it and hope to have them supported soon.
+ </p>
+ </div>
+ </Tabs.Content>
+ </Tabs.Root>
</div>