feat(node): Application mode sessions

Add API to capture application mode sessions associated with a specific
release, and send them to Sentry as part of the Release Health functionality.

Author: ahmedetefy

packages/node/src/client.ts

@@ -1,5 +1,7 @@
 import { BaseClient, Scope, SDK_VERSION } from '@sentry/core';
+import { Session } from '@sentry/hub';
 import { Event, EventHint } from '@sentry/types';
+import { logger } from '@sentry/utils';
 
 import { NodeBackend, NodeOptions } from './backend';
 
@@ -30,6 +32,19 @@ export class NodeClient extends BaseClient<NodeBackend, NodeOptions> {
     super(NodeBackend, options);
   }
 
+  /**
+   * @inheritDoc
+   */
+  public captureSession(session: Session): void {
+    if (!session.release) {
+      logger.warn('Discarded session because of missing release');
+    } else {
+      this._sendSession(session);
+      // After sending, we set init false to inidcate it's not the first occurence
+      session.update({ init: false });
+    }
+  }
+
   /**
    * @inheritDoc
    */

packages/node/src/transports/base.ts

@@ -1,5 +1,5 @@
-import { API, eventToSentryRequest, SDK_VERSION } from '@sentry/core';
-import { Event, Response, Status, Transport, TransportOptions } from '@sentry/types';
+import { API, SDK_VERSION } from '@sentry/core';
+import { Event, Response, SentryRequest, Session, Status, Transport, TransportOptions } from '@sentry/types';
 import { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';
 import * as fs from 'fs';
 import * as http from 'http';
@@ -63,6 +63,13 @@ export abstract class BaseTransport implements Transport {
     throw new SentryError('Transport Class has to implement `sendEvent` method.');
   }
 
+  /**
+   * @inheritDoc
+   */
+  public sendSession(_: Session): PromiseLike<Response> {
+    throw new SentryError('Transport Class has to implement `sendSession` method.');
+  }
+
   /**
    * @inheritDoc
    */
@@ -96,7 +103,7 @@ export abstract class BaseTransport implements Transport {
   }
 
   /** JSDoc */
-  protected async _sendWithModule(httpModule: HTTPModule, event: Event): Promise<Response> {
+  protected async _sendWithModule(httpModule: HTTPModule, sentryReq: SentryRequest): Promise<Response> {
     if (new Date(Date.now()) < this._disabledUntil) {
       return Promise.reject(new SentryError(`Transport locked till ${this._disabledUntil} due to too many requests.`));
     }
@@ -106,7 +113,6 @@ export abstract class BaseTransport implements Transport {
     }
     return this._buffer.add(
       new Promise<Response>((resolve, reject) => {
-        const sentryReq = eventToSentryRequest(event, this._api);
         const options = this._getRequestOptions(new url.URL(sentryReq.url));
 
         const req = httpModule.request(options, (res: http.IncomingMessage) => {

packages/node/src/transports/http.ts

@@ -1,4 +1,5 @@
-import { Event, Response, TransportOptions } from '@sentry/types';
+import { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';
+import { Event, Response, Session, TransportOptions } from '@sentry/types';
 import { SentryError } from '@sentry/utils';
 import * as http from 'http';
 
@@ -23,6 +24,16 @@ export class HTTPTransport extends BaseTransport {
     if (!this.module) {
       throw new SentryError('No module available in HTTPTransport');
     }
-    return this._sendWithModule(this.module, event);
+    return this._sendWithModule(this.module, eventToSentryRequest(event, this._api));
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public sendSession(session: Session): PromiseLike<Response> {
+    if (!this.module) {
+      throw new SentryError('No module available in HTTPTransport');
+    }
+    return this._sendWithModule(this.module, sessionToSentryRequest(session, this._api));
   }
 }

packages/node/src/transports/https.ts

@@ -1,4 +1,5 @@
-import { Event, Response, TransportOptions } from '@sentry/types';
+import { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';
+import { Event, Response, Session, TransportOptions } from '@sentry/types';
 import { SentryError } from '@sentry/utils';
 import * as https from 'https';
 
@@ -23,6 +24,16 @@ export class HTTPSTransport extends BaseTransport {
     if (!this.module) {
       throw new SentryError('No module available in HTTPSTransport');
     }
-    return this._sendWithModule(this.module, event);
+    return this._sendWithModule(this.module, eventToSentryRequest(event, this._api));
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public sendSession(session: Session): PromiseLike<Response> {
+    if (!this.module) {
+      throw new SentryError('No module available in HTTPTransport');
+    }
+    return this._sendWithModule(this.module, sessionToSentryRequest(session, this._api));
   }
 }

packages/node/test/transports/http.test.ts

@@ -1,3 +1,4 @@
+import { Session } from '@sentry/hub';
 import { TransportOptions } from '@sentry/types';
 import { SentryError } from '@sentry/utils';
 import * as HttpsProxyAgent from 'https-proxy-agent';
@@ -7,6 +8,7 @@ import { HTTPTransport } from '../../src/transports/http';
 const mockSetEncoding = jest.fn();
 const dsn = 'http://[email protected]:8989/mysubpath/50622';
 const transportPath = '/mysubpath/api/50622/store/';
+const envelopePath = '/mysubpath/api/50622/envelope/';
 let mockReturnCode = 200;
 let mockHeaders = {};
 
@@ -27,12 +29,12 @@ function createTransport(options: TransportOptions): HTTPTransport {
   return transport;
 }
 
-function assertBasicOptions(options: any): void {
+function assertBasicOptions(options: any, useEnvelope: boolean = false): void {
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_version');
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_client');
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_key');
   expect(options.port).toEqual('8989');
-  expect(options.path).toEqual(transportPath);
+  expect(options.path).toEqual(useEnvelope ? envelopePath : transportPath);
   expect(options.hostname).toEqual('sentry.io');
 }
 
@@ -69,6 +71,28 @@ describe('HTTPTransport', () => {
     }
   });
 
+  test('send 200 session', async () => {
+    const transport = createTransport({ dsn });
+    await transport.sendSession(new Session());
+
+    const requestOptions = (transport.module!.request as jest.Mock).mock.calls[0][0];
+    assertBasicOptions(requestOptions, true);
+    expect(mockSetEncoding).toHaveBeenCalled();
+  });
+
+  test('send 400 session', async () => {
+    mockReturnCode = 400;
+    const transport = createTransport({ dsn });
+
+    try {
+      await transport.sendSession(new Session());
+    } catch (e) {
+      const requestOptions = (transport.module!.request as jest.Mock).mock.calls[0][0];
+      assertBasicOptions(requestOptions, true);
+      expect(e).toEqual(new SentryError(`HTTP Error (${mockReturnCode})`));
+    }
+  });
+
   test('send x-sentry-error header', async () => {
     mockReturnCode = 429;
     mockHeaders = {

packages/node/test/transports/https.test.ts

@@ -1,3 +1,4 @@
+import { Session } from '@sentry/hub';
 import { TransportOptions } from '@sentry/types';
 import { SentryError } from '@sentry/utils';
 import * as HttpsProxyAgent from 'https-proxy-agent';
@@ -7,6 +8,7 @@ import { HTTPSTransport } from '../../src/transports/https';
 const mockSetEncoding = jest.fn();
 const dsn = 'https://[email protected]:8989/mysubpath/50622';
 const transportPath = '/mysubpath/api/50622/store/';
+const envelopePath = '/mysubpath/api/50622/envelope/';
 let mockReturnCode = 200;
 let mockHeaders = {};
 
@@ -33,12 +35,12 @@ function createTransport(options: TransportOptions): HTTPSTransport {
   return transport;
 }
 
-function assertBasicOptions(options: any): void {
+function assertBasicOptions(options: any, useEnvelope: boolean = false): void {
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_version');
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_client');
   expect(options.headers['X-Sentry-Auth']).toContain('sentry_key');
   expect(options.port).toEqual('8989');
-  expect(options.path).toEqual(transportPath);
+  expect(options.path).toEqual(useEnvelope ? envelopePath : transportPath);
   expect(options.hostname).toEqual('sentry.io');
 }
 
@@ -75,6 +77,28 @@ describe('HTTPSTransport', () => {
     }
   });
 
+  test('send 200 session', async () => {
+    const transport = createTransport({ dsn });
+    await transport.sendSession(new Session());
+
+    const requestOptions = (transport.module!.request as jest.Mock).mock.calls[0][0];
+    assertBasicOptions(requestOptions, true);
+    expect(mockSetEncoding).toHaveBeenCalled();
+  });
+
+  test('send 400 session', async () => {
+    mockReturnCode = 400;
+    const transport = createTransport({ dsn });
+
+    try {
+      await transport.sendSession(new Session());
+    } catch (e) {
+      const requestOptions = (transport.module!.request as jest.Mock).mock.calls[0][0];
+      assertBasicOptions(requestOptions, true);
+      expect(e).toEqual(new SentryError(`HTTP Error (${mockReturnCode})`));
+    }
+  });
+
   test('send x-sentry-error header', async () => {
     mockReturnCode = 429;
     mockHeaders = {