Skip to content

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

feat: custom metrics with multiple different ways of displaying added

dduxb4fb4d925f06
diff --git a/CLAUDE.md b/CLAUDE.md
index f2825f40..6da40136 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -14,6 +14,8 @@ Traceway is an error tracking and monitoring platform consisting of:
## Code Style
- **No pointless comments**: Do not add comments that simply describe what the code does. The code should be self-explanatory. Only add comments when explaining non-obvious "why" decisions.
+- **No `py-4` in dialog form content**: Do not add `py-4` on the content wrapper inside `AlertDialog` or `Dialog` components — it creates too much blank space between the form and the action buttons.
+- **Dialog button labels & toasts**: For form dialogs, use descriptive button labels with icons instead of generic "Create"/"Update". Create actions: `<Plus icon> {Action} {Entity}` (e.g., "+ New Widget Group"). Update actions: `<Check icon> Update {Entity}`. After successful create/update, show a `toast.success('Successfully {action} the {Entity}', { position: 'top-center' })`. The button should only be `disabled` during the loading state — never disable it to enforce validation; let the backend return 422 and show the error in the dialog instead.
---
@@ -102,6 +104,8 @@ func (c *AuthController) Register(ctx *gin.Context) {
- Commits on status codes: 200, 201, 303
- Rolls back on all other status codes or panics
+**Preference:** For CRUD controller methods, always prefer using `middleware.Transactional` in the route + `middleware.GetTx(ctx)` in the controller over `pgdb.ExecuteTransaction`. The middleware approach keeps controllers flat, avoids nested closures, and follows the established pattern.
+
#### Repository Pattern
Repositories accept `*sql.Tx` to participate in transactions:
```go
diff --git a/backend/app/controllers/clientcontrollers/client.controller.go b/backend/app/controllers/clientcontrollers/client.controller.go
index 98e6ddc7..d866dc66 100644
--- a/backend/app/controllers/clientcontrollers/client.controller.go
+++ b/backend/app/controllers/clientcontrollers/client.controller.go
@@ -57,7 +57,7 @@ func (e clientController) Report(c *gin.Context) {
endpointsToInsert := []models.Endpoint{}
tasksToInsert := []models.Task{}
exceptionStackTraceToInsert := []models.ExceptionStackTrace{}
- metricRecordsToInsert := []models.MetricRecord{}
+ metricPointsToInsert := []models.MetricPoint{}
spansToInsert := []models.Span{}
type recordingWork struct {
@@ -130,9 +130,9 @@ func (e clientController) Report(c *gin.Context) {
}
for _, cm := range cf.Metrics {
- mr := cm.ToMetricRecord(request.ServerName)
- mr.ProjectId = projectId
- metricRecordsToInsert = append(metricRecordsToInsert, mr)
+ mp := cm.ToMetricPoint(request.ServerName)
+ mp.ProjectId = projectId
+ metricPointsToInsert = append(metricPointsToInsert, mp)
}
for _, sr := range cf.SessionRecordings {
@@ -173,11 +173,14 @@ func (e clientController) Report(c *gin.Context) {
return
}
- err = repositories.MetricRecordRepository.InsertAsync(c, metricRecordsToInsert)
+ if len(metricPointsToInsert) > 0 {
+ if err := repositories.MetricPointRepository.InsertAsync(c, metricPointsToInsert); err != nil {
+ c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting metricPointsToInsert: %w", err))
+ return
+ }
- if err != nil {
- c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting metricRecordsToInsert: %w", err))
- return
+ metricNames := collectUniqueMetricNames(metricPointsToInsert)
+ go autoRegisterMetrics(projectId, metricNames)
}
err = repositories.SpanRepository.InsertAsync(c, spansToInsert)
@@ -228,6 +231,27 @@ func (e clientController) Report(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{})
}
+func collectUniqueMetricNames(points []models.MetricPoint) []string {
+ seen := make(map[string]struct{}, len(points))
+ var names []string
+ for _, p := range points {
+ if _, ok := seen[p.Name]; !ok {
+ seen[p.Name] = struct{}{}
+ names = append(names, p.Name)
+ }
+ }
+ return names
+}
+
+func autoRegisterMetrics(projectId uuid.UUID, names []string) {
+ _, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (struct{}, error) {
+ return struct{}{}, repositories.MetricRegistryRepository.EnsureRegistered(tx, projectId, names)
+ })
+ if err != nil {
+ traceway.CaptureException(fmt.Errorf("failed to auto-register metrics: %w", err))
+ }
+}
+
var (
errorMessageRe = regexp.MustCompile(`(?m)^(\*?[\w.]+):\s*.+`)
absolutePathRe = regexp.MustCompile(`/[^\s:]+/([^/\s:]+:\d+)`)
diff --git a/backend/app/controllers/dashboard.controller.go b/backend/app/controllers/dashboard.controller.go
index 104a4557..1f2f03c3 100644
--- a/backend/app/controllers/dashboard.controller.go
+++ b/backend/app/controllers/dashboard.controller.go
@@ -112,7 +112,7 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
intervalMinutes := calculateIntervalMinutes(duration)
// Get available servers in the time range
- availableServers, err := repositories.MetricRecordRepository.GetDistinctServers(c, projectId, start, end)
+ availableServers, err := repositories.MetricPointRepository.GetDistinctServers(c, projectId, start, end)
if err != nil {
availableServers = []string{}
}
@@ -175,79 +175,79 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
// 5. CPU Usage
span = traceway.StartSpan(c, "loading cpu usage")
- cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, selectedServers)
+ cpuPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
- cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
+ cpuPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 6. Memory Usage (MB)
span = traceway.StartSpan(c, "loading memory usage")
- memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, selectedServers)
+ memPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
- memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
+ memPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("memory_usage", "Memory Usage", "MB", memPerServer, memPrev, "memory"))
// 7. Total System Memory (MB)
span = traceway.StartSpan(c, "loading total memory")
- memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, selectedServers)
+ memTotalPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
- memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
+ memTotalPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
// 8. Go Routines
span = traceway.StartSpan(c, "loading go routines")
- goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, selectedServers)
+ goRoutinesPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
- goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
+ goRoutinesPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 9. Heap Objects
span = traceway.StartSpan(c, "loading heap objects")
- heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, selectedServers)
+ heapObjectsPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
- heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
+ heapObjectsPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
// 10. Num GC
span = traceway.StartSpan(c, "loading gc cycles")
- numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, selectedServers)
+ numGCPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
- numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
+ numGCPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("num_gc", "GC Cycles", "", numGCPerServer, numGCPrev, "num_gc"))
// 11. GC Pause Total (convert from nanoseconds to milliseconds)
span = traceway.StartSpan(c, "loading gc pause")
- gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, selectedServers)
+ gcPausePerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
@@ -259,7 +259,7 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
gcPausePerServer[serverName][i].Value = points[i].Value / 1_000_000
}
}
- gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
+ gcPausePrevRaw, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
span.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
diff --git a/backend/app/controllers/metric_query.controller.go b/backend/app/controllers/metric_query.controller.go
new file mode 100644
index 00000000..05ce5fdc
--- /dev/null
+++ b/backend/app/controllers/metric_query.controller.go
@@ -0,0 +1,220 @@
+package controllers
+
+import (
+ "backend/app/middleware"
+ "backend/app/models"
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "database/sql"
+ "fmt"
+ "net/http"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ traceway "go.tracewayapp.com"
+)
+
+type metricQueryController struct{}
+
+type MetricQueryRequest struct {
+ Queries []MetricQueryItem `json:"queries" binding:"required,min=1"`
+ From time.Time `json:"from" binding:"required"`
+ To time.Time `json:"to" binding:"required"`
+ IntervalMinutes int `json:"intervalMinutes"`
+}
+
+type MetricQueryItem struct {
+ Name string `json:"name" binding:"required"`
+ Aggregation string `json:"aggregation"`
+ TagFilters map[string]string `json:"tagFilters"`
+ GroupBy string `json:"groupBy"`
+}
+
+type MetricQueryResponse struct {
+ Results []MetricQueryResult `json:"results"`
+}
+
+type MetricQueryResult struct {
+ Name string `json:"name"`
+ Series map[string][]models.TimeSeriesPoint `json:"series"`
+}
+
+func (c *metricQueryController) Query(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ var req MetricQueryRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if req.IntervalMinutes <= 0 {
+ req.IntervalMinutes = calculateIntervalMinutes(req.To.Sub(req.From))
+ }
+
+ var results []MetricQueryResult
+ for _, q := range req.Queries {
+ agg := q.Aggregation
+ if agg == "" {
+ agg = "avg"
+ }
+
+ series, err := repositories.MetricPointRepository.QueryTimeSeries(
+ ctx, projectId, q.Name, req.From, req.To,
+ req.IntervalMinutes, agg, q.TagFilters, q.GroupBy,
+ )
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to query metric %s: %w", q.Name, err))
+ return
+ }
+
+ results = append(results, MetricQueryResult{
+ Name: q.Name,
+ Series: series,
+ })
+ }
+
+ ctx.JSON(http.StatusOK, MetricQueryResponse{Results: results})
+}
+
+type DiscoverResponse struct {
+ Metrics []models.DiscoveredMetric `json:"metrics"`
+}
+
+func (c *metricQueryController) Discover(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ from := time.Now().AddDate(0, 0, -7)
+ to := time.Now()
+
+ if fromStr := ctx.Query("from"); fromStr != "" {
+ if parsed, err := time.Parse(time.RFC3339, fromStr); err == nil {
+ from = parsed
+ }
+ }
+ if toStr := ctx.Query("to"); toStr != "" {
+ if parsed, err := time.Parse(time.RFC3339, toStr); err == nil {
+ to = parsed
+ }
+ }
+
+ discovered, err := repositories.MetricPointRepository.DiscoverMetrics(ctx, projectId, from, to)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to discover metrics: %w", err))
+ return
+ }
+
+ registry, regErr := pgdb.ExecuteTransaction(func(tx *sql.Tx) ([]*models.MetricRegistry, error) {
+ return repositories.MetricRegistryRepository.FindByProject(tx, projectId)
+ })
+
+ if regErr != nil {
+ traceway.CaptureException(fmt.Errorf("failed to load metric registry for discover: %w", regErr))
+ }
+ if regErr == nil {
+ regMap := make(map[string]*models.MetricRegistry, len(registry))
+ for _, r := range registry {
+ regMap[r.Name] = r
+ }
+ for i := range discovered {
+ if reg, ok := regMap[discovered[i].Name]; ok {
+ discovered[i].MetricType = reg.MetricType
+ discovered[i].Unit = reg.Unit
+ }
+ }
+ }
+
+ ctx.JSON(http.StatusOK, DiscoverResponse{Metrics: discovered})
+}
+
+func (c *metricQueryController) DiscoverTags(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ name := ctx.Query("name")
+ key := ctx.Query("key")
+ if name == "" || key == "" {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "name and key query params are required"})
+ return
+ }
+
+ from := time.Now().AddDate(0, 0, -7)
+ to := time.Now()
+
+ values, err := repositories.MetricPointRepository.DiscoverTagValues(ctx, projectId, name, key, from, to)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to discover tag values: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"values": values})
+}
+
+func (c *metricQueryController) UpdateRegistry(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ var req struct {
+ Name string `json:"name" binding:"required"`
+ MetricType string `json:"metricType"`
+ Unit string `json:"unit"`
+ Description string `json:"description"`
+ }
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if req.MetricType != "" && req.MetricType != "gauge" && req.MetricType != "counter" {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "metricType must be 'gauge' or 'counter'"})
+ return
+ }
+
+ updated, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (*models.MetricRegistry, error) {
+ entry, err := repositories.MetricRegistryRepository.FindByProjectAndName(tx, projectId, req.Name)
+ if err != nil {
+ return nil, err
+ }
+ if entry == nil {
+ return nil, nil
+ }
+ if req.MetricType != "" {
+ entry.MetricType = req.MetricType
+ }
+ if req.Unit != "" {
+ entry.Unit = req.Unit
+ }
+ entry.Description = req.Description
+ if err := repositories.MetricRegistryRepository.Update(tx, entry); err != nil {
+ return nil, err
+ }
+ return entry, nil
+ })
+
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update metric registry: %w", err))
+ return
+ }
+ if updated == nil {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "metric not found in registry"})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, updated)
+}
+
+var MetricQueryController = metricQueryController{}
diff --git a/backend/app/controllers/metric_record.controller.go b/backend/app/controllers/metric_record.controller.go
index f4e7f643..874e308e 100644
--- a/backend/app/controllers/metric_record.controller.go
+++ b/backend/app/controllers/metric_record.controller.go
@@ -57,13 +57,13 @@ func (e metricRecordController) FindHomepageStats(c *gin.Context) {
// ram usage last 24h vs previous 24h
span = traceway.StartSpan(c, "loading ram usage")
- ramNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, oneDayAgo, now)
+ ramNow, err := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, oneDayAgo, now)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading ramNow: %w", err))
return
}
- ramPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, twoDaysAgo, oneDayAgo)
+ ramPrev, err := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, twoDaysAgo, oneDayAgo)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading ramPrev: %w", err))
@@ -72,13 +72,13 @@ func (e metricRecordController) FindHomepageStats(c *gin.Context) {
// memory usage last 24h vs previous 24h
span = traceway.StartSpan(c, "loading cpu usage")
- cpuNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, oneDayAgo, now)
+ cpuNow, err := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, oneDayAgo, now)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuNow: %w", err))
return
}
- cpuPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, twoDaysAgo, oneDayAgo)
+ cpuPrev, err := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, twoDaysAgo, oneDayAgo)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPrev: %w", err))
diff --git a/backend/app/controllers/metrics.controller.go b/backend/app/controllers/metrics.controller.go
index b8e3d956..bd64cf2e 100644
--- a/backend/app/controllers/metrics.controller.go
+++ b/backend/app/controllers/metrics.controller.go
@@ -51,7 +51,7 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
intervalMinutes := calculateIntervalMinutes(duration)
// Get available servers in the time range
- availableServers, err := repositories.MetricRecordRepository.GetDistinctServers(c, projectId, start, end)
+ availableServers, err := repositories.MetricPointRepository.GetDistinctServers(c, projectId, start, end)
if err != nil {
availableServers = []string{}
}
@@ -63,43 +63,43 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
// 1. Go Routines
span := traceway.StartSpan(c, "loading go routines")
- goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, emptyServers)
+ goRoutinesPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
- goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
+ goRoutinesPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 2. Heap Objects
span = traceway.StartSpan(c, "loading heap objects")
- heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, emptyServers)
+ heapObjectsPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
- heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
+ heapObjectsPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
// 3. GC Cycles (Num GC)
span = traceway.StartSpan(c, "loading gc cycles")
- numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, emptyServers)
+ numGCPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
- numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
+ numGCPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("num_gc", "GC Cycles", "", numGCPerServer, numGCPrev, "num_gc"))
// 4. GC Pause Total (convert from nanoseconds to milliseconds)
span = traceway.StartSpan(c, "loading gc pause")
- gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, emptyServers)
+ gcPausePerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
@@ -111,7 +111,7 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
gcPausePerServer[serverName][i].Value = points[i].Value / 1_000_000
}
}
- gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
+ gcPausePrevRaw, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
span.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
@@ -224,7 +224,7 @@ func (m metricsController) GetServerMetrics(c *gin.Context) {
intervalMinutes := calculateIntervalMinutes(duration)
// Get available servers in the time range
- availableServers, err := repositories.MetricRecordRepository.GetDistinctServers(c, projectId, start, end)
+ availableServers, err := repositories.MetricPointRepository.GetDistinctServers(c, projectId, start, end)
if err != nil {
availableServers = []string{}
}
@@ -236,37 +236,37 @@ func (m metricsController) GetServerMetrics(c *gin.Context) {
// 1. CPU Usage
span := traceway.StartSpan(c, "loading cpu usage")
- cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, emptyServers)
+ cpuPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
- cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
+ cpuPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 2. Memory Usage (MB)
span = traceway.StartSpan(c, "loading memory usage")
- memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, emptyServers)
+ memPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
- memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
+ memPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("memory_usage", "Memory Usage", "MB", memPerServer, memPrev, "memory"))
// 3. Total System Memory (MB)
span = traceway.StartSpan(c, "loading total memory")
- memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, emptyServers)
+ memTotalPerServer, err := repositories.MetricPointRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
- memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
+ memTotalPrev, _ := repositories.MetricPointRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
span.End()
metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
diff --git a/backend/app/controllers/otelcontrollers/metric_converter.go b/backend/app/controllers/otelcontrollers/metric_converter.go
index 139ca863..c81c9adc 100644
--- a/backend/app/controllers/otelcontrollers/metric_converter.go
+++ b/backend/app/controllers/otelcontrollers/metric_converter.go
@@ -8,15 +8,12 @@ import (
metricspb "go.opentelemetry.io/proto/otlp/metrics/v1"
)
-func convertMetrics(projectId uuid.UUID, req *colmetricspb.ExportMetricsServiceRequest, serverName string) []models.MetricRecord {
- var records []models.MetricRecord
+func convertMetricPoints(projectId uuid.UUID, req *colmetricspb.ExportMetricsServiceRequest) []models.MetricPoint {
+ var points []models.MetricPoint
for _, rm := range req.ResourceMetrics {
resAttrs := rm.GetResource().GetAttributes()
sn := getStringAttribute(resAttrs, "service.name")
- if sn == "" {
- sn = serverName
- }
for _, sm := range rm.ScopeMetrics {
for _, metric := range sm.Metrics {
@@ -24,37 +21,41 @@ func convertMetrics(projectId uuid.UUID, req *colmetricspb.ExportMetricsServiceR
switch data := metric.Data.(type) {
case *metricspb.Metric_Gauge:
- records = appendNumberDataPoints(records, projectId, name, sn, data.Gauge.GetDataPoints())
+ points = appendNumberDataPoints(points, projectId, name, sn, data.Gauge.GetDataPoints())
case *metricspb.Metric_Sum:
- records = appendNumberDataPoints(records, projectId, name, sn, data.Sum.GetDataPoints())
+ points = appendNumberDataPoints(points, projectId, name, sn, data.Sum.GetDataPoints())
case *metricspb.Metric_Histogram:
for _, dp := range data.Histogram.GetDataPoints() {
ts := nanoToTime(dp.TimeUnixNano)
+ tags := make(map[string]string)
+ if sn != "" {
+ tags["server_name"] = sn
+ }
if dp.Count > 0 && dp.Sum != nil {
- records = append(records, models.MetricRecord{
+ points = append(points, models.MetricPoint{
ProjectId: projectId,
Name: name + ".avg",
Value: *dp.Sum / float64(dp.Count),
+ Tags: tags,
RecordedAt: ts,
- ServerName: sn,
})
}
- records = append(records, models.MetricRecord{
+ points = append(points, models.MetricPoint{
ProjectId: projectId,
Name: name + ".count",
Value: float64(dp.Count),
+ Tags: tags,
RecordedAt: ts,
- ServerName: sn,
})
}
}
}
}
}
- return records
+ return points
}
-func appendNumberDataPoints(records []models.MetricRecord, projectId uuid.UUID, name, serverName string, dps []*metricspb.NumberDataPoint) []models.MetricRecord {
+func appendNumberDataPoints(points []models.MetricPoint, projectId uuid.UUID, name, serverName string, dps []*metricspb.NumberDataPoint) []models.MetricPoint {
for _, dp := range dps {
var value float64
switch v := dp.Value.(type) {
@@ -63,13 +64,17 @@ func appendNumberDataPoints(records []models.MetricRecord, projectId uuid.UUID,
case *metricspb.NumberDataPoint_AsInt:
value = float64(v.AsInt)
}
- records = append(records, models.MetricRecord{
+ tags := make(map[string]string)
+ if serverName != "" {
+ tags["server_name"] = serverName
+ }
+ points = append(points, models.MetricPoint{
ProjectId: projectId,
Name: name,
Value: value,
+ Tags: tags,
RecordedAt: nanoToTime(dp.TimeUnixNano),
- ServerName: serverName,
})
}
- return records
+ return points
}
diff --git a/backend/app/controllers/otelcontrollers/otel.controller.go b/backend/app/controllers/otelcontrollers/otel.controller.go
index fca5d474..65cb48a3 100644
--- a/backend/app/controllers/otelcontrollers/otel.controller.go
+++ b/backend/app/controllers/otelcontrollers/otel.controller.go
@@ -99,11 +99,12 @@ func (o otelController) ExportMetrics(c *gin.Context) {
return
}
- records := convertMetrics(projectId, req, "")
-
- if err := repositories.MetricRecordRepository.InsertAsync(c, records); err != nil {
- c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting OTEL metrics: %w", err))
- return
+ points := convertMetricPoints(projectId, req)
+ if len(points) > 0 {
+ if err := repositories.MetricPointRepository.InsertAsync(c, points); err != nil {
+ c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting OTEL metric points: %w", err))
+ return
+ }
}
writeMetricsResponse(c)
diff --git a/backend/app/controllers/routes.go b/backend/app/controllers/routes.go
index 0b571b47..5781d34f 100644
--- a/backend/app/controllers/routes.go
+++ b/backend/app/controllers/routes.go
@@ -51,6 +51,25 @@ func RegisterControllers(router *gin.RouterGroup) {
router.GET("/metrics/stats", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricsController.GetStatsMetrics)
router.GET("/metrics/server", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricsController.GetServerMetrics)
+ // New metrics query API
+ router.POST("/metrics/query", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricQueryController.Query)
+ router.GET("/metrics/discover", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricQueryController.Discover)
+ router.GET("/metrics/discover/tags", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricQueryController.DiscoverTags)
+ router.PUT("/metrics/registry", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, MetricQueryController.UpdateRegistry)
+
+ // Widget groups
+ router.GET("/widget-groups", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.Transactional, WidgetGroupController.List)
+ router.POST("/widget-groups", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetGroupController.Create)
+ router.GET("/widget-groups/:id", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.Transactional, WidgetGroupController.GetWithWidgets)
+ router.PUT("/widget-groups/:id", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetGroupController.Update)
+ router.DELETE("/widget-groups/:id", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetGroupController.Delete)
+
+ // Widgets (within widget groups)
+ router.POST("/widget-groups/:id/widgets", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetController.Add)
+ router.PUT("/widget-groups/:id/widgets/:wid", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetController.Update)
+ router.PUT("/widget-groups/:id/widgets/:wid/move", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetController.Move)
+ router.DELETE("/widget-groups/:id/widgets/:wid", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, middleware.Transactional, WidgetController.Delete)
+
// Endpoints (projectId in body)
router.POST("/endpoints", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.FindAllEndpoints)
router.POST("/endpoints/grouped", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.FindGroupedByEndpoint)
diff --git a/backend/app/controllers/widget.controller.go b/backend/app/controllers/widget.controller.go
new file mode 100644
index 00000000..13beab99
--- /dev/null
+++ b/backend/app/controllers/widget.controller.go
@@ -0,0 +1,338 @@
+package controllers
+
+import (
+ "backend/app/middleware"
+ "backend/app/models"
+ "backend/app/repositories"
+ "encoding/json"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ traceway "go.tracewayapp.com"
+)
+
+type widgetController struct{}
+
+type AddWidgetRequest struct {
+ Title string `json:"title"`
+ WidgetType string `json:"widgetType" binding:"required"`
+ Config json.RawMessage `json:"config"`
+}
+
+func (c *widgetController) Add(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ idStr := ctx.Param("id")
+ groupId, err := strconv.Atoi(idStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ var req AddWidgetRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if req.Config == nil {
+ req.Config = json.RawMessage(`{}`)
+ }
+ if msg := validateWidgetConfig(req.Config); msg != "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": msg})
+ return
+ }
+
+ req.Title = strings.TrimSpace(req.Title)
+ if req.Title == "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Title is required."})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ group, err := repositories.WidgetGroupRepository.FindById(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to add widget: %w", err))
+ return
+ }
+ if group == nil || group.ProjectId != projectId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget group not found"})
+ return
+ }
+
+ existing, err := repositories.WidgetGroupRepository.FindWidgetsByGroup(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to add widget: %w", err))
+ return
+ }
+
+ w := &models.WidgetGroupWidget{
+ WidgetGroupId: groupId,
+ Title: req.Title,
+ WidgetType: req.WidgetType,
+ Config: req.Config,
+ Position: len(existing),
+ CreatedAt: time.Now().UTC(),
+ UpdatedAt: time.Now().UTC(),
+ }
+ id, err := repositories.WidgetGroupRepository.CreateWidget(tx, w)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to add widget: %w", err))
+ return
+ }
+ w.Id = id
+
+ ctx.JSON(http.StatusCreated, w)
+}
+
+func (c *widgetController) Update(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ groupIdStr := ctx.Param("id")
+ groupId, err := strconv.Atoi(groupIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ widgetIdStr := ctx.Param("wid")
+ widgetId, err := strconv.Atoi(widgetIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget id"})
+ return
+ }
+
+ var req AddWidgetRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if req.Config != nil {
+ if msg := validateWidgetConfig(req.Config); msg != "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": msg})
+ return
+ }
+ }
+
+ req.Title = strings.TrimSpace(req.Title)
+ if req.Title == "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Title is required."})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ group, err := repositories.WidgetGroupRepository.FindById(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update widget: %w", err))
+ return
+ }
+ if group == nil || group.ProjectId != projectId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget group not found"})
+ return
+ }
+
+ widget, err := repositories.WidgetGroupRepository.FindWidgetById(tx, widgetId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update widget: %w", err))
+ return
+ }
+ if widget == nil || widget.WidgetGroupId != groupId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget not found"})
+ return
+ }
+
+ widget.Title = req.Title
+ widget.WidgetType = req.WidgetType
+ if req.Config != nil {
+ widget.Config = req.Config
+ }
+ widget.UpdatedAt = time.Now().UTC()
+
+ if err := repositories.WidgetGroupRepository.UpdateWidget(tx, widget); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update widget: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, widget)
+}
+
+type MoveWidgetRequest struct {
+ Offset int `json:"offset" binding:"required"`
+}
+
+func (c *widgetController) Move(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ groupIdStr := ctx.Param("id")
+ groupId, err := strconv.Atoi(groupIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ widgetIdStr := ctx.Param("wid")
+ widgetId, err := strconv.Atoi(widgetIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget id"})
+ return
+ }
+
+ var req MoveWidgetRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ group, err := repositories.WidgetGroupRepository.FindById(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to move widget: %w", err))
+ return
+ }
+ if group == nil || group.ProjectId != projectId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget group not found"})
+ return
+ }
+
+ allWidgets, err := repositories.WidgetGroupRepository.FindWidgetsByGroup(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to move widget: %w", err))
+ return
+ }
+
+ sort.Slice(allWidgets, func(i, j int) bool {
+ return allWidgets[i].Position < allWidgets[j].Position
+ })
+
+ currentIndex := -1
+ for i, w := range allWidgets {
+ if w.Id == widgetId {
+ currentIndex = i
+ break
+ }
+ }
+ if currentIndex == -1 {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget not found"})
+ return
+ }
+
+ targetIndex := currentIndex + req.Offset
+ if targetIndex < 0 || targetIndex >= len(allWidgets) {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "cannot move beyond boundary"})
+ return
+ }
+
+ widget := allWidgets[currentIndex]
+ targetWidget := allWidgets[targetIndex]
+
+ now := time.Now().UTC()
+ widget.Position, targetWidget.Position = targetWidget.Position, widget.Position
+ widget.UpdatedAt = now
+ targetWidget.UpdatedAt = now
+
+ if err := repositories.WidgetGroupRepository.UpdateWidget(tx, targetWidget); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to move widget: %w", err))
+ return
+ }
+ if err := repositories.WidgetGroupRepository.UpdateWidget(tx, widget); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to move widget: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"moved": true})
+}
+
+func (c *widgetController) Delete(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ groupIdStr := ctx.Param("id")
+ groupId, err := strconv.Atoi(groupIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ widgetIdStr := ctx.Param("wid")
+ widgetId, err := strconv.Atoi(widgetIdStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget id"})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ group, err := repositories.WidgetGroupRepository.FindById(tx, groupId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to delete widget: %w", err))
+ return
+ }
+ if group == nil || group.ProjectId != projectId {
+ ctx.JSON(http.StatusOK, gin.H{"deleted": true})
+ return
+ }
+
+ widget, err := repositories.WidgetGroupRepository.FindWidgetById(tx, widgetId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to delete widget: %w", err))
+ return
+ }
+ if widget == nil || widget.WidgetGroupId != groupId {
+ ctx.JSON(http.StatusOK, gin.H{"deleted": true})
+ return
+ }
+
+ if err := repositories.WidgetGroupRepository.DeleteWidget(tx, widgetId); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to delete widget: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"deleted": true})
+}
+
+func validateWidgetConfig(raw json.RawMessage) string {
+ var cfg struct {
+ Sources []struct {
+ Name string `json:"name"`
+ } `json:"sources"`
+ }
+ if err := json.Unmarshal(raw, &cfg); err != nil {
+ return "Invalid widget configuration."
+ }
+ hasMetric := false
+ for _, s := range cfg.Sources {
+ if strings.TrimSpace(s.Name) != "" {
+ hasMetric = true
+ break
+ }
+ }
+ if !hasMetric {
+ return "Please select a Metric."
+ }
+ return ""
+}
+
+var WidgetController = widgetController{}
diff --git a/backend/app/controllers/widget_group.controller.go b/backend/app/controllers/widget_group.controller.go
new file mode 100644
index 00000000..f021432e
--- /dev/null
+++ b/backend/app/controllers/widget_group.controller.go
@@ -0,0 +1,352 @@
+package controllers
+
+import (
+ "backend/app/middleware"
+ "backend/app/models"
+ "backend/app/repositories"
+ "database/sql"
+ "encoding/json"
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ "github.com/google/uuid"
+ traceway "go.tracewayapp.com"
+)
+
+type widgetGroupController struct{}
+
+func (c *widgetGroupController) List(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ list, err := repositories.WidgetGroupRepository.FindByProject(tx, projectId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to list widget groups: %w", err))
+ return
+ }
+ if len(list) == 0 {
+ if err := ensureDefaultWidgetGroups(tx, projectId); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to create default widget groups: %w", err))
+ return
+ }
+ list, err = repositories.WidgetGroupRepository.FindByProject(tx, projectId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to list widget groups: %w", err))
+ return
+ }
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"widgetGroups": list})
+}
+
+type CreateWidgetGroupRequest struct {
+ Name string `json:"name"`
+ Description string `json:"description"`
+}
+
+func (c *widgetGroupController) Create(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ var req CreateWidgetGroupRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ req.Name = strings.TrimSpace(req.Name)
+ if req.Name == "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Name is required."})
+ return
+ }
+ if len(req.Name) > 12 {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Name must be 12 characters or fewer."})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ existing, err := repositories.WidgetGroupRepository.FindByProject(tx, projectId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to check duplicate widget group name: %w", err))
+ return
+ }
+ for _, g := range existing {
+ if strings.EqualFold(g.Name, req.Name) {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "A group with this name already exists."})
+ return
+ }
+ }
+
+ userId := middleware.GetUserId(ctx)
+ var createdBy *int
+ if userId > 0 {
+ createdBy = &userId
+ }
+
+ g := &models.WidgetGroup{
+ ProjectId: projectId,
+ Name: req.Name,
+ Description: req.Description,
+ IsDefault: false,
+ CreatedBy: createdBy,
+ CreatedAt: time.Now().UTC(),
+ UpdatedAt: time.Now().UTC(),
+ }
+ id, err := repositories.WidgetGroupRepository.Create(tx, g)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to create widget group: %w", err))
+ return
+ }
+ g.Id = id
+
+ ctx.JSON(http.StatusCreated, g)
+}
+
+func (c *widgetGroupController) GetWithWidgets(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ idStr := ctx.Param("id")
+ id, err := strconv.Atoi(idStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ group, err := repositories.WidgetGroupRepository.FindById(tx, id)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to get widget group: %w", err))
+ return
+ }
+ if group == nil || group.ProjectId != projectId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget group not found"})
+ return
+ }
+
+ widgets, err := repositories.WidgetGroupRepository.FindWidgetsByGroup(tx, id)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to get widget group widgets: %w", err))
+ return
+ }
+
+ widgetSlice := []models.WidgetGroupWidget{}
+ for _, w := range widgets {
+ widgetSlice = append(widgetSlice, *w)
+ }
+
+ ctx.JSON(http.StatusOK, &models.WidgetGroupWithWidgets{
+ WidgetGroup: *group,
+ Widgets: widgetSlice,
+ })
+}
+
+func (c *widgetGroupController) Update(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ idStr := ctx.Param("id")
+ id, err := strconv.Atoi(idStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ var req CreateWidgetGroupRequest
+ if err := ctx.ShouldBindJSON(&req); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ req.Name = strings.TrimSpace(req.Name)
+ if req.Name == "" {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Name is required."})
+ return
+ }
+ if len(req.Name) > 12 {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Name must be 12 characters or fewer."})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ existing, err := repositories.WidgetGroupRepository.FindById(tx, id)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update widget group: %w", err))
+ return
+ }
+ if existing == nil || existing.ProjectId != projectId {
+ ctx.JSON(http.StatusNotFound, gin.H{"error": "widget group not found"})
+ return
+ }
+
+ allGroups, err := repositories.WidgetGroupRepository.FindByProject(tx, projectId)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to check duplicate widget group name: %w", err))
+ return
+ }
+ for _, g := range allGroups {
+ if g.Id != id && strings.EqualFold(g.Name, req.Name) {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "A group with this name already exists."})
+ return
+ }
+ }
+
+ existing.Name = req.Name
+ existing.Description = req.Description
+ existing.UpdatedAt = time.Now().UTC()
+
+ if err := repositories.WidgetGroupRepository.Update(tx, existing); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to update widget group: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, existing)
+}
+
+func (c *widgetGroupController) Delete(ctx *gin.Context) {
+ projectId, err := middleware.GetProjectId(ctx)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ idStr := ctx.Param("id")
+ id, err := strconv.Atoi(idStr)
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid widget group id"})
+ return
+ }
+
+ tx := middleware.GetTx(ctx)
+
+ existing, err := repositories.WidgetGroupRepository.FindById(tx, id)
+ if err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to delete widget group: %w", err))
+ return
+ }
+ if existing == nil || existing.ProjectId != projectId {
+ ctx.JSON(http.StatusOK, gin.H{"deleted": true})
+ return
+ }
+
+ if existing.IsDefault {
+ ctx.JSON(http.StatusUnprocessableEntity, gin.H{"error": "Default groups cannot be deleted."})
+ return
+ }
+
+ if err := repositories.WidgetGroupRepository.Delete(tx, id); err != nil {
+ ctx.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to delete widget group: %w", err))
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"deleted": true})
+}
+
+func ensureDefaultWidgetGroups(tx *sql.Tx, projectId uuid.UUID) error {
+ project, err := repositories.ProjectRepository.FindById(tx, projectId)
+ if err != nil {
+ return err
+ }
+
+ jsFrameworks := map[string]bool{
+ "react": true, "svelte": true, "vuejs": true,
+ "nextjs": true, "nestjs": true, "express": true, "remix": true,
+ }
+ isJS := project != nil && jsFrameworks[project.Framework]
+
+ type widgetDef struct {
+ title string
+ name string
+ }
+ type groupDef struct {
+ name string
+ widgets []widgetDef
+ }
+
+ var groupDefs []groupDef
+
+ if !isJS {
+ groupDefs = append(groupDefs, groupDef{
+ name: "Application",
+ widgets: []widgetDef{
+ {"Go Routines", "go.go_routines"},
+ {"Heap Objects", "go.heap_objects"},
+ {"GC Cycles", "go.num_gc"},
+ {"GC Pause", "go.gc_pause"},
+ },
+ })
+ }
+
+ groupDefs = append(groupDefs,
+ groupDef{
+ name: "Stats",
+ widgets: []widgetDef{
+ {"Memory Usage", "mem.used"},
+ {"Memory Used %", "mem.used_pcnt"},
+ {"Total Memory", "mem.total"},
+ },
+ },
+ groupDef{
+ name: "CPU / Mem",
+ widgets: []widgetDef{
+ {"CPU Usage", "cpu.used_pcnt"},
+ {"Memory Usage", "mem.used"},
+ },
+ },
+ )
+
+ now := time.Now().UTC()
+ for _, gd := range groupDefs {
+ g := &models.WidgetGroup{
+ ProjectId: projectId,
+ Name: gd.name,
+ IsDefault: true,
+ CreatedAt: now,
+ UpdatedAt: now,
+ }
+ groupId, err := repositories.WidgetGroupRepository.Create(tx, g)
+ if err != nil {
+ return err
+ }
+
+ for i, w := range gd.widgets {
+ config := json.RawMessage(`{"sources":[{"type":"metric","name":"` + w.name + `","aggregation":"avg"}]}`)
+ widget := &models.WidgetGroupWidget{
+ WidgetGroupId: groupId,
+ Title: w.title,
+ WidgetType: "line_chart",
+ Config: config,
+ Position: i,
+ CreatedAt: now,
+ UpdatedAt: now,
+ }
+ if _, err := repositories.WidgetGroupRepository.CreateWidget(tx, widget); err != nil {
+ return err
+ }
+ }
+ }
+
+ return nil
+}
+
+var WidgetGroupController = widgetGroupController{}
diff --git a/backend/app/migrations/ch/0027_create_metric_points.up.sql b/backend/app/migrations/ch/0027_create_metric_points.up.sql
new file mode 100644
index 00000000..4436a486
--- /dev/null
+++ b/backend/app/migrations/ch/0027_create_metric_points.up.sql
@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS metric_points (
+ `project_id` UUID,
+ `name` LowCardinality(String),
+ `value` Float64,
+ `tags` Map(LowCardinality(String), String),
+ `recorded_at` DateTime64(3),
+ INDEX idx_tags_keys mapKeys(tags) TYPE bloom_filter(0.01) GRANULARITY 4,
+ INDEX idx_tags_values mapValues(tags) TYPE bloom_filter(0.01) GRANULARITY 4
+) ENGINE = MergeTree
+PARTITION BY toYYYYMMDD(recorded_at)
+ORDER BY (project_id, name, recorded_at)
+SETTINGS index_granularity = 8192
diff --git a/backend/app/migrations/ch/0028_create_metric_points_1m.up.sql b/backend/app/migrations/ch/0028_create_metric_points_1m.up.sql
new file mode 100644
index 00000000..b806ef5e
--- /dev/null
+++ b/backend/app/migrations/ch/0028_create_metric_points_1m.up.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS metric_points_1m (
+ `project_id` UUID,
+ `name` LowCardinality(String),
+ `tags` Map(LowCardinality(String), String),
+ `recorded_at` DateTime64(3),
+ `min_val` AggregateFunction(min, Float64),
+ `max_val` AggregateFunction(max, Float64),
+ `sum_val` AggregateFunction(sum, Float64),
+ `count_val` AggregateFunction(count)
+) ENGINE = AggregatingMergeTree
+PARTITION BY toYYYYMMDD(recorded_at)
+ORDER BY (project_id, name, recorded_at, tags)
+SETTINGS index_granularity = 8192
diff --git a/backend/app/migrations/ch/0029_create_metric_points_1m_mv.up.sql b/backend/app/migrations/ch/0029_create_metric_points_1m_mv.up.sql
new file mode 100644
index 00000000..1a7ccc6c
--- /dev/null
+++ b/backend/app/migrations/ch/0029_create_metric_points_1m_mv.up.sql
@@ -0,0 +1,12 @@
+CREATE MATERIALIZED VIEW IF NOT EXISTS metric_points_1m_mv TO metric_points_1m AS
+SELECT
+ project_id,
+ name,
+ tags,
+ toStartOfMinute(recorded_at) AS recorded_at,
+ minState(value) AS min_val,
+ maxState(value) AS max_val,
+ sumState(value) AS sum_val,
+ countState() AS count_val
+FROM metric_points
+GROUP BY project_id, name, tags, recorded_at
diff --git a/backend/app/migrations/ch/0030_create_metric_points_1h.up.sql b/backend/app/migrations/ch/0030_create_metric_points_1h.up.sql
new file mode 100644
index 00000000..ed686931
--- /dev/null
+++ b/backend/app/migrations/ch/0030_create_metric_points_1h.up.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS metric_points_1h (
+ `project_id` UUID,
+ `name` LowCardinality(String),
+ `tags` Map(LowCardinality(String), String),
+ `recorded_at` DateTime64(3),
+ `min_val` AggregateFunction(min, Float64),
+ `max_val` AggregateFunction(max, Float64),
+ `sum_val` AggregateFunction(sum, Float64),
+ `count_val` AggregateFunction(count)
+) ENGINE = AggregatingMergeTree
+PARTITION BY toYYYYMM(recorded_at)
+ORDER BY (project_id, name, recorded_at, tags)
+SETTINGS index_granularity = 8192
diff --git a/backend/app/migrations/ch/0031_create_metric_points_1h_mv.up.sql b/backend/app/migrations/ch/0031_create_metric_points_1h_mv.up.sql
new file mode 100644
index 00000000..449637ee
--- /dev/null
+++ b/backend/app/migrations/ch/0031_create_metric_points_1h_mv.up.sql
@@ -0,0 +1,12 @@
+CREATE MATERIALIZED VIEW IF NOT EXISTS metric_points_1h_mv TO metric_points_1h AS
+SELECT
+ project_id,
+ name,
+ tags,
+ toStartOfHour(recorded_at) AS recorded_at,
+ minState(value) AS min_val,
+ maxState(value) AS max_val,
+ sumState(value) AS sum_val,
+ countState() AS count_val
+FROM metric_points
+GROUP BY project_id, name, tags, recorded_at
diff --git a/backend/app/migrations/ch/0032_create_metric_points_1d.up.sql b/backend/app/migrations/ch/0032_create_metric_points_1d.up.sql
new file mode 100644
index 00000000..874e8b42
--- /dev/null
+++ b/backend/app/migrations/ch/0032_create_metric_points_1d.up.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS metric_points_1d (
+ `project_id` UUID,
+ `name` LowCardinality(String),
+ `tags` Map(LowCardinality(String), String),
+ `recorded_at` DateTime64(3),
+ `min_val` AggregateFunction(min, Float64),
+ `max_val` AggregateFunction(max, Float64),
+ `sum_val` AggregateFunction(sum, Float64),
+ `count_val` AggregateFunction(count)
+) ENGINE = AggregatingMergeTree
+PARTITION BY toYYYYMM(recorded_at)
+ORDER BY (project_id, name, recorded_at, tags)
+SETTINGS index_granularity = 8192
diff --git a/backend/app/migrations/ch/0033_create_metric_points_1d_mv.up.sql b/backend/app/migrations/ch/0033_create_metric_points_1d_mv.up.sql
new file mode 100644
index 00000000..32a6ac38
--- /dev/null
+++ b/backend/app/migrations/ch/0033_create_metric_points_1d_mv.up.sql
@@ -0,0 +1,12 @@
+CREATE MATERIALIZED VIEW IF NOT EXISTS metric_points_1d_mv TO metric_points_1d AS
+SELECT
+ project_id,
+ name,
+ tags,
+ toStartOfDay(recorded_at) AS recorded_at,
+ minState(value) AS min_val,
+ maxState(value) AS max_val,
+ sumState(value) AS sum_val,
+ countState() AS count_val
+FROM metric_points
+GROUP BY project_id, name, tags, recorded_at
diff --git a/backend/app/migrations/ch/0034_add_ttl_metric_points.up.sql b/backend/app/migrations/ch/0034_add_ttl_metric_points.up.sql
new file mode 100644
index 00000000..7c178c0e
--- /dev/null
+++ b/backend/app/migrations/ch/0034_add_ttl_metric_points.up.sql
@@ -0,0 +1 @@
+ALTER TABLE metric_points MODIFY TTL toDateTime(recorded_at) + INTERVAL 7 DAY
diff --git a/backend/app/migrations/ch/0035_add_ttl_metric_points_1m.up.sql b/backend/app/migrations/ch/0035_add_ttl_metric_points_1m.up.sql
new file mode 100644
index 00000000..c31fae85
--- /dev/null
+++ b/backend/app/migrations/ch/0035_add_ttl_metric_points_1m.up.sql
@@ -0,0 +1 @@
+ALTER TABLE metric_points_1m MODIFY TTL toDateTime(recorded_at) + INTERVAL 30 DAY
diff --git a/backend/app/migrations/ch/0036_add_ttl_metric_points_1h.up.sql b/backend/app/migrations/ch/0036_add_ttl_metric_points_1h.up.sql
new file mode 100644
index 00000000..1e2f4821
--- /dev/null
+++ b/backend/app/migrations/ch/0036_add_ttl_metric_points_1h.up.sql
@@ -0,0 +1 @@
+ALTER TABLE metric_points_1h MODIFY TTL toDateTime(recorded_at) + INTERVAL 1 YEAR
diff --git a/backend/app/migrations/pg/0016_create_metric_registry.up.sql b/backend/app/migrations/pg/0016_create_metric_registry.up.sql
new file mode 100644
index 00000000..8bdb0e48
--- /dev/null
+++ b/backend/app/migrations/pg/0016_create_metric_registry.up.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS metric_registry (
+ id SERIAL PRIMARY KEY,
+ project_id UUID NOT NULL REFERENCES projects(id),
+ name VARCHAR(300) NOT NULL,
+ metric_type VARCHAR(20) NOT NULL DEFAULT 'gauge',
+ unit VARCHAR(50) DEFAULT '',
+ description TEXT DEFAULT '',
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ UNIQUE(project_id, name)
+);
diff --git a/backend/app/migrations/pg/0017_create_metrics_tabs.up.sql b/backend/app/migrations/pg/0017_create_metrics_tabs.up.sql
new file mode 100644
index 00000000..39365297
--- /dev/null
+++ b/backend/app/migrations/pg/0017_create_metrics_tabs.up.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS widget_groups (
+ id SERIAL PRIMARY KEY,
+ project_id UUID NOT NULL REFERENCES projects(id),
+ name VARCHAR(200) NOT NULL,
+ description TEXT DEFAULT '',
+ is_default BOOLEAN NOT NULL DEFAULT false,
+ created_by INTEGER REFERENCES users(id),
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
diff --git a/backend/app/migrations/pg/0018_create_metrics_tabs_project_idx.up.sql b/backend/app/migrations/pg/0018_create_metrics_tabs_project_idx.up.sql
new file mode 100644
index 00000000..1d281775
--- /dev/null
+++ b/backend/app/migrations/pg/0018_create_metrics_tabs_project_idx.up.sql
@@ -0,0 +1 @@
+CREATE INDEX IF NOT EXISTS idx_widget_groups_project_id ON widget_groups(project_id);
diff --git a/backend/app/migrations/pg/0019_create_metrics_tab_widgets.up.sql b/backend/app/migrations/pg/0019_create_metrics_tab_widgets.up.sql
new file mode 100644
index 00000000..8da60dde
--- /dev/null
+++ b/backend/app/migrations/pg/0019_create_metrics_tab_widgets.up.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS widget_group_widgets (
+ id SERIAL PRIMARY KEY,
+ widget_group_id INTEGER NOT NULL REFERENCES widget_groups(id) ON DELETE CASCADE,
+ title VARCHAR(200) NOT NULL,
+ widget_type VARCHAR(50) NOT NULL,
+ config JSONB NOT NULL DEFAULT '{}',
+ position INTEGER NOT NULL DEFAULT 0,
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
diff --git a/backend/app/migrations/pg/0020_create_metrics_tab_widgets_dashboard_idx.up.sql b/backend/app/migrations/pg/0020_create_metrics_tab_widgets_dashboard_idx.up.sql
new file mode 100644
index 00000000..b8234189
--- /dev/null
+++ b/backend/app/migrations/pg/0020_create_metrics_tab_widgets_dashboard_idx.up.sql
@@ -0,0 +1 @@
+CREATE INDEX IF NOT EXISTS idx_widget_group_widgets_widget_group_id ON widget_group_widgets(widget_group_id);
diff --git a/backend/app/models/clientmodels/clientmodels.model.go b/backend/app/models/clientmodels/clientmodels.model.go
index aaf575be..d3d5f882 100644
--- a/backend/app/models/clientmodels/clientmodels.model.go
+++ b/backend/app/models/clientmodels/clientmodels.model.go
@@ -45,17 +45,25 @@ func (c *ClientExceptionStackTrace) ToExceptionStackTrace(exceptionHash, appVers
}
type ClientMetricRecord struct {
- Name string `json:"name"`
- Value float64 `json:"value"`
- RecordedAt time.Time `json:"recordedAt"`
+ Name string `json:"name"`
+ Value float64 `json:"value"`
+ RecordedAt time.Time `json:"recordedAt"`
+ Tags map[string]string `json:"tags,omitempty"`
}
-func (c *ClientMetricRecord) ToMetricRecord(serverName string) models.MetricRecord {
- return models.MetricRecord{
+func (c *ClientMetricRecord) ToMetricPoint(serverName string) models.MetricPoint {
+ tags := make(map[string]string, len(c.Tags)+1)
+ for k, v := range c.Tags {
+ tags[k] = v
+ }
+ if serverName != "" {
+ tags["server_name"] = serverName
+ }
+ return models.MetricPoint{
Name: c.Name,
Value: c.Value,
+ Tags: tags,
RecordedAt: c.RecordedAt,
- ServerName: serverName,
}
}
diff --git a/backend/app/models/metric_record.model.go b/backend/app/models/metric_record.model.go
index 7e8ca87e..2930b39f 100644
--- a/backend/app/models/metric_record.model.go
+++ b/backend/app/models/metric_record.model.go
@@ -6,12 +6,19 @@ import (
"github.com/google/uuid"
)
-type MetricRecord struct {
- ProjectId uuid.UUID `json:"projectId" ch:"project_id"`
- Name string `json:"name" ch:"name"`
- Value float64 `json:"value" ch:"value"`
- RecordedAt time.Time `json:"recordedAt" ch:"recorded_at"`
- ServerName string `json:"serverName" ch:"server_name"`
+type MetricPoint struct {
+ ProjectId uuid.UUID `json:"projectId" ch:"project_id"`
+ Name string `json:"name" ch:"name"`
+ Value float64 `json:"value" ch:"value"`
+ Tags map[string]string `json:"tags" ch:"tags"`
+ RecordedAt time.Time `json:"recordedAt" ch:"recorded_at"`
+}
+
+type DiscoveredMetric struct {
+ Name string `json:"name"`
+ TagKeys []string `json:"tagKeys"`
+ MetricType string `json:"metricType,omitempty"`
+ Unit string `json:"unit,omitempty"`
}
const (
diff --git a/backend/app/models/metric_registry.model.go b/backend/app/models/metric_registry.model.go
new file mode 100644
index 00000000..3112839d
--- /dev/null
+++ b/backend/app/models/metric_registry.model.go
@@ -0,0 +1,17 @@
+package models
+
+import (
+ "time"
+
+ "github.com/google/uuid"
+)
+
+type MetricRegistry struct {
+ Id int `json:"id" lit:"id"`
+ ProjectId uuid.UUID `json:"projectId" lit:"project_id"`
+ Name string `json:"name" lit:"name"`
+ MetricType string `json:"metricType" lit:"metric_type"`
+ Unit string `json:"unit" lit:"unit"`
+ Description string `json:"description" lit:"description"`
+ CreatedAt time.Time `json:"createdAt" lit:"created_at"`
+}
diff --git a/backend/app/models/models.go b/backend/app/models/models.go
index 002893e0..2fee2710 100644
--- a/backend/app/models/models.go
+++ b/backend/app/models/models.go
@@ -17,6 +17,9 @@ func Init() {
lit.RegisterModel[UserOrganizationResponse](lit.PostgreSQL)
lit.RegisterModel[CountResult](lit.PostgreSQL)
lit.RegisterModel[SourceMap](lit.PostgreSQL)
+ lit.RegisterModel[MetricRegistry](lit.PostgreSQL)
+ lit.RegisterModel[WidgetGroup](lit.PostgreSQL)
+ lit.RegisterModel[WidgetGroupWidget](lit.PostgreSQL)
for _, register := range ExtensionModelRegistrations {
register()
diff --git a/backend/app/models/widget_group.model.go b/backend/app/models/widget_group.model.go
new file mode 100644
index 00000000..29805626
--- /dev/null
+++ b/backend/app/models/widget_group.model.go
@@ -0,0 +1,35 @@
+package models
+
+import (
+ "encoding/json"
+ "time"
+
+ "github.com/google/uuid"
+)
+
+type WidgetGroup struct {
+ Id int `json:"id" lit:"id"`
+ ProjectId uuid.UUID `json:"projectId" lit:"project_id"`
+ Name string `json:"name" lit:"name"`
+ Description string `json:"description" lit:"description"`
+ IsDefault bool `json:"isDefault" lit:"is_default"`
+ CreatedBy *int `json:"createdBy" lit:"created_by"`
+ CreatedAt time.Time `json:"createdAt" lit:"created_at"`
+ UpdatedAt time.Time `json:"updatedAt" lit:"updated_at"`
+}
+
+type WidgetGroupWidget struct {
+ Id int `json:"id" lit:"id"`
+ WidgetGroupId int `json:"widgetGroupId" lit:"widget_group_id"`
+ Title string `json:"title" lit:"title"`
+ WidgetType string `json:"widgetType" lit:"widget_type"`
+ Config json.RawMessage `json:"config" lit:"config"`
+ Position int `json:"position" lit:"position"`
+ CreatedAt time.Time `json:"createdAt" lit:"created_at"`
+ UpdatedAt time.Time `json:"updatedAt" lit:"updated_at"`
+}
+
+type WidgetGroupWithWidgets struct {
+ WidgetGroup
+ Widgets []WidgetGroupWidget `json:"widgets"`
+}
diff --git a/backend/app/repositories/metric_point.repository.go b/backend/app/repositories/metric_point.repository.go
new file mode 100644
index 00000000..2134b07d
--- /dev/null
+++ b/backend/app/repositories/metric_point.repository.go
@@ -0,0 +1,261 @@
+package repositories
+
+import (
+ "backend/app/chdb"
+ "backend/app/models"
+ "context"
+ "time"
+
+ "github.com/ClickHouse/clickhouse-go/v2"
+ "github.com/google/uuid"
+)
+
+type metricPointRepository struct{}
+
+func (r *metricPointRepository) InsertAsync(ctx context.Context, points []models.MetricPoint) error {
+ batch, err := (*chdb.Conn).PrepareBatch(clickhouse.Context(context.Background(), clickhouse.WithAsync(false)), "INSERT INTO metric_points (project_id, name, value, tags, recorded_at)")
+ if err != nil {
+ return err
+ }
+ for _, p := range points {
+ if err := batch.Append(p.ProjectId, p.Name, p.Value, p.Tags, p.RecordedAt); err != nil {
+ return err
+ }
+ }
+ return batch.Send()
+}
+
+func (r *metricPointRepository) QueryTimeSeries(ctx context.Context, projectId uuid.UUID, name string, from, to time.Time, intervalMinutes int, aggregation string, tagFilters map[string]string, groupBy string) (map[string][]models.TimeSeriesPoint, error) {
+ table := selectTable(to.Sub(from))
+
+ aggFunc := aggregationFunc(aggregation, table)
+
+ query := "SELECT toStartOfInterval(recorded_at, INTERVAL ? MINUTE) AS bucket"
+
+ args := []interface{}{intervalMinutes}
+
+ hasGroupBy := groupBy != ""
+ if hasGroupBy {
+ query += ", tags[?] AS group_key"
+ args = append(args, groupBy)
+ }
+
+ query += ", " + aggFunc + " AS agg_value FROM " + table + " WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?"
+ args = append(args, projectId, name, from, to)
+
+ for k, v := range tagFilters {
+ query += " AND tags[?] = ?"
+ args = append(args, k, v)
+ }
+
+ query += " GROUP BY bucket"
+ if hasGroupBy {
+ query += ", group_key"
+ }
+ query += " ORDER BY bucket ASC"
+
+ rows, err := (*chdb.Conn).Query(ctx, query, args...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ result := make(map[string][]models.TimeSeriesPoint)
+ for rows.Next() {
+ var bucket time.Time
+ var value float64
+ groupKey := "__all__"
+
+ if hasGroupBy {
+ if err := rows.Scan(&bucket, &groupKey, &value); err != nil {
+ return nil, err
+ }
+ } else {
+ if err := rows.Scan(&bucket, &value); err != nil {
+ return nil, err
+ }
+ }
+
+ if groupKey == "" {
+ groupKey = "(empty)"
+ }
+ result[groupKey] = append(result[groupKey], models.TimeSeriesPoint{
+ Timestamp: bucket,
+ Value: value,
+ })
+ }
+ return result, nil
+}
+
+func (r *metricPointRepository) DiscoverMetrics(ctx context.Context, projectId uuid.UUID, from, to time.Time) ([]models.DiscoveredMetric, error) {
+ query := `SELECT name, groupUniqArrayArray(mapKeys(tags)) AS tag_keys
+ FROM metric_points
+ WHERE project_id = ? AND recorded_at >= ? AND recorded_at <= ?
+ GROUP BY name
+ ORDER BY name ASC`
+
+ rows, err := (*chdb.Conn).Query(ctx, query, projectId, from, to)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ var metrics []models.DiscoveredMetric
+ for rows.Next() {
+ var m models.DiscoveredMetric
+ if err := rows.Scan(&m.Name, &m.TagKeys); err != nil {
+ return nil, err
+ }
+ metrics = append(metrics, m)
+ }
+ return metrics, nil
+}
+
+func (r *metricPointRepository) DiscoverTagValues(ctx context.Context, projectId uuid.UUID, metricName, tagKey string, from, to time.Time) ([]string, error) {
+ query := `SELECT DISTINCT tags[?] AS tag_value
+ FROM metric_points
+ WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?
+ AND tags[?] != ''
+ ORDER BY tag_value ASC`
+
+ rows, err := (*chdb.Conn).Query(ctx, query, tagKey, projectId, metricName, from, to, tagKey)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ var values []string
+ for rows.Next() {
+ var v string
+ if err := rows.Scan(&v); err != nil {
+ return nil, err
+ }
+ values = append(values, v)
+ }
+ return values, nil
+}
+
+func selectTable(duration time.Duration) string {
+ switch {
+ case duration <= 6*time.Hour:
+ return "metric_points"
+ case duration <= 72*time.Hour:
+ return "metric_points_1m"
+ case duration <= 720*time.Hour:
+ return "metric_points_1h"
+ default:
+ return "metric_points_1d"
+ }
+}
+
+func aggregationFunc(agg string, table string) string {
+ if table == "metric_points" {
+ switch agg {
+ case "min":
+ return "min(value)"
+ case "max":
+ return "max(value)"
+ case "sum":
+ return "sum(value)"
+ case "count":
+ return "count()"
+ default:
+ return "avg(value)"
+ }
+ }
+ switch agg {
+ case "min":
+ return "minMerge(min_val)"
+ case "max":
+ return "maxMerge(max_val)"
+ case "sum":
+ return "sumMerge(sum_val)"
+ case "count":
+ return "countMerge(count_val)"
+ default:
+ return "sumMerge(sum_val) / countMerge(count_val)"
+ }
+}
+
+func (r *metricPointRepository) GetAverageBetween(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time) (float64, error) {
+ table := selectTable(end.Sub(start))
+ var query string
+ if table == "metric_points" {
+ query = "SELECT coalesce(avg(value), 0) FROM metric_points WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?"
+ } else {
+ query = "SELECT coalesce(sumMerge(sum_val) / countMerge(count_val), 0) FROM " + table + " WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?"
+ }
+ var avg float64
+ err := (*chdb.Conn).QueryRow(ctx, query, projectId, name, start, end).Scan(&avg)
+ return avg, err
+}
+
+func (r *metricPointRepository) GetDistinctServers(ctx context.Context, projectId uuid.UUID, start, end time.Time) ([]string, error) {
+ query := `SELECT DISTINCT tags['server_name'] AS sn
+ FROM metric_points
+ WHERE project_id = ? AND recorded_at >= ? AND recorded_at <= ?
+ AND tags['server_name'] != ''
+ ORDER BY sn ASC`
+
+ rows, err := (*chdb.Conn).Query(ctx, query, projectId, start, end)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ var servers []string
+ for rows.Next() {
+ var s string
+ if err := rows.Scan(&s); err != nil {
+ return nil, err
+ }
+ servers = append(servers, s)
+ }
+ return servers, nil
+}
+
+func (r *metricPointRepository) GetAverageByIntervalPerServer(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time, intervalMinutes int, servers []string) (map[string][]models.TimeSeriesPoint, error) {
+ table := selectTable(end.Sub(start))
+ aggFunc := aggregationFunc("avg", table)
+
+ query := `SELECT
+ toStartOfInterval(recorded_at, INTERVAL ? MINUTE) as bucket,
+ tags['server_name'] AS sn,
+ ` + aggFunc + ` as avg_value
+ FROM ` + table + `
+ WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?`
+
+ args := []interface{}{intervalMinutes, projectId, name, start, end}
+
+ if len(servers) > 0 {
+ query += " AND tags['server_name'] IN (?)"
+ args = append(args, servers)
+ } else {
+ query += " AND tags['server_name'] != ''"
+ }
+
+ query += " GROUP BY bucket, sn ORDER BY bucket ASC, sn ASC"
+
+ rows, err := (*chdb.Conn).Query(ctx, query, args...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ result := make(map[string][]models.TimeSeriesPoint)
+ for rows.Next() {
+ var bucket time.Time
+ var serverName string
+ var value float64
+ if err := rows.Scan(&bucket, &serverName, &value); err != nil {
+ return nil, err
+ }
+ result[serverName] = append(result[serverName], models.TimeSeriesPoint{
+ Timestamp: bucket,
+ Value: value,
+ })
+ }
+ return result, nil
+}
+
+var MetricPointRepository = metricPointRepository{}
diff --git a/backend/app/repositories/metric_record.repository.go b/backend/app/repositories/metric_record.repository.go
deleted file mode 100644
index a9be228c..00000000
--- a/backend/app/repositories/metric_record.repository.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package repositories
-
-import (
- "backend/app/chdb"
- "backend/app/models"
- "context"
- "time"
-
- "github.com/ClickHouse/clickhouse-go/v2"
- "github.com/google/uuid"
-)
-
-type metricRecordRepository struct{}
-
-func (e *metricRecordRepository) InsertAsync(ctx context.Context, lines []models.MetricRecord) error {
- batch, err := (*chdb.Conn).PrepareBatch(clickhouse.Context(context.Background(), clickhouse.WithAsync(false)), "INSERT INTO metric_records (project_id, name, value, recorded_at, server_name)")
- if err != nil {
- return err
- }
- for _, m := range lines {
- if err := batch.Append(m.ProjectId, m.Name, m.Value, m.RecordedAt, m.ServerName); err != nil {
- return err
- }
- }
- return batch.Send()
-}
-
-func (e *metricRecordRepository) GetAverageBetween(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time) (float64, error) {
- var avg float64
- err := (*chdb.Conn).QueryRow(ctx, "SELECT coalesce(avg(value), 0) FROM metric_records WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?", projectId, name, start, end).Scan(&avg)
- return avg, err
-}
-
-// GetAverageByHour returns metric averages grouped by hour
-func (e *metricRecordRepository) GetAverageByHour(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time) ([]models.TimeSeriesPoint, error) {
- query := `SELECT
- toStartOfHour(recorded_at) as hour,
- avg(value) as avg_value
- FROM metric_records
- WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?
- GROUP BY hour
- ORDER BY hour ASC`
-
- rows, err := (*chdb.Conn).Query(ctx, query, projectId, name, start, end)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var points []models.TimeSeriesPoint
- for rows.Next() {
- var p models.TimeSeriesPoint
- if err := rows.Scan(&p.Timestamp, &p.Value); err != nil {
- return nil, err
- }
- points = append(points, p)
- }
-
- return points, nil
-}
-
-// GetAverageByInterval returns metric averages grouped by configurable interval in minutes
-func (e *metricRecordRepository) GetAverageByInterval(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time, intervalMinutes int) ([]models.TimeSeriesPoint, error) {
- query := `SELECT
- toStartOfInterval(recorded_at, INTERVAL ? MINUTE) as bucket,
- avg(value) as avg_value
- FROM metric_records
- WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?
- GROUP BY bucket
- ORDER BY bucket ASC`
-
- rows, err := (*chdb.Conn).Query(ctx, query, intervalMinutes, projectId, name, start, end)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var points []models.TimeSeriesPoint
- for rows.Next() {
- var p models.TimeSeriesPoint
- if err := rows.Scan(&p.Timestamp, &p.Value); err != nil {
- return nil, err
- }
- points = append(points, p)
- }
-
- return points, nil
-}
-
-// GetDistinctServers returns all unique server names with data in the time range
-func (e *metricRecordRepository) GetDistinctServers(ctx context.Context, projectId uuid.UUID, start, end time.Time) ([]string, error) {
- query := `SELECT DISTINCT server_name FROM metric_records
- WHERE project_id = ? AND recorded_at >= ? AND recorded_at <= ?
- AND server_name != ''
- ORDER BY server_name ASC`
-
- rows, err := (*chdb.Conn).Query(ctx, query, projectId, start, end)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- var servers []string
- for rows.Next() {
- var s string
- if err := rows.Scan(&s); err != nil {
- return nil, err
- }
- servers = append(servers, s)
- }
- return servers, nil
-}
-
-// GetAverageByIntervalPerServer returns metric averages grouped by interval and server
-func (e *metricRecordRepository) GetAverageByIntervalPerServer(ctx context.Context, projectId uuid.UUID, name string, start, end time.Time, intervalMinutes int, servers []string) (map[string][]models.TimeSeriesPoint, error) {
- query := `SELECT
- toStartOfInterval(recorded_at, INTERVAL ? MINUTE) as bucket,
- server_name,
- avg(value) as avg_value
- FROM metric_records
- WHERE project_id = ? AND name = ? AND recorded_at >= ? AND recorded_at <= ?`
-
- args := []interface{}{intervalMinutes, projectId, name, start, end}
-
- if len(servers) > 0 {
- query += " AND server_name IN (?)"
- args = append(args, servers)
- } else {
- query += " AND server_name != ''"
- }
-
- query += " GROUP BY bucket, server_name ORDER BY bucket ASC, server_name ASC"
-
- rows, err := (*chdb.Conn).Query(ctx, query, args...)
- if err != nil {
- return nil, err
- }
- defer rows.Close()
-
- result := make(map[string][]models.TimeSeriesPoint)
- for rows.Next() {
- var bucket time.Time
- var serverName string
- var value float64
- if err := rows.Scan(&bucket, &serverName, &value); err != nil {
- return nil, err
- }
- result[serverName] = append(result[serverName], models.TimeSeriesPoint{
- Timestamp: bucket,
- Value: value,
- })
- }
- return result, nil
-}
-
-var MetricRecordRepository = metricRecordRepository{}
diff --git a/backend/app/repositories/metric_registry.repository.go b/backend/app/repositories/metric_registry.repository.go
new file mode 100644
index 00000000..b0ebdad2
--- /dev/null
+++ b/backend/app/repositories/metric_registry.repository.go
@@ -0,0 +1,96 @@
+package repositories
+
+import (
+ "backend/app/models"
+ "database/sql"
+ "sync"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/tracewayapp/go-lightning/lit"
+)
+
+type metricRegistryRepository struct {
+ knownMetrics sync.Map
+}
+
+func (r *metricRegistryRepository) EnsureRegistered(tx *sql.Tx, projectId uuid.UUID, names []string) error {
+ for _, name := range names {
+ key := projectId.String() + ":" + name
+ if _, loaded := r.knownMetrics.Load(key); loaded {
+ continue
+ }
+
+ metricType := defaultMetricType(name)
+ unit := defaultUnit(name)
+
+ entry := &models.MetricRegistry{
+ ProjectId: projectId,
+ Name: name,
+ MetricType: metricType,
+ Unit: unit,
+ Description: "",
+ CreatedAt: time.Now().UTC(),
+ }
+
+ _, err := lit.Insert[models.MetricRegistry](tx, entry)
+ if err != nil {
+ existing, findErr := r.FindByProjectAndName(tx, projectId, name)
+ if findErr != nil || existing == nil {
+ return err
+ }
+ }
+ r.knownMetrics.Store(key, true)
+ }
+ return nil
+}
+
+func (r *metricRegistryRepository) FindByProject(tx *sql.Tx, projectId uuid.UUID) ([]*models.MetricRegistry, error) {
+ return lit.Select[models.MetricRegistry](
+ tx,
+ "SELECT id, project_id, name, metric_type, unit, description, created_at FROM metric_registry WHERE project_id = $1 ORDER BY name ASC",
+ projectId,
+ )
+}
+
+func (r *metricRegistryRepository) FindByProjectAndName(tx *sql.Tx, projectId uuid.UUID, name string) (*models.MetricRegistry, error) {
+ return lit.SelectSingle[models.MetricRegistry](
+ tx,
+ "SELECT id, project_id, name, metric_type, unit, description, created_at FROM metric_registry WHERE project_id = $1 AND name = $2",
+ projectId, name,
+ )
+}
+
+func (r *metricRegistryRepository) Update(tx *sql.Tx, entry *models.MetricRegistry) error {
+ return lit.Update(tx, entry, "id = $1", entry.Id)
+}
+
+func defaultMetricType(name string) string {
+ switch name {
+ case models.MetricNameNumGC:
+ return "counter"
+ case models.MetricNameGCPauseTotal:
+ return "counter"
+ default:
+ return "gauge"
+ }
+}
+
+func defaultUnit(name string) string {
+ switch name {
+ case models.MetricNameCpuUsage:
+ return "%"
+ case models.MetricNameMemoryUsage, models.MetricNameMemoryTotal:
+ return "MB"
+ case models.MetricNameGoRoutines, models.MetricNameHeapObjects:
+ return "count"
+ case models.MetricNameNumGC:
+ return "count"
+ case models.MetricNameGCPauseTotal:
+ return "ns"
+ default:
+ return ""
+ }
+}
+
+var MetricRegistryRepository = metricRegistryRepository{}
diff --git a/backend/app/repositories/widget_group.repository.go b/backend/app/repositories/widget_group.repository.go
new file mode 100644
index 00000000..d7412bfe
--- /dev/null
+++ b/backend/app/repositories/widget_group.repository.go
@@ -0,0 +1,69 @@
+package repositories
+
+import (
+ "backend/app/models"
+ "database/sql"
+
+ "github.com/google/uuid"
+ "github.com/tracewayapp/go-lightning/lit"
+)
+
+type widgetGroupRepository struct{}
+
+func (r *widgetGroupRepository) FindByProject(tx *sql.Tx, projectId uuid.UUID) ([]*models.WidgetGroup, error) {
+ return lit.Select[models.WidgetGroup](
+ tx,
+ "SELECT id, project_id, name, description, is_default, created_by, created_at, updated_at FROM widget_groups WHERE project_id = $1 ORDER BY is_default DESC, name ASC",
+ projectId,
+ )
+}
+
+func (r *widgetGroupRepository) FindById(tx *sql.Tx, id int) (*models.WidgetGroup, error) {
+ return lit.SelectSingle[models.WidgetGroup](
+ tx,
+ "SELECT id, project_id, name, description, is_default, created_by, created_at, updated_at FROM widget_groups WHERE id = $1",
+ id,
+ )
+}
+
+func (r *widgetGroupRepository) Create(tx *sql.Tx, group *models.WidgetGroup) (int, error) {
+ return lit.Insert[models.WidgetGroup](tx, group)
+}
+
+func (r *widgetGroupRepository) Update(tx *sql.Tx, group *models.WidgetGroup) error {
+ return lit.Update(tx, group, "id = $1", group.Id)
+}
+
+func (r *widgetGroupRepository) Delete(tx *sql.Tx, id int) error {
+ return lit.Delete(tx, "DELETE FROM widget_groups WHERE id = $1", id)
+}
+
+func (r *widgetGroupRepository) FindWidgetsByGroup(tx *sql.Tx, widgetGroupId int) ([]*models.WidgetGroupWidget, error) {
+ return lit.Select[models.WidgetGroupWidget](
+ tx,
+ "SELECT id, widget_group_id, title, widget_type, config, position, created_at, updated_at FROM widget_group_widgets WHERE widget_group_id = $1 ORDER BY position ASC",
+ widgetGroupId,
+ )
+}
+
+func (r *widgetGroupRepository) FindWidgetById(tx *sql.Tx, id int) (*models.WidgetGroupWidget, error) {
+ return lit.SelectSingle[models.WidgetGroupWidget](
+ tx,
+ "SELECT id, widget_group_id, title, widget_type, config, position, created_at, updated_at FROM widget_group_widgets WHERE id = $1",
+ id,
+ )
+}
+
+func (r *widgetGroupRepository) CreateWidget(tx *sql.Tx, widget *models.WidgetGroupWidget) (int, error) {
+ return lit.Insert[models.WidgetGroupWidget](tx, widget)
+}
+
+func (r *widgetGroupRepository) UpdateWidget(tx *sql.Tx, widget *models.WidgetGroupWidget) error {
+ return lit.Update(tx, widget, "id = $1", widget.Id)
+}
+
+func (r *widgetGroupRepository) DeleteWidget(tx *sql.Tx, id int) error {
+ return lit.Delete(tx, "DELETE FROM widget_group_widgets WHERE id = $1", id)
+}
+
+var WidgetGroupRepository = widgetGroupRepository{}
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index f76b327b..06cb12a0 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -54,6 +54,13 @@ async function request(method: string, endpoint: string, data?: unknown, options
throw new Error('Forbidden');
}
+ if (response.status === 422) {
+ const body = await response.json().catch(() => ({}));
+ const error = new Error(body.error || 'Validation failed') as Error & { status: number };
+ error.status = 422;
+ throw error;
+ }
+
if (!response.ok) {
const error = new Error(`API Error: ${response.statusText}`) as Error & { status: number };
error.status = response.status;
diff --git a/frontend/src/lib/components/dashboard/d3-line-chart.svelte b/frontend/src/lib/components/dashboard/d3-line-chart.svelte
index 1731a9c1..12e3de77 100644
--- a/frontend/src/lib/components/dashboard/d3-line-chart.svelte
+++ b/frontend/src/lib/components/dashboard/d3-line-chart.svelte
@@ -1,6 +1,6 @@
<script lang="ts">
import { scaleUtc, scaleLinear, type NumberValue } from 'd3-scale';
- import { line } from 'd3-shape';
+ import { line, area } from 'd3-shape';
import { min, max } from 'd3-array';
import { formatDateTime } from '$lib/utils/formatters';
import { getTimezone } from '$lib/state/timezone.svelte';
@@ -33,6 +33,7 @@
serverColorMap = {},
unit = '',
formatValue,
+ areaFill = false,
sharedHoverTime = null,
isSourceChart = false,
onHoverTimeChange
@@ -48,6 +49,7 @@
serverColorMap?: Record<string, string>;
unit?: string;
formatValue?: (value: number) => string;
+ areaFill?: boolean;
sharedHoverTime?: Date | null;
isSourceChart?: boolean;
onHoverTimeChange?: (time: Date | null) => void;
@@ -141,6 +143,17 @@
return lineGen(seriesData) || '';
}
+ function generateAreaPath(seriesData: DataPoint[]): string {
+ if (seriesData.length === 0) return '';
+
+ const areaGen = area<DataPoint>()
+ .x(d => xScale(d.timestamp))
+ .y0(chartHeight)
+ .y1(d => yScale(d.value));
+
+ return areaGen(seriesData) || '';
+ }
+
const hasData = $derived(allData.length > 0);
// Check if we have multi-server data
@@ -477,6 +490,20 @@
{@const segments = getLineSegments(s.data)}
{@const isolated = getIsolatedPoints(s.data)}
+ <!-- Draw area fills (when areaFill is enabled) -->
+ {#if areaFill}
+ {#each segments as segment}
+ {#if segment.length > 1}
+ <path
+ d={generateAreaPath(segment)}
+ fill={s.color}
+ fill-opacity="0.15"
+ stroke="none"
+ />
+ {/if}
+ {/each}
+ {/if}
+
<!-- Draw line segments (only segments with 2+ points) -->
{#each segments as segment}
{#if segment.length > 1}
diff --git a/frontend/src/lib/components/dashboard/metrics-tab-content.svelte b/frontend/src/lib/components/dashboard/metrics-tab-content.svelte
deleted file mode 100644
index ec299624..00000000
--- a/frontend/src/lib/components/dashboard/metrics-tab-content.svelte
+++ /dev/null
@@ -1,143 +0,0 @@
-<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) : []
- );
-
- // Hover state coordination for shadow tooltip lines across charts
- let currentHoverTime = $state<Date | null>(null);
- let currentHoverChartId = $state<string | null>(null);
-
- function handleChartHoverChange(chartId: string, time: Date | null) {
- if (time !== null) {
- currentHoverTime = time;
- currentHoverChartId = chartId;
- } else if (currentHoverChartId === chartId) {
- // Only clear if the chart that's leaving is the current source
- currentHoverTime = null;
- currentHoverChartId = null;
- }
- }
-</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}
- sharedHoverTime={currentHoverTime}
- isSourceChart={currentHoverChartId === metric.id}
- onHoverTimeChange={(time) => handleChartHoverChange(metric.id, time)}
- />
- {/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/tag-filter.svelte b/frontend/src/lib/components/dashboard/tag-filter.svelte
new file mode 100644
index 00000000..87979e30
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/tag-filter.svelte
@@ -0,0 +1,111 @@
+<script lang="ts">
+ import { Button } from '$lib/components/ui/button';
+ import * as Select from '$lib/components/ui/select';
+ import { X } from 'lucide-svelte';
+
+ let {
+ tagKeys = [],
+ activeFilters = {},
+ onFilterChange,
+ onLoadTagValues
+ } = $props<{
+ tagKeys: string[];
+ activeFilters: Record<string, string>;
+ onFilterChange: (filters: Record<string, string>) => void;
+ onLoadTagValues: (key: string) => Promise<string[]>;
+ }>();
+
+ let selectedKey = $state('');
+ let tagValueOptions = $state<Record<string, string[]>>({});
+ let loadingValues = $state(false);
+
+ async function handleKeySelect(key: string) {
+ selectedKey = key;
+ if (!tagValueOptions[key]) {
+ loadingValues = true;
+ try {
+ tagValueOptions[key] = await onLoadTagValues(key);
+ } catch {
+ tagValueOptions[key] = [];
+ } finally {
+ loadingValues = false;
+ }
+ }
+ }
+
+ function handleValueSelect(value: string) {
+ if (!selectedKey) return;
+ const newFilters = { ...activeFilters, [selectedKey]: value };
+ onFilterChange(newFilters);
+ selectedKey = '';
+ }
+
+ function removeFilter(key: string) {
+ const newFilters = { ...activeFilters };
+ delete newFilters[key];
+ onFilterChange(newFilters);
+ }
+
+ const availableKeys = $derived(tagKeys.filter((k: string) => !(k in activeFilters)));
+</script>
+
+<div class="flex flex-wrap items-center gap-2">
+ {#each Object.entries(activeFilters) as [key, value]}
+ <div
+ class="flex items-center gap-1 rounded-md border bg-muted/50 px-2 py-1 text-xs"
+ >
+ <span class="font-medium">{key}</span>
+ <span class="text-muted-foreground">=</span>
+ <span>{value}</span>
+ <button
+ class="ml-1 rounded hover:bg-muted"
+ onclick={() => removeFilter(key)}
+ >
+ <X class="h-3 w-3" />
+ </button>
+ </div>
+ {/each}
+
+ {#if availableKeys.length > 0}
+ {#if selectedKey}
+ <Select.Root
+ type="single"
+ onValueChange={(v) => {
+ if (v) handleValueSelect(v);
+ }}
+ >
+ <Select.Trigger class="h-7 w-[140px] text-xs">
+ {#if loadingValues}
+ Loading...
+ {:else}
+ Select value
+ {/if}
+ </Select.Trigger>
+ <Select.Content>
+ {#each tagValueOptions[selectedKey] ?? [] as val}
+ <Select.Item value={val}>{val}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" onclick={() => (selectedKey = '')}>
+ Cancel
+ </Button>
+ {:else}
+ <Select.Root
+ type="single"
+ onValueChange={(v) => {
+ if (v) handleKeySelect(v);
+ }}
+ >
+ <Select.Trigger class="h-7 w-[140px] text-xs">
+ + Filter by tag
+ </Select.Trigger>
+ <Select.Content>
+ {#each availableKeys as key}
+ <Select.Item value={key}>{key}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ {/if}
+ {/if}
+</div>
diff --git a/frontend/src/lib/components/dashboard/widget-config-panel.svelte b/frontend/src/lib/components/dashboard/widget-config-panel.svelte
new file mode 100644
index 00000000..0bfb21f6
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/widget-config-panel.svelte
@@ -0,0 +1,207 @@
+<script lang="ts">
+ import { Button } from '$lib/components/ui/button';
+ import { Input } from '$lib/components/ui/input';
+ import * as Select from '$lib/components/ui/select';
+ import * as AlertDialog from '$lib/components/ui/alert-dialog';
+ import TagFilter from './tag-filter.svelte';
+ import { api } from '$lib/api';
+ import { projectsState } from '$lib/state/projects.svelte';
+ import { Plus, Check, CircleAlert } from 'lucide-svelte';
+ import * as Alert from '$lib/components/ui/alert';
+ import type { DiscoveredMetric } from '$lib/types/dashboard';
+
+ type WidgetSource = {
+ type: 'metric';
+ name: string;
+ aggregation: string;
+ tagFilters?: Record<string, string>;
+ groupBy?: string;
+ };
+
+ let {
+ open = $bindable(false),
+ widget = null,
+ availableMetrics = [],
+ error = '',
+ onSave,
+ onCancel
+ } = $props<{
+ open: boolean;
+ widget: { id?: number; title: string; widgetType: string; config: any } | null;
+ availableMetrics: DiscoveredMetric[];
+ error?: string;
+ onSave: (data: { title: string; widgetType: string; config: any }) => void;
+ onCancel: () => void;
+ }>();
+
+ let title = $state(widget?.title ?? '');
+ let widgetType = $state(widget?.widgetType ?? 'line_chart');
+ let sources = $state<WidgetSource[]>(
+ widget?.config?.sources ?? [{ type: 'metric', name: '', aggregation: 'avg' }]
+ );
+
+ $effect(() => {
+ if (open) {
+ title = widget?.title ?? '';
+ widgetType = widget?.widgetType ?? 'line_chart';
+ sources = widget?.config?.sources
+ ? [...widget.config.sources]
+ : [{ type: 'metric', name: '', aggregation: 'avg' }];
+ }
+ });
+
+ function getMetricTagKeys(metricName: string): string[] {
+ const m = availableMetrics.find((m: DiscoveredMetric) => m.name === metricName);
+ return m?.tagKeys ?? [];
+ }
+
+ async function loadTagValues(metricName: string, key: string): Promise<string[]> {
+ try {
+ const response = await api.get(
+ `/metrics/discover/tags?name=${encodeURIComponent(metricName)}&key=${encodeURIComponent(key)}`,
+ { projectId: projectsState.currentProjectId ?? undefined }
+ );
+ return response.values || [];
+ } catch {
+ return [];
+ }
+ }
+
+ function handleSave() {
+ const validSources = sources.filter((s: WidgetSource) => s.name);
+ const displayTitle = title.trim() || validSources[0]?.name || '';
+ const config: Record<string, any> = { sources: validSources };
+ onSave({
+ title: displayTitle,
+ widgetType,
+ config
+ });
+ }
+
+ function handleClose() {
+ open = false;
+ onCancel();
+ }
+</script>
+
+<AlertDialog.Root bind:open>
+ <AlertDialog.Content class="max-w-xl" interactOutsideBehavior="close">
+ <AlertDialog.Header>
+ <AlertDialog.Title>{widget?.id ? 'Edit Widget' : 'Add Widget'}</AlertDialog.Title>
+ </AlertDialog.Header>
+ {#if error}
+ <Alert.Root variant="destructive" class="bg-red-50 border-red-200">
+ <CircleAlert class="h-4 w-4 text-red-700" />
+ <Alert.Title class="text-red-800">Error</Alert.Title>
+ <Alert.Description class="text-red-700">{error}</Alert.Description>
+ </Alert.Root>
+ {/if}
+ <div class="space-y-4">
+ <div>
+ <label class="text-sm font-medium" for="widget-title">Title (optional)</label>
+ <Input id="widget-title" bind:value={title} placeholder="Defaults to metric name" />
+ </div>
+
+ <div>
+ <label class="text-sm font-medium">Widget Type</label>
+ <Select.Root
+ type="single"
+ value={widgetType}
+ onValueChange={(v) => {
+ if (v) widgetType = v;
+ }}
+ >
+ <Select.Trigger>
+ {({ line_chart: 'Line Chart', area_chart: 'Area Chart', bar_chart: 'Bar Chart', single_value: 'Single Value', table: 'Table' } as Record<string, string>)[widgetType] ?? widgetType}
+ </Select.Trigger>
+ <Select.Content>
+ <Select.Item value="line_chart">Line Chart</Select.Item>
+ <Select.Item value="area_chart">Area Chart</Select.Item>
+ <Select.Item value="bar_chart">Bar Chart</Select.Item>
+ <Select.Item value="single_value">Single Value</Select.Item>
+ <Select.Item value="table">Table</Select.Item>
+ </Select.Content>
+ </Select.Root>
+ </div>
+
+ {#each sources as source, i}
+ <div class="space-y-2 rounded-md border p-3">
+ <div class="flex items-center gap-2">
+ <Select.Root
+ type="single"
+ value={source.name}
+ onValueChange={(v) => {
+ if (v) sources[i].name = v;
+ }}
+ >
+ <Select.Trigger class="flex-1">{source.name || 'Select metric'}</Select.Trigger>
+ <Select.Content>
+ {#each availableMetrics as m}
+ <Select.Item value={m.name}>{m.name}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+
+ <Select.Root
+ type="single"
+ value={source.aggregation}
+ onValueChange={(v) => {
+ if (v) sources[i].aggregation = v;
+ }}
+ >
+ <Select.Trigger class="w-20">{source.aggregation}</Select.Trigger>
+ <Select.Content>
+ <Select.Item value="avg">avg</Select.Item>
+ <Select.Item value="min">min</Select.Item>
+ <Select.Item value="max">max</Select.Item>
+ <Select.Item value="sum">sum</Select.Item>
+ <Select.Item value="count">count</Select.Item>
+ </Select.Content>
+ </Select.Root>
+ </div>
+
+ {#if source.name && getMetricTagKeys(source.name).length > 0}
+ <div class="space-y-1">
+ <span class="text-xs text-muted-foreground">Tag Filters</span>
+ <TagFilter
+ tagKeys={getMetricTagKeys(source.name)}
+ activeFilters={source.tagFilters ?? {}}
+ onFilterChange={(filters) => {
+ sources[i].tagFilters = Object.keys(filters).length > 0 ? filters : undefined;
+ }}
+ onLoadTagValues={(key) => loadTagValues(source.name, key)}
+ />
+ </div>
+
+ <div>
+ <span class="text-xs text-muted-foreground">Group By</span>
+ <Select.Root
+ type="single"
+ value={source.groupBy ?? ''}
+ onValueChange={(v) => {
+ sources[i].groupBy = v || undefined;
+ }}
+ >
+ <Select.Trigger class="h-7 w-[160px] text-xs"
+ >{source.groupBy || 'None'}</Select.Trigger
+ >
+ <Select.Content>
+ <Select.Item value="">None</Select.Item>
+ {#each getMetricTagKeys(source.name) as key}
+ <Select.Item value={key}>{key}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ </div>
+ {/if}
+ </div>
+ {/each}
+ </div>
+ <AlertDialog.Footer>
+ <Button variant="outline" onclick={handleClose}>Cancel</Button>
+ <Button onclick={handleSave}>
+ {#if widget?.id}<Check class="mr-1 h-4 w-4" /> Update Widget{:else}<Plus class="mr-1 h-4 w-4" /> Add Widget{/if}
+ </Button>
+ </AlertDialog.Footer>
+ </AlertDialog.Content>
+</AlertDialog.Root>
diff --git a/frontend/src/lib/components/dashboard/widget-grid.svelte b/frontend/src/lib/components/dashboard/widget-grid.svelte
new file mode 100644
index 00000000..9b6fe9ad
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/widget-grid.svelte
@@ -0,0 +1,155 @@
+<script lang="ts">
+ import * as Card from '$lib/components/ui/card';
+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu';
+ import {
+ Plus,
+ EllipsisVertical,
+ Pencil,
+ Move,
+ ArrowUp,
+ ArrowDown,
+ ArrowLeft,
+ ArrowRight,
+ Trash2
+ } from 'lucide-svelte';
+ import WidgetRenderer from './widget-renderer.svelte';
+
+ type Widget = {
+ id: number;
+ title: string;
+ widgetType: string;
+ config: any;
+ position: number;
+ };
+
+ let {
+ widgets = [],
+ fromDateUTC,
+ toDateUTC,
+ timeDomain = null,
+ onEditWidget,
+ onDeleteWidget,
+ onMoveWidget,
+ onAddWidget,
+ onRangeSelect
+ } = $props<{
+ widgets: Widget[];
+ fromDateUTC: string;
+ toDateUTC: string;
+ timeDomain: [Date, Date] | null;
+ onEditWidget?: (widget: Widget) => void;
+ onDeleteWidget?: (widget: Widget) => void;
+ onMoveWidget?: (widgetId: number, offset: number) => void;
+ onAddWidget?: () => void;
+ onRangeSelect?: (from: Date, to: Date) => void;
+ }>();
+
+ let sharedHoverTime = $state<Date | null>(null);
+ let cols = $state(3);
+
+ $effect(() => {
+ const mql = window.matchMedia('(min-width: 768px)');
+ const handler = (e: MediaQueryListEvent | MediaQueryList) => {
+ cols = e.matches ? 3 : 1;
+ };
+ handler(mql);
+ mql.addEventListener('change', handler);
+ return () => mql.removeEventListener('change', handler);
+ });
+
+ const sortedWidgets = $derived([...widgets].sort((a, b) => a.position - b.position));
+</script>
+
+<div class="grid grid-cols-1 gap-4 md:grid-cols-3">
+ {#each sortedWidgets as widget, i (widget.id)}
+ <div>
+ <Card.Root class="h-full gap-0">
+ <Card.Header class="pr-2 pb-1">
+ <div class="flex items-center justify-between">
+ <Card.Title class="text-sm font-medium">{widget.title}</Card.Title>
+ <DropdownMenu.Root>
+ <DropdownMenu.Trigger
+ class="inline-flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+ >
+ <EllipsisVertical class="h-4 w-4" />
+ </DropdownMenu.Trigger>
+ <DropdownMenu.Content align="end">
+ <DropdownMenu.Item onclick={() => onEditWidget?.(widget)}>
+ <Pencil class="mr-2 h-4 w-4" />
+ Edit
+ </DropdownMenu.Item>
+ <DropdownMenu.Sub>
+ <DropdownMenu.SubTrigger>
+ <Move class="mr-2 h-4 w-4" />
+ Move
+ </DropdownMenu.SubTrigger>
+ <DropdownMenu.SubContent>
+ <DropdownMenu.Item
+ disabled={i < cols}
+ onclick={() => onMoveWidget?.(widget.id, -cols)}
+ >
+ <ArrowUp class="mr-2 h-4 w-4" />
+ Up
+ </DropdownMenu.Item>
+ <DropdownMenu.Item
+ disabled={i > sortedWidgets.length - 1 - cols}
+ onclick={() => onMoveWidget?.(widget.id, cols)}
+ >
+ <ArrowDown class="mr-2 h-4 w-4" />
+ Down
+ </DropdownMenu.Item>
+ {#if cols > 1}
+ <DropdownMenu.Item
+ disabled={i % cols === 0}
+ onclick={() => onMoveWidget?.(widget.id, -1)}
+ >
+ <ArrowLeft class="mr-2 h-4 w-4" />
+ Left
+ </DropdownMenu.Item>
+ <DropdownMenu.Item
+ disabled={i % cols === cols - 1 || i + 1 >= sortedWidgets.length}
+ onclick={() => onMoveWidget?.(widget.id, 1)}
+ >
+ <ArrowRight class="mr-2 h-4 w-4" />
+ Right
+ </DropdownMenu.Item>
+ {/if}
+ </DropdownMenu.SubContent>
+ </DropdownMenu.Sub>
+ <DropdownMenu.Separator />
+ <DropdownMenu.Item
+ class="text-destructive"
+ onclick={() => onDeleteWidget?.(widget)}
+ >
+ <Trash2 class="mr-2 h-4 w-4" />
+ Delete
+ </DropdownMenu.Item>
+ </DropdownMenu.Content>
+ </DropdownMenu.Root>
+ </div>
+ </Card.Header>
+ <Card.Content class="p-1">
+ <WidgetRenderer
+ {widget}
+ {fromDateUTC}
+ {toDateUTC}
+ {timeDomain}
+ {onRangeSelect}
+ {sharedHoverTime}
+ onHoverTimeChange={(time) => (sharedHoverTime = time)}
+ isSourceChart={false}
+ />
+ </Card.Content>
+ </Card.Root>
+ </div>
+ {/each}
+ <button
+ class="flex min-h-[240px] cursor-pointer items-center justify-center rounded-lg border border-dashed border-muted-foreground/25 text-muted-foreground transition-colors hover:border-primary hover:text-primary"
+ onclick={() => onAddWidget?.()}
+ >
+ <div class="flex flex-col items-center gap-2">
+ <Plus class="h-8 w-8" />
+ <span class="text-sm font-medium">Add Metric Widget</span>
+ </div>
+ </button>
+</div>
diff --git a/frontend/src/lib/components/dashboard/widget-renderer.svelte b/frontend/src/lib/components/dashboard/widget-renderer.svelte
new file mode 100644
index 00000000..7fac2033
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/widget-renderer.svelte
@@ -0,0 +1,184 @@
+<script lang="ts">
+ import D3LineChart from './d3-line-chart.svelte';
+ import D3HorizontalBarChart from './d3-horizontal-bar-chart.svelte';
+ import WidgetTable from './widget-table.svelte';
+ import { api } from '$lib/api';
+ import { projectsState } from '$lib/state/projects.svelte';
+ import { LoadingCircle } from '$lib/components/ui/loading-circle';
+ import type { MetricTrendPoint, MetricQueryResponse } from '$lib/types/dashboard';
+
+ type WidgetSource = {
+ type: 'metric';
+ name: string;
+ tagFilters?: Record<string, string>;
+ aggregation: string;
+ groupBy?: string;
+ };
+
+ type WidgetConfig = {
+ sources?: WidgetSource[];
+ yAxisLabel?: string;
+ showLegend?: boolean;
+ };
+
+ let {
+ widget,
+ fromDateUTC,
+ toDateUTC,
+ timeDomain = null,
+ onRangeSelect,
+ sharedHoverTime = null,
+ isSourceChart = false,
+ onHoverTimeChange
+ } = $props<{
+ widget: {
+ id: number;
+ title: string;
+ widgetType: string;
+ config: WidgetConfig;
+ };
+ fromDateUTC: string;
+ toDateUTC: string;
+ timeDomain: [Date, Date] | null;
+ onRangeSelect?: (from: Date, to: Date) => void;
+ sharedHoverTime?: Date | null;
+ isSourceChart?: boolean;
+ onHoverTimeChange?: (time: Date | null) => void;
+ }>();
+
+ let series = $state<Array<{ key: string; data: MetricTrendPoint[]; color: string }>>([]);
+ let loading = $state(true);
+ let singleValue = $state<number | null>(null);
+
+ const colors = ['#3b82f6', '#ef4444', '#22c55e', '#f59e0b', '#8b5cf6', '#ec4899'];
+
+ async function loadData() {
+ const sources = widget.config.sources;
+ if (!sources || sources.length === 0) {
+ loading = false;
+ return;
+ }
+
+ loading = true;
+ try {
+ const newSeries: Array<{ key: string; data: MetricTrendPoint[]; color: string }> = [];
+ let colorIdx = 0;
+
+ const queries = sources.map((s: WidgetSource) => ({
+ name: s.name,
+ aggregation: s.aggregation || 'avg',
+ tagFilters: s.tagFilters,
+ groupBy: s.groupBy
+ }));
+
+ const response: MetricQueryResponse = await api.post(
+ '/metrics/query',
+ { queries, from: fromDateUTC, to: toDateUTC },
+ { projectId: projectsState.currentProjectId ?? undefined }
+ );
+
+ for (const result of response.results) {
+ for (const [key, points] of Object.entries(result.series)) {
+ const label = Object.keys(result.series).length > 1 ? `${result.name} (${key})` : result.name;
+ newSeries.push({
+ key: label,
+ data: points.map((p) => ({
+ timestamp: new Date(p.Timestamp),
+ value: p.Value
+ })),
+ color: colors[colorIdx % colors.length]
+ });
+ colorIdx++;
+ }
+ }
+
+ series = newSeries;
+
+ if (widget.widgetType === 'single_value' && newSeries.length > 0 && newSeries[0].data.length > 0) {
+ singleValue = newSeries[0].data[newSeries[0].data.length - 1].value;
+ }
+ } catch {
+ // keep empty
+ } finally {
+ loading = false;
+ }
+ }
+
+ $effect(() => {
+ if (fromDateUTC && toDateUTC) {
+ loadData();
+ }
+ });
+
+ const barData = $derived(
+ series.map((s) => ({
+ endpoint: s.key,
+ value: s.data.length > 0 ? s.data[s.data.length - 1].value : 0
+ }))
+ );
+</script>
+
+<div class="h-full w-full min-h-[200px]">
+ {#if loading}
+ <div class="flex h-full items-center justify-center">
+ <LoadingCircle size="md" />
+ </div>
+ {:else if widget.widgetType === 'single_value'}
+ <div class="flex h-full flex-col items-center justify-center">
+ <span class="text-3xl font-bold">
+ {singleValue !== null ? (Number.isInteger(singleValue) ? singleValue : singleValue.toFixed(2)) : '-'}
+ </span>
+ </div>
+ {:else if widget.widgetType === 'bar_chart'}
+ {#if barData.length > 0}
+ <D3HorizontalBarChart data={barData} height={200} unit="" />
+ {:else}
+ <div class="flex h-full items-center justify-center text-sm text-muted-foreground">
+ No data
+ </div>
+ {/if}
+ {:else if widget.widgetType === 'table'}
+ {#if series.length > 0}
+ <WidgetTable {series} />
+ {:else}
+ <div class="flex h-full items-center justify-center text-sm text-muted-foreground">
+ No data
+ </div>
+ {/if}
+ {:else if widget.widgetType === 'area_chart'}
+ {#if series.length > 0}
+ <D3LineChart
+ {series}
+ xDomain={timeDomain ?? undefined}
+ height={200}
+ padding={{ top: 10, right: 4, bottom: 20, left: 45 }}
+ {onRangeSelect}
+ data={series[0]?.data ?? []}
+ areaFill={true}
+ {sharedHoverTime}
+ {isSourceChart}
+ {onHoverTimeChange}
+ />
+ {:else}
+ <div class="flex h-full items-center justify-center text-sm text-muted-foreground">
+ No data
+ </div>
+ {/if}
+ {:else if series.length > 0}
+ <D3LineChart
+ {series}
+ xDomain={timeDomain ?? undefined}
+ height={200}
+ padding={{ top: 10, right: 4, bottom: 20, left: 45 }}
+ {onRangeSelect}
+ data={series[0]?.data ?? []}
+ {sharedHoverTime}
+ {isSourceChart}
+ {onHoverTimeChange}
+ />
+ {:else}
+ <div class="flex h-full items-center justify-center text-sm text-muted-foreground">
+ No data
+ </div>
+ {/if}
+</div>
diff --git a/frontend/src/lib/components/dashboard/widget-table.svelte b/frontend/src/lib/components/dashboard/widget-table.svelte
new file mode 100644
index 00000000..e1e57fea
--- /dev/null
+++ b/frontend/src/lib/components/dashboard/widget-table.svelte
@@ -0,0 +1,52 @@
+<script lang="ts">
+ import * as Table from '$lib/components/ui/table';
+ import type { MetricTrendPoint } from '$lib/types/dashboard';
+
+ type SeriesItem = {
+ key: string;
+ data: MetricTrendPoint[];
+ };
+
+ let { series = [] } = $props<{
+ series: SeriesItem[];
+ }>();
+
+ const stats = $derived(() => {
+ const s = series[0];
+ if (!s) return [];
+ const values = s.data.map((d: MetricTrendPoint) => d.value);
+ if (values.length === 0) {
+ return [
+ { label: 'Latest', value: 0 },
+ { label: 'Min', value: 0 },
+ { label: 'Max', value: 0 },
+ { label: 'Avg', value: 0 }
+ ];
+ }
+ const sum = values.reduce((a: number, b: number) => a + b, 0);
+ return [
+ { label: 'Latest', value: values[values.length - 1] },
+ { label: 'Min', value: Math.min(...values) },
+ { label: 'Max', value: Math.max(...values) },
+ { label: 'Avg', value: sum / values.length }
+ ];
+ });
+
+ function fmt(v: number): string {
+ if (Number.isInteger(v)) return v.toString();
+ return v.toFixed(2);
+ }
+</script>
+
+<div class="overflow-auto">
+ <Table.Root>
+ <Table.Body>
+ {#each stats() as stat}
+ <Table.Row>
+ <Table.Cell class="font-medium">{stat.label}</Table.Cell>
+ <Table.Cell class="text-right">{fmt(stat.value)}</Table.Cell>
+ </Table.Row>
+ {/each}
+ </Table.Body>
+ </Table.Root>
+</div>
diff --git a/frontend/src/lib/components/ui/button/button.svelte b/frontend/src/lib/components/ui/button/button.svelte
index 5c050afd..609abfa9 100644
--- a/frontend/src/lib/components/ui/button/button.svelte
+++ b/frontend/src/lib/components/ui/button/button.svelte
@@ -1,42 +1,42 @@
<script lang="ts" module>
- import { cn, type WithElementRef } from "$lib/utils.js";
- import type { HTMLAnchorAttributes, HTMLButtonAttributes } from "svelte/elements";
- import { type VariantProps, tv } from "tailwind-variants";
+ import { cn, type WithElementRef } from '$lib/utils.js';
+ import type { HTMLAnchorAttributes, HTMLButtonAttributes } from 'svelte/elements';
+ import { type VariantProps, tv } from 'tailwind-variants';
export const buttonVariants = tv({
- base: "cursor-pointer focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+ base: "cursor-pointer focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-[3px] rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
variants: {
variant: {
- default: "bg-primary text-primary-foreground hover:bg-primary/90 shadow-xs",
+ default: 'bg-primary text-primary-foreground hover:bg-primary/90 shadow-xs',
destructive:
- "bg-destructive hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white shadow-xs",
+ 'bg-destructive hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white shadow-xs',
destructiveOutline:
- "border border-destructive text-destructive hover:bg-destructive/10 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:border-destructive/60 dark:text-destructive/90 dark:hover:bg-destructive/20 shadow-xs",
+ 'border border-destructive text-destructive hover:bg-destructive/10 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:border-destructive/60 dark:text-destructive/90 dark:hover:bg-destructive/20 shadow-xs',
success:
- "bg-emerald-600 hover:bg-emerald-600/90 focus-visible:ring-emerald-600/20 dark:focus-visible:ring-emerald-600/40 dark:bg-emerald-600/60 text-white shadow-xs",
+ 'bg-emerald-600 hover:bg-emerald-600/90 focus-visible:ring-emerald-600/20 dark:focus-visible:ring-emerald-600/40 dark:bg-emerald-600/60 text-white shadow-xs',
outline:
- "bg-background hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 border shadow-xs",
- secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 shadow-xs",
- ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
- link: "text-primary underline-offset-4 hover:underline",
+ 'bg-background hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 border shadow-xs',
+ secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80 shadow-xs',
+ ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
+ link: 'text-primary underline-offset-4 hover:underline'
},
size: {
- default: "h-9 px-4 py-2 has-[>svg]:px-3",
- sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5",
- lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
- icon: "size-9",
- "icon-sm": "size-8",
- "icon-lg": "size-10",
- },
+ default: 'h-9 px-4 py-2 has-[>svg]:px-3',
+ sm: 'h-8 gap-[3px] rounded-md px-3 has-[>svg]:px-2.5',
+ lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
+ icon: 'size-9',
+ 'icon-sm': 'size-8',
+ 'icon-lg': 'size-10'
+ }
},
defaultVariants: {
- variant: "default",
- size: "default",
- },
+ variant: 'default',
+ size: 'default'
+ }
});
- export type ButtonVariant = VariantProps<typeof buttonVariants>["variant"];
- export type ButtonSize = VariantProps<typeof buttonVariants>["size"];
+ export type ButtonVariant = VariantProps<typeof buttonVariants>['variant'];
+ export type ButtonSize = VariantProps<typeof buttonVariants>['size'];
export type ButtonProps = WithElementRef<HTMLButtonAttributes> &
WithElementRef<HTMLAnchorAttributes> & {
@@ -48,11 +48,11 @@
<script lang="ts">
let {
class: className,
- variant = "default",
- size = "default",
+ variant = 'default',
+ size = 'default',
ref = $bindable(null),
href = undefined,
- type = "button",
+ type = 'button',
disabled,
children,
...restProps
@@ -66,7 +66,7 @@
class={cn(buttonVariants({ variant, size }), className)}
href={disabled ? undefined : href}
aria-disabled={disabled}
- role={disabled ? "link" : undefined}
+ role={disabled ? 'link' : undefined}
tabindex={disabled ? -1 : undefined}
{...restProps}
>
diff --git a/frontend/src/lib/types/dashboard.ts b/frontend/src/lib/types/dashboard.ts
index 624558d8..4de40a36 100644
--- a/frontend/src/lib/types/dashboard.ts
+++ b/frontend/src/lib/types/dashboard.ts
@@ -50,3 +50,41 @@ export type ServerMetricsData = {
availableServers: string[];
lastUpdated: Date;
};
+
+// New metrics query API types
+export type DiscoveredMetric = {
+ name: string;
+ tagKeys: string[];
+ metricType?: string;
+ unit?: string;
+};
+
+export type MetricQueryItem = {
+ name: string;
+ aggregation: string;
+ tagFilters?: Record<string, string>;
+ groupBy?: string;
+};
+
+export type MetricQueryRequest = {
+ queries: MetricQueryItem[];
+ from: string;
+ to: string;
+ intervalMinutes?: number;
+};
+
+export type TimeSeriesPoint = {
+ Timestamp: string;
+ Value: number;
+};
+
+export type MetricQueryResult = {
+ name: string;
+ series: Record<string, TimeSeriesPoint[]>;
+};
+
+export type MetricQueryResponse = {
+ results: MetricQueryResult[];
+};
+
+export type ExplorerMetricsTab = 'application' | 'stats' | 'server' | 'explorer';
diff --git a/frontend/src/routes/endpoints/[endpoint]/+page.svelte b/frontend/src/routes/endpoints/[endpoint]/+page.svelte
index 612c531e..75a9a692 100644
--- a/frontend/src/routes/endpoints/[endpoint]/+page.svelte
+++ b/frontend/src/routes/endpoints/[endpoint]/+page.svelte
@@ -544,7 +544,7 @@
</div>
<AlertDialog.Root bind:open={showSlowDialog}>
- <AlertDialog.Content>
+ <AlertDialog.Content interactOutsideBehavior="close">
<AlertDialog.Header>
<AlertDialog.Title>Expected Performance</AlertDialog.Title>
<AlertDialog.Description>
diff --git a/frontend/src/routes/metrics/+page.svelte b/frontend/src/routes/metrics/+page.svelte
index 04c35b9a..4ba24716 100644
--- a/frontend/src/routes/metrics/+page.svelte
+++ b/frontend/src/routes/metrics/+page.svelte
@@ -1,30 +1,19 @@
<script lang="ts">
import { onMount } from 'svelte';
- import { browser } from '$app/environment';
import { Button } from '$lib/components/ui/button';
- import { RefreshCw, Code, Info } from 'lucide-svelte';
- import * as Alert from '$lib/components/ui/alert';
- import ServerFilter from '$lib/components/dashboard/server-filter.svelte';
- import MetricsTabContent from '$lib/components/dashboard/metrics-tab-content.svelte';
+ import { Input } from '$lib/components/ui/input';
+ import { LoadingCircle } from '$lib/components/ui/loading-circle';
+ import * as AlertDialog from '$lib/components/ui/alert-dialog';
+ import * as Select from '$lib/components/ui/select';
import * as Tabs from '$lib/components/ui/tabs';
- import type {
- DashboardMetric,
- ServerMetricTrend,
- MetricTrendPoint,
- MetricsTab,
- ApplicationMetricsData,
- StatsMetricsData,
- ServerMetricsData
- } from '$lib/types/dashboard';
+ import WidgetGrid from '$lib/components/dashboard/widget-grid.svelte';
+ import WidgetConfigPanel from '$lib/components/dashboard/widget-config-panel.svelte';
import { api } from '$lib/api';
- import { projectsState, isJsFramework } from '$lib/state/projects.svelte';
+ import { projectsState } from '$lib/state/projects.svelte';
import { getTimezone } from '$lib/state/timezone.svelte';
import { toUTCISO, calendarDateTimeToLuxon, formatDateTime } from '$lib/utils/formatters';
import { TimeRangePicker } from '$lib/components/ui/time-range-picker';
- import { CalendarDate } from '@internationalized/date';
- import { getServerColorMap } from '$lib/utils/server-colors';
import {
- presetMinutes,
getTimeRangeFromPreset,
dateToCalendarDate,
dateToTimeString,
@@ -32,125 +21,110 @@
getResolvedTimeRange,
updateUrl
} from '$lib/utils/url-params';
+ import { CalendarDate } from '@internationalized/date';
+ import { Trash2, Plus, RefreshCw, CircleAlert } from 'lucide-svelte';
+ import * as Alert from '$lib/components/ui/alert';
+ import { toast } from 'svelte-sonner';
+ import type { DiscoveredMetric } from '$lib/types/dashboard';
const timezone = $derived(getTimezone());
- const hideApplicationTab = $derived(
- projectsState.currentProject ? isJsFramework(projectsState.currentProject.framework) : false
- );
-
- // Tab state
- let activeTab = $state<MetricsTab>('application');
-
- // 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()));
-
- // Parse extended URL params (includes servers and tab)
- function parseMetricsUrlParams(): {
- preset: string | null;
- from: Date | null;
- to: Date | null;
- servers: string[];
- tab: MetricsTab;
- } {
- if (!browser) return { preset: '24h', from: null, to: null, servers: [], tab: 'application' };
-
- const params = new URLSearchParams(window.location.search);
- const serversParam = params.get('servers');
- const tabParam = params.get('tab') as MetricsTab | null;
-
- const servers = serversParam ? serversParam.split(',').filter((s) => s.length > 0) : [];
- const defaultTab: MetricsTab = hideApplicationTab ? 'stats' : 'application';
- const tab: MetricsTab =
- tabParam && ['application', 'stats', 'server'].includes(tabParam)
- ? tabParam === 'application' && hideApplicationTab
- ? 'stats'
- : tabParam
- : defaultTab;
-
- const timeParams = parseTimeRangeFromUrl(timezone);
- return { ...timeParams, servers, tab };
- }
-
- // Initialize from URL or defaults
- const initialUrlParams = parseMetricsUrlParams();
+ type Widget = {
+ id: number;
+ title: string;
+ widgetType: string;
+ config: any;
+ position: number;
+ };
+
+ type WidgetGroup = {
+ id: number;
+ name: string;
+ description: string;
+ isDefault: boolean;
+ createdAt: string;
+ };
+
+ type WidgetGroupWithWidgets = WidgetGroup & {
+ widgets: Widget[];
+ };
+
+ let widgetGroups = $state<WidgetGroup[]>([]);
+ let loading = $state(true);
+ let activeTabId = $state<string>('');
+ let activeGroup = $state<WidgetGroupWithWidgets | null>(null);
+ let loadingGroup = $state(false);
+
+ let showCreateDialog = $state(false);
+ let newName = $state('');
+ let creating = $state(false);
+ let createError = $state('');
+
+ let showDeleteDialog = $state(false);
+ let deleting = $state(false);
+ let deleteError = $state('');
+
+ let showWidgetConfig = $state(false);
+ let editingWidget = $state<Widget | null>(null);
+ let availableMetrics = $state<DiscoveredMetric[]>([]);
+ let widgetConfigError = $state('');
+
+ let showDeleteWidgetDialog = $state(false);
+ let deletingWidget = $state<Widget | null>(null);
+ let deletingWidgetLoading = $state(false);
+ let deleteWidgetError = $state('');
+
+ let lastUpdated = $state<Date | null>(null);
+
+ let tabsListEl = $state<HTMLElement | null>(null);
+ let hasOverflow = $state(false);
+
+ const initialUrlParams = parseTimeRangeFromUrl(timezone);
const initialRange = getResolvedTimeRange(initialUrlParams, timezone);
- let selectedPreset = $state<string | null>(initialUrlParams.preset);
+ let selectedPreset = $state<string | null>(initialUrlParams.preset ?? '24h');
let fromDate = $state<CalendarDate>(dateToCalendarDate(initialRange.from, timezone));
let toDate = $state<CalendarDate>(dateToCalendarDate(initialRange.to, timezone));
let fromTime = $state(dateToTimeString(initialRange.from, timezone));
let toTime = $state(dateToTimeString(initialRange.to, timezone));
let sharedTimeDomain = $state<[Date, Date] | null>(null);
- // Initialize tab from URL
- activeTab = initialUrlParams.tab;
-
- // Update URL with current state
- function updateMetricsUrl(pushToHistory = true) {
- if (!browser) return;
-
- const params: Record<string, string | null | undefined> = {
- tab: activeTab
- };
+ const lastUpdatedFormatted = $derived(
+ lastUpdated ? formatDateTime(lastUpdated, { timezone, format: 'time' }) : ''
+ );
+ function reloadGroupWidgets() {
if (selectedPreset) {
- params.preset = selectedPreset;
- } else {
- params.from = getFromDateTimeUTC();
- params.to = getToDateTimeUTC();
+ const range = getTimeRangeFromPreset(selectedPreset, timezone);
+ fromDate = dateToCalendarDate(range.from, timezone);
+ toDate = dateToCalendarDate(range.to, timezone);
+ fromTime = dateToTimeString(range.from, timezone);
+ toTime = dateToTimeString(range.to, timezone);
}
+ sharedTimeDomain = [new Date(getFromDateTimeUTC()), new Date(getToDateTimeUTC())];
+ if (activeTabId) loadGroupWidgets(activeTabId);
+ }
- if (selectedServers.length > 0 && selectedServers.length < availableServers().length) {
- params.servers = selectedServers.join(',');
+ function checkOverflow() {
+ if (tabsListEl) {
+ hasOverflow = tabsListEl.scrollWidth > tabsListEl.clientWidth;
}
-
- updateUrl(params, { pushToHistory });
}
- // Handle browser back/forward navigation
- function handlePopState() {
- const urlParams = parseMetricsUrlParams();
- const range = getResolvedTimeRange(urlParams, timezone);
-
- selectedPreset = urlParams.preset;
- fromDate = dateToCalendarDate(range.from, timezone);
- fromTime = dateToTimeString(range.from, timezone);
- toDate = dateToCalendarDate(range.to, timezone);
- toTime = dateToTimeString(range.to, timezone);
- selectedServers = urlParams.servers;
- activeTab = urlParams.tab;
-
- // Clear cached data and reload active tab
- clearAllData();
- loadActiveTab(false);
- }
+ $effect(() => {
+ if (!tabsListEl) return;
+ const observer = new ResizeObserver(() => checkOverflow());
+ observer.observe(tabsListEl);
+ checkOverflow();
+ return () => observer.disconnect();
+ });
+
+ $effect(() => {
+ widgetGroups;
+ if (tabsListEl) {
+ requestAnimationFrame(() => checkOverflow());
+ }
+ });
function getFromDateTimeUTC(): string {
const [hour, minute] = (fromTime || '00:00').split(':').map(Number);
@@ -170,114 +144,119 @@
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 = '';
-
+ async function loadWidgetGroups() {
+ loading = true;
try {
- const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
- const response = await api.get(`/metrics/application?${queryParams}`, {
+ const response = await api.get('/widget-groups', {
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);
+ widgetGroups = response.widgetGroups || [];
+ if (widgetGroups.length > 0 && !activeTabId) {
+ activeTabId = String(widgetGroups[0].id);
+ }
+ } catch (e) {
+ console.error('Failed to load widget groups:', e);
} finally {
- loadingApplication = false;
+ loading = false;
}
}
- // Load Stats metrics
- async function loadStatsMetrics() {
- loadingStats = true;
- errorStats = '';
-
+ async function loadGroupWidgets(groupId: string) {
+ loadingGroup = true;
try {
- const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
- const response = await api.get(`/metrics/stats?${queryParams}`, {
+ const result = await api.get(`/widget-groups/${groupId}`, {
projectId: projectsState.currentProjectId ?? undefined
});
+ activeGroup = result;
+ lastUpdated = new Date();
+ } catch (e) {
+ console.error('Failed to load widget group:', e);
+ activeGroup = null;
+ } finally {
+ loadingGroup = false;
+ }
+ }
+
+ $effect(() => {
+ if (activeTabId) {
+ loadGroupWidgets(activeTabId);
+ }
+ });
+
+ $effect(() => {
+ if (!showWidgetConfig) {
+ widgetConfigError = '';
+ }
+ });
+
+ function handleTabChange(tab: string) {
+ activeTabId = tab;
+ showWidgetConfig = false;
+ editingWidget = null;
+ }
- statsData = {
- metrics: transformMetrics(response.metrics),
- lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date()
- };
+ async function createWidgetGroup() {
+ creating = true;
+ createError = '';
+ try {
+ const group = await api.post(
+ '/widget-groups',
+ { name: newName },
+ { projectId: projectsState.currentProjectId ?? undefined }
+ );
+ toast.success('Successfully created a new Widget Group', { position: 'top-center' });
+ showCreateDialog = false;
+ newName = '';
+ await loadWidgetGroups();
+ activeTabId = String(group.id);
} catch (e: any) {
- errorStats = e.message || 'Failed to load stats metrics';
- console.error(e);
+ if (e?.status === 422) {
+ createError = e.message;
+ } else {
+ console.error('Failed to create widget group:', e);
+ }
} finally {
- loadingStats = false;
+ creating = false;
}
}
- // Load Server metrics
- async function loadServerMetrics() {
- loadingServer = true;
- errorServer = '';
-
+ async function deleteWidgetGroup() {
+ if (!activeGroup) return;
+ deleting = true;
+ deleteError = '';
try {
- const queryParams = `fromDate=${getFromDateTimeUTC()}&toDate=${getToDateTimeUTC()}`;
- const response = await api.get(`/metrics/server?${queryParams}`, {
+ await api.delete(`/widget-groups/${activeGroup.id}`, {
projectId: projectsState.currentProjectId ?? undefined
});
-
- serverData = {
- metrics: transformMetrics(response.metrics),
- availableServers: response.availableServers || [],
- lastUpdated: response.lastUpdated ? new Date(response.lastUpdated) : new Date()
- };
+ showDeleteDialog = false;
+ activeTabId = '';
+ activeGroup = null;
+ await loadWidgetGroups();
+ if (widgetGroups.length > 0) {
+ activeTabId = String(widgetGroups[0].id);
+ }
} catch (e: any) {
- errorServer = e.message || 'Failed to load server metrics';
- console.error(e);
+ if (e?.status === 422) {
+ deleteError = e.message;
+ } else {
+ console.error('Failed to delete widget group:', e);
+ }
} finally {
- loadingServer = false;
+ deleting = false;
}
}
- // Load only the active tab's data (lazy loading)
- function loadActiveTab(pushToHistory = true) {
+ function handleTimeRangeChange(
+ from: { date: CalendarDate; time: string },
+ to: { date: CalendarDate; time: string },
+ preset: string | null
+ ) {
+ fromDate = from.date;
+ fromTime = from.time;
+ toDate = to.date;
+ toTime = to.time;
+ selectedPreset = preset;
+
if (selectedPreset) {
const range = getTimeRangeFromPreset(selectedPreset, timezone);
fromDate = dateToCalendarDate(range.from, timezone);
@@ -286,136 +265,136 @@
toTime = dateToTimeString(range.to, timezone);
}
- if (pushToHistory) updateMetricsUrl(true);
-
- // Update shared time domain
sharedTimeDomain = [new Date(getFromDateTimeUTC()), new Date(getToDateTimeUTC())];
+ updateUrl({ preset: selectedPreset ?? undefined });
+ }
- switch (activeTab) {
- case 'application':
- if (!applicationData) loadApplicationMetrics();
- break;
- case 'stats':
- if (!statsData) loadStatsMetrics();
- if (!serverData) loadServerMetrics();
- break;
- case 'server':
- if (!serverData) loadServerMetrics();
- break;
- }
+ function handleChartRangeSelect(from: Date, to: Date) {
+ 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')}`;
+ sharedTimeDomain = [from, to];
}
- // Force reload (for refresh button & time range change)
- function reloadActiveTab() {
- if (selectedPreset) {
- const range = getTimeRangeFromPreset(selectedPreset, timezone);
- fromDate = dateToCalendarDate(range.from, timezone);
- toDate = dateToCalendarDate(range.to, timezone);
- fromTime = dateToTimeString(range.from, timezone);
- toTime = dateToTimeString(range.to, timezone);
+ async function loadMetrics() {
+ try {
+ const discoverResponse = await api.get(
+ `/metrics/discover?from=${getFromDateTimeUTC()}&to=${getToDateTimeUTC()}`,
+ { projectId: projectsState.currentProjectId ?? undefined }
+ );
+ availableMetrics = discoverResponse.metrics || [];
+ } catch {
+ // ignore
}
+ }
- updateMetricsUrl(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();
- loadServerMetrics();
- break;
- case 'server':
- loadServerMetrics();
- break;
- }
+ function openAddWidget() {
+ editingWidget = null;
+ showWidgetConfig = true;
+ loadMetrics();
}
- // Handle time range change
- function handleTimeRangeChange(
- from: { date: CalendarDate; time: string },
- to: { date: CalendarDate; time: string },
- preset: string | null
- ) {
- fromDate = from.date;
- fromTime = from.time;
- toDate = to.date;
- toTime = to.time;
- selectedPreset = preset;
- reloadActiveTab();
+ function openEditWidget(widget: Widget) {
+ editingWidget = widget;
+ showWidgetConfig = true;
+ loadMetrics();
}
- // Handle tab change - lazy load if data not loaded
- function handleTabChange(tab: string) {
- activeTab = tab as MetricsTab;
- loadActiveTab(false);
- updateMetricsUrl(false);
+ function openDeleteWidgetDialog(widget: Widget) {
+ deletingWidget = widget;
+ showDeleteWidgetDialog = true;
}
- // Client-side server filtering - NO API call needed
- function handleServerSelectionChange(servers: string[]) {
- selectedServers = servers;
- updateMetricsUrl(false);
+ async function confirmDeleteWidget() {
+ if (!activeGroup || !deletingWidget?.id) return;
+ deletingWidgetLoading = true;
+ deleteWidgetError = '';
+ try {
+ await api.delete(`/widget-groups/${activeGroup.id}/widgets/${deletingWidget.id}`, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+ showDeleteWidgetDialog = false;
+ deletingWidget = null;
+ await loadGroupWidgets(activeTabId);
+ } catch (e: any) {
+ if (e?.status === 422) {
+ deleteWidgetError = e.message;
+ } else {
+ console.error('Failed to delete widget:', e);
+ }
+ } finally {
+ deletingWidgetLoading = false;
+ }
}
- // Handle drag-to-zoom selection from chart overlay
- function handleChartRangeSelect(from: Date, to: Date) {
- 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')}`;
- reloadActiveTab();
+ async function handleMoveWidget(widgetId: number, offset: number) {
+ if (!activeGroup) return;
+ try {
+ await api.put(
+ `/widget-groups/${activeGroup.id}/widgets/${widgetId}/move`,
+ { offset },
+ { projectId: projectsState.currentProjectId ?? undefined }
+ );
+ await loadGroupWidgets(activeTabId);
+ toast.success('Successfully moved the Widget', { position: 'top-center' });
+ } catch (e) {
+ console.error('Failed to move widget:', e);
+ }
}
- // 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;
+ async function handleWidgetSave(data: { title: string; widgetType: string; config: any }) {
+ if (!activeGroup) return;
+
+ widgetConfigError = '';
+ try {
+ if (editingWidget?.id) {
+ await api.put(`/widget-groups/${activeGroup.id}/widgets/${editingWidget.id}`, data, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+ toast.success('Successfully updated the Widget', { position: 'top-center' });
+ } else {
+ await api.post(`/widget-groups/${activeGroup.id}/widgets`, data, {
+ projectId: projectsState.currentProjectId ?? undefined
+ });
+ toast.success('Successfully added the Widget', { position: 'top-center' });
+ }
+ showWidgetConfig = false;
+ editingWidget = null;
+ await loadGroupWidgets(activeTabId);
+ } catch (e: any) {
+ if (e?.status === 422) {
+ widgetConfigError = e.message;
+ } else {
+ console.error('Failed to save widget:', e);
+ }
}
- });
+ }
- const lastUpdatedFormatted = $derived(
- lastUpdated() ? formatDateTime(lastUpdated()!, { timezone, format: 'time' }) : ''
+ const activeIsDefault = $derived(
+ widgetGroups.find((g) => String(g.id) === activeTabId)?.isDefault ?? 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;
- }
- });
+ const activeTabName = $derived(
+ widgetGroups.find((g) => String(g.id) === activeTabId)?.name ?? ''
+ );
onMount(() => {
- // Only load the active tab on mount (lazy loading)
- loadActiveTab(false);
+ loadWidgetGroups();
- window.addEventListener('popstate', handlePopState);
- return () => window.removeEventListener('popstate', handlePopState);
+ if (selectedPreset) {
+ const range = getTimeRangeFromPreset(selectedPreset, timezone);
+ fromDate = dateToCalendarDate(range.from, timezone);
+ toDate = dateToCalendarDate(range.to, timezone);
+ fromTime = dateToTimeString(range.from, timezone);
+ toTime = dateToTimeString(range.to, timezone);
+ }
+ sharedTimeDomain = [new Date(getFromDateTimeUTC()), new Date(getToDateTimeUTC())];
});
</script>
<div class="space-y-4">
- <!-- Header -->
<div class="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
<h2 class="text-2xl font-bold tracking-tight">Metrics</h2>
<div class="flex items-center gap-2">
@@ -427,121 +406,207 @@
bind:preset={selectedPreset}
onApply={handleTimeRangeChange}
/>
+ {#if !activeIsDefault && activeTabId}
+ <Button variant="destructive" size="sm" onclick={() => (showDeleteDialog = true)}>
+ <Trash2 class="mr-1 h-4 w-4" />
+ Delete
+ </Button>
+ {/if}
</div>
</div>
- <!-- 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>
- {#if !hideApplicationTab}
- <Tabs.Trigger value="application">Application</Tabs.Trigger>
- {/if}
- <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}
- />
- {/if}
- </div>
-
- {#if lastUpdated()}
- <div class="flex items-center gap-1">
- <span class="text-sm whitespace-nowrap text-muted-foreground">
- Updated: {lastUpdatedFormatted}
- </span>
-
- <Button
- variant="ghost"
- size="sm"
- onclick={() => reloadActiveTab()}
- disabled={isCurrentTabLoading()}
- >
- <RefreshCw class="h-4 w-4 {isCurrentTabLoading() ? 'animate-spin' : ''}" />
- </Button>
- </div>
- {/if}
+ {#if loading}
+ <div class="flex items-center justify-center py-20">
+ <LoadingCircle size="xlg" />
</div>
-
- <!-- 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">
- {#if availableServers().length > 1}
- <Alert.Root
- class="mt-2 mb-2 border-none"
- style="background: color-mix(in srgb, var(--sidebar-accent) 8%, transparent);"
+ {:else if widgetGroups.length === 0}
+ <div class="flex flex-col items-center justify-center py-20 text-center text-muted-foreground">
+ <p class="mb-4">No widget groups yet. Create one to get started.</p>
+ <Button onclick={() => (showCreateDialog = true)}>
+ <Plus class="mr-1 h-4 w-4" />
+ Create your first widget group
+ </Button>
+ </div>
+ {:else}
+ <Tabs.Root value={activeTabId} onValueChange={handleTabChange}>
+ <div class="flex items-center gap-2">
+ {#if hasOverflow}
+ <Select.Root
+ type="single"
+ value={activeTabId}
+ onValueChange={(v) => {
+ if (v) handleTabChange(v);
+ }}
+ >
+ <Select.Trigger size="sm">{activeTabName}</Select.Trigger>
+ <Select.Content>
+ {#each widgetGroups as group (group.id)}
+ <Select.Item value={String(group.id)}>{group.name}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ {/if}
+ <div
+ class="flex min-w-0 items-center overflow-hidden"
+ class:invisible={hasOverflow}
+ class:h-0={hasOverflow}
+ bind:this={tabsListEl}
>
- <Info class="h-4 w-4" style="color: var(--sidebar-accent);" />
- <Alert.Description style="color: var(--sidebar-accent);">
- Stats are aggregated across all servers. Switch to CPU / Mem for per-server breakdowns.
- </Alert.Description>
- </Alert.Root>
- {/if}
- <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="mb-4 rounded-full bg-muted p-3">
- <Code class="h-6 w-6 text-muted-foreground" />
+ <Tabs.List>
+ {#each widgetGroups as group (group.id)}
+ <Tabs.Trigger value={String(group.id)}>{group.name}</Tabs.Trigger>
+ {/each}
+ </Tabs.List>
</div>
- <h3 class="mb-2 text-lg font-semibold">Custom Metrics not supported</h3>
- <p class="mb-4 max-w-md text-sm text-muted-foreground">
- Custom Metrics are not currently supported, but we're working on it and hope to have them
- supported soon.
- </p>
+ <button
+ class="inline-flex items-center justify-center rounded-md px-2 py-1 text-muted-foreground transition-all hover:bg-muted hover:text-foreground"
+ onclick={() => (showCreateDialog = true)}
+ >
+ <Plus class="h-4 w-4" />
+ </button>
+ {#if lastUpdated}
+ <div class="ml-auto flex items-center gap-1">
+ <span class="text-sm whitespace-nowrap text-muted-foreground">
+ Updated: {lastUpdatedFormatted}
+ </span>
+ <Button variant="ghost" size="sm" onclick={reloadGroupWidgets} disabled={loadingGroup}>
+ <RefreshCw class="h-4 w-4 {loadingGroup ? 'animate-spin' : ''}" />
+ </Button>
+ </div>
+ {/if}
</div>
- </Tabs.Content>
- </Tabs.Root>
+
+ {#each widgetGroups as group (group.id)}
+ <Tabs.Content value={String(group.id)}>
+ {#if loadingGroup && activeTabId === String(group.id)}
+ <div class="flex items-center justify-center py-20">
+ <LoadingCircle size="xlg" />
+ </div>
+ {:else if activeGroup && activeTabId === String(group.id)}
+ <WidgetGrid
+ widgets={activeGroup.widgets ?? []}
+ fromDateUTC={getFromDateTimeUTC()}
+ toDateUTC={getToDateTimeUTC()}
+ timeDomain={sharedTimeDomain}
+ onEditWidget={openEditWidget}
+ onDeleteWidget={openDeleteWidgetDialog}
+ onMoveWidget={handleMoveWidget}
+ onAddWidget={openAddWidget}
+ onRangeSelect={handleChartRangeSelect}
+ />
+ {/if}
+ </Tabs.Content>
+ {/each}
+ </Tabs.Root>
+ {/if}
</div>
+
+<WidgetConfigPanel
+ bind:open={showWidgetConfig}
+ widget={editingWidget}
+ {availableMetrics}
+ error={widgetConfigError}
+ onSave={handleWidgetSave}
+ onCancel={() => {
+ showWidgetConfig = false;
+ editingWidget = null;
+ widgetConfigError = '';
+ }}
+/>
+
+<AlertDialog.Root
+ bind:open={showCreateDialog}
+ onOpenChange={(o) => {
+ if (!o) createError = '';
+ }}
+>
+ <AlertDialog.Content interactOutsideBehavior="close">
+ <AlertDialog.Header>
+ <AlertDialog.Title>New Widget Group</AlertDialog.Title>
+ </AlertDialog.Header>
+ {#if createError}
+ <Alert.Root variant="destructive" class="bg-red-50 border-red-200">
+ <CircleAlert class="h-4 w-4 text-red-700" />
+ <Alert.Title class="text-red-800">Error</Alert.Title>
+ <Alert.Description class="text-red-700">{createError}</Alert.Description>
+ </Alert.Root>
+ {/if}
+ <div class="space-y-4">
+ <div>
+ <label class="text-sm font-medium" for="new-group-name">Name</label>
+ <Input id="new-group-name" bind:value={newName} placeholder="My Group" maxlength={12} />
+ </div>
+ </div>
+ <AlertDialog.Footer>
+ <Button variant="outline" onclick={() => (showCreateDialog = false)}>Cancel</Button>
+ <Button onclick={createWidgetGroup} disabled={creating}>
+ {#if creating}Creating...{:else}<Plus class="mr-1 h-4 w-4" /> New Widget Group{/if}
+ </Button>
+ </AlertDialog.Footer>
+ </AlertDialog.Content>
+</AlertDialog.Root>
+
+<AlertDialog.Root
+ bind:open={showDeleteDialog}
+ onOpenChange={(o) => {
+ if (!o) deleteError = '';
+ }}
+>
+ <AlertDialog.Content interactOutsideBehavior="close">
+ <AlertDialog.Header>
+ <AlertDialog.Title>Delete Widget Group</AlertDialog.Title>
+ <AlertDialog.Description>
+ Are you sure you want to delete "{activeGroup?.name}"? This will remove all widgets in this
+ group. This action cannot be undone.
+ </AlertDialog.Description>
+ </AlertDialog.Header>
+ {#if deleteError}
+ <Alert.Root variant="destructive" class="bg-red-50 border-red-200">
+ <CircleAlert class="h-4 w-4 text-red-700" />
+ <Alert.Title class="text-red-800">Error</Alert.Title>
+ <Alert.Description class="text-red-700">{deleteError}</Alert.Description>
+ </Alert.Root>
+ {/if}
+ <AlertDialog.Footer>
+ <Button variant="outline" onclick={() => (showDeleteDialog = false)} disabled={deleting}
+ >Cancel</Button
+ >
+ <Button variant="destructive" onclick={deleteWidgetGroup} disabled={deleting}>
+ {deleting ? 'Deleting...' : 'Delete'}
+ </Button>
+ </AlertDialog.Footer>
+ </AlertDialog.Content>
+</AlertDialog.Root>
+
+<AlertDialog.Root
+ bind:open={showDeleteWidgetDialog}
+ onOpenChange={(o) => {
+ if (!o) deleteWidgetError = '';
+ }}
+>
+ <AlertDialog.Content interactOutsideBehavior="close">
+ <AlertDialog.Header>
+ <AlertDialog.Title>Delete Widget</AlertDialog.Title>
+ <AlertDialog.Description>
+ Are you sure you want to delete "{deletingWidget?.title}"? This action cannot be undone.
+ </AlertDialog.Description>
+ </AlertDialog.Header>
+ {#if deleteWidgetError}
+ <Alert.Root variant="destructive" class="bg-red-50 border-red-200">
+ <CircleAlert class="h-4 w-4 text-red-700" />
+ <Alert.Title class="text-red-800">Error</Alert.Title>
+ <Alert.Description class="text-red-700">{deleteWidgetError}</Alert.Description>
+ </Alert.Root>
+ {/if}
+ <AlertDialog.Footer>
+ <Button
+ variant="outline"
+ onclick={() => (showDeleteWidgetDialog = false)}
+ disabled={deletingWidgetLoading}>Cancel</Button
+ >
+ <Button variant="destructive" onclick={confirmDeleteWidget} disabled={deletingWidgetLoading}>
+ {deletingWidgetLoading ? 'Deleting...' : 'Delete'}
+ </Button>
+ </AlertDialog.Footer>
+ </AlertDialog.Content>
+</AlertDialog.Root>
diff --git a/testing/devtesting/devtesting.go b/testing/devtesting/devtesting.go
index a5cfc5c1..711c43d4 100644
--- a/testing/devtesting/devtesting.go
+++ b/testing/devtesting/devtesting.go
@@ -210,6 +210,25 @@ func testGin() {
traceway.PrintCollectionFrameMetrics()
})
+ router.GET("/test-metrics", func(ctx *gin.Context) {
+ queueSize := 50 + rand.IntN(450)
+ traceway.CaptureMetricWithTags("app.queue_size", float64(queueSize), map[string]string{
+ "queue": []string{"emails", "notifications", "exports"}[rand.IntN(3)],
+ "priority": []string{"high", "low"}[rand.IntN(2)],
+ })
+
+ latency := 5.0 + rand.Float64()*195.0
+ traceway.CaptureMetricWithTags("app.cache_latency_ms", latency, map[string]string{
+ "cache": []string{"redis", "memcached"}[rand.IntN(2)],
+ "operation": []string{"get", "set", "delete"}[rand.IntN(3)],
+ })
+
+ ctx.JSON(200, gin.H{
+ "queue_size": queueSize,
+ "cache_latency_ms": latency,
+ })
+ })
+
router.GET("/test-cerror-simple", func(ctx *gin.Context) {
ctx.Error(errors.New("simple error without stack"))
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "simple error"})