Merge remote-tracking branch 'origin/master' into lforst-node-transports

Author: Luca Forstner

packages/browser/src/backend.ts

@@ -1,9 +1,9 @@
-import { BaseBackend } from '@sentry/core';
-import { Event, EventHint, Options, Severity, Transport } from '@sentry/types';
+import { BaseBackend, getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails } from '@sentry/core';
+import { Event, EventHint, Options, Severity, Transport, TransportOptions } from '@sentry/types';
 import { supportsFetch } from '@sentry/utils';
 
 import { eventFromException, eventFromMessage } from './eventbuilder';
-import { FetchTransport, XHRTransport } from './transports';
+import { FetchTransport, makeNewFetchTransport, XHRTransport } from './transports';
 
 /**
  * Configuration options for the Sentry Browser SDK.
@@ -58,18 +58,23 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
       return super._setupTransport();
     }
 
-    const transportOptions = {
+    const transportOptions: TransportOptions = {
       ...this._options.transportOptions,
       dsn: this._options.dsn,
       tunnel: this._options.tunnel,
       sendClientReports: this._options.sendClientReports,
       _metadata: this._options._metadata,
     };
 
+    const api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);
+    const url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);
+
     if (this._options.transport) {
       return new this._options.transport(transportOptions);
     }
     if (supportsFetch()) {
+      const requestOptions: RequestInit = { ...transportOptions.fetchParameters };
+      this._newTransport = makeNewFetchTransport({ requestOptions, url });
       return new FetchTransport(transportOptions);
     }
     return new XHRTransport(transportOptions);

packages/browser/src/transports/index.ts

@@ -1,3 +1,5 @@
 export { BaseTransport } from './base';
 export { FetchTransport } from './fetch';
 export { XHRTransport } from './xhr';
+
+export { makeNewFetchTransport } from './new-fetch';

packages/browser/src/transports/new-fetch.ts

@@ -0,0 +1,44 @@
+import {
+  BaseTransportOptions,
+  createTransport,
+  NewTransport,
+  TransportMakeRequestResponse,
+  TransportRequest,
+} from '@sentry/core';
+
+import { FetchImpl, getNativeFetchImplementation } from './utils';
+
+export interface FetchTransportOptions extends BaseTransportOptions {
+  requestOptions?: RequestInit;
+}
+
+/**
+ * Creates a Transport that uses the Fetch API to send events to Sentry.
+ */
+export function makeNewFetchTransport(
+  options: FetchTransportOptions,
+  nativeFetch: FetchImpl = getNativeFetchImplementation(),
+): NewTransport {
+  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {
+    const requestOptions: RequestInit = {
+      body: request.body,
+      method: 'POST',
+      referrerPolicy: 'origin',
+      ...options.requestOptions,
+    };
+
+    return nativeFetch(options.url, requestOptions).then(response => {
+      return response.text().then(body => ({
+        body,
+        headers: {
+          'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+          'retry-after': response.headers.get('Retry-After'),
+        },
+        reason: response.statusText,
+        statusCode: response.status,
+      }));
+    });
+  }
+
+  return createTransport({ bufferSize: options.bufferSize }, makeRequest);
+}

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

