Skip to content

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

better visibility

ddux894377c9402b
diff --git a/backend/app/controllers/dashboard.controller.go b/backend/app/controllers/dashboard.controller.go
index 666c1d71..c4a2267f 100644
--- a/backend/app/controllers/dashboard.controller.go
+++ b/backend/app/controllers/dashboard.controller.go
@@ -32,14 +32,18 @@ func (d dashboardController) GetDashboardOverview(c *gin.Context) {
start := now.Add(-24 * time.Hour)
// Get last 10 issues in the last 24 hours (only exceptions, not messages)
+ seg := traceway.StartSegment(c, "loading recent issues")
recentIssues, _, err := repositories.ExceptionStackTraceRepository.FindGrouped(c, projectId, start, now, 1, 10, "last_seen", "", "issues", false)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading recent issues: %w", err))
return
}
// Get 10 worst performing endpoints
+ seg = traceway.StartSegment(c, "loading worst endpoints")
worstEndpoints, err := repositories.EndpointRepository.FindWorstEndpoints(c, projectId, start, now, 10)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading worst endpoints: %w", err))
return
@@ -49,8 +53,10 @@ func (d dashboardController) GetDashboardOverview(c *gin.Context) {
if len(worstEndpoints) == 0 && len(recentIssues) == 0 {
// Check if project has received ANY data (all time, not just 24h)
var epoch time.Time // zero time = beginning of time
+ seg = traceway.StartSegment(c, "checking project data")
endpointCount, _ := repositories.EndpointRepository.CountBetween(c, projectId, epoch, now)
exceptionCount, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, epoch, now)
+ seg.End()
hasData = endpointCount > 0 || exceptionCount > 0
}
@@ -114,104 +120,136 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
metrics := make([]models.DashboardMetric, 0, 11)
// 1. Requests count
+ seg := traceway.StartSegment(c, "loading requests trend")
requestsTrend, err := repositories.EndpointRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsTrend: %w", err))
return
}
requestsCurrent, _ := repositories.EndpointRepository.CountBetween(c, projectId, start, end)
requestsPrev, _ := repositories.EndpointRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetric("requests", "Requests", float64(requestsCurrent), "count", requestsTrend, float64(requestsPrev), "requests"))
// 2. Exceptions count
+ seg = traceway.StartSegment(c, "loading exceptions trend")
exceptionsTrend, err := repositories.ExceptionStackTraceRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptionsTrend: %w", err))
return
}
exceptionsCurrent, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, start, end)
exceptionsPrev, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetric("exceptions", "Exceptions", float64(exceptionsCurrent), "count", exceptionsTrend, float64(exceptionsPrev), "exceptions"))
// 3. Average Response Time
+ seg = traceway.StartSegment(c, "loading avg response time")
avgDurationTrend, err := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading avgDurationTrend: %w", err))
return
}
avgDurationCurrent := getLastValue(avgDurationTrend)
avgDurationPrevTrend, _ := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
avgDurationPrev := getAverageValue(avgDurationPrevTrend)
+ seg.End()
metrics = append(metrics, buildMetric("avg_response_time", "Avg Response Time", avgDurationCurrent, "ms", avgDurationTrend, avgDurationPrev, "response_time"))
// 4. Error Rate
+ seg = traceway.StartSegment(c, "loading error rate")
errorRateTrend, err := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading errorRateTrend: %w", err))
return
}
errorRateCurrent := getLastValue(errorRateTrend)
errorRatePrevTrend, _ := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
errorRatePrev := getAverageValue(errorRatePrevTrend)
+ seg.End()
metrics = append(metrics, buildMetric("error_rate", "Error Rate", errorRateCurrent, "%", errorRateTrend, errorRatePrev, "error_rate"))
// 5. CPU Usage
+ seg = traceway.StartSegment(c, "loading cpu usage")
cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 6. Memory Usage (MB)
+ seg = traceway.StartSegment(c, "loading memory usage")
memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("memory_usage", "Memory Usage", "MB", memPerServer, memPrev, "memory"))
// 7. Total System Memory (MB)
+ seg = traceway.StartSegment(c, "loading total memory")
memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
// 8. Go Routines
+ seg = traceway.StartSegment(c, "loading go routines")
goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 9. Heap Objects
+ seg = traceway.StartSegment(c, "loading heap objects")
heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
// 10. Num GC
+ seg = traceway.StartSegment(c, "loading gc cycles")
numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("num_gc", "GC Cycles", "", numGCPerServer, numGCPrev, "num_gc"))
// 11. GC Pause Total (convert from nanoseconds to milliseconds)
+ seg = traceway.StartSegment(c, "loading gc pause")
gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
return
}
@@ -222,6 +260,7 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
}
}
gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
+ seg.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
diff --git a/backend/app/controllers/endpoint.controller.go b/backend/app/controllers/endpoint.controller.go
index e1c70372..31e2cbc2 100644
--- a/backend/app/controllers/endpoint.controller.go
+++ b/backend/app/controllers/endpoint.controller.go
@@ -56,7 +56,9 @@ func (e endpointController) FindAllEndpoints(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading endpoints")
endpoints, total, err := repositories.EndpointRepository.FindAll(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading endpoints: %w", err))
return
@@ -86,7 +88,9 @@ func (e endpointController) FindGroupedByEndpoint(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading grouped endpoints")
stats, total, err := repositories.EndpointRepository.FindGroupedByEndpoint(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats: %w", err))
return
@@ -128,14 +132,18 @@ func (e endpointController) FindByEndpoint(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading endpoint instances")
endpoints, total, err := repositories.EndpointRepository.FindByEndpoint(c, projectId, endpoint, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading endpoints: %w", err))
return
}
// Get aggregate stats for this endpoint
+ seg = traceway.StartSegment(c, "loading endpoint stats")
stats, err := repositories.EndpointRepository.GetEndpointStats(c, projectId, endpoint, request.FromDate, request.ToDate)
+ seg.End()
if err != nil {
// Don't fail the request if stats fail, just return nil stats
stats = nil
@@ -176,7 +184,9 @@ func (e endpointController) GetStackedChart(c *gin.Context) {
request.MetricType = "total_time" // default
}
+ seg := traceway.StartSegment(c, "loading stacked chart")
data, err := repositories.EndpointRepository.GetEndpointStackedChart(c, projectId, request.FromDate, request.ToDate, request.IntervalMinutes, request.MetricType)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stacked chart data: %w", err))
return
diff --git a/backend/app/controllers/endpoint_detail.controller.go b/backend/app/controllers/endpoint_detail.controller.go
index 30e8dc23..e7fb6d45 100644
--- a/backend/app/controllers/endpoint_detail.controller.go
+++ b/backend/app/controllers/endpoint_detail.controller.go
@@ -49,14 +49,18 @@ func (t endpointDetailController) GetEndpointDetail(c *gin.Context) {
}
// Get endpoint
+ seg := traceway.StartSegment(c, "loading endpoint")
endpoint, err := repositories.EndpointRepository.FindById(c, projectId, endpointId)
+ seg.End()
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Endpoint not found"})
return
}
// Get segments (flat list ordered by start_time)
+ seg = traceway.StartSegment(c, "loading segments")
segments, err := repositories.SegmentRepository.FindByTransactionId(c, projectId, endpointId)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading segments: %w", err))
return
@@ -66,7 +70,9 @@ func (t endpointDetailController) GetEndpointDetail(c *gin.Context) {
var exceptionInfo *EndpointExceptionInfo
var messages []EndpointMessageInfo
+ seg = traceway.StartSegment(c, "loading exceptions")
allExceptions, err := repositories.ExceptionStackTraceRepository.FindAllByTransactionId(c, projectId, endpointId)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading all exceptions: %w", err))
return
diff --git a/backend/app/controllers/exception_stack_trace.controller.go b/backend/app/controllers/exception_stack_trace.controller.go
index bcd676c1..57250132 100644
--- a/backend/app/controllers/exception_stack_trace.controller.go
+++ b/backend/app/controllers/exception_stack_trace.controller.go
@@ -52,7 +52,9 @@ func (e exceptionStackTraceController) FindGrouppedExceptionStackTraces(c *gin.C
return
}
+ seg := traceway.StartSegment(c, "loading grouped exceptions")
exceptions, total, err := repositories.ExceptionStackTraceRepository.FindGrouped(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.Search, request.SearchType, request.IncludeArchived)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptions: %w", err))
return
@@ -69,7 +71,9 @@ func (e exceptionStackTraceController) FindGrouppedExceptionStackTraces(c *gin.C
now := time.Now()
start24h := now.Add(-24 * time.Hour)
+ seg = traceway.StartSegment(c, "loading hourly trends")
trends, err := repositories.ExceptionStackTraceRepository.GetHourlyTrendForHashes(c, projectId, hashes, start24h, now)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading trends: %w", err))
return
@@ -115,7 +119,9 @@ func (e exceptionStackTraceController) FindByHash(c *gin.Context) {
request.Pagination = PaginationParams{Page: 1, PageSize: 20}
}
+ seg := traceway.StartSegment(c, "loading exception by hash")
group, occurrences, total, err := repositories.ExceptionStackTraceRepository.FindByHash(c, projectId, exceptionHash, request.Pagination.Page, request.Pagination.PageSize)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading the group: %w", err))
return
@@ -205,7 +211,9 @@ func (e exceptionStackTraceController) FindById(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading exception by id")
exception, err := repositories.ExceptionStackTraceRepository.FindById(c, projectId, exceptionId)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading the exception: %w", err))
return
diff --git a/backend/app/controllers/metric_record.controller.go b/backend/app/controllers/metric_record.controller.go
index 9f62ca67..3b726a05 100644
--- a/backend/app/controllers/metric_record.controller.go
+++ b/backend/app/controllers/metric_record.controller.go
@@ -26,48 +26,60 @@ func (e metricRecordController) FindHomepageStats(c *gin.Context) {
twoDaysAgo := now.Add(-48 * time.Hour)
// requests
+ seg := traceway.StartSegment(c, "loading requests stats")
requestsNow, err := repositories.EndpointRepository.CountBetween(c, projectId, oneDayAgo, now)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsNow: %w", err))
return
}
requestsPrev, err := repositories.EndpointRepository.CountBetween(c, projectId, twoDaysAgo, oneDayAgo)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsPrev: %w", err))
return
}
// exceptions
+ seg = traceway.StartSegment(c, "loading exceptions stats")
exceptionsNow, err := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, oneDayAgo, now)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptionsNow: %w", err))
return
}
exceptionsPrev, err := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, twoDaysAgo, oneDayAgo)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptionsPrev: %w", err))
return
}
// ram usage last 24h vs previous 24h
+ seg = traceway.StartSegment(c, "loading ram usage")
ramNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, oneDayAgo, now)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading ramNow: %w", err))
return
}
ramPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, twoDaysAgo, oneDayAgo)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading ramPrev: %w", err))
return
}
// memory usage last 24h vs previous 24h
+ seg = traceway.StartSegment(c, "loading cpu usage")
cpuNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, oneDayAgo, now)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuNow: %w", err))
return
}
cpuPrev, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, twoDaysAgo, oneDayAgo)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPrev: %w", err))
return
diff --git a/backend/app/controllers/metrics.controller.go b/backend/app/controllers/metrics.controller.go
index ca04d053..3724cc80 100644
--- a/backend/app/controllers/metrics.controller.go
+++ b/backend/app/controllers/metrics.controller.go
@@ -62,35 +62,46 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
metrics := make([]models.DashboardMetric, 0, 4)
// 1. Go Routines
+ seg := traceway.StartSegment(c, "loading go routines")
goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 2. Heap Objects
+ seg = traceway.StartSegment(c, "loading heap objects")
heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
// 3. GC Cycles (Num GC)
+ seg = traceway.StartSegment(c, "loading gc cycles")
numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("num_gc", "GC Cycles", "", numGCPerServer, numGCPrev, "num_gc"))
// 4. GC Pause Total (convert from nanoseconds to milliseconds)
+ seg = traceway.StartSegment(c, "loading gc pause")
gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
return
}
@@ -101,6 +112,7 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
}
}
gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
+ seg.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
@@ -133,45 +145,57 @@ func (m metricsController) GetStatsMetrics(c *gin.Context) {
metrics := make([]models.DashboardMetric, 0, 4)
// 1. Requests count
+ seg := traceway.StartSegment(c, "loading requests trend")
requestsTrend, err := repositories.EndpointRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsTrend: %w", err))
return
}
requestsCurrent, _ := repositories.EndpointRepository.CountBetween(c, projectId, start, end)
requestsPrev, _ := repositories.EndpointRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetric("requests", "Requests", float64(requestsCurrent), "count", requestsTrend, float64(requestsPrev), "requests"))
// 2. Exceptions count
+ seg = traceway.StartSegment(c, "loading exceptions trend")
exceptionsTrend, err := repositories.ExceptionStackTraceRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptionsTrend: %w", err))
return
}
exceptionsCurrent, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, start, end)
exceptionsPrev, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetric("exceptions", "Exceptions", float64(exceptionsCurrent), "count", exceptionsTrend, float64(exceptionsPrev), "exceptions"))
// 3. Average Response Time
+ seg = traceway.StartSegment(c, "loading avg response time")
avgDurationTrend, err := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading avgDurationTrend: %w", err))
return
}
avgDurationCurrent := getLastValue(avgDurationTrend)
avgDurationPrevTrend, _ := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
avgDurationPrev := getAverageValue(avgDurationPrevTrend)
+ seg.End()
metrics = append(metrics, buildMetric("avg_response_time", "Avg Response Time", avgDurationCurrent, "ms", avgDurationTrend, avgDurationPrev, "response_time"))
// 4. Error Rate
+ seg = traceway.StartSegment(c, "loading error rate")
errorRateTrend, err := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading errorRateTrend: %w", err))
return
}
errorRateCurrent := getLastValue(errorRateTrend)
errorRatePrevTrend, _ := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, prevStart, prevEnd, intervalMinutes)
errorRatePrev := getAverageValue(errorRatePrevTrend)
+ seg.End()
metrics = append(metrics, buildMetric("error_rate", "Error Rate", errorRateCurrent, "%", errorRateTrend, errorRatePrev, "error_rate"))
c.JSON(http.StatusOK, StatsMetricsResponse{
@@ -211,30 +235,39 @@ func (m metricsController) GetServerMetrics(c *gin.Context) {
metrics := make([]models.DashboardMetric, 0, 3)
// 1. CPU Usage
+ seg := traceway.StartSegment(c, "loading cpu usage")
cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 2. Memory Usage (MB)
+ seg = traceway.StartSegment(c, "loading memory usage")
memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("memory_usage", "Memory Usage", "MB", memPerServer, memPrev, "memory"))
// 3. Total System Memory (MB)
+ seg = traceway.StartSegment(c, "loading total memory")
memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
+ seg.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
+ seg.End()
metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
c.JSON(http.StatusOK, ServerMetricsResponse{
diff --git a/backend/app/controllers/task.controller.go b/backend/app/controllers/task.controller.go
index 8703ce57..8eecc15b 100644
--- a/backend/app/controllers/task.controller.go
+++ b/backend/app/controllers/task.controller.go
@@ -49,7 +49,9 @@ func (e taskController) FindAllTasks(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading tasks")
tasks, total, err := repositories.TaskRepository.FindAll(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading tasks: %w", err))
return
@@ -79,7 +81,9 @@ func (e taskController) FindGroupedByTaskName(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading grouped tasks")
stats, total, err := repositories.TaskRepository.FindGroupedByTaskName(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats by name: %w", err))
return
@@ -121,14 +125,18 @@ func (e taskController) FindByTaskName(c *gin.Context) {
return
}
+ seg := traceway.StartSegment(c, "loading task instances")
tasks, total, err := repositories.TaskRepository.FindByTaskName(c, projectId, taskName, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading tasks by name: %w", err))
return
}
// Get aggregate stats for this task
+ seg = traceway.StartSegment(c, "loading task stats")
stats, err := repositories.TaskRepository.GetTaskStats(c, projectId, taskName, request.FromDate, request.ToDate)
+ seg.End()
if err != nil {
// Don't fail the request if stats fail, just return nil stats
stats = nil
diff --git a/backend/app/controllers/task_detail.controller.go b/backend/app/controllers/task_detail.controller.go
index 5938a243..b186c5b4 100644
--- a/backend/app/controllers/task_detail.controller.go
+++ b/backend/app/controllers/task_detail.controller.go
@@ -49,14 +49,18 @@ func (t taskDetailController) GetTaskDetail(c *gin.Context) {
}
// Get task
+ seg := traceway.StartSegment(c, "loading task")
task, err := repositories.TaskRepository.FindById(c, projectId, taskId)
+ seg.End()
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Task not found"})
return
}
// Get segments (flat list ordered by start_time)
+ seg = traceway.StartSegment(c, "loading segments")
segments, err := repositories.SegmentRepository.FindByTransactionId(c, projectId, taskId)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading segments: %w", err))
return
@@ -66,7 +70,9 @@ func (t taskDetailController) GetTaskDetail(c *gin.Context) {
var exceptionInfo *TaskExceptionInfo
var messages []TaskMessageInfo
+ seg = traceway.StartSegment(c, "loading exceptions")
allExceptions, err := repositories.ExceptionStackTraceRepository.FindAllByTransactionId(c, projectId, taskId)
+ seg.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading allExceptions: %w", err))
return