Skip to content

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

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