@@ -0,0 +1,98 @@
+import { EventEnvelope, EventItem } from '@sentry/types';
+import { createEnvelope, serializeEnvelope } from '@sentry/utils';
+
+import { FetchTransportOptions, makeNewFetchTransport } from '../../../src/transports/new-fetch';
+import { FetchImpl } from '../../../src/transports/utils';
+
+const DEFAULT_FETCH_TRANSPORT_OPTIONS: FetchTransportOptions = {
+  url: 'https://sentry.io/api/42/store/?sentry_key=123&sentry_version=7',
+};
+
+const ERROR_ENVELOPE = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' }, [
+  [{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
+]);
+
+class Headers {
+  headers: { [key: string]: string } = {};
+  get(key: string) {
+    return this.headers[key] || null;
+  }
+  set(key: string, value: string) {
+    this.headers[key] = value;
+  }
+}
+
+describe('NewFetchTransport', () => {
+  it('calls fetch with the given URL', async () => {
+    const mockFetch = jest.fn(() =>
+      Promise.resolve({
+        headers: new Headers(),
+        status: 200,
+        text: () => Promise.resolve({}),
+      }),
+    ) as unknown as FetchImpl;
+    const transport = makeNewFetchTransport(DEFAULT_FETCH_TRANSPORT_OPTIONS, mockFetch);
+
+    expect(mockFetch).toHaveBeenCalledTimes(0);
+    const res = await transport.send(ERROR_ENVELOPE);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    expect(res.status).toBe('success');
+
+    expect(mockFetch).toHaveBeenLastCalledWith(DEFAULT_FETCH_TRANSPORT_OPTIONS.url, {
+      body: serializeEnvelope(ERROR_ENVELOPE),
+      method: 'POST',
+      referrerPolicy: 'origin',
+    });
+  });
+
+  it('sets rate limit headers', async () => {
+    const headers = {
+      get: jest.fn(),
+    };
+
+    const mockFetch = jest.fn(() =>
+      Promise.resolve({
+        headers,
+        status: 200,
+        text: () => Promise.resolve({}),
+      }),
+    ) as unknown as FetchImpl;
+    const transport = makeNewFetchTransport(DEFAULT_FETCH_TRANSPORT_OPTIONS, mockFetch);
+
+    expect(headers.get).toHaveBeenCalledTimes(0);
+    await transport.send(ERROR_ENVELOPE);
+
+    expect(headers.get).toHaveBeenCalledTimes(2);
+    expect(headers.get).toHaveBeenCalledWith('X-Sentry-Rate-Limits');
+    expect(headers.get).toHaveBeenCalledWith('Retry-After');
+  });
+
+  it('allows for custom options to be passed in', async () => {
+    const mockFetch = jest.fn(() =>
+      Promise.resolve({
+        headers: new Headers(),
+        status: 200,
+        text: () => Promise.resolve({}),
+      }),
+    ) as unknown as FetchImpl;
+
+    const REQUEST_OPTIONS: RequestInit = {
+      referrerPolicy: 'strict-origin',
+      keepalive: true,
+      referrer: 'http://example.org',
+    };
+
+    const transport = makeNewFetchTransport(
+      { ...DEFAULT_FETCH_TRANSPORT_OPTIONS, requestOptions: REQUEST_OPTIONS },
+      mockFetch,
+    );
+
+    await transport.send(ERROR_ENVELOPE);
+    expect(mockFetch).toHaveBeenLastCalledWith(DEFAULT_FETCH_TRANSPORT_OPTIONS.url, {
+      body: serializeEnvelope(ERROR_ENVELOPE),
+      method: 'POST',
+      ...REQUEST_OPTIONS,
+    });
+  });
+});

packages/integration-tests/suites/new-transports/fetch-captureException/subject.js

@@ -0,0 +1 @@
+Sentry.captureException(new Error('this is an error'));

packages/integration-tests/suites/new-transports/fetch-captureException/test.ts

@@ -0,0 +1,21 @@
+import { expect } from '@playwright/test';
+import { Event } from '@sentry/types';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+
+sentryTest('should capture an error with the new fetch transport', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(eventData.exception?.values).toHaveLength(1);
+  expect(eventData.exception?.values?.[0]).toMatchObject({
+    type: 'Error',
+    value: 'this is an error',
+    mechanism: {
+      type: 'generic',
+      handled: true,
+    },
+  });
+});

packages/integration-tests/suites/new-transports/fetch-startTransaction/subject.js

@@ -0,0 +1,2 @@
+const transaction = Sentry.startTransaction({ name: 'test_transaction_1' });
+transaction.finish();

packages/integration-tests/suites/new-transports/fetch-startTransaction/test.ts

@@ -0,0 +1,13 @@
+import { expect } from '@playwright/test';
+import { Event } from '@sentry/types';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+
+sentryTest('should report a transaction with the new fetch transport', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+  const transaction = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(transaction.transaction).toBe('test_transaction_1');
+  expect(transaction.spans).toBeDefined();
+});

packages/integration-tests/suites/new-transports/init.js

@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/browser';
+// eslint-disable-next-line no-unused-vars
+import * as _ from '@sentry/tracing';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  _experiments: {
+    newTransport: true,
+  },
+  tracesSampleRate: 1.0,
+});

packages/node-integration-tests/README.md

