The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
package controllers
import (
"database/sql"
"errors"
"net/http"
"net/url"
"strings"
"time"
"github.com/tracewayapp/traceway/backend/app/middleware"
"github.com/tracewayapp/traceway/backend/app/models"
"github.com/tracewayapp/traceway/backend/app/repositories/telemetry"
"github.com/gin-gonic/gin"
traceway "go.tracewayapp.com"
)
type endpointController struct{}
type EndpointSearchRequest struct {
FromDate time.Time `json:"fromDate"`
ToDate time.Time `json:"toDate"`
OrderBy string `json:"orderBy"`
SortDirection string `json:"sortDirection"`
Pagination PaginationParams `json:"pagination"`
Search string `json:"search"`
RootFilter string `json:"rootFilter"`
MethodFilter string `json:"methodFilter"`
}
type EndpointInstancesRequest struct {
FromDate time.Time `json:"fromDate"`
ToDate time.Time `json:"toDate"`
OrderBy string `json:"orderBy"`
SortDirection string `json:"sortDirection"`
Search string `json:"search"`
AttributeFilters []SessionAttributeFilter `json:"attributeFilters"`
Pagination PaginationParams `json:"pagination"`
}
type EndpointInstancesResponse struct {
Data []models.Endpoint `json:"data"`
Stats *models.EndpointDetailStats `json:"stats"`
Pagination Pagination `json:"pagination"`
}
type EndpointStackedChartRequest struct {
FromDate time.Time `json:"fromDate"`
ToDate time.Time `json:"toDate"`
MetricType string `json:"metricType"` // total_time, p50, p95, p99
IntervalMinutes int `json:"intervalMinutes"` // bucket size
Search string `json:"search"`
RootFilter string `json:"rootFilter"`
MethodFilter string `json:"methodFilter"`
}
var validEndpointMethods = map[string]bool{
"GET": true, "HEAD": true, "POST": true, "PUT": true, "DELETE": true,
"CONNECT": true, "OPTIONS": true, "TRACE": true, "PATCH": true,
}
func normalizeMethodFilter(method string) (string, bool) {
if method == "" {
return "", true
}
method = strings.ToUpper(method)
return method, validEndpointMethods[method]
}
const invalidMethodFilterMessage = "methodFilter must be an HTTP method such as GET or POST"
func (e endpointController) FindAllEndpoints(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
var request EndpointSearchRequest
if err := c.ShouldBindJSON(&request); err != nil {
middleware.RejectBindError(c, err, err.Error())
return
}
span := traceway.StartSpan(c, "loading endpoints")
endpoints, total, err := telemetry.EndpointRepository.FindAll(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading endpoints: %w", err))
return
}
c.JSON(http.StatusOK, PaginatedResponse[models.Endpoint]{
Data: endpoints,
Pagination: Pagination{
Page: request.Pagination.Page,
PageSize: request.Pagination.PageSize,
Total: total,
TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
},
})
}
func (e endpointController) FindGroupedByEndpoint(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
var request EndpointSearchRequest
if err := c.ShouldBindJSON(&request); err != nil {
middleware.RejectBindError(c, err, err.Error())
return
}
methodFilter, ok := normalizeMethodFilter(request.MethodFilter)
if !ok {
c.JSON(http.StatusUnprocessableEntity, gin.H{"error": invalidMethodFilterMessage})
return
}
span := traceway.StartSpan(c, "loading grouped endpoints")
stats, total, err := telemetry.EndpointRepository.FindGroupedByEndpoint(c, projectId, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection, request.Search, request.RootFilter, methodFilter)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stats: %w", err))
return
}
c.JSON(http.StatusOK, PaginatedResponse[models.EndpointStats]{
Data: stats,
Pagination: Pagination{
Page: request.Pagination.Page,
PageSize: request.Pagination.PageSize,
Total: total,
TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
},
})
}
func (e endpointController) FindByEndpoint(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
rawEndpoint := c.Query("endpoint")
if rawEndpoint == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "endpoint is required"})
return
}
// URL decode the endpoint (it may contain encoded slashes and spaces)
endpoint, err := url.PathUnescape(rawEndpoint)
if err != nil {
endpoint = rawEndpoint // fallback to raw value if decoding fails
}
var request EndpointInstancesRequest
if err := c.ShouldBindJSON(&request); err != nil {
middleware.RejectBindError(c, err, err.Error())
return
}
filters := make([]telemetry.SessionAttributeFilter, 0, len(request.AttributeFilters))
for _, f := range request.AttributeFilters {
if f.Key == "" {
continue
}
filters = append(filters, telemetry.SessionAttributeFilter{Key: f.Key, Value: f.Value, Exclude: f.Exclude, Contains: f.Contains})
}
span := traceway.StartSpan(c, "loading endpoint instances")
endpoints, total, err := telemetry.EndpointRepository.FindByEndpoint(c, projectId, endpoint, request.FromDate, request.ToDate, request.Pagination.Page, request.Pagination.PageSize, request.OrderBy, request.SortDirection, request.Search, filters)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading endpoints: %w", err))
return
}
// Get aggregate stats for this endpoint
span = traceway.StartSpan(c, "loading endpoint stats")
stats, err := telemetry.EndpointRepository.GetEndpointStats(c, projectId, endpoint, request.FromDate, request.ToDate)
span.End()
if err != nil {
// Don't fail the request if stats fail, just return nil stats
stats = nil
}
c.JSON(http.StatusOK, EndpointInstancesResponse{
Data: endpoints,
Stats: stats,
Pagination: Pagination{
Page: request.Pagination.Page,
PageSize: request.Pagination.PageSize,
Total: total,
TotalPages: (total + int64(request.Pagination.PageSize) - 1) / int64(request.Pagination.PageSize),
},
})
}
func (e endpointController) GetStackedChart(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
var request EndpointStackedChartRequest
if err := c.ShouldBindJSON(&request); err != nil {
middleware.RejectBindError(c, err, err.Error())
return
}
// Validate interval
if request.IntervalMinutes < 1 {
request.IntervalMinutes = 5 // default to 5 minutes
}
// Validate metric type
validMetrics := map[string]bool{"total_time": true, "p50": true, "p95": true, "p99": true}
if !validMetrics[request.MetricType] {
request.MetricType = "total_time" // default
}
methodFilter, ok := normalizeMethodFilter(request.MethodFilter)
if !ok {
c.JSON(http.StatusUnprocessableEntity, gin.H{"error": invalidMethodFilterMessage})
return
}
span := traceway.StartSpan(c, "loading stacked chart")
data, err := telemetry.EndpointRepository.GetEndpointStackedChart(c, projectId, request.FromDate, request.ToDate, request.IntervalMinutes, request.MetricType, request.Search, request.RootFilter, methodFilter)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading stacked chart data: %w", err))
return
}
c.JSON(http.StatusOK, data)
}
func (e endpointController) GetSlowEndpoint(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
rawEndpoint := c.Query("endpoint")
if rawEndpoint == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "endpoint is required"})
return
}
endpoint, err := url.PathUnescape(rawEndpoint)
if err != nil {
endpoint = rawEndpoint
}
offsetMs, reason, err := telemetry.EndpointRepository.GetSlowEndpoint(c, projectId, endpoint)
if errors.Is(err, sql.ErrNoRows) {
c.JSON(http.StatusOK, gin.H{"offsetMs": 0, "reason": ""})
return
}
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("error loading slow endpoint: %w", err))
return
}
c.JSON(http.StatusOK, gin.H{"offsetMs": offsetMs, "reason": reason})
}
type SetSlowEndpointRequest struct {
Endpoint string `json:"endpoint" binding:"required"`
OffsetMs uint32 `json:"offsetMs"`
Reason string `json:"reason"`
}
func (e endpointController) SetSlowEndpoint(c *gin.Context) {
projectId, err := middleware.GetProjectId(c)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
return
}
var request SetSlowEndpointRequest
if err := c.ShouldBindJSON(&request); err != nil {
middleware.RejectBindError(c, err, err.Error())
return
}
if err := telemetry.EndpointRepository.UpsertSlowEndpoint(c, projectId, request.Endpoint, request.OffsetMs, request.Reason); err != nil {
c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("error saving slow endpoint: %w", err))
return
}
c.JSON(http.StatusOK, gin.H{"offsetMs": request.OffsetMs})
}
var EndpointController = endpointController{}