Skip to content

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

fix: end sessions at their last activity inside the cap instead of at the cap (#382)

Jovan Stojiljkovic895b03c12b5b
diff --git a/CLAUDE.md b/CLAUDE.md
index 13f19ddb..b8a26b8f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1116,7 +1116,7 @@ Observability (emitted every 10s via `traceway.CaptureMetric`):
Sustained drops also fire a rate-limited (1/min) `traceway.CaptureException` so overload is visible in the issues feed without flooding it.
-**Session end is derived on read.** The browser SDK's closing payload is unreliable (a keepalive body over 64 KB is rejected on unload, and frozen mobile tabs never fire `pagehide`), so the stored `sessions.ended_at` is only a hint. Each segment row carries its client-side `ended_at` (`ch/0100`, `sqlite_telemetry/0027`, `duckdb_telemetry/0008`), and every session read joins the latest segment activity and applies `shared.ResolveSessionEnd`: an explicit end is kept only when it lands within `SessionIdleTimeout` (15 min, the SDK's inactivity timeout) after the last activity, otherwise the session ends at its last activity; it is still live while a segment arrived (server time) within the timeout. Every session is capped at `shared.SessionMaxSpan` (65 min: the SDK's 60 min cap plus slack) because `@tracewayapp/frontend` <= 1.2.0 kept uploading segments under an ended session id for the tab's whole lifetime (18h "sessions"); the end and duration are clamped to it (sessions without segments too), except that when segments run past it a stored close inside it wins (the SDK's own 60 min close; `Session.CutoffAt` carries the resulting cut-off), a session whose segments run past it is never live (compared on the client clock, so skew between browser and server cannot end a live session), and the session detail and `GET /api/sessions/:id/recording` drop exceptions and segments past `CutoffAt`, anchored on the stored session start rather than the `startedAt` query param (`shared.SegmentsWithinSession`). `HasRecording` is set when any segment exists, and the frontend labels an old session with neither as "No recording" (`utils/session-duration.ts`). Sorting the list by duration uses a SQL copy of the same rule in each backend (`sessionDurationSortKey`); `TestSessionRepository_EndFromRecordingActivity` holds the SQL order to the Go rule. `GET /api/sessions/:id/recording?startedAt=` bounds the segment lookup to the session's window, and segments are read from storage 16 at a time.
+**Session end is derived on read.** The browser SDK's closing payload is unreliable (a keepalive body over 64 KB is rejected on unload, and frozen mobile tabs never fire `pagehide`), so the stored `sessions.ended_at` is only a hint. Each segment row carries its client-side `ended_at` (`ch/0100`, `sqlite_telemetry/0027`, `duckdb_telemetry/0008`), and every session read joins the latest segment activity and applies `shared.ResolveSessionEnd`: an explicit end is kept only when it lands within `SessionIdleTimeout` (15 min, the SDK's inactivity timeout) after the last activity, otherwise the session ends at its last activity; it is still live while a segment arrived (server time) within the timeout. Every session is capped at `shared.SessionMaxSpan` (65 min: the SDK's 60 min cap plus slack) because `@tracewayapp/frontend` <= 1.2.0 kept uploading segments under an ended session id for the tab's whole lifetime (18h "sessions"); the end and duration are clamped to it (sessions without segments too), and when segments run past it the session ends at the last segment inside it (`span_activity`, computed per backend against the session start; the usual 15 min rule then honours the SDK's own close), not at the cap, because an idle tab uploads nothing until it wakes hours later (sleep/wake, or 1.2.0's zombie uploads) and resumes under the same id; `Session.CutoffAt` carries the resulting cut-off, a session whose segments run past it is never live (compared on the client clock, so skew between browser and server cannot end a live session), and the session detail and `GET /api/sessions/:id/recording` drop exceptions and segments past `CutoffAt`, anchored on the stored session start rather than the `startedAt` query param (`shared.SegmentsWithinSession`). `HasRecording` is set when any segment exists, and the frontend labels an old session with neither as "No recording" (`utils/session-duration.ts`). Sorting the list by duration uses a SQL copy of the same rule in each backend (`sessionDurationSortKey`); `TestSessionRepository_EndFromRecordingActivity` holds the SQL order to the Go rule. `GET /api/sessions/:id/recording?startedAt=` bounds the segment lookup to the session's window, and segments are read from storage 16 at a time.
#### Users, Organizations & Projects
diff --git a/backend/app/repositories/telemetry/clickhouse/session.repository.go b/backend/app/repositories/telemetry/clickhouse/session.repository.go
index 9dc44dfc..92ccb399 100644
--- a/backend/app/repositories/telemetry/clickhouse/session.repository.go
+++ b/backend/app/repositories/telemetry/clickhouse/session.repository.go
@@ -68,14 +68,14 @@ func (r *sessionRepository) FindAll(ctx context.Context, projectId uuid.UUID, fr
offset := (page - 1) * pageSize
recFrom, recTo := shared.SessionRecordingWindow(fromDate, toDate)
- query := "SELECT s.id, s.project_id, s.started_at, s.ended_at, s.duration, s.client_ip, s.attributes, s.app_version, s.server_name, s.trace_id, a.last_activity, a.last_received" +
+ query := "SELECT s.id, s.project_id, s.started_at, s.ended_at, s.duration, s.client_ip, s.attributes, s.app_version, s.server_name, s.trace_id, a.last_activity, a.span_activity, a.last_received" +
" FROM (SELECT id, project_id, started_at, ended_at, duration, client_ip, attributes, app_version, server_name, trace_id FROM sessions FINAL WHERE project_id = ? AND started_at >= ? AND started_at <= ?" + whereExtra + ") AS s" +
" LEFT JOIN (" + sessionActivityQuery + ") AS a ON a.sid = s.id" +
" ORDER BY " + orderExpr + " " + sortDir + " LIMIT ? OFFSET ?" +
" SETTINGS join_use_nulls = 1"
queryArgs := []interface{}{projectId, fromDate, toDate}
queryArgs = append(queryArgs, extraArgs...)
- queryArgs = append(queryArgs, projectId, recFrom, recTo)
+ queryArgs = append(queryArgs, projectId, fromDate, toDate, projectId, recFrom, recTo)
queryArgs = append(queryArgs, pageSize, offset)
rows, err := chdb.Conn.Query(ctx, query, queryArgs...)
if err != nil {
@@ -88,7 +88,7 @@ func (r *sessionRepository) FindAll(ctx context.Context, projectId uuid.UUID, fr
for rows.Next() {
var s models.Session
var activity shared.SessionActivity
- if err := rows.Scan(&s.Id, &s.ProjectId, &s.StartedAt, &s.EndedAt, &s.Duration, &s.ClientIP, &s.Attributes, &s.AppVersion, &s.ServerName, &s.TraceId, &activity.LastActivity, &activity.LastReceived); err != nil {
+ if err := rows.Scan(&s.Id, &s.ProjectId, &s.StartedAt, &s.EndedAt, &s.Duration, &s.ClientIP, &s.Attributes, &s.AppVersion, &s.ServerName, &s.TraceId, &activity.LastActivity, &activity.LastActivityInSpan, &activity.LastReceived); err != nil {
return nil, 0, err
}
shared.ResolveSessionEnd(&s, activity, now)
@@ -100,23 +100,26 @@ func (r *sessionRepository) FindAll(ctx context.Context, projectId uuid.UUID, fr
return sessions, int64(count), nil
}
-const sessionActivityQuery = `SELECT assumeNotNull(session_id) AS sid,
- max(coalesce(ended_at, toDateTime64(recorded_at, 3))) AS last_activity,
- max(recorded_at) AS last_received
- FROM session_recordings
- WHERE project_id = ? AND session_id IS NOT NULL AND recorded_at >= ? AND recorded_at <= ?
- GROUP BY sid`
-
-var sessionDurationSortKey = fmt.Sprintf(`multiIf(a.last_activity IS NULL, least(intDiv(s.duration, 1000000), %[2]d),
- assumeNotNull(a.last_activity) > toDateTime64(s.started_at, 3) + INTERVAL %[3]d MINUTE
- AND s.ended_at > s.started_at AND s.ended_at <= s.started_at + INTERVAL %[3]d MINUTE,
- toInt64(dateDiff('millisecond', toDateTime64(s.started_at, 3), toDateTime64(assumeNotNull(s.ended_at), 3))),
+var sessionActivityQuery = fmt.Sprintf(`SELECT assumeNotNull(r.session_id) AS sid,
+ max(coalesce(r.ended_at, toDateTime64(r.recorded_at, 3))) AS last_activity,
+ maxIfOrNull(coalesce(r.ended_at, toDateTime64(r.recorded_at, 3)),
+ coalesce(r.ended_at, toDateTime64(r.recorded_at, 3)) <= toDateTime64(ss.started_at, 3) + INTERVAL %d MINUTE) AS span_activity,
+ max(r.recorded_at) AS last_received
+ FROM session_recordings AS r
+ INNER JOIN (SELECT id, started_at FROM sessions FINAL WHERE project_id = ? AND started_at >= ? AND started_at <= ?) AS ss ON ss.id = assumeNotNull(r.session_id)
+ WHERE r.project_id = ? AND r.session_id IS NOT NULL AND r.recorded_at >= ? AND r.recorded_at <= ?
+ GROUP BY sid`, int(shared.SessionMaxSpan/time.Minute))
+
+var sessionLastActivity = fmt.Sprintf(`if(assumeNotNull(a.last_activity) > toDateTime64(s.started_at, 3) + INTERVAL %d MINUTE,
+ assumeNotNull(coalesce(a.span_activity, toDateTime64(s.started_at, 3))), assumeNotNull(a.last_activity))`, int(shared.SessionMaxSpan/time.Minute))
+
+var sessionDurationSortKey = strings.ReplaceAll(fmt.Sprintf(`if(a.last_activity IS NULL, least(intDiv(s.duration, 1000000), %[2]d),
least(toInt64(dateDiff('millisecond', toDateTime64(s.started_at, 3), if(
- s.ended_at > greatest(assumeNotNull(a.last_activity), toDateTime64(s.started_at, 3))
- AND s.ended_at < greatest(assumeNotNull(a.last_activity), toDateTime64(s.started_at, 3)) + INTERVAL %[1]d MINUTE,
+ s.ended_at > greatest({last}, toDateTime64(s.started_at, 3))
+ AND s.ended_at < greatest({last}, toDateTime64(s.started_at, 3)) + INTERVAL %[1]d MINUTE,
toDateTime64(assumeNotNull(s.ended_at), 3),
- greatest(assumeNotNull(a.last_activity), toDateTime64(s.started_at, 3))))), %[2]d))`,
- int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds(), int(shared.SessionMaxSpan/time.Minute))
+ greatest({last}, toDateTime64(s.started_at, 3))))), %[2]d))`,
+ int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds()), "{last}", sessionLastActivity)
func (r *sessionRepository) FindById(ctx context.Context, projectId, sessionId uuid.UUID, startedAt *time.Time) (*models.Session, error) {
var s models.Session
@@ -145,17 +148,20 @@ func (r *sessionRepository) FindById(ctx context.Context, projectId, sessionId u
from, to := shared.TraceWindowBounds(s.StartedAt)
var segments uint64
var lastActivity, lastReceived time.Time
+ var spanActivity *time.Time
err = chdb.Conn.QueryRow(ctx,
- `SELECT count(), max(coalesce(ended_at, toDateTime64(recorded_at, 3))), max(recorded_at)
+ `SELECT count(), max(coalesce(ended_at, toDateTime64(recorded_at, 3))),
+ maxIfOrNull(coalesce(ended_at, toDateTime64(recorded_at, 3)), coalesce(ended_at, toDateTime64(recorded_at, 3)) <= ?),
+ max(recorded_at)
FROM session_recordings
WHERE project_id = ? AND session_id = ? AND recorded_at >= ? AND recorded_at <= ?`,
- projectId, sessionId, from, to).Scan(&segments, &lastActivity, &lastReceived)
+ s.StartedAt.Add(shared.SessionMaxSpan), projectId, sessionId, from, to).Scan(&segments, &lastActivity, &spanActivity, &lastReceived)
if err != nil {
return nil, err
}
var activity shared.SessionActivity
if segments > 0 {
- activity = shared.SessionActivity{LastActivity: &lastActivity, LastReceived: &lastReceived}
+ activity = shared.SessionActivity{LastActivity: &lastActivity, LastActivityInSpan: spanActivity, LastReceived: &lastReceived}
}
shared.ResolveSessionEnd(&s, activity, time.Now())
return &s, nil
diff --git a/backend/app/repositories/telemetry/duckdb/session.repository.go b/backend/app/repositories/telemetry/duckdb/session.repository.go
index ee348130..177c3d16 100644
--- a/backend/app/repositories/telemetry/duckdb/session.repository.go
+++ b/backend/app/repositories/telemetry/duckdb/session.repository.go
@@ -30,6 +30,7 @@ type sessionRow struct {
TraceId string `lit:"trace_id"`
LastActivity *sqlitetypes.SQLiteTime `lit:"last_activity"`
+ SpanActivity *sqlitetypes.SQLiteTime `lit:"span_activity"`
LastReceived *sqlitetypes.SQLiteTime `lit:"last_received"`
}
@@ -63,29 +64,31 @@ func (row *sessionRow) toModel() models.Session {
if row.Attributes != nil {
s.Attributes = map[string]string(row.Attributes)
}
- activity := sqlitetypes.SessionActivityResult{LastActivity: row.LastActivity, LastReceived: row.LastReceived}
+ activity := sqlitetypes.SessionActivityResult{LastActivity: row.LastActivity, SpanActivity: row.SpanActivity, LastReceived: row.LastReceived}
shared.ResolveSessionEnd(&s, activity.Activity(), time.Now())
return s
}
-const sessionActivityJoin = ` LEFT JOIN (
- SELECT session_id,
- MAX(COALESCE(ended_at, recorded_at)) AS last_activity,
- MAX(recorded_at) AS last_received
- FROM session_recordings
- WHERE project_id = :project_id AND session_id IS NOT NULL AND recorded_at >= :rec_from AND recorded_at <= :rec_to
- GROUP BY session_id
-) AS activity ON activity.session_id = sessions.id`
+var sessionActivityJoin = fmt.Sprintf(` LEFT JOIN (
+ SELECT r.session_id,
+ MAX(COALESCE(r.ended_at, r.recorded_at)) AS last_activity,
+ MAX(CASE WHEN COALESCE(r.ended_at, r.recorded_at) <= s.started_at + INTERVAL %d MINUTE THEN COALESCE(r.ended_at, r.recorded_at) END) AS span_activity,
+ MAX(r.recorded_at) AS last_received
+ FROM session_recordings AS r
+ JOIN sessions AS s ON s.id = r.session_id AND s.project_id = r.project_id
+ WHERE r.project_id = :project_id AND r.session_id IS NOT NULL AND r.recorded_at >= :rec_from AND r.recorded_at <= :rec_to
+ GROUP BY r.session_id
+) AS activity ON activity.session_id = sessions.id`, int(shared.SessionMaxSpan/time.Minute))
-var sessionDurationSortKey = fmt.Sprintf(`CASE WHEN activity.last_activity IS NULL THEN least(CAST(sessions.duration // 1000000 AS BIGINT), %[2]d)
- WHEN activity.last_activity > sessions.started_at + INTERVAL %[3]d MINUTE
- AND sessions.ended_at > sessions.started_at AND sessions.ended_at <= sessions.started_at + INTERVAL %[3]d MINUTE
- THEN epoch_ms(sessions.ended_at) - epoch_ms(sessions.started_at)
+var sessionLastActivity = fmt.Sprintf(`(CASE WHEN activity.last_activity > sessions.started_at + INTERVAL %d MINUTE
+ THEN COALESCE(activity.span_activity, sessions.started_at) ELSE activity.last_activity END)`, int(shared.SessionMaxSpan/time.Minute))
+
+var sessionDurationSortKey = strings.ReplaceAll(fmt.Sprintf(`CASE WHEN activity.last_activity IS NULL THEN least(CAST(sessions.duration // 1000000 AS BIGINT), %[2]d)
ELSE least(epoch_ms(CASE
- WHEN sessions.ended_at > greatest(activity.last_activity, sessions.started_at)
- AND sessions.ended_at < greatest(activity.last_activity, sessions.started_at) + INTERVAL %[1]d MINUTE
- THEN sessions.ended_at ELSE greatest(activity.last_activity, sessions.started_at) END) - epoch_ms(sessions.started_at), %[2]d) END`,
- int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds(), int(shared.SessionMaxSpan/time.Minute))
+ WHEN sessions.ended_at > greatest({last}, sessions.started_at)
+ AND sessions.ended_at < greatest({last}, sessions.started_at) + INTERVAL %[1]d MINUTE
+ THEN sessions.ended_at ELSE greatest({last}, sessions.started_at) END) - epoch_ms(sessions.started_at), %[2]d) END`,
+ int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds()), "{last}", sessionLastActivity)
type sessionRepository struct{}
@@ -193,7 +196,7 @@ func (r *sessionRepository) FindAll(ctx context.Context, projectId uuid.UUID, fr
}
offset := (page - 1) * pageSize
- query := "SELECT sessions.id, sessions.project_id, sessions.started_at, sessions.ended_at, sessions.duration, sessions.client_ip, sessions.attributes, sessions.app_version, sessions.server_name, sessions.trace_id, activity.last_activity, activity.last_received FROM sessions" + sessionActivityJoin +
+ query := "SELECT sessions.id, sessions.project_id, sessions.started_at, sessions.ended_at, sessions.duration, sessions.client_ip, sessions.attributes, sessions.app_version, sessions.server_name, sessions.trace_id, activity.last_activity, activity.span_activity, activity.last_received FROM sessions" + sessionActivityJoin +
" WHERE sessions.project_id = :project_id AND sessions.started_at >= :start AND sessions.started_at <= :end" + whereExtra + " ORDER BY " + orderExpr + " " + sortDir + " LIMIT :limit OFFSET :offset"
recFrom, recTo := shared.SessionRecordingWindow(fromDate, toDate)
@@ -271,13 +274,13 @@ func (r *sessionRepository) FindById(ctx context.Context, projectId, sessionId u
from, to := shared.TraceWindowBounds(row.StartedAt.Time)
activity, err := lit.SelectSingleNamed[sqlitetypes.SessionActivityResult](db.TelemetryDB,
- "SELECT MAX(COALESCE(ended_at, recorded_at)) AS last_activity, MAX(recorded_at) AS last_received FROM session_recordings WHERE project_id = :project_id AND session_id = :session_id AND recorded_at >= :from AND recorded_at <= :to",
- lit.P{"project_id": projectId, "session_id": sessionId, "from": from.UTC(), "to": to.UTC()})
+ "SELECT MAX(COALESCE(ended_at, recorded_at)) AS last_activity, MAX(CASE WHEN COALESCE(ended_at, recorded_at) <= :span_end THEN COALESCE(ended_at, recorded_at) END) AS span_activity, MAX(recorded_at) AS last_received FROM session_recordings WHERE project_id = :project_id AND session_id = :session_id AND recorded_at >= :from AND recorded_at <= :to",
+ lit.P{"project_id": projectId, "session_id": sessionId, "from": from.UTC(), "to": to.UTC(), "span_end": row.StartedAt.Time.Add(shared.SessionMaxSpan).UTC()})
if err != nil {
return nil, err
}
if activity != nil {
- row.LastActivity, row.LastReceived = activity.LastActivity, activity.LastReceived
+ row.LastActivity, row.SpanActivity, row.LastReceived = activity.LastActivity, activity.SpanActivity, activity.LastReceived
}
s := row.toModel()
return &s, nil
diff --git a/backend/app/repositories/telemetry/session_repository_test.go b/backend/app/repositories/telemetry/session_repository_test.go
index 61617e8a..e49051e5 100644
--- a/backend/app/repositories/telemetry/session_repository_test.go
+++ b/backend/app/repositories/telemetry/session_repository_test.go
@@ -109,7 +109,8 @@ func TestSessionRepository_EndFromRecordingActivity(t *testing.T) {
skewedClock := models.Session{Id: uuid.New(), ProjectId: projectID, StartedAt: ago(30 * time.Minute), EndedAt: ptr(ago(16 * time.Minute)), Duration: int64(14 * time.Minute)}
recordedPastCap := models.Session{Id: uuid.New(), ProjectId: projectID, StartedAt: ago(100 * time.Minute), EndedAt: ptr(ago(40 * time.Minute)), Duration: int64(60 * time.Minute)}
longIdle := models.Session{Id: uuid.New(), ProjectId: projectID, StartedAt: ago(110 * time.Minute)}
- if err := SessionRepository.Upsert(ctx, []models.Session{idle, closedByPagehide, closedByLateTimer, live, unrecorded, skewedClock, recordedPastCap, longIdle}); err != nil {
+ idleThenWoken := models.Session{Id: uuid.New(), ProjectId: projectID, StartedAt: ago(105 * time.Minute)}
+ if err := SessionRepository.Upsert(ctx, []models.Session{idle, closedByPagehide, closedByLateTimer, live, unrecorded, skewedClock, recordedPastCap, longIdle, idleThenWoken}); err != nil {
t.Fatal(err)
}
@@ -124,8 +125,11 @@ func TestSessionRepository_EndFromRecordingActivity(t *testing.T) {
segment(live, 0, ago(time.Minute)),
segment(skewedClock, 0, ago(32*time.Minute)),
segment(recordedPastCap, 0, ago(90*time.Minute)),
- segment(recordedPastCap, 1, ago(time.Minute)),
+ segment(recordedPastCap, 1, ago(41*time.Minute)),
+ segment(recordedPastCap, 2, ago(time.Minute)),
segment(longIdle, 0, ago(48*time.Minute)),
+ segment(idleThenWoken, 0, ago(105*time.Minute-8*time.Second)),
+ segment(idleThenWoken, 1, ago(2*time.Minute)),
}); err != nil {
t.Fatal(err)
}
@@ -143,6 +147,7 @@ func TestSessionRepository_EndFromRecordingActivity(t *testing.T) {
{live, 9 * time.Minute, false, true},
{closedByLateTimer, 5 * time.Minute, true, true},
{closedByPagehide, 2 * time.Minute, true, true},
+ {idleThenWoken, 8 * time.Second, true, true},
{unrecorded, 0, false, false},
}
diff --git a/backend/app/repositories/telemetry/shared/session_activity.go b/backend/app/repositories/telemetry/shared/session_activity.go
index 760fe3a1..c00f26f7 100644
--- a/backend/app/repositories/telemetry/shared/session_activity.go
+++ b/backend/app/repositories/telemetry/shared/session_activity.go
@@ -13,8 +13,9 @@ const SessionMaxSpan = 65 * time.Minute
const sessionEndTolerance = time.Second
type SessionActivity struct {
- LastActivity *time.Time
- LastReceived *time.Time
+ LastActivity *time.Time
+ LastActivityInSpan *time.Time
+ LastReceived *time.Time
}
func SessionRecordingWindow(from, to time.Time) (time.Time, time.Time) {
@@ -36,17 +37,16 @@ func ResolveSessionEnd(s *models.Session, activity SessionActivity, now time.Tim
}
last := *activity.LastActivity
- if last.Before(s.StartedAt) {
- last = s.StartedAt
- }
pastLimit := last.After(limit)
if pastLimit {
- last = limit
- if s.EndedAt != nil && s.EndedAt.After(s.StartedAt) && !s.EndedAt.After(limit) {
- last = *s.EndedAt
- s.CutoffAt = last
+ last = s.StartedAt
+ if activity.LastActivityInSpan != nil {
+ last = *activity.LastActivityInSpan
}
}
+ if last.Before(s.StartedAt) {
+ last = s.StartedAt
+ }
end := last
if s.EndedAt != nil && s.EndedAt.After(last) && s.EndedAt.Before(last.Add(SessionIdleTimeout)) {
@@ -64,6 +64,9 @@ func ResolveSessionEnd(s *models.Session, activity SessionActivity, now time.Tim
idle := now.Sub(lastReceived) >= SessionIdleTimeout || pastLimit
s.Duration = end.Sub(s.StartedAt).Nanoseconds()
+ if pastLimit {
+ s.CutoffAt = end
+ }
if endedByRecord || idle {
s.EndedAt = &end
} else {
diff --git a/backend/app/repositories/telemetry/shared/session_activity_test.go b/backend/app/repositories/telemetry/shared/session_activity_test.go
index c02128d7..fe751996 100644
--- a/backend/app/repositories/telemetry/shared/session_activity_test.go
+++ b/backend/app/repositories/telemetry/shared/session_activity_test.go
@@ -18,6 +18,7 @@ func TestResolveSessionEnd(t *testing.T) {
endedAt *time.Time
duration time.Duration
lastActivity *time.Time
+ inSpan *time.Time
lastReceived *time.Time
now time.Time
wantEnd *time.Time
@@ -35,9 +36,11 @@ func TestResolveSessionEnd(t *testing.T) {
{name: "activity before start on a skewed clock clamps to zero", lastActivity: at(-2), now: *at(30), wantEnd: at(0), wantDuration: 0, wantRecorded: true},
{name: "second-precision end just before the last segment still closes", endedAt: at(5), lastActivity: at(5.01), now: *at(6), wantEnd: at(5.01), wantDuration: time.Duration(5.01 * float64(time.Minute)), wantRecorded: true},
{name: "explicit end is measured from the clamped activity", endedAt: at(14), lastActivity: at(-2), now: *at(30), wantEnd: at(14), wantDuration: 14 * time.Minute, wantRecorded: true},
- {name: "segments uploaded after the SDK closed the session keep its close", endedAt: at(60), lastActivity: at(18 * 60), now: *at(18*60 + 1), wantEnd: at(60), wantDuration: 60 * time.Minute, wantRecorded: true},
- {name: "a close past the max span falls back to the cap when segments run on", endedAt: at(70), lastActivity: at(18 * 60), now: *at(18*60 + 1), wantEnd: at(65), wantDuration: 65 * time.Minute, wantRecorded: true},
- {name: "a session past the max span is over while segments still arrive", lastActivity: at(300), now: *at(301), wantEnd: at(65), wantDuration: 65 * time.Minute, wantRecorded: true},
+ {name: "segments uploaded after the SDK closed the session keep its close", endedAt: at(60), lastActivity: at(18 * 60), inSpan: at(59.5), now: *at(18*60 + 1), wantEnd: at(60), wantDuration: 60 * time.Minute, wantRecorded: true},
+ {name: "a close past the max span falls back to the cap when segments run on", endedAt: at(70), lastActivity: at(18 * 60), inSpan: at(64), now: *at(18*60 + 1), wantEnd: at(65), wantDuration: 65 * time.Minute, wantRecorded: true},
+ {name: "a session past the max span is over while segments still arrive", lastActivity: at(300), inSpan: at(40), now: *at(301), wantEnd: at(40), wantDuration: 40 * time.Minute, wantRecorded: true},
+ {name: "a tab idle after a few seconds ends there, not at the cap", lastActivity: at(18 * 60), inSpan: at(8.0 / 60), now: *at(18*60 + 1), wantEnd: at(8.0 / 60), wantDuration: 8 * time.Second, wantRecorded: true},
+ {name: "segments only past the max span leave nothing recorded inside it", lastActivity: at(300), now: *at(301), wantEnd: at(0), wantDuration: 0, wantRecorded: true},
{name: "explicit end past the max span is capped", endedAt: at(70), lastActivity: at(64), now: *at(71), wantEnd: at(65), wantDuration: 65 * time.Minute, wantRecorded: true},
{name: "no segments and an end past the max span is capped", endedAt: at(18 * 60), duration: 18 * time.Hour, now: *at(18*60 + 1), wantEnd: at(65), wantDuration: 65 * time.Minute},
{name: "a client clock behind the server keeps a live session open", lastActivity: at(29), lastReceived: at(129), now: *at(130), wantDuration: 29 * time.Minute, wantRecorded: true},
@@ -45,7 +48,7 @@ func TestResolveSessionEnd(t *testing.T) {
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
s := models.Session{StartedAt: start, EndedAt: tc.endedAt, Duration: tc.duration.Nanoseconds()}
- ResolveSessionEnd(&s, SessionActivity{LastActivity: tc.lastActivity, LastReceived: tc.lastReceived}, tc.now)
+ ResolveSessionEnd(&s, SessionActivity{LastActivity: tc.lastActivity, LastActivityInSpan: tc.inSpan, LastReceived: tc.lastReceived}, tc.now)
if s.HasRecording != tc.wantRecorded {
t.Fatalf("HasRecording = %v, want %v", s.HasRecording, tc.wantRecorded)
}
@@ -86,17 +89,18 @@ func TestResolveSessionEndCutoff(t *testing.T) {
name string
endedAt *time.Time
lastActivity *time.Time
+ inSpan *time.Time
want time.Time
}{
{name: "no segments", endedAt: at(20), want: *at(65)},
{name: "activity within the cap", endedAt: at(20), lastActivity: at(30), want: *at(65)},
- {name: "activity past the cap with the SDK close inside it", endedAt: at(60), lastActivity: at(600), want: *at(60)},
- {name: "activity past the cap without a close", lastActivity: at(600), want: *at(65)},
+ {name: "activity past the cap with the SDK close inside it", endedAt: at(60), lastActivity: at(600), inSpan: at(59), want: *at(60)},
+ {name: "activity past the cap ends at the last activity inside it", lastActivity: at(600), inSpan: at(12), want: *at(12)},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
s := models.Session{StartedAt: start, EndedAt: tc.endedAt}
- ResolveSessionEnd(&s, SessionActivity{LastActivity: tc.lastActivity}, *at(601))
+ ResolveSessionEnd(&s, SessionActivity{LastActivity: tc.lastActivity, LastActivityInSpan: tc.inSpan}, *at(601))
if !s.CutoffAt.Equal(tc.want) {
t.Fatalf("CutoffAt = %v, want %v", s.CutoffAt, tc.want)
}
diff --git a/backend/app/repositories/telemetry/sqlite/session.repository.go b/backend/app/repositories/telemetry/sqlite/session.repository.go
index 1b96559c..53ef6a61 100644
--- a/backend/app/repositories/telemetry/sqlite/session.repository.go
+++ b/backend/app/repositories/telemetry/sqlite/session.repository.go
@@ -29,6 +29,7 @@ type sessionRow struct {
TraceId string `lit:"trace_id"`
LastActivity *sqlitetypes.SQLiteTime `lit:"last_activity"`
+ SpanActivity *sqlitetypes.SQLiteTime `lit:"span_activity"`
LastReceived *sqlitetypes.SQLiteTime `lit:"last_received"`
}
@@ -81,30 +82,31 @@ func (row *sessionRow) toModel() models.Session {
if row.Attributes != nil {
s.Attributes = map[string]string(row.Attributes)
}
- activity := sqlitetypes.SessionActivityResult{LastActivity: row.LastActivity, LastReceived: row.LastReceived}
+ activity := sqlitetypes.SessionActivityResult{LastActivity: row.LastActivity, SpanActivity: row.SpanActivity, LastReceived: row.LastReceived}
shared.ResolveSessionEnd(&s, activity.Activity(), time.Now())
return s
}
-const sessionActivityJoin = ` LEFT JOIN (
- SELECT session_id,
- MAX(COALESCE(ended_at, recorded_at)) AS last_activity,
- MAX(recorded_at) AS last_received
- FROM session_recordings
- WHERE project_id = :project_id AND session_id IS NOT NULL AND recorded_at >= :rec_from AND recorded_at <= :rec_to
- GROUP BY session_id
-) AS activity ON activity.session_id = sessions.id`
+var sessionActivityJoin = fmt.Sprintf(` LEFT JOIN (
+ SELECT r.session_id,
+ MAX(COALESCE(r.ended_at, r.recorded_at)) AS last_activity,
+ MAX(CASE WHEN julianday(COALESCE(r.ended_at, r.recorded_at)) <= julianday(s.started_at) + %d / 1440.0 THEN COALESCE(r.ended_at, r.recorded_at) END) AS span_activity,
+ MAX(r.recorded_at) AS last_received
+ FROM session_recordings AS r
+ JOIN sessions AS s ON s.id = r.session_id AND s.project_id = r.project_id
+ WHERE r.project_id = :project_id AND r.session_id IS NOT NULL AND r.recorded_at >= :rec_from AND r.recorded_at <= :rec_to
+ GROUP BY r.session_id
+) AS activity ON activity.session_id = sessions.id`, int(shared.SessionMaxSpan/time.Minute))
-var sessionDurationSortKey = fmt.Sprintf(`CASE WHEN activity.last_activity IS NULL THEN MIN(sessions.duration / 1000000, %[2]d)
- WHEN julianday(activity.last_activity) > julianday(sessions.started_at) + %[3]d / 1440.0
- AND julianday(sessions.ended_at) > julianday(sessions.started_at)
- AND julianday(sessions.ended_at) <= julianday(sessions.started_at) + %[3]d / 1440.0
- THEN CAST(ROUND((julianday(sessions.ended_at) - julianday(sessions.started_at)) * 86400000) AS INTEGER)
+var sessionLastActivity = fmt.Sprintf(`(CASE WHEN julianday(activity.last_activity) > julianday(sessions.started_at) + %d / 1440.0
+ THEN COALESCE(activity.span_activity, sessions.started_at) ELSE activity.last_activity END)`, int(shared.SessionMaxSpan/time.Minute))
+
+var sessionDurationSortKey = strings.ReplaceAll(fmt.Sprintf(`CASE WHEN activity.last_activity IS NULL THEN MIN(sessions.duration / 1000000, %[2]d)
ELSE MIN(CAST(ROUND((julianday(CASE
- WHEN sessions.ended_at > MAX(activity.last_activity, sessions.started_at)
- AND julianday(sessions.ended_at) < julianday(MAX(activity.last_activity, sessions.started_at)) + %[1]d / 1440.0
- THEN sessions.ended_at ELSE MAX(activity.last_activity, sessions.started_at) END) - julianday(sessions.started_at)) * 86400000) AS INTEGER), %[2]d) END`,
- int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds(), int(shared.SessionMaxSpan/time.Minute))
+ WHEN sessions.ended_at > MAX({last}, sessions.started_at)
+ AND julianday(sessions.ended_at) < julianday(MAX({last}, sessions.started_at)) + %[1]d / 1440.0
+ THEN sessions.ended_at ELSE MAX({last}, sessions.started_at) END) - julianday(sessions.started_at)) * 86400000) AS INTEGER), %[2]d) END`,
+ int(shared.SessionIdleTimeout/time.Minute), shared.SessionMaxSpan.Milliseconds()), "{last}", sessionLastActivity)
type sessionRepository struct{}
@@ -201,7 +203,7 @@ func (r *sessionRepository) FindAll(ctx context.Context, projectId uuid.UUID, fr
}
offset := (page - 1) * pageSize
- query := "SELECT sessions.id, sessions.project_id, sessions.started_at, sessions.ended_at, sessions.duration, sessions.client_ip, sessions.attributes, sessions.app_version, sessions.server_name, sessions.trace_id, activity.last_activity, activity.last_received FROM sessions" + sessionActivityJoin +
+ query := "SELECT sessions.id, sessions.project_id, sessions.started_at, sessions.ended_at, sessions.duration, sessions.client_ip, sessions.attributes, sessions.app_version, sessions.server_name, sessions.trace_id, activity.last_activity, activity.span_activity, activity.last_received FROM sessions" + sessionActivityJoin +
" WHERE sessions.project_id = :project_id AND sessions.started_at >= :start AND sessions.started_at <= :end" + whereExtra + " ORDER BY " + orderExpr + " " + sortDir + " LIMIT :limit OFFSET :offset"
recFrom, recTo := shared.SessionRecordingWindow(fromDate, toDate)
@@ -279,13 +281,13 @@ func (r *sessionRepository) FindById(ctx context.Context, projectId, sessionId u
from, to := shared.TraceWindowBounds(row.StartedAt.Time)
activity, err := lit.SelectSingleNamed[sqlitetypes.SessionActivityResult](db.TelemetryDB,
- "SELECT MAX(COALESCE(ended_at, recorded_at)) AS last_activity, MAX(recorded_at) AS last_received FROM session_recordings WHERE project_id = :project_id AND session_id = :session_id AND recorded_at >= :from AND recorded_at <= :to",
- lit.P{"project_id": projectId, "session_id": sessionId, "from": sqlitetypes.NewSQLiteTime(from), "to": sqlitetypes.NewSQLiteTime(to)})
+ "SELECT MAX(COALESCE(ended_at, recorded_at)) AS last_activity, MAX(CASE WHEN julianday(COALESCE(ended_at, recorded_at)) <= julianday(:span_end) THEN COALESCE(ended_at, recorded_at) END) AS span_activity, MAX(recorded_at) AS last_received FROM session_recordings WHERE project_id = :project_id AND session_id = :session_id AND recorded_at >= :from AND recorded_at <= :to",
+ lit.P{"project_id": projectId, "session_id": sessionId, "from": sqlitetypes.NewSQLiteTime(from), "to": sqlitetypes.NewSQLiteTime(to), "span_end": sqlitetypes.NewSQLiteTime(row.StartedAt.Time.Add(shared.SessionMaxSpan))})
if err != nil {
return nil, err
}
if activity != nil {
- row.LastActivity, row.LastReceived = activity.LastActivity, activity.LastReceived
+ row.LastActivity, row.SpanActivity, row.LastReceived = activity.LastActivity, activity.SpanActivity, activity.LastReceived
}
s := row.toModel()
return &s, nil
diff --git a/backend/app/repositories/telemetry/sqlitetypes/sqlitetypes.go b/backend/app/repositories/telemetry/sqlitetypes/sqlitetypes.go
index e77c2104..5c3c860d 100644
--- a/backend/app/repositories/telemetry/sqlitetypes/sqlitetypes.go
+++ b/backend/app/repositories/telemetry/sqlitetypes/sqlitetypes.go
@@ -128,6 +128,7 @@ type FilePathResult struct {
type SessionActivityResult struct {
LastActivity *SQLiteTime `lit:"last_activity"`
+ SpanActivity *SQLiteTime `lit:"span_activity"`
LastReceived *SQLiteTime `lit:"last_received"`
}
@@ -137,6 +138,10 @@ func (r SessionActivityResult) Activity() shared.SessionActivity {
t := r.LastActivity.Time
activity.LastActivity = &t
}
+ if r.SpanActivity != nil {
+ t := r.SpanActivity.Time
+ activity.LastActivityInSpan = &t
+ }
if r.LastReceived != nil {
t := r.LastReceived.Time
activity.LastReceived = &t
diff --git a/docs/pages/learn/sessions.mdx b/docs/pages/learn/sessions.mdx
index e234f8c7..77979076 100644
--- a/docs/pages/learn/sessions.mdx
+++ b/docs/pages/learn/sessions.mdx
@@ -43,7 +43,7 @@ It ends on the first of:
| **Maximum duration** | 60 minutes from session start | Hard cap regardless of activity |
| **Page unload** | `pagehide` fires (close tab, hard refresh, navigate away) | Final segment is drained, closing payload sent via `fetch keepalive` |
-The closing payload is not guaranteed to arrive: the browser can be force-quit before `pagehide` runs, mobile browsers freeze background tabs without firing it, and the flush itself can be dropped. The backend therefore does not depend on it. Once no replay segment has arrived for 15 minutes, the session ends at the time of its last recorded segment. A close reported more than 15 minutes after the last segment, which is what the inactivity timer sends from a tab that sat frozen in the background, is replaced the same way, so the duration reflects activity rather than time the tab spent unattended. Replay segments recorded more than 65 minutes after a session started (the 60 minute cap plus slack for a late timer) are not part of it: browser SDK versions up to 1.2.0 kept uploading segments under an ended session for as long as the tab stayed open, and those sessions end at the close the SDK reported, or at the cap when there is none. A session with no recorded segments and no close is shown as **No recording**.
+The closing payload is not guaranteed to arrive: the browser can be force-quit before `pagehide` runs, mobile browsers freeze background tabs without firing it, and the flush itself can be dropped. The backend therefore does not depend on it. Once no replay segment has arrived for 15 minutes, the session ends at the time of its last recorded segment. A close reported more than 15 minutes after the last segment, which is what the inactivity timer sends from a tab that sat frozen in the background, is replaced the same way, so the duration reflects activity rather than time the tab spent unattended. Replay segments recorded more than 65 minutes after a session started (the 60 minute cap plus slack for a late timer) are not part of it: browser SDK versions up to 1.2.0 kept uploading segments under an ended session for as long as the tab stayed open, and those sessions end at their last recorded activity within the first 65 minutes. A session with no recorded segments and no close is shown as **No recording**.
## Attributes