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/browser/src/transports/base.ts

@@ -15,6 +15,7 @@ const CATEGORY_MAPPING: {
   event: 'error',
   transaction: 'transaction',
   session: 'session',
+  sessions: 'sessions',
 };
 
 /** Base Transport class implementation */

packages/browser/test/unit/transports/fetch.test.ts

@@ -366,7 +366,7 @@ describe('FetchTransport', () => {
           .returns(afterLimit);
 
         const headers = new Headers();
-        headers.set('X-Sentry-Rate-Limits', `${retryAfterSeconds}:error;transaction:scope`);
+        headers.set('X-Sentry-Rate-Limits', `${retryAfterSeconds}::scope`);
         fetch.returns(Promise.resolve({ status: 429, headers }));
 
         try {

packages/core/src/baseclient.ts

@@ -7,6 +7,7 @@ import {
   Integration,
   IntegrationClass,
   Options,
+  RequestSessionStatus,
   SessionStatus,
   Severity,
 } from '@sentry/types';
@@ -100,6 +101,19 @@ 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;
 
+    if (this._options.autoSessionTracking && scope) {
+      const requestSession = scope.getRequestSession();
+      // Necessary check to ensure this is code block is executed only within a request
+      if (requestSession.status !== undefined) {
+        const scopeExtras = scope.getExtras();
+        if (scopeExtras.unhandledPromiseRejection || scopeExtras.onUncaughtException) {
+          requestSession.status = RequestSessionStatus.Crashed;
+        } else {
+          requestSession.status = RequestSessionStatus.Errored;
+        }
+      }
+    }
+
     this._process(
       this._getBackend()
         .eventFromException(exception, hint)
@@ -139,6 +153,17 @@ 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 isTransaction = event.type === 'transaction';
+
+      if (!isTransaction && scope) {
+        const requestSession = scope.getRequestSession();
+        if (requestSession.status === RequestSessionStatus.Ok) {
+          requestSession.status = RequestSessionStatus.Errored;
+        }
+      }
+    }
+
     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,5 @@
-import { Event, SdkInfo, SentryRequest, Session } from '@sentry/types';
+import { AggregatedSessions, Event, SdkInfo, SentryRequest, Session } from '@sentry/types';
+import { logger } from '@sentry/utils';
 
 import { API } from './api';
 
@@ -31,7 +32,7 @@ function enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {
   return event;
 }
 
-/** Creates a SentryRequest from an event. */
+/** Creates a SentryRequest from a Session. */
 export function sessionToSentryRequest(session: Session, api: API): SentryRequest {
   const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
   const envelopeHeaders = JSON.stringify({
@@ -49,6 +50,24 @@ 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 }),
+  });
+  const itemHeaders = JSON.stringify({
+    type: 'sessions',
+  });
+
+  return {
+    body: `${envelopeHeaders}\n${itemHeaders}\n${JSON.stringify(aggregatedSessions)}`,
+    type: 'sessions',
+    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,63 @@ 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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(scope.getRequestSession()).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.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(scope.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      scope.setExtra('onUncaughtException', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(scope.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      scope.setExtra('unhandledPromiseRejection', true);
+      client.captureException(new Error('test exception'), {}, scope);
+      expect(scope.getRequestSession()).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.getRequestSession()).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.getRequestSession()).toEqual({});
+    });
   });
 
   describe('captureMessage', () => {
@@ -477,6 +534,45 @@ 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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(scope.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(scope.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Crashed);
+      client.captureEvent({ message: 'message' }, undefined, scope);
+      expect(scope.getRequestSession()).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.getRequestSession()).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();
+      scope.setRequestSession(RequestSessionStatus.Ok);
+      client.captureEvent({ message: 'message', type: 'transaction' }, undefined, scope);
+      expect(scope.getRequestSession()).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,