@@ -0,0 +1,50 @@
+# Integration Tests for Sentry Node.JS SDK
+
+## Structure
+
+```
+suites/
+|---- public-api/
+      |---- captureMessage/
+            |---- test.ts [assertions]
+            |---- scenario.ts [Sentry initialization and test subject]
+      |---- customTest/
+            |---- test.ts [assertions]
+            |---- scenario_1.ts [optional extra test scenario]
+            |---- scenario_2.ts [optional extra test scenario]
+            |---- server_with_mongo.ts [optional custom server]
+            |---- server_with_postgres.ts [optional custom server]
+utils/
+|---- defaults/
+      |---- server.ts [default Express server configuration]
+```
+
+The tests are grouped by their scopes, such as `public-api` or `tracing`. In every group of tests, there are multiple folders containing test scenarios and assertions.
+
+Tests run on Express servers (a server instance per test). By default, a simple server template inside `utils/defaults/server.ts` is used. Every server instance runs on a different port.
+
+A custom server configuration can be used, supplying a script that exports a valid express server instance as default. `runServer` utility function accepts an optional `serverPath` argument for this purpose.
+
+`scenario.ts` contains the initialization logic and the test subject. By default, `{TEST_DIR}/scenario.ts` is used, but `runServer` also accepts an optional `scenarioPath` argument for non-standard usage.
+
+`test.ts` is required for each test case, and contains the server runner logic, request interceptors for Sentry requests, and assertions. Test server, interceptors and assertions are all run on the same Jest thread.
+
+### Utilities
+
+`utils/` contains helpers and Sentry-specific assertions that can be used in (`test.ts`).
+
+## Running Tests Locally
+
+Tests can be run locally with:
+
+`yarn test`
+
+To run tests with Jest's watch mode:
+
+`yarn test:jest`
+
+To filter tests by their title:
+
+`yarn test -t "set different properties of a scope"`
+
+You can refer to [Jest documentation](https://jestjs.io/docs/cli) for other CLI options.

packages/node-integration-tests/package.json

@@ -11,11 +11,19 @@
     "lint:eslint": "eslint . --cache --cache-location '../../eslintcache/' --format stylish",
     "lint:prettier": "prettier --check \"{suites,utils}/**/*.ts\"",
     "type-check": "tsc",
-    "test": "jest --detectOpenHandles --runInBand --forceExit"
+    "test": "jest --detectOpenHandles --runInBand --forceExit",
+    "test:watch": "yarn test --watch"
   },
   "dependencies": {
+    "@types/mongodb": "^3.6.20",
+    "@types/mysql": "^2.15.21",
+    "@types/pg": "^8.6.5",
     "express": "^4.17.3",
+    "mysql": "^2.18.1",
+    "mongodb": "^3.7.3",
+    "mongodb-memory-server": "^8.4.1",
     "nock": "^13.1.0",
+    "pg": "^8.7.3",
     "portfinder": "^1.0.28"
   }
 }

packages/node-integration-tests/suites/tracing/manual-tracing-unnamed-import/scenario.ts renamed to packages/node-integration-tests/suites/public-api/startTransaction/basic-usage/scenario.ts

@@ -1,4 +1,4 @@
-import { assertSentryTransaction, getEnvelopeRequest, runServer } from '../../../utils';
+import { assertSentryTransaction, getEnvelopeRequest, runServer } from '../../../../utils';
 
 test('should send a manually started transaction when @sentry/tracing is imported using unnamed import.', async () => {
   const url = await runServer(__dirname);

packages/node-integration-tests/suites/tracing/manual-tracing-unnamed-import/test.ts renamed to packages/node-integration-tests/suites/public-api/startTransaction/basic-usage/test.ts

@@ -0,0 +1,40 @@
+import '@sentry/tracing';
+
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+});
+
+const transaction = Sentry.startTransaction({ name: 'test_transaction_1' });
+const span_1 = transaction.startChild({
+  op: 'span_1',
+  data: {
+    foo: 'bar',
+    baz: [1, 2, 3],
+  },
+});
+for (let i = 0; i < 2000; i++);
+
+// span_1 finishes
+span_1.finish();
+
+// span_2 doesn't finish
+transaction.startChild({ op: 'span_2' });
+for (let i = 0; i < 4000; i++);
+
+const span_3 = transaction.startChild({ op: 'span_3' });
+for (let i = 0; i < 4000; i++);
+
+// span_4 is the child of span_3 but doesn't finish.
+span_3.startChild({ op: 'span_4', data: { qux: 'quux' } });
+
+// span_5 is another child of span_3 but finishes.
+span_3.startChild({ op: 'span_5' }).finish();
+
+// span_3 also finishes
+span_3.finish();
+
+transaction.finish();

packages/node-integration-tests/suites/public-api/startTransaction/with-nested-spans/scenario.ts

@@ -0,0 +1,36 @@
+import { assertSentryTransaction, getEnvelopeRequest, runServer } from '../../../../utils';
+
+test('should report finished spans as children of the root transaction.', async () => {
+  const url = await runServer(__dirname);
+  const envelope = await getEnvelopeRequest(url);
+
+  expect(envelope).toHaveLength(3);
+
+  const rootSpanId = (envelope?.[2] as any)?.contexts?.trace?.span_id;
+  const span3Id = (envelope?.[2] as any)?.spans?.[1].span_id;
+
+  expect(rootSpanId).toEqual(expect.any(String));
+  expect(span3Id).toEqual(expect.any(String));
+
+  assertSentryTransaction(envelope[2], {
+    transaction: 'test_transaction_1',
+    spans: [
+      {
+        op: 'span_1',
+        data: {
+          foo: 'bar',
+          baz: [1, 2, 3],
+        },
+        parent_span_id: rootSpanId,
+      },
+      {
+        op: 'span_3',
+        parent_span_id: rootSpanId,
+      },
+      {
+        op: 'span_5',
+        parent_span_id: span3Id,
+      },
+    ],
+  });
+});