feat(node): Application mode sessions

ahmedetefy · ahmedetefy · commit 812f3178d02e · 2021-04-21T12:10:49.000+02:00
Add API to capture application mode sessions associated with a specific
release, and send them to Sentry as part of the Release Health functionality.
diff --git a/packages/node/package.json b/packages/node/package.json
@@ -56,11 +56,12 @@
     "fix": "run-s fix:eslint fix:prettier",
     "fix:prettier": "prettier --write \"{src,test}/**/*.ts\"",
     "fix:eslint": "eslint . --format stylish --fix",
-    "test": "run-s test:jest test:express test:webpack",
+    "test": "run-s test:jest test:express test:webpack test:release-health",
     "test:jest": "jest",
     "test:watch": "jest --watch",
     "test:express": "node test/manual/express-scope-separation/start.js",
     "test:webpack": "cd test/manual/webpack-domain/ && yarn && node npm-build.js",
+    "test:release-health": "node test/manual/release-health/*.js",
     "pack": "npm pack"
   },
   "volta": {
diff --git a/packages/node/src/transports/base.ts b/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, Status, Transport, TransportOptions } from '@sentry/types';
 import { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';
 import * as fs from 'fs';
 import * as http from 'http';
@@ -96,7 +96,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.`));
     }
@@ -106,10 +109,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);
 
diff --git a/packages/node/src/transports/http.ts b/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));
   }
 }
diff --git a/packages/node/src/transports/https.ts b/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));
   }
 }
diff --git a/packages/node/test/manual/release-health/application-mode-session.js b/packages/node/test/manual/release-health/application-mode-session.js
@@ -0,0 +1,85 @@
+const http = require('http');
+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: "ok",
+          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');
+      server.close();
+      process.exit(0);
+    }
+
+    return Promise.resolve({
+      status: 'success',
+    });
+  }
+}
+
+Sentry.init({
+  dsn: 'http://test@example.com/1337',
+  release: '1.1',
+  transport: DummyTransport,
+});
+
+
+app.use(Sentry.Handlers.requestHandler());
+
+app.get('/foo', (req) => {
+  const currentHub = Sentry.getCurrentHub();
+  currentHub.startSession({user: {username: 'ahmed'}});
+  currentHub.captureSession();
+});
+
+app.get('/bar', req => {
+  const currentHub = Sentry.getCurrentHub();
+  currentHub.startSession({user: {username: 'ahmed2'}});
+  throw new Error('bar');
+  currentHub.captureSession();
+});
+
+app.use(Sentry.Handlers.errorHandler());
+
+const server = app.listen(0, () => {
+  const port = server.address().port;
+  http.get(`http://localhost:${port}/foo`);
+  http.get(`http://localhost:${port}/bar`);
+});
+
diff --git a/packages/node/test/transports/http.test.ts b/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';
@@ -6,7 +7,8 @@ import { HTTPTransport } from '../../src/transports/http';
 
 const mockSetEncoding = jest.fn();
 const dsn = 'http://9e9fd4523d784609a5fc0ebb1080592f@sentry.io: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 = {};
 
@@ -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 : storePath);
   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 = {
diff --git a/packages/node/test/transports/https.test.ts b/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';
@@ -6,7 +7,8 @@ import { HTTPSTransport } from '../../src/transports/https';
 
 const mockSetEncoding = jest.fn();
 const dsn = 'https://9e9fd4523d784609a5fc0ebb1080592f@sentry.io: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 = {};
 
@@ -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 : storePath);
   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 = {
