The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
feat: custom metrics with multiple different ways of displaying added
dduxb4fb4d925f06
diff --git a/CLAUDE.md b/CLAUDE.mdindex 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 PatternRepositories accept `*sql.Tx` to participate in transactions:```godiff --git a/backend/app/controllers/clientcontrollers/client.controller.go b/backend/app/controllers/clientcontrollers/client.controller.goindex 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.goindex 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 Usagespan = 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 Routinesspan = 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 Objectsspan = 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 GCspan = 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_000metrics = 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.gonew file mode 100644index 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.goindex 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 24hspan = 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 24hspan = 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.goindex 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 Routinesspan := 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 Objectsspan = 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_000metrics = 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 Usagespan := 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.goindex 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.MetricPointfor _, 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.ExportMetricsServiceRswitch 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 float64switch 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.goindex 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.sqlnew file mode 100644index 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 = 8192diff --git a/backend/app/migrations/ch/0028_create_metric_points_1m.up.sql b/backend/app/migrations/ch/0028_create_metric_points_1m.up.sqlnew file mode 100644index 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 = 8192diff --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.sqlnew file mode 100644index 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_atdiff --git a/backend/app/migrations/ch/0030_create_metric_points_1h.up.sql b/backend/app/migrations/ch/0030_create_metric_points_1h.up.sqlnew file mode 100644index 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 = 8192diff --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.sqlnew file mode 100644index 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_atdiff --git a/backend/app/migrations/ch/0032_create_metric_points_1d.up.sql b/backend/app/migrations/ch/0032_create_metric_points_1d.up.sqlnew file mode 100644index 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 = 8192diff --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.sqlnew file mode 100644index 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_atdiff --git a/backend/app/migrations/ch/0034_add_ttl_metric_points.up.sql b/backend/app/migrations/ch/0034_add_ttl_metric_points.up.sqlnew file mode 100644index 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 DAYdiff --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.sqlnew file mode 100644index 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 DAYdiff --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.sqlnew file mode 100644index 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 YEARdiff --git a/backend/app/migrations/pg/0016_create_metric_registry.up.sql b/backend/app/migrations/pg/0016_create_metric_registry.up.sqlnew file mode 100644index 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.sqlnew file mode 100644index 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.sqlnew file mode 100644index 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.sqlnew file mode 100644index 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.sqlnew file mode 100644index 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.goindex 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.goindex 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.gonew file mode 100644index 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.godeleted file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.tsindex 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, optionsthrow 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.svelteindex 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.sveltedeleted file mode 100644index 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.sveltenew file mode 100644index 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.sveltenew file mode 100644index 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.sveltenew file mode 100644index 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.sveltenew file mode 100644index 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.sveltenew file mode 100644index 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.svelteindex 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.tsindex 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.svelteindex 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.svelteindex 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 domainsharedTimeDomain = [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.goindex 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"})