Skip to content

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

renamed segments to spans

ddux3d0782c3dd0b
diff --git a/backend/app/controllers/clientcontrollers/client.controller.go b/backend/app/controllers/clientcontrollers/client.controller.go
index 69d688d0..07554e3c 100644
--- a/backend/app/controllers/clientcontrollers/client.controller.go
+++ b/backend/app/controllers/clientcontrollers/client.controller.go
@@ -51,7 +51,7 @@ func (e clientController) Report(c *gin.Context) {
tasksToInsert := []models.Task{}
exceptionStackTraceToInsert := []models.ExceptionStackTrace{}
metricRecordsToInsert := []models.MetricRecord{}
- segmentsToInsert := []models.Segment{}
+ spansToInsert := []models.Span{}
for _, cf := range request.CollectionFrames {
for _, ct := range cf.Traces {
if ct.IsTask {
@@ -64,11 +64,11 @@ func (e clientController) Report(c *gin.Context) {
endpointsToInsert = append(endpointsToInsert, e)
}
- // Extract segments from transaction
- for _, cs := range ct.Segments {
- seg := cs.ToSegment(ct.ParsedId())
- seg.ProjectId = projectId
- segmentsToInsert = append(segmentsToInsert, seg)
+ // Extract spans from trace
+ for _, cs := range ct.Spans {
+ span := cs.ToSpan(ct.ParsedId())
+ span.ProjectId = projectId
+ spansToInsert = append(spansToInsert, span)
}
}
@@ -116,10 +116,10 @@ func (e clientController) Report(c *gin.Context) {
return
}
- err = repositories.SegmentRepository.InsertAsync(c, segmentsToInsert)
+ err = repositories.SpanRepository.InsertAsync(c, spansToInsert)
if err != nil {
- c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting segmentsToInsert: %w", err))
+ c.AbortWithError(500, traceway.NewStackTraceErrorf("error inserting spansToInsert: %w", err))
return
}
diff --git a/backend/app/controllers/dashboard.controller.go b/backend/app/controllers/dashboard.controller.go
index c4a2267f..104a4557 100644
--- a/backend/app/controllers/dashboard.controller.go
+++ b/backend/app/controllers/dashboard.controller.go
@@ -32,18 +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")
+ span := traceway.StartSpan(c, "loading recent issues")
recentIssues, _, err := repositories.ExceptionStackTraceRepository.FindGrouped(c, projectId, start, now, 1, 10, "last_seen", "", "issues", false)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading worst endpoints")
worstEndpoints, err := repositories.EndpointRepository.FindWorstEndpoints(c, projectId, start, now, 10)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading worst endpoints: %w", err))
return
@@ -53,10 +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")
+ span = traceway.StartSpan(c, "checking project data")
endpointCount, _ := repositories.EndpointRepository.CountBetween(c, projectId, epoch, now)
exceptionCount, _ := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, epoch, now)
- seg.End()
+ span.End()
hasData = endpointCount > 0 || exceptionCount > 0
}
@@ -120,136 +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")
+ span := traceway.StartSpan(c, "loading requests trend")
requestsTrend, err := repositories.EndpointRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.End()
metrics = append(metrics, buildMetric("requests", "Requests", float64(requestsCurrent), "count", requestsTrend, float64(requestsPrev), "requests"))
// 2. Exceptions count
- seg = traceway.StartSegment(c, "loading exceptions trend")
+ span = traceway.StartSpan(c, "loading exceptions trend")
exceptionsTrend, err := repositories.ExceptionStackTraceRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.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")
+ span = traceway.StartSpan(c, "loading avg response time")
avgDurationTrend, err := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.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")
+ span = traceway.StartSpan(c, "loading error rate")
errorRateTrend, err := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.End()
metrics = append(metrics, buildMetric("error_rate", "Error Rate", errorRateCurrent, "%", errorRateTrend, errorRatePrev, "error_rate"))
// 5. CPU Usage
- seg = traceway.StartSegment(c, "loading cpu usage")
+ span = traceway.StartSpan(c, "loading cpu usage")
cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 6. Memory Usage (MB)
- seg = traceway.StartSegment(c, "loading memory usage")
+ span = traceway.StartSpan(c, "loading memory usage")
memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading total memory")
memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("memory_total", "Total Memory", "MB", memTotalPerServer, memTotalPrev, "memory_total"))
// 8. Go Routines
- seg = traceway.StartSegment(c, "loading go routines")
+ span = traceway.StartSpan(c, "loading go routines")
goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 9. Heap Objects
- seg = traceway.StartSegment(c, "loading heap objects")
+ span = traceway.StartSpan(c, "loading heap objects")
heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("heap_objects", "Heap Objects", "", heapObjectsPerServer, heapObjectsPrev, "heap_objects"))
// 10. Num GC
- seg = traceway.StartSegment(c, "loading gc cycles")
+ span = traceway.StartSpan(c, "loading gc cycles")
numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading gc pause")
gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, selectedServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
return
}
@@ -260,7 +260,7 @@ func (d dashboardController) GetDashboard(c *gin.Context) {
}
}
gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
- seg.End()
+ span.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
diff --git a/backend/app/controllers/endpoint.controller.go b/backend/app/controllers/endpoint.controller.go
index 31e2cbc2..d8dbe0ed 100644
--- a/backend/app/controllers/endpoint.controller.go
+++ b/backend/app/controllers/endpoint.controller.go
@@ -56,9 +56,9 @@ func (e endpointController) FindAllEndpoints(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading endpoints")
+ span := traceway.StartSpan(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()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading endpoints: %w", err))
return
@@ -88,9 +88,9 @@ func (e endpointController) FindGroupedByEndpoint(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading grouped endpoints")
+ span := traceway.StartSpan(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()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats: %w", err))
return
@@ -132,18 +132,18 @@ func (e endpointController) FindByEndpoint(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading endpoint instances")
+ span := traceway.StartSpan(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()
+ span.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")
+ span = traceway.StartSpan(c, "loading endpoint stats")
stats, err := repositories.EndpointRepository.GetEndpointStats(c, projectId, endpoint, request.FromDate, request.ToDate)
- seg.End()
+ span.End()
if err != nil {
// Don't fail the request if stats fail, just return nil stats
stats = nil
@@ -184,9 +184,9 @@ func (e endpointController) GetStackedChart(c *gin.Context) {
request.MetricType = "total_time" // default
}
- seg := traceway.StartSegment(c, "loading stacked chart")
+ span := traceway.StartSpan(c, "loading stacked chart")
data, err := repositories.EndpointRepository.GetEndpointStackedChart(c, projectId, request.FromDate, request.ToDate, request.IntervalMinutes, request.MetricType)
- seg.End()
+ span.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 239c03a6..364b8996 100644
--- a/backend/app/controllers/endpoint_detail.controller.go
+++ b/backend/app/controllers/endpoint_detail.controller.go
@@ -28,9 +28,9 @@ type EndpointMessageInfo struct {
}
type EndpointDetailResponse struct {
- Endpoint *models.Endpoint `json:"endpoint"`
- Segments []models.Segment `json:"segments"`
- HasSegments bool `json:"hasSegments"`
+ Endpoint *models.Endpoint `json:"endpoint"`
+ Spans []models.Span `json:"spans"`
+ HasSpans bool `json:"hasSpans"`
Exception *EndpointExceptionInfo `json:"exception,omitempty"`
Messages []EndpointMessageInfo `json:"messages"`
}
@@ -49,20 +49,20 @@ func (t endpointDetailController) GetEndpointDetail(c *gin.Context) {
}
// Get endpoint
- seg := traceway.StartSegment(c, "loading endpoint")
+ span := traceway.StartSpan(c, "loading endpoint")
endpoint, err := repositories.EndpointRepository.FindById(c, projectId, endpointId)
- seg.End()
+ span.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.FindByTraceId(c, projectId, endpointId)
- seg.End()
+ // Get spans (flat list ordered by start_time)
+ span = traceway.StartSpan(c, "loading spans")
+ spans, err := repositories.SpanRepository.FindByTraceId(c, projectId, endpointId)
+ span.End()
if err != nil {
- c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading segments: %w", err))
+ c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading spans: %w", err))
return
}
@@ -70,9 +70,9 @@ func (t endpointDetailController) GetEndpointDetail(c *gin.Context) {
var exceptionInfo *EndpointExceptionInfo
var messages []EndpointMessageInfo
- seg = traceway.StartSegment(c, "loading exceptions")
+ span = traceway.StartSpan(c, "loading exceptions")
allExceptions, err := repositories.ExceptionStackTraceRepository.FindAllByTraceId(c, projectId, endpointId)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading all exceptions: %w", err))
return
@@ -103,9 +103,9 @@ func (t endpointDetailController) GetEndpointDetail(c *gin.Context) {
}
c.JSON(http.StatusOK, EndpointDetailResponse{
- Endpoint: endpoint,
- Segments: segments,
- HasSegments: len(segments) > 0,
+ Endpoint: endpoint,
+ Spans: spans,
+ HasSpans: len(spans) > 0,
Exception: exceptionInfo,
Messages: messages,
})
diff --git a/backend/app/controllers/exception_stack_trace.controller.go b/backend/app/controllers/exception_stack_trace.controller.go
index 57250132..4ff36ae2 100644
--- a/backend/app/controllers/exception_stack_trace.controller.go
+++ b/backend/app/controllers/exception_stack_trace.controller.go
@@ -52,9 +52,9 @@ func (e exceptionStackTraceController) FindGrouppedExceptionStackTraces(c *gin.C
return
}
- seg := traceway.StartSegment(c, "loading grouped exceptions")
+ span := traceway.StartSpan(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()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptions: %w", err))
return
@@ -71,9 +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")
+ span = traceway.StartSpan(c, "loading hourly trends")
trends, err := repositories.ExceptionStackTraceRepository.GetHourlyTrendForHashes(c, projectId, hashes, start24h, now)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading trends: %w", err))
return
@@ -119,9 +119,9 @@ func (e exceptionStackTraceController) FindByHash(c *gin.Context) {
request.Pagination = PaginationParams{Page: 1, PageSize: 20}
}
- seg := traceway.StartSegment(c, "loading exception by hash")
+ span := traceway.StartSpan(c, "loading exception by hash")
group, occurrences, total, err := repositories.ExceptionStackTraceRepository.FindByHash(c, projectId, exceptionHash, request.Pagination.Page, request.Pagination.PageSize)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading the group: %w", err))
return
@@ -211,9 +211,9 @@ func (e exceptionStackTraceController) FindById(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading exception by id")
+ span := traceway.StartSpan(c, "loading exception by id")
exception, err := repositories.ExceptionStackTraceRepository.FindById(c, projectId, exceptionId)
- seg.End()
+ span.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 3b726a05..f4e7f643 100644
--- a/backend/app/controllers/metric_record.controller.go
+++ b/backend/app/controllers/metric_record.controller.go
@@ -26,60 +26,60 @@ func (e metricRecordController) FindHomepageStats(c *gin.Context) {
twoDaysAgo := now.Add(-48 * time.Hour)
// requests
- seg := traceway.StartSegment(c, "loading requests stats")
+ span := traceway.StartSpan(c, "loading requests stats")
requestsNow, err := repositories.EndpointRepository.CountBetween(c, projectId, oneDayAgo, now)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsNow: %w", err))
return
}
requestsPrev, err := repositories.EndpointRepository.CountBetween(c, projectId, twoDaysAgo, oneDayAgo)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading requestsPrev: %w", err))
return
}
// exceptions
- seg = traceway.StartSegment(c, "loading exceptions stats")
+ span = traceway.StartSpan(c, "loading exceptions stats")
exceptionsNow, err := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, oneDayAgo, now)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading exceptionsNow: %w", err))
return
}
exceptionsPrev, err := repositories.ExceptionStackTraceRepository.CountBetween(c, projectId, twoDaysAgo, oneDayAgo)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading ram usage")
ramNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, oneDayAgo, now)
if err != nil {
- seg.End()
+ span.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()
+ span.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")
+ span = traceway.StartSpan(c, "loading cpu usage")
cpuNow, err := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, oneDayAgo, now)
if err != nil {
- seg.End()
+ span.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()
+ span.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 3724cc80..b8e3d956 100644
--- a/backend/app/controllers/metrics.controller.go
+++ b/backend/app/controllers/metrics.controller.go
@@ -62,46 +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")
+ span := traceway.StartSpan(c, "loading go routines")
goRoutinesPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGoRoutines, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading goRoutinesPerServer: %w", err))
return
}
goRoutinesPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGoRoutines, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("go_routines", "Go Routines", "", goRoutinesPerServer, goRoutinesPrev, "go_routines"))
// 2. Heap Objects
- seg = traceway.StartSegment(c, "loading heap objects")
+ span = traceway.StartSpan(c, "loading heap objects")
heapObjectsPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameHeapObjects, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading heapObjectsPerServer: %w", err))
return
}
heapObjectsPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameHeapObjects, prevStart, prevEnd)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading gc cycles")
numGCPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameNumGC, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading numGCPerServer: %w", err))
return
}
numGCPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameNumGC, prevStart, prevEnd)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading gc pause")
gcPausePerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameGCPauseTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading gcPausePerServer: %w", err))
return
}
@@ -112,7 +112,7 @@ func (m metricsController) GetApplicationMetrics(c *gin.Context) {
}
}
gcPausePrevRaw, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameGCPauseTotal, prevStart, prevEnd)
- seg.End()
+ span.End()
gcPausePrev := gcPausePrevRaw / 1_000_000
metrics = append(metrics, buildMetricWithServers("gc_pause", "GC Pause", "ms", gcPausePerServer, gcPausePrev, "gc_pause"))
@@ -145,57 +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")
+ span := traceway.StartSpan(c, "loading requests trend")
requestsTrend, err := repositories.EndpointRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.End()
metrics = append(metrics, buildMetric("requests", "Requests", float64(requestsCurrent), "count", requestsTrend, float64(requestsPrev), "requests"))
// 2. Exceptions count
- seg = traceway.StartSegment(c, "loading exceptions trend")
+ span = traceway.StartSpan(c, "loading exceptions trend")
exceptionsTrend, err := repositories.ExceptionStackTraceRepository.CountByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.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")
+ span = traceway.StartSpan(c, "loading avg response time")
avgDurationTrend, err := repositories.EndpointRepository.AvgDurationByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.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")
+ span = traceway.StartSpan(c, "loading error rate")
errorRateTrend, err := repositories.EndpointRepository.ErrorRateByInterval(c, projectId, start, end, intervalMinutes)
if err != nil {
- seg.End()
+ span.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()
+ span.End()
metrics = append(metrics, buildMetric("error_rate", "Error Rate", errorRateCurrent, "%", errorRateTrend, errorRatePrev, "error_rate"))
c.JSON(http.StatusOK, StatsMetricsResponse{
@@ -235,39 +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")
+ span := traceway.StartSpan(c, "loading cpu usage")
cpuPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameCpuUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading cpuPerServer: %w", err))
return
}
cpuPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameCpuUsage, prevStart, prevEnd)
- seg.End()
+ span.End()
metrics = append(metrics, buildMetricWithServers("cpu_usage", "CPU Usage", "%", cpuPerServer, cpuPrev, "cpu"))
// 2. Memory Usage (MB)
- seg = traceway.StartSegment(c, "loading memory usage")
+ span = traceway.StartSpan(c, "loading memory usage")
memPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryUsage, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memPerServer: %w", err))
return
}
memPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryUsage, prevStart, prevEnd)
- seg.End()
+ span.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")
+ span = traceway.StartSpan(c, "loading total memory")
memTotalPerServer, err := repositories.MetricRecordRepository.GetAverageByIntervalPerServer(c, projectId, models.MetricNameMemoryTotal, start, end, intervalMinutes, emptyServers)
if err != nil {
- seg.End()
+ span.End()
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading memTotalPerServer: %w", err))
return
}
memTotalPrev, _ := repositories.MetricRecordRepository.GetAverageBetween(c, projectId, models.MetricNameMemoryTotal, prevStart, prevEnd)
- seg.End()
+ span.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 8eecc15b..8e4d3317 100644
--- a/backend/app/controllers/task.controller.go
+++ b/backend/app/controllers/task.controller.go
@@ -49,9 +49,9 @@ func (e taskController) FindAllTasks(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading tasks")
+ span := traceway.StartSpan(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()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading tasks: %w", err))
return
@@ -81,9 +81,9 @@ func (e taskController) FindGroupedByTaskName(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading grouped tasks")
+ span := traceway.StartSpan(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()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats by name: %w", err))
return
@@ -125,18 +125,18 @@ func (e taskController) FindByTaskName(c *gin.Context) {
return
}
- seg := traceway.StartSegment(c, "loading task instances")
+ span := traceway.StartSpan(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()
+ span.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")
+ span = traceway.StartSpan(c, "loading task stats")
stats, err := repositories.TaskRepository.GetTaskStats(c, projectId, taskName, request.FromDate, request.ToDate)
- seg.End()
+ span.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 9360af00..d5bbc46b 100644
--- a/backend/app/controllers/task_detail.controller.go
+++ b/backend/app/controllers/task_detail.controller.go
@@ -28,9 +28,9 @@ type TaskMessageInfo struct {
}
type TaskDetailResponse struct {
- Task *models.Task `json:"task"`
- Segments []models.Segment `json:"segments"`
- HasSegments bool `json:"hasSegments"`
+ Task *models.Task `json:"task"`
+ Spans []models.Span `json:"spans"`
+ HasSpans bool `json:"hasSpans"`
Exception *TaskExceptionInfo `json:"exception,omitempty"`
Messages []TaskMessageInfo `json:"messages"`
}
@@ -49,20 +49,20 @@ func (t taskDetailController) GetTaskDetail(c *gin.Context) {
}
// Get task
- seg := traceway.StartSegment(c, "loading task")
+ span := traceway.StartSpan(c, "loading task")
task, err := repositories.TaskRepository.FindById(c, projectId, taskId)
- seg.End()
+ span.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.FindByTraceId(c, projectId, taskId)
- seg.End()
+ // Get spans (flat list ordered by start_time)
+ span = traceway.StartSpan(c, "loading spans")
+ spans, err := repositories.SpanRepository.FindByTraceId(c, projectId, taskId)
+ span.End()
if err != nil {
- c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading segments: %w", err))
+ c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading spans: %w", err))
return
}
@@ -70,9 +70,9 @@ func (t taskDetailController) GetTaskDetail(c *gin.Context) {
var exceptionInfo *TaskExceptionInfo
var messages []TaskMessageInfo
- seg = traceway.StartSegment(c, "loading exceptions")
+ span = traceway.StartSpan(c, "loading exceptions")
allExceptions, err := repositories.ExceptionStackTraceRepository.FindAllByTraceId(c, projectId, taskId)
- seg.End()
+ span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading allExceptions: %w", err))
return
@@ -103,9 +103,9 @@ func (t taskDetailController) GetTaskDetail(c *gin.Context) {
}
c.JSON(http.StatusOK, TaskDetailResponse{
- Task: task,
- Segments: segments,
- HasSegments: len(segments) > 0,
+ Task: task,
+ Spans: spans,
+ HasSpans: len(spans) > 0,
Exception: exceptionInfo,
Messages: messages,
})
diff --git a/backend/app/migrations/ch/0012_rename_segments_to_spans.up.sql b/backend/app/migrations/ch/0012_rename_segments_to_spans.up.sql
new file mode 100644
index 00000000..5f43530c
--- /dev/null
+++ b/backend/app/migrations/ch/0012_rename_segments_to_spans.up.sql
@@ -0,0 +1 @@
+RENAME TABLE segments TO spans;
diff --git a/backend/app/models/clientmodels/clientmodels.model.go b/backend/app/models/clientmodels/clientmodels.model.go
index 3a64df49..69aae286 100644
--- a/backend/app/models/clientmodels/clientmodels.model.go
+++ b/backend/app/models/clientmodels/clientmodels.model.go
@@ -66,7 +66,7 @@ type ClientTrace struct {
BodySize int `json:"bodySize"`
ClientIP string `json:"clientIP"`
Scope map[string]string `json:"scope"`
- Segments []*ClientSegment `json:"segments"`
+ Spans []*ClientSpan `json:"spans"`
IsTask bool `json:"isTask"`
}
@@ -106,23 +106,23 @@ func (c *ClientTrace) ToTask(appVersion, serverName string) models.Task {
}
}
-type ClientSegment struct {
+type ClientSpan struct {
Id string `json:"id"`
Name string `json:"name"`
StartTime time.Time `json:"startTime"`
Duration time.Duration `json:"duration"`
}
-// ParsedId returns the segment ID as uuid.UUID
-func (c *ClientSegment) ParsedId() uuid.UUID {
+// ParsedId returns the span ID as uuid.UUID
+func (c *ClientSpan) ParsedId() uuid.UUID {
if parsed, err := uuid.Parse(c.Id); err == nil {
return parsed
}
return uuid.New()
}
-func (c *ClientSegment) ToSegment(traceId uuid.UUID) models.Segment {
- return models.Segment{
+func (c *ClientSpan) ToSpan(traceId uuid.UUID) models.Span {
+ return models.Span{
Id: c.ParsedId(),
TraceId: traceId,
Name: c.Name,
diff --git a/backend/app/models/segment.model.go b/backend/app/models/span.model.go
similarity index 95%
rename from backend/app/models/segment.model.go
rename to backend/app/models/span.model.go
index d6990958..0a34af0c 100644
--- a/backend/app/models/segment.model.go
+++ b/backend/app/models/span.model.go
@@ -6,7 +6,7 @@ import (
"github.com/google/uuid"
)
-type Segment struct {
+type Span struct {
Id uuid.UUID `json:"id" ch:"id"`
TraceId uuid.UUID `json:"traceId" ch:"trace_id"`
ProjectId uuid.UUID `json:"projectId" ch:"project_id"`
diff --git a/backend/app/repositories/segment.repository.go b/backend/app/repositories/span.repository.go
similarity index 63%
rename from backend/app/repositories/segment.repository.go
rename to backend/app/repositories/span.repository.go
index ddd48b3c..0527ac70 100644
--- a/backend/app/repositories/segment.repository.go
+++ b/backend/app/repositories/span.repository.go
@@ -9,20 +9,20 @@ import (
"github.com/google/uuid"
)
-type segmentRepository struct{}
+type spanRepository struct{}
-func (r *segmentRepository) InsertAsync(ctx context.Context, segments []models.Segment) error {
- if len(segments) == 0 {
+func (r *spanRepository) InsertAsync(ctx context.Context, spans []models.Span) error {
+ if len(spans) == 0 {
return nil
}
batch, err := (*chdb.Conn).PrepareBatch(clickhouse.Context(context.Background(), clickhouse.WithAsync(false)),
- "INSERT INTO segments (id, trace_id, project_id, name, start_time, duration, recorded_at)")
+ "INSERT INTO spans (id, trace_id, project_id, name, start_time, duration, recorded_at)")
if err != nil {
return err
}
- for _, s := range segments {
+ for _, s := range spans {
if err := batch.Append(
s.Id,
s.TraceId,
@@ -39,10 +39,10 @@ func (r *segmentRepository) InsertAsync(ctx context.Context, segments []models.S
return batch.Send()
}
-func (r *segmentRepository) FindByTraceId(ctx context.Context, projectId, traceId uuid.UUID) ([]models.Segment, error) {
+func (r *spanRepository) FindByTraceId(ctx context.Context, projectId, traceId uuid.UUID) ([]models.Span, error) {
query := `SELECT
id, trace_id, project_id, name, start_time, duration, recorded_at
- FROM segments
+ FROM spans
WHERE project_id = ? AND trace_id = ?
ORDER BY start_time ASC`
@@ -52,19 +52,19 @@ func (r *segmentRepository) FindByTraceId(ctx context.Context, projectId, traceI
}
defer rows.Close()
- var segments []models.Segment
+ var spans []models.Span
for rows.Next() {
- var s models.Segment
+ var s models.Span
if err := rows.Scan(
&s.Id, &s.TraceId, &s.ProjectId,
&s.Name, &s.StartTime, &s.Duration, &s.RecordedAt,
); err != nil {
return nil, err
}
- segments = append(segments, s)
+ spans = append(spans, s)
}
- return segments, nil
+ return spans, nil
}
-var SegmentRepository = segmentRepository{}
+var SpanRepository = spanRepository{}
diff --git a/backend/go.mod b/backend/go.mod
index 6d32726c..571dbd56 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -67,3 +67,5 @@ require (
golang.org/x/sync v0.19.0 // indirect
golang.org/x/text v0.32.0 // indirect
)
+
+replace go.tracewayapp.com => /Users/dusanstanojevic/Documents/workspace/go-client
diff --git a/frontend/src/lib/components/segments/segment-empty-state.svelte b/frontend/src/lib/components/spans/span-empty-state.svelte
similarity index 75%
rename from frontend/src/lib/components/segments/segment-empty-state.svelte
rename to frontend/src/lib/components/spans/span-empty-state.svelte
index df87be81..dffab113 100644
--- a/frontend/src/lib/components/segments/segment-empty-state.svelte
+++ b/frontend/src/lib/components/spans/span-empty-state.svelte
@@ -16,17 +16,17 @@
function getDocsUrl(fw: Framework): string {
switch (fw) {
case 'gin':
- return 'https://docs.traceway.io/go/gin/segments';
+ return 'https://docs.traceway.io/go/gin/spans';
case 'fiber':
- return 'https://docs.traceway.io/go/fiber/segments';
+ return 'https://docs.traceway.io/go/fiber/spans';
case 'chi':
- return 'https://docs.traceway.io/go/chi/segments';
+ return 'https://docs.traceway.io/go/chi/spans';
case 'fasthttp':
- return 'https://docs.traceway.io/go/fasthttp/segments';
+ return 'https://docs.traceway.io/go/fasthttp/spans';
case 'stdlib':
- return 'https://docs.traceway.io/go/stdlib/segments';
+ return 'https://docs.traceway.io/go/stdlib/spans';
default:
- return 'https://docs.traceway.io/go/segments';
+ return 'https://docs.traceway.io/go/spans';
}
}
@@ -35,39 +35,39 @@
case 'gin':
return `// In your Gin handler
func MyHandler(c *gin.Context) {
- // Start a segment for database operation
- seg := traceway.StartSegment(c.Request.Context(), "db.query")
- defer seg.End()
+ // Start a span for database operation
+ span := traceway.StartSpan(c.Request.Context(), "db.query")
+ defer span.End()
// Your database operation here
result, err := db.Query("SELECT * FROM users")
- // Another segment for cache
- cacheSeg := traceway.StartSegment(c.Request.Context(), "cache.set")
+ // Another span for cache
+ cacheSpan := traceway.StartSpan(c.Request.Context(), "cache.set")
cache.Set("users", result)
- cacheSeg.End()
+ cacheSpan.End()
}`;
case 'fiber':
return `// In your Fiber handler
func MyHandler(c *fiber.Ctx) error {
- // Start a segment for database operation
- seg := traceway.StartSegment(c.UserContext(), "db.query")
- defer seg.End()
+ // Start a span for database operation
+ span := traceway.StartSpan(c.UserContext(), "db.query")
+ defer span.End()
// Your database operation here
result, err := db.Query("SELECT * FROM users")
- // Another segment for cache
- cacheSeg := traceway.StartSegment(c.UserContext(), "cache.set")
+ // Another span for cache
+ cacheSpan := traceway.StartSpan(c.UserContext(), "cache.set")
cache.Set("users", result)
- cacheSeg.End()
+ cacheSpan.End()
return c.JSON(result)
}`;
default:
- return `seg := traceway.StartSegment(ctx, "db.load")
+ return `span := traceway.StartSpan(ctx, "db.load")
// perform your operations here
-seg.End()`;
+span.End()`;
}
}
@@ -79,9 +79,9 @@ seg.End()`;
<div class="bg-muted mb-4 rounded-full p-3">
<Code class="text-muted-foreground h-6 w-6" />
</div>
- <h3 class="mb-2 text-lg font-semibold">No Segments Recorded</h3>
+ <h3 class="mb-2 text-lg font-semibold">No Spans Recorded</h3>
<p class="text-muted-foreground mb-4 max-w-md text-sm">
- Segments allow you to track the timing of individual operations within a transaction, such as
+ Spans allow you to track the timing of individual operations within a transaction, such as
database queries, HTTP calls, or cache operations.
</p>
diff --git a/frontend/src/lib/components/segments/segment-row.svelte b/frontend/src/lib/components/spans/span-row.svelte
similarity index 70%
rename from frontend/src/lib/components/segments/segment-row.svelte
rename to frontend/src/lib/components/spans/span-row.svelte
index 7303ce16..37fb2dfc 100644
--- a/frontend/src/lib/components/segments/segment-row.svelte
+++ b/frontend/src/lib/components/spans/span-row.svelte
@@ -1,5 +1,5 @@
<script lang="ts">
- import type { Segment } from '$lib/types/segments';
+ import type { Span } from '$lib/types/spans';
import { cn } from '$lib/utils';
import { formatDuration } from '$lib/utils/formatters';
import * as Popover from '$lib/components/ui/popover';
@@ -8,42 +8,42 @@
type Props = {
row: number;
- segment: Segment;
+ span: Span;
traceStart: number;
traceDuration: number;
isOdd: boolean;
nameColumnWidth: number;
updateNameWidth: (width: number) => void;
- segmentCellHandleMouseEnter: (x: number) => void;
- segmentCellHandleMouseMove: (x: number) => void;
- segmentCellHandleMouseLeave: () => void;
+ spanCellHandleMouseEnter: (x: number) => void;
+ spanCellHandleMouseMove: (x: number) => void;
+ spanCellHandleMouseLeave: () => void;
};
let {
row,
- segment,
+ span,
traceStart,
traceDuration,
isOdd,
nameColumnWidth,
updateNameWidth,
- segmentCellHandleMouseEnter,
- segmentCellHandleMouseMove,
- segmentCellHandleMouseLeave
+ spanCellHandleMouseEnter,
+ spanCellHandleMouseMove,
+ spanCellHandleMouseLeave
}: Props = $props();
- const segmentStartMs = $derived(new Date(segment.startTime).getTime() - traceStart);
- const segmentDurationMs = $derived(segment.duration / 1_000_000);
+ const spanStartMs = $derived(new Date(span.startTime).getTime() - traceStart);
+ const spanDurationMs = $derived(span.duration / 1_000_000);
const traceDurationMs = $derived(traceDuration / 1_000_000);
// Calculate position and width as percentages
- const leftPercent = $derived(Math.max(0, (segmentStartMs / traceDurationMs) * 100));
+ const leftPercent = $derived(Math.max(0, (spanStartMs / traceDurationMs) * 100));
const widthPercent = $derived(
- Math.min(100 - leftPercent, (segmentDurationMs / traceDurationMs) * 100)
+ Math.min(100 - leftPercent, (spanDurationMs / traceDurationMs) * 100)
);
- const segmentColors = [
+ const spanColors = [
{ bg: 'bg-blue-400', ring: 'ring-blue-500' },
{ bg: 'bg-green-400', ring: 'ring-green-500' },
{ bg: 'bg-purple-400', ring: 'ring-purple-500' },
@@ -60,7 +60,7 @@
{ bg: 'bg-slate-400', ring: 'ring-slate-500' }
];
- const segmentColor = $derived(segmentColors[row % segmentColors.length]);
+ const spanColor = $derived(spanColors[row % spanColors.length]);
// Tooltip state (this is the tooltip on top of the line)
let isHovered = $state(false);
@@ -75,22 +75,22 @@
}
let containerElement: HTMLDivElement;
- function containerSegmentCellHandleMouseEnter(e: MouseEvent) {
+ function containerSpanCellHandleMouseEnter(e: MouseEvent) {
const rect = containerElement.getBoundingClientRect();
const x = e.clientX - rect.left;
- segmentCellHandleMouseEnter(x);
+ spanCellHandleMouseEnter(x);
}
- function containerSegmentCellHandleMouseMove(e: MouseEvent) {
+ function containerSpanCellHandleMouseMove(e: MouseEvent) {
const rect = containerElement.getBoundingClientRect();
const x = e.clientX - rect.left;
- segmentCellHandleMouseMove(x);
+ spanCellHandleMouseMove(x);
}
let nameElement: HTMLDivElement;
let copied = $state(false);
- async function copySegmentName() {
- await navigator.clipboard.writeText(segment.name);
+ async function copySpanName() {
+ await navigator.clipboard.writeText(span.name);
copied = true;
setTimeout(() => (copied = false), 2000);
}
@@ -107,7 +107,7 @@
<div
class={cn('flex items-center border-b border-border last:border-b-0', isOdd ? 'bg-muted/40' : '')}
>
- <!-- Segment name -->
+ <!-- Span name -->
<Popover.Root>
<Popover.Trigger class="text-left cursor-pointer">
<div
@@ -115,13 +115,13 @@
class="flex-shrink-0 truncate border-r border-border px-3 py-1.5 font-mono text-xs"
style="min-width: {nameColumnWidth}px; max-width: {nameColumnWidth}px"
>
- {segment.name}
+ {span.name}
</div>
</Popover.Trigger>
<Popover.Content class="w-auto max-w-sm" align="start">
<div class="flex items-start gap-2">
- <span class="font-mono text-xs break-all select-text">{segment.name}</span>
- <button onclick={copySegmentName} class="shrink-0 p-1 rounded hover:bg-muted">
+ <span class="font-mono text-xs break-all select-text">{span.name}</span>
+ <button onclick={copySpanName} class="shrink-0 p-1 rounded hover:bg-muted">
{#if copied}
<Check class="h-3.5 w-3.5 text-green-500" />
{:else}
@@ -136,17 +136,17 @@
<div
class="relative flex min-w-[200px] flex-1 items-center self-stretch"
bind:this={containerElement}
- onmouseenter={containerSegmentCellHandleMouseEnter}
- onmousemove={containerSegmentCellHandleMouseMove}
- onmouseleave={segmentCellHandleMouseLeave}
+ onmouseenter={containerSpanCellHandleMouseEnter}
+ onmousemove={containerSpanCellHandleMouseMove}
+ onmouseleave={spanCellHandleMouseLeave}
>
<div class="relative h-4 w-full">
<div
bind:this={barElement}
class={cn(
'absolute h-full rounded-[2px] transition-all',
- segmentColor.bg,
- isHovered && `ring-2 ${segmentColor.ring}`
+ spanColor.bg,
+ isHovered && `ring-2 ${spanColor.ring}`
)}
style="left: {leftPercent}%; width: {Math.max(widthPercent, 1)}%"
onmouseenter={handleMouseEnter}
@@ -160,6 +160,6 @@
<div
class="w-[100px] flex-shrink-0 border-l border-border px-3 py-1.5 text-right font-mono text-xs text-muted-foreground"
>
- {formatDuration(segment.duration)}
+ {formatDuration(span.duration)}
</div>
</div>
diff --git a/frontend/src/lib/components/segments/segment-waterfall.svelte b/frontend/src/lib/components/spans/span-waterfall.svelte
similarity index 77%
rename from frontend/src/lib/components/segments/segment-waterfall.svelte
rename to frontend/src/lib/components/spans/span-waterfall.svelte
index c339a60f..32791fd5 100644
--- a/frontend/src/lib/components/segments/segment-waterfall.svelte
+++ b/frontend/src/lib/components/spans/span-waterfall.svelte
@@ -1,23 +1,23 @@
<script lang="ts">
- import type { Segment } from '$lib/types/segments';
+ import type { Span } from '$lib/types/spans';
import ScrollArea from '../ui/scroll-area/scroll-area.svelte';
- import SegmentRow from './segment-row.svelte';
+ import SpanRow from './span-row.svelte';
type Props = {
- segments: Segment[];
+ spans: Span[];
traceDuration: number;
traceStartTime: string;
};
- let { segments, traceDuration, traceStartTime }: Props = $props();
+ let { spans, traceDuration, traceStartTime }: Props = $props();
const traceStart = $derived(
- segments.length === 0
+ spans.length === 0
? new Date(traceStartTime).getTime()
- : segments.reduce((earliest, seg) => {
- const segTime = new Date(seg.startTime).getTime();
- return segTime < earliest ? segTime : earliest;
- }, new Date(segments[0].startTime).getTime())
+ : spans.reduce((earliest, s) => {
+ const sTime = new Date(s.startTime).getTime();
+ return sTime < earliest ? sTime : earliest;
+ }, new Date(spans[0].startTime).getTime())
);
const durationMs = $derived(traceDuration / 1_000_000);
@@ -61,7 +61,7 @@
class="flex-shrink-0 border-r border-border px-3 py-1.5 text-xs font-medium"
style="min-width: {nameColumnWidth}px"
>
- Segment Name
+ Span Name
</div>
<div bind:this={timelineElement} class="min-w-[200px] flex-1 px-3 py-1.5">
<div class="flex justify-between text-xs text-muted-foreground">
@@ -77,19 +77,19 @@
</div>
</div>
- <!-- Segments -->
- {#each segments as segment, i}
- <SegmentRow
+ <!-- Spans -->
+ {#each spans as span, i}
+ <SpanRow
row={i}
- {segment}
+ {span}
{traceStart}
{traceDuration}
isOdd={i % 2 === 1}
{nameColumnWidth}
{updateNameWidth}
- segmentCellHandleMouseEnter={handleMouseEnter}
- segmentCellHandleMouseMove={handleMouseMove}
- segmentCellHandleMouseLeave={handleMouseLeave}
+ spanCellHandleMouseEnter={handleMouseEnter}
+ spanCellHandleMouseMove={handleMouseMove}
+ spanCellHandleMouseLeave={handleMouseLeave}
/>
{/each}
diff --git a/frontend/src/lib/types/segments.ts b/frontend/src/lib/types/spans.ts
similarity index 91%
rename from frontend/src/lib/types/segments.ts
rename to frontend/src/lib/types/spans.ts
index 33c8f1ed..fdd7e348 100644
--- a/frontend/src/lib/types/segments.ts
+++ b/frontend/src/lib/types/spans.ts
@@ -1,4 +1,4 @@
-export type Segment = {
+export type Span = {
id: string;
traceId: string;
projectId: string;
@@ -38,8 +38,8 @@ export type MessageInfo = {
export type TraceDetailResponse = {
endpoint: TraceDetail;
- segments: Segment[];
- hasSegments: boolean;
+ spans: Span[];
+ hasSpans: boolean;
exception?: ExceptionInfo;
messages: MessageInfo[];
};
diff --git a/frontend/src/routes/endpoints/[endpoint]/[endpointId]/+page.svelte b/frontend/src/routes/endpoints/[endpoint]/[endpointId]/+page.svelte
index c21f67f9..6fc38b79 100644
--- a/frontend/src/routes/endpoints/[endpoint]/[endpointId]/+page.svelte
+++ b/frontend/src/routes/endpoints/[endpoint]/[endpointId]/+page.svelte
@@ -13,9 +13,9 @@
import { ArrowLeft, ArrowRight, TriangleAlert, ClipboardList } from 'lucide-svelte';
import { LabelValue } from '$lib/components/ui/label-value';
import { ContextGrid } from '$lib/components/ui/context-grid';
- import SegmentWaterfall from '$lib/components/segments/segment-waterfall.svelte';
- import SegmentEmptyState from '$lib/components/segments/segment-empty-state.svelte';
- import type { TraceDetailResponse } from '$lib/types/segments';
+ import SpanWaterfall from '$lib/components/spans/span-waterfall.svelte';
+ import SpanEmptyState from '$lib/components/spans/span-empty-state.svelte';
+ import type { TraceDetailResponse } from '$lib/types/spans';
import PageHeader from '$lib/components/issues/page-header.svelte';
import { createSmartBackHandler } from '$lib/utils/back-navigation';
import { resolve } from '$app/paths';
@@ -245,27 +245,27 @@
</Card.Root>
{/if}
- <!-- Segments Section -->
+ <!-- Spans Section -->
<Card.Root>
<Card.Header>
- <Card.Title>Segments</Card.Title>
+ <Card.Title>Spans</Card.Title>
<Card.Description>
- {#if response.hasSegments}
+ {#if response.hasSpans}
Timing breakdown of operations within this endpoint request
{:else}
- No segments recorded for this endpoint request
+ No spans recorded for this endpoint request
{/if}
</Card.Description>
</Card.Header>
<Card.Content>
- {#if response.hasSegments}
- <SegmentWaterfall
- segments={response.segments}
+ {#if response.hasSpans}
+ <SpanWaterfall
+ spans={response.spans}
traceDuration={response.endpoint.duration}
traceStartTime={response.endpoint.recordedAt}
/>
{:else}
- <SegmentEmptyState framework={projectsState.currentProject?.framework ?? 'gin'} />
+ <SpanEmptyState framework={projectsState.currentProject?.framework ?? 'gin'} />
{/if}
</Card.Content>
</Card.Root>
diff --git a/frontend/src/routes/tasks/[task]/[taskId]/+page.svelte b/frontend/src/routes/tasks/[task]/[taskId]/+page.svelte
index 2bc34b95..3ba6787b 100644
--- a/frontend/src/routes/tasks/[task]/[taskId]/+page.svelte
+++ b/frontend/src/routes/tasks/[task]/[taskId]/+page.svelte
@@ -13,8 +13,8 @@
import { ArrowRight, TriangleAlert, ClipboardList } from 'lucide-svelte';
import { LabelValue } from '$lib/components/ui/label-value';
import { ContextGrid } from '$lib/components/ui/context-grid';
- import SegmentWaterfall from '$lib/components/segments/segment-waterfall.svelte';
- import SegmentEmptyState from '$lib/components/segments/segment-empty-state.svelte';
+ import SpanWaterfall from '$lib/components/spans/span-waterfall.svelte';
+ import SpanEmptyState from '$lib/components/spans/span-empty-state.svelte';
import PageHeader from '$lib/components/issues/page-header.svelte';
import { createSmartBackHandler } from '$lib/utils/back-navigation';
import { resolve } from '$app/paths';
@@ -41,8 +41,8 @@
recordedAt: string;
scope?: Record<string, string>;
}[];
- segments: any[];
- hasSegments: boolean;
+ spans: any[];
+ hasSpans: boolean;
};
let { data } = $props();
@@ -243,27 +243,27 @@
</Card.Root>
{/if}
- <!-- Segments Section -->
+ <!-- Spans Section -->
<Card.Root>
<Card.Header>
- <Card.Title>Segments</Card.Title>
+ <Card.Title>Spans</Card.Title>
<Card.Description>
- {#if response.hasSegments}
+ {#if response.hasSpans}
Timing breakdown of operations within this task
{:else}
- No segments recorded for this task
+ No spans recorded for this task
{/if}
</Card.Description>
</Card.Header>
<Card.Content>
- {#if response.hasSegments}
- <SegmentWaterfall
- segments={response.segments}
+ {#if response.hasSpans}
+ <SpanWaterfall
+ spans={response.spans}
traceDuration={response.task.duration}
traceStartTime={response.task.recordedAt}
/>
{:else}
- <SegmentEmptyState framework={projectsState.currentProject?.framework ?? 'gin'} />
+ <SpanEmptyState framework={projectsState.currentProject?.framework ?? 'gin'} />
{/if}
</Card.Content>
</Card.Root>