Skip to content

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

10.1 KB
Raw Blame
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{}