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 (
"context"
"encoding/json"
"net/http"
"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/tracewayapp/traceway/backend/app/repositories/telemetry/shared"
"github.com/tracewayapp/traceway/backend/app/storage"
"golang.org/x/sync/errgroup"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
traceway "go.tracewayapp.com"
)
type sessionDetailController struct{}
type sessionDetailRequest struct {
StartedAt *time.Time `json:"startedAt"`
}
type SessionExceptionInfo struct {
Id uuid.UUID `json:"id"`
ExceptionHash string `json:"exceptionHash"`
StackTrace string `json:"stackTrace"`
RecordedAt string `json:"recordedAt"`
IsMessage bool `json:"isMessage"`
}
type SessionDetailResponse struct {
Session *models.Session `json:"session"`
Exceptions []SessionExceptionInfo `json:"exceptions"`
}
// SessionRecordingPayload is the shape consumed by the frontend SessionReplay
// component. We concatenate rrweb event arrays from every segment ordered by
// segment_index, plus union the optional logs/actions arrays. Logs/actions are
// kept as raw JSON since the backend never inspects them.
type SessionRecordingPayload struct {
Events []json.RawMessage `json:"events"`
Logs []json.RawMessage `json:"logs,omitempty"`
Actions []json.RawMessage `json:"actions,omitempty"`
StartedAt *time.Time `json:"startedAt,omitempty"`
EndedAt *time.Time `json:"endedAt,omitempty"`
}
func (s sessionDetailController) GetSessionDetail(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
}
sessionId, err := uuid.Parse(c.Param("sessionId"))
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid sessionId"})
return
}
var request sessionDetailRequest
_ = c.ShouldBindJSON(&request)
span := traceway.StartSpan(c, "loading session")
session, err := findSession(c, projectId, sessionId, request.StartedAt)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading session: %w", err))
return
}
if session == nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Session not found"})
return
}
span = traceway.StartSpan(c, "loading session exceptions")
exceptions, err := telemetry.ExceptionStackTraceRepository.FindAllBySessionId(c, projectId, sessionId, session.StartedAt)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading session exceptions: %w", err))
return
}
out := make([]SessionExceptionInfo, 0, len(exceptions))
for _, e := range exceptions {
if e.RecordedAt.After(session.CutoffAt) {
continue
}
out = append(out, SessionExceptionInfo{
Id: e.Id,
ExceptionHash: e.ExceptionHash,
StackTrace: e.StackTrace,
RecordedAt: e.RecordedAt.Format("2006-01-02T15:04:05Z07:00"),
IsMessage: e.IsMessage,
})
}
c.JSON(http.StatusOK, SessionDetailResponse{
Session: session,
Exceptions: out,
})
}
func (s sessionDetailController) GetSessionRecording(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
}
sessionId, err := uuid.Parse(c.Param("sessionId"))
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid sessionId"})
return
}
var startedAt *time.Time
if t, err := time.Parse(time.RFC3339Nano, c.Query("startedAt")); err == nil {
startedAt = &t
}
span := traceway.StartSpan(c, "loading session")
session, err := findSession(c, projectId, sessionId, startedAt)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading session: %w", err))
return
}
if session == nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Session not found"})
return
}
span = traceway.StartSpan(c, "loading session segments")
segments, err := telemetry.SessionRecordingRepository.FindBySessionId(c, projectId, sessionId, &session.StartedAt)
span.End()
if err != nil {
c.AbortWithError(500, traceway.NewStackTraceErrorf("error loading session segments: %w", err))
return
}
segments = shared.SegmentsWithinSession(segments, session.CutoffAt)
span = traceway.StartSpan(c, "reading session segments")
bodies := readSegments(c.Request.Context(), segments)
span.End()
payload := SessionRecordingPayload{
Events: []json.RawMessage{},
}
for _, body := range bodies {
if body == nil {
continue
}
payload.Events = append(payload.Events, body.events...)
payload.Logs = append(payload.Logs, body.logs...)
payload.Actions = append(payload.Actions, body.actions...)
if body.StartedAt != nil && (payload.StartedAt == nil || body.StartedAt.Before(*payload.StartedAt)) {
t := *body.StartedAt
payload.StartedAt = &t
}
if body.EndedAt != nil && (payload.EndedAt == nil || body.EndedAt.After(*payload.EndedAt)) {
t := *body.EndedAt
payload.EndedAt = &t
}
}
c.JSON(http.StatusOK, payload)
}
func findSession(c *gin.Context, projectId, sessionId uuid.UUID, startedAt *time.Time) (*models.Session, error) {
session, err := telemetry.SessionRepository.FindById(c, projectId, sessionId, startedAt)
if session == nil && err == nil && startedAt != nil {
return telemetry.SessionRepository.FindById(c, projectId, sessionId, nil)
}
return session, err
}
const segmentReadConcurrency = 16
type segmentBody struct {
Events json.RawMessage `json:"events"`
Logs json.RawMessage `json:"logs"`
Actions json.RawMessage `json:"actions"`
StartedAt *time.Time `json:"startedAt"`
EndedAt *time.Time `json:"endedAt"`
events []json.RawMessage
logs []json.RawMessage
actions []json.RawMessage
}
func readSegments(ctx context.Context, segments []models.SessionRecording) []*segmentBody {
bodies := make([]*segmentBody, len(segments))
var group errgroup.Group
group.SetLimit(segmentReadConcurrency)
for i, seg := range segments {
group.Go(func() error {
raw, err := storage.Store.Read(ctx, seg.FilePath)
if err != nil {
if ctx.Err() == nil {
traceway.CaptureException(traceway.NewStackTraceErrorf("failed to read session segment (key=%s): %w", seg.FilePath, err))
}
return nil
}
var body segmentBody
if err := json.Unmarshal(raw, &body); err != nil {
traceway.CaptureException(traceway.NewStackTraceErrorf("failed to parse session segment (key=%s): %w", seg.FilePath, err))
return nil
}
body.events = decodeArray(body.Events)
body.logs = decodeArray(body.Logs)
body.actions = decodeArray(body.Actions)
body.Events, body.Logs, body.Actions = nil, nil, nil
bodies[i] = &body
return nil
})
}
_ = group.Wait()
return bodies
}
func decodeArray(raw json.RawMessage) []json.RawMessage {
if len(raw) == 0 {
return nil
}
var items []json.RawMessage
if err := json.Unmarshal(raw, &items); err != nil {
return nil
}
return items
}
var SessionDetailController = sessionDetailController{}