feat(node): Add release health feature to Node.js

Captures request mode sessions associated with a specific release, and sends them to the server as part of the release health functionality. Also added functionality that captures application mode sessions in Node.js

Author: ahmedetefy

packages/core/src/baseclient.ts

@@ -7,6 +7,7 @@ import {
   Integration,
   IntegrationClass,
   Options,
+  RequestSessionStatus,
   SessionStatus,
   Severity,
 } from '@sentry/types';
@@ -100,6 +101,24 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
   public captureException(exception: any, hint?: EventHint, scope?: Scope): string | undefined {
     let eventId: string | undefined = hint && hint.event_id;
 
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    if (this._options.autoSessionTracking && scope) {
+      const requestSession = (scope as any)._requestSession;
+
+      // Necessary check to ensure this is code block is executed only within a request
+      if (requestSession.status !== undefined) {
+        const scopeExtras = (scope as any)._extra;
+        // Set status to crashed, if captureException call is made from either onunhandledrejection handler
+        // or the onuncaughtexception handler
+        if (scopeExtras.unhandledPromiseRejection || scopeExtras.onUncaughtException) {
+          requestSession.status = RequestSessionStatus.Crashed;
+        } else {
+          requestSession.status = RequestSessionStatus.Errored;
+        }
+      }
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+
     this._process(
       this._getBackend()
         .eventFromException(exception, hint)
@@ -139,6 +158,24 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
   public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {
     let eventId: string | undefined = hint && hint.event_id;
 
+    if (this._options.autoSessionTracking) {
+      const eventType = event.type || 'event';
+      const isException = eventType === 'event';
+
+      // If the event is of type Exception, then a request session should be captured
+      if (isException && scope) {
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+        const requestSession = (scope as any)._requestSession;
+
+        // Ensure that this is happening within a request, and make sure not to override if Errored/Crashed
+        if (requestSession.status === RequestSessionStatus.Ok) {
+          requestSession.status = RequestSessionStatus.Errored;
+        }
+
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      }
+    }
+
     this._process(
       this._captureEvent(event, hint, scope).then(result => {
         eventId = result;

packages/core/src/index.ts

@@ -17,7 +17,7 @@ export { addGlobalEventProcessor, getCurrentHub, getHubFromCarrier, Hub, makeMai
 export { API } from './api';
 export { BaseClient } from './baseclient';
 export { BackendClass, BaseBackend } from './basebackend';
-export { eventToSentryRequest, sessionToSentryRequest } from './request';
+export { eventToSentryRequest, sessionToSentryRequest, aggregateSessionsToSentryRequest } from './request';
 export { initAndBind, ClientClass } from './sdk';
 export { NoopTransport } from './transports/noop';
 export { SDK_VERSION } from './version';

packages/core/src/request.ts

@@ -1,4 +1,4 @@
-import { Event, SdkInfo, SentryRequest, Session } from '@sentry/types';
+import { AggregatedSessions, Event, SdkInfo, SentryRequest, Session } from '@sentry/types';
 
 import { API } from './api';
 
@@ -49,6 +49,26 @@ export function sessionToSentryRequest(session: Session, api: API): SentryReques
   };
 }
 
+/** Creates a SentryRequest from an Aggregate of Request mode sessions */
+export function aggregateSessionsToSentryRequest(aggregatedSessions: AggregatedSessions, api: API): SentryRequest {
+  const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
+  const envelopeHeaders = JSON.stringify({
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+  });
+  // The server expects the headers for request mode sessions to be `sessions` while the SDK considers
+  // request mode sessions to be of type `session`
+  const itemHeaders = JSON.stringify({
+    type: 'sessions',
+  });
+
+  return {
+    body: `${envelopeHeaders}\n${itemHeaders}\n${JSON.stringify(aggregatedSessions)}`,
+    type: 'session',
+    url: api.getEnvelopeEndpointWithUrlEncodedAuth(),
+  };
+}
+
 /** Creates a SentryRequest from an event. */
 export function eventToSentryRequest(event: Event, api: API): SentryRequest {
   const sdkInfo = getSdkMetadataForEnvelopeHeader(api);

packages/core/test/lib/base.test.ts

@@ -1,5 +1,5 @@
 import { Hub, Scope } from '@sentry/hub';
-import { Event, Severity, Span } from '@sentry/types';
+import { Event, RequestSessionStatus, Severity, Span } from '@sentry/types';
 import { logger, SentryError, SyncPromise } from '@sentry/utils';
 
 import { TestBackend } from '../mocks/backend';
@@ -238,6 +238,67 @@ describe('BaseClient', () => {
         }),
       );
     });
+
+    test('when autoSessionTracking is disabled, does not set requestSession status', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: false });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Ok });
+    });
+
+    test('Does not set requestSession status when an exception occurs outside of a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      client.captureException(new Error('test exception'), {}, scope);
+      expect((scope as any)._requestSession).toEqual({});
+    });
+
+    test('Sets requestSession status to Errored when an exception occurs within a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Errored });
+    });
+
+    test('Sets requestSession status to Crashed when an onuncaughtexception occurs within a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      scope.setExtra('onUncaughtException', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Crashed });
+    });
+
+    test('Does not set requestSession status when an onunhandledrejection occurs outside a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      scope.setExtra('unhandledPromiseRejection', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Crashed });
+    });
+
+    test('Does not set requestSession status when an onuncaughtexception occurs outside a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      scope.setExtra('onUncaughtException', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect((scope as any)._requestSession).toEqual({});
+    });
+
+    test('Sets requestSession status to Crashed when an onunhandledrejection occurs within a request', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      scope.setExtra('unhandledPromiseRejection', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect((scope as any)._requestSession).toEqual({});
+    });
   });
 
   describe('captureMessage', () => {
@@ -477,6 +538,49 @@ describe('BaseClient', () => {
       });
     });
 
+    test('If autoSessionTracking is disabled, requestSession status should not be set', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: false });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Ok });
+    });
+
+    test('When captureEvent is called with an exception, requestSession status should be set to Errored', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Errored });
+    });
+
+    test('When captureEvent is called with an exception and, requestSession status is Crashed, it should not be overridden', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Crashed;
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Crashed });
+    });
+
+    test('When captureEvent is called with an exception but outside of a request, then requestStatus should not be set', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect((scope as any)._requestSession).toEqual({});
+    });
+
+    test('When captureEvent is called with a transaction, then requestStatus should not be set', () => {
+      const client = new TestClient({ dsn: PUBLIC_DSN, autoSessionTracking: true });
+      const scope = new Scope();
+      const requestSession = (scope as any)._requestSession;
+      requestSession.status = RequestSessionStatus.Ok;
+      client.captureEvent({ message: 'message', type: 'transaction' }, undefined, scope);
+      expect(requestSession).toEqual({ status: RequestSessionStatus.Ok });
+    });
+
     test('normalizes event with default depth of 3', () => {
       expect.assertions(1);
       const client = new TestClient({ dsn: PUBLIC_DSN });

packages/core/test/lib/request.test.ts

@@ -1,9 +1,19 @@
 import { DebugMeta, Event, SentryRequest, TransactionSamplingMethod } from '@sentry/types';
 
 import { API } from '../../src/api';
-import { eventToSentryRequest } from '../../src/request';
+import { aggregateSessionsToSentryRequest, eventToSentryRequest } from '../../src/request';
+
+const api = new API('https://[email protected]/12312012', {
+  sdk: {
+    integrations: ['AWSLambda'],
+    name: 'sentry.javascript.browser',
+    version: `12.31.12`,
+    packages: [{ name: 'npm:@sentry/browser', version: `12.31.12` }],
+  },
+});
 
 describe('eventToSentryRequest', () => {
+  let event: Event;
   function parseEnvelopeRequest(request: SentryRequest): any {
     const [envelopeHeaderString, itemHeaderString, eventString] = request.body.split('\n');
 
@@ -14,16 +24,6 @@ describe('eventToSentryRequest', () => {
     };
   }
 
-  const api = new API('https://[email protected]/12312012', {
-    sdk: {
-      integrations: ['AWSLambda'],
-      name: 'sentry.javascript.browser',
-      version: `12.31.12`,
-      packages: [{ name: 'npm:@sentry/browser', version: `12.31.12` }],
-    },
-  });
-  let event: Event;
-
   beforeEach(() => {
     event = {
       contexts: { trace: { trace_id: '1231201211212012', span_id: '12261980', op: 'pageload' } },
@@ -125,3 +125,32 @@ describe('eventToSentryRequest', () => {
     );
   });
 });
+
+describe('aggregateSessionsToSentryRequest', () => {
+  it('test envelope creation for aggregateSessions', () => {
+    const aggregatedSession = {
+      attrs: { release: '1.0.x', environment: 'prod' },
+      aggregates: [{ started: '2021-04-08T12:18:00.000Z', exited: 2 }],
+    };
+    const result = aggregateSessionsToSentryRequest(aggregatedSession, api);
+
+    const [envelopeHeaderString, itemHeaderString, sessionString] = result.body.split('\n');
+
+    expect(JSON.parse(envelopeHeaderString)).toEqual(
+      expect.objectContaining({
+        sdk: { name: 'sentry.javascript.browser', version: '12.31.12' },
+      }),
+    );
+    expect(JSON.parse(itemHeaderString)).toEqual(
+      expect.objectContaining({
+        type: 'sessions',
+      }),
+    );
+    expect(JSON.parse(sessionString)).toEqual(
+      expect.objectContaining({
+        attrs: { release: '1.0.x', environment: 'prod' },
+        aggregates: [{ started: '2021-04-08T12:18:00.000Z', exited: 2 }],
+      }),
+    );
+  });
+});

packages/hub/src/index.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line deprecation/deprecation
 export { Carrier, DomainAsCarrier, Layer } from './interfaces';
 export { addGlobalEventProcessor, Scope } from './scope';
-export { Session } from './session';
+export { Session, SessionFlusher } from './session';
 export {
   // eslint-disable-next-line deprecation/deprecation
   getActiveDomain,

packages/hub/src/scope.ts

@@ -10,6 +10,7 @@ import {
   Extra,
   Extras,
   Primitive,
+  RequestSessionStatus,
   Scope as ScopeInterface,
   ScopeContext,
   Severity,
@@ -65,6 +66,9 @@ export class Scope implements ScopeInterface {
   /** Session */
   protected _session?: Session;
 
+  /** Request Mode Session Status */
+  protected _requestSession: { status?: RequestSessionStatus } = {};
+
   /**
    * Inherit values from the parent scope.
    * @param scope to clone.
@@ -83,6 +87,9 @@ export class Scope implements ScopeInterface {
       newScope._transactionName = scope._transactionName;
       newScope._fingerprint = scope._fingerprint;
       newScope._eventProcessors = [...scope._eventProcessors];
+      if (scope._requestSession) {
+        newScope._requestSession = scope._requestSession;
+      }
     }
     return newScope;
   }
@@ -288,6 +295,7 @@ export class Scope implements ScopeInterface {
       this._tags = { ...this._tags, ...captureContext._tags };
       this._extra = { ...this._extra, ...captureContext._extra };
       this._contexts = { ...this._contexts, ...captureContext._contexts };
+      this._requestSession = { ...this._requestSession, ...captureContext._requestSession };
       if (captureContext._user && Object.keys(captureContext._user).length) {
         this._user = captureContext._user;
       }
@@ -312,6 +320,9 @@ export class Scope implements ScopeInterface {
       if (captureContext.fingerprint) {
         this._fingerprint = captureContext.fingerprint;
       }
+      if (captureContext.requestSession) {
+        this._requestSession = captureContext.requestSession;
+      }
     }
 
     return this;
@@ -326,6 +337,7 @@ export class Scope implements ScopeInterface {
     this._extra = {};
     this._user = {};
     this._contexts = {};
+    this._requestSession = {};
     this._level = undefined;
     this._transactionName = undefined;
     this._fingerprint = undefined;