feat(core): Introduce New Transports API

Author: AbhiPrasad

packages/core/src/transports/base.ts

@@ -0,0 +1,128 @@
+import { Envelope, EventStatus } from '@sentry/types';
+import {
+  disabledUntil,
+  eventStatusFromHttpCode,
+  isRateLimited,
+  makePromiseBuffer,
+  PromiseBuffer,
+  RateLimits,
+  rejectedSyncPromise,
+  resolvedSyncPromise,
+  SentryError,
+  serializeEnvelope,
+  updateRateLimits,
+} from '@sentry/utils';
+
+type TransportCategory = 'error' | 'transaction' | 'attachment' | 'session';
+
+export type TransportRequest = {
+  body: string;
+  category: TransportCategory;
+};
+
+export type TransportMakeRequestResponse = {
+  body?: string;
+  headers?: Record<string, string | null>;
+  reason?: string;
+  statusCode: number;
+};
+
+export type TransportResponse = {
+  status: EventStatus;
+  reason?: string;
+};
+
+export interface BaseTransportOptions {
+  // url to send the event
+  // transport does not care about dsn specific - client should take care of
+  // parsing and figuring that out
+  url: string;
+  bufferSize?: number;
+}
+
+// TODO: Move into Browser Transport
+export interface BrowserTransportOptions extends BaseTransportOptions {
+  // options to pass into fetch request
+  fetchParams: Record<string, string>;
+  headers?: Record<string, string>;
+  sendClientReports?: boolean;
+}
+
+// TODO: Move into Node transport
+export interface NodeTransportOptions extends BaseTransportOptions {
+  // Set a HTTP proxy that should be used for outbound requests.
+  httpProxy?: string;
+  // Set a HTTPS proxy that should be used for outbound requests.
+  httpsProxy?: string;
+  // HTTPS proxy certificates path
+  caCerts?: string;
+}
+
+interface NewTransport {
+  // If `$` is set, we know that this is a new transport.
+  // TODO(v7): Remove this as we will no longer have split between
+  // old and new transports.
+  $: boolean;
+  send(request: Envelope, category: TransportCategory): PromiseLike<TransportResponse>;
+  flush(timeout: number): PromiseLike<boolean>;
+}
+
+type MakeTransportRequest = (request: TransportRequest) => PromiseLike<TransportMakeRequestResponse>;
+
+export const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+
+/**
+ * Creates a `NewTransport`
+ *
+ * @param options
+ * @param makeRequest
+ */
+export function createTransport<O extends BaseTransportOptions>(
+  options: O,
+  makeRequest: MakeTransportRequest,
+  buffer: PromiseBuffer<TransportResponse> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),
+): NewTransport {
+  const rateLimits: RateLimits = {};
+
+  const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);
+
+  function send(envelope: Envelope, category: TransportCategory): PromiseLike<TransportResponse> {
+    const request: TransportRequest = {
+      category,
+      body: serializeEnvelope(envelope),
+    };
+
+    if (isRateLimited(rateLimits, category)) {
+      return rejectedSyncPromise(
+        new SentryError(`Too many ${category} requests, backing off until: ${disabledUntil(rateLimits, category)}`),
+      );
+    }
+
+    const requestTask = (): PromiseLike<TransportResponse> =>
+      makeRequest(request)
+        .then(({ body, headers, reason, statusCode }): PromiseLike<TransportResponse> => {
+          if (headers) {
+            updateRateLimits(rateLimits, headers);
+          }
+
+          // TODO: This is the happy path!
+          const status = eventStatusFromHttpCode(statusCode);
+          if (status === 'success') {
+            return resolvedSyncPromise({ status });
+          }
+
+          return rejectedSyncPromise(new SentryError(body || reason || 'Unknown transport error'));
+        })
+        .then(null, e => {
+          return rejectedSyncPromise(e);
+        });
+
+    return buffer.add(requestTask);
+  }
+
+  return {
+    $: true,
+    send,
+    flush,
+  };
+}

packages/core/test/lib/transports/base.test.ts

@@ -0,0 +1,32 @@
+import { createTransport, MakeTransportRequest, TransportResponse } from '../../../src/transports/base';
+import { resolvedSyncPromise, PromiseBuffer } from '@sentry/utils';
+
+const ENVELOPE_URL = 'https://sentry.io/api/42/envelope/?sentry_key=123&sentry_version=7';
+
+const DEFAULT_TRANSPORT_OPTIONS = { url: ENVELOPE_URL };
+
+const SUCCESS_REQUEST: MakeTransportRequest = _ => resolvedSyncPromise({ statusCode: 200 });
+
+describe('createTransport', () => {
+  it('has $ property', () => {
+    const transport = createTransport(DEFAULT_TRANSPORT_OPTIONS, SUCCESS_REQUEST);
+    expect(transport.$).toBeDefined();
+  });
+
+  it('flushes the buffer', () => {
+    const mockBuffer: PromiseBuffer<TransportResponse> = {
+      $: [],
+      add: jest.fn(),
+      drain: jest.fn(),
+    };
+    const transport = createTransport(DEFAULT_TRANSPORT_OPTIONS, SUCCESS_REQUEST, mockBuffer);
+    expect(mockBuffer.drain).toHaveBeenCalledTimes(0);
+    transport.flush(1000);
+    expect(mockBuffer.drain).toHaveBeenCalledTimes(1);
+    expect(mockBuffer.drain).toHaveBeenLastCalledWith(1000);
+  });
+
+  describe('send', () => {
+    it('');
+  });
+});