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

@@ -1,5 +1,5 @@
-import { API, eventToSentryRequest, SDK_VERSION } from '@sentry/core';
-import { DsnProtocol, Event, Response, Status, Transport, TransportOptions } from '@sentry/types';
+import { API, SDK_VERSION } from '@sentry/core';
+import { DsnProtocol, Event, Response, SentryRequest, Status, Transport, TransportOptions } from '@sentry/types';
 import { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';
 import * as fs from 'fs';
 import * as http from 'http';
@@ -124,7 +124,10 @@ export abstract class BaseTransport implements Transport {
   }
 
   /** JSDoc */
-  protected async _sendWithModule(httpModule: HTTPModule, event: Event): Promise<Response> {
+  protected async _send(sentryReq: SentryRequest): Promise<Response> {
+    if (!this.module) {
+      throw new SentryError('No module available');
+    }
     if (new Date(Date.now()) < this._disabledUntil) {
       return Promise.reject(new SentryError(`Transport locked till ${this._disabledUntil} due to too many requests.`));
     }
@@ -134,10 +137,11 @@ export abstract class BaseTransport implements Transport {
     }
     return this._buffer.add(
       new Promise<Response>((resolve, reject) => {
-        const sentryReq = eventToSentryRequest(event, this._api);
+        if (!this.module) {
+          throw new SentryError('No module available');
+        }
         const options = this._getRequestOptions(new url.URL(sentryReq.url));
-
-        const req = httpModule.request(options, (res: http.IncomingMessage) => {
+        const req = this.module.request(options, (res: http.IncomingMessage) => {
           const statusCode = res.statusCode || 500;
           const status = Status.fromHttpCode(statusCode);
 

packages/node/src/transports/http.ts

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

packages/node/src/transports/https.ts

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

packages/node/test/manual/release-health/application-mode-session.js

@@ -0,0 +1,68 @@
+const express = require('express');
+const app = express();
+const Sentry = require('../../../dist');
+
+function assertSessions(actual, expected) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    console.error('FAILED: Sessions do not match');
+    process.exit(1);
+  }
+}
+
+function constructStrippedSessionObject(actual) {
+  const { init, status, errors, release } = actual;
+  return { init, status, errors, release };
+}
+
+let remaining = 2;
+
+class DummyTransport {
+  sendSession(session) {
+    if (session.did === 'ahmed') {
+      assertSessions(constructStrippedSessionObject(session),
+        {
+          init: true,
+          status: "exited",
+          errors: 0,
+          release: "1.1"
+        }
+      )
+    }
+    else if (session.did === 'ahmed2') {
+      assertSessions(constructStrippedSessionObject(session),
+        {
+          init: true,
+          status: "ok",
+          errors: 1,
+          release: "1.1"
+        }
+      )
+    }
+    --remaining;
+
+    if (!remaining) {
+      console.error('SUCCESS: All application mode sessions were sent to node transport as expected');
+      process.exit(0);
+    }
+
+    return Promise.resolve({
+      status: 'success',
+    });
+  }
+}
+
+Sentry.init({
+  dsn: 'http://[email protected]/1337',
+  release: '1.1',
+  transport: DummyTransport,
+});
+
+const currentHub = Sentry.getCurrentHub();
+currentHub.startSession({user: {username: 'ahmed'}});
+currentHub.captureSession(true);
+
+const currentHub2 = Sentry.getCurrentHub();
+currentHub2.startSession({user: {username: 'ahmed2'}});
+throw new Error('bar');
+
+app.use(Sentry.Handlers.errorHandler());

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 http from 'http';
@@ -7,7 +8,8 @@ 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 storePath = '/mysubpath/api/50622/store/';
+const envelopePath = '/mysubpath/api/50622/envelope/';
 let mockReturnCode = 200;
 let mockHeaders = {};
 
@@ -28,12 +30,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 : storePath);
   expect(options.hostname).toEqual('sentry.io');
 }
 
@@ -70,6 +72,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 https from 'https';
@@ -7,7 +8,8 @@ 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 storePath = '/mysubpath/api/50622/store/';
+const envelopePath = '/mysubpath/api/50622/envelope/';
 let mockReturnCode = 200;
 let mockHeaders = {};
 
@@ -34,12 +36,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 : storePath);
   expect(options.hostname).toEqual('sentry.io');
 }
 
@@ -76,6 +78,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 = {