Session Timing

Adds session duration information to all events, tracking time since Sentry initialization. This integration provides temporal context for errors and helps understand application session lifecycle.

Capabilities

Modern Function-based Integration

/**
 * Adds session timing information to all events
 * @returns Integration instance that tracks session duration
 */
function sessionTimingIntegration(): Integration;

Legacy Class-based Integration (Deprecated)

/**
 * Legacy class-based session timing integration
 * @deprecated Use sessionTimingIntegration() instead
 */
class SessionTiming implements Integration {
  name: string;
  processEvent(event: Event): Event;
}

Behavior

The integration adds three timing properties to the extra field of every event:

Session Start Time

• Property: session:start
• Value: Timestamp (milliseconds) when integration was initialized
• Purpose: Reference point for session duration calculations

Session Duration

• Property: session:duration
• Value: Milliseconds elapsed since session start
• Purpose: How long the application has been running when event occurred

Event Time

• Property: session:end
• Value: Timestamp (milliseconds) when event was processed
• Purpose: Exact moment when the event was created

Usage Examples

import { sessionTimingIntegration } from '@sentry/integrations';
import * as Sentry from '@sentry/browser';

// Add session timing to all events
Sentry.init({
  dsn: 'YOUR_DSN',
  integrations: [
    sessionTimingIntegration()
  ]
});

// Session timing works with any error or message
setTimeout(() => {
  throw new Error('Error after 5 seconds');
}, 5000);

// The error event will include timing information:
// extra: {
//   'session:start': 1640995200000,
//   'session:duration': 5000,
//   'session:end': 1640995205000
// }

Event Enhancement

All events processed by this integration receive additional timing context:

// Original event
{
  message: "User action failed",
  extra: {
    userId: "12345"
  }
}

// Enhanced with session timing
{
  message: "User action failed", 
  extra: {
    userId: "12345",
    "session:start": 1640995200000,    // Session initialized
    "session:duration": 15000,         // 15 seconds since start
    "session:end": 1640995215000       // Current timestamp
  }
}

Use Cases

Error Context Analysis

Understanding when errors occur during the application lifecycle:

• Immediate errors: Problems during application startup
• Long-running sessions: Issues that appear after extended usage
• Session patterns: Correlating error frequency with session duration

Performance Monitoring

Tracking application behavior over time:

• Memory leaks: Errors increasing with session duration
• Resource exhaustion: Problems appearing after certain runtime thresholds
• Lifecycle issues: Errors specific to application startup or long usage

User Experience Analysis

Understanding user interaction patterns:

• Quick exits: Errors causing immediate user departure
• Extended usage: Problems affecting long-term users
• Session quality: Correlation between session length and error rates

Integration with Other Tools

Custom Dashboards

Session timing data enables temporal analysis:

// Query events by session duration ranges
// 0-30s: startup errors
// 30s-5min: short session errors  
// 5min+: long session errors

Alert Configuration

Set up alerts based on session timing:

// Alert on errors occurring very early in sessions
if (event.extra['session:duration'] < 10000) {
  // Potential startup issue
}

No Configuration Required

This integration has no configuration options - it automatically tracks timing for all events from the moment it's initialized. The timing starts when the integration is created, not when Sentry.init() is called, providing accurate session duration measurement.

This integration is lightweight and provides valuable temporal context for debugging and analysis without any performance impact or additional setup requirements.