Sentry Release Health Sessions with window.sessionStorage

[AbhiPrasad]

https://docs.sentry.io/platforms/javascript/configuration/releases/#release-health

Currently the automated session tracking in the JavaScript SDK works of of the history API. As per the docs:

We create a session for every page load. For single-page applications, we will create a new session for every navigation change (History API).

Here is an integration that uses window.sessionStorage to do it instead: https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage

import * as Sentry from '@sentry/browser';
import type { EventProcessor, Integration, Session, SerializedSession } from '@sentry/types';
import { dropUndefinedKeys } from '@sentry/utils';
import { makeSession } from '@sentry/core';

class SessionTracking implements Integration {
  public static id = 'SessionTracking';
  public name = SessionTracking.id;
  private _hasSessionStorage: boolean = 'sessionStorage' in window;

  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Sentry.Hub): void {
    if (!this._hasSessionStorage) {
      return;
    }
    const hub = getCurrentHub();

    // Attempt to get session from storage.
    const existingSerializedSession = this._getSession();
    if (existingSerializedSession) {
      // If it exists, set it on the scope so that errors can be associated with it.
      hub.getScope().setSession(this._deserializeSession(hub, existingSerializedSession));
    } else {
      // If it doesn't exist, create a new session and set it on the scope.
      const session = hub.startSession();
      hub.captureSession();
      // Store this new session in session storage.
      this._setSession(session);
    }
  }

  private _setSession(session: Session): void {
    try {
      window.sessionStorage.setItem('__SENTRY_SDK_SESSION__', JSON.stringify(session));
    } catch {
      // this shouldn't happen
    }
  }

  private _getSession(): SerializedSession | undefined {
    try {
      const stringSession = window.sessionStorage.getItem('__SENTRY_SDK_SESSION__');
      if (stringSession) {
        return JSON.parse(stringSession) as SerializedSession;
      }
    } catch {
      // this shouldn't happen
    }

    return undefined;
  }

  private _deserializeSession(hub: Sentry.Hub, session: SerializedSession): Session {
    return makeSession(
      dropUndefinedKeys({
        sid: session.sid,
        init: false,
        started: new Date(session.started).getTime(),
        timestamp: new Date(session.timestamp).getTime(),
        status: session.status,
        errors: session.errors,
        did: session.did,
        duration: session.duration,
        release: session.attrs?.release,
        environment: session.attrs?.environment,
        ipAddress: session.attrs?.ip_address,
        userAgent: session.attrs?.user_agent,
      })
    );
  }
}

Sentry.init({
  dsn: '__SENTRY_DSN__',
  release: '__SENTRY_RELEASE__',
  autoSessionTracking: false,
  integrations: [new SessionTracking()],
});