feat: node transports

packages/browser/src/backend.ts

@@ -1,13 +1,13 @@
 import { Backend, DSN, Options, SentryError } from '@sentry/core';
 import { addBreadcrumb, captureEvent } from '@sentry/minimal';
-import { SentryEvent } from '@sentry/types';
+import { SentryEvent, SentryResponse } from '@sentry/types';
 import { supportsFetch } from '@sentry/utils/supports';
 import { Raven } from './raven';
 import { FetchTransport, XHRTransport } from './transports';
 
 /**
  * Configuration options for the Sentry Browser SDK.
- * @see BrowserClient for more information.
+ * @see BrowserClient afor more information.
  */
 export interface BrowserOptions extends Options {
   /**
@@ -115,7 +115,7 @@ export class BrowserBackend implements Backend {
   /**
    * @inheritDoc
    */
-  public async sendEvent(event: SentryEvent): Promise<number> {
+  public async sendEvent(event: SentryEvent): Promise<SentryResponse> {
     let dsn: DSN;
 
     if (!this.options.dsn) {
@@ -130,10 +130,7 @@ export class BrowserBackend implements Backend {
         ? new FetchTransport({ dsn })
         : new XHRTransport({ dsn });
 
-    return transport
-      .send(event)
-      .then((response: Response | XMLHttpRequest) => response.status)
-      .catch((error: Response | XMLHttpRequest) => error.status);
+    return transport.send(event);
   }
 
   /**

packages/browser/src/client.ts

@@ -22,7 +22,7 @@ export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * @inheritDoc
    */
-  protected getSdkInfo(): SdkInfo {
+  public getSdkInfo(): SdkInfo {
     return {
       name: 'sentry-browser',
       version: Raven.VERSION,
@@ -32,6 +32,7 @@ export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * Instruments the given function and sends an event to Sentry every time the
    * function throws an exception.
+   * TODO remove this
    *
    * @param fn A function to wrap.
    * @returns The wrapped function.

packages/browser/src/index.ts

@@ -4,9 +4,11 @@ export {
   SdkInfo,
   SentryEvent,
   SentryException,
+  SentryResponse,
   Severity,
   StackFrame,
   Stacktrace,
+  Status,
   Thread,
   User,
 } from '@sentry/types';
@@ -27,3 +29,6 @@ export { init } from './sdk';
 
 import * as Integrations from './integrations';
 export { Integrations };
+
+import * as Transports from './transports';
+export { Transports };

packages/browser/src/transports/base.ts

@@ -2,6 +2,7 @@ import { DSN, SentryError } from '@sentry/core';
 import {
   DSNComponents,
   SentryEvent,
+  SentryResponse,
   Transport,
   TransportOptions,
 } from '@sentry/types';
@@ -49,7 +50,7 @@ export abstract class BaseTransport implements Transport {
   /**
    * @inheritDoc
    */
-  public async send(_: SentryEvent): Promise<Response | XMLHttpRequest> {
+  public async send(_: SentryEvent): Promise<SentryResponse> {
     throw new SentryError('Transport Class has to implement `send` method');
   }
 }

packages/browser/src/transports/fetch.ts

@@ -1,4 +1,4 @@
-import { SentryEvent } from '@sentry/types';
+import { SentryEvent, SentryResponse, Status } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { serialize } from '@sentry/utils/object';
 import { supportsReferrerPolicy } from '@sentry/utils/supports';
@@ -11,7 +11,7 @@ export class FetchTransport extends BaseTransport {
   /**
    * @inheritDoc
    */
-  public async send(event: SentryEvent): Promise<Response> {
+  public async send(event: SentryEvent): Promise<SentryResponse> {
     const defaultOptions: RequestInit = {
       body: serialize(event),
       keepalive: true,
@@ -25,6 +25,12 @@ export class FetchTransport extends BaseTransport {
         : '') as ReferrerPolicy,
     };
 
-    return (global as Window).fetch(this.url, defaultOptions);
+    const response = await (global as Window).fetch(this.url, defaultOptions);
+
+    return {
+      code: response.status,
+      event_id: event.event_id,
+      status: Status.fromHttpCode(response.status),
+    };
   }
 }

packages/browser/src/transports/xhr.ts

@@ -1,4 +1,4 @@
-import { SentryEvent } from '@sentry/types';
+import { SentryEvent, SentryResponse, Status } from '@sentry/types';
 import { serialize } from '@sentry/utils/object';
 import { BaseTransport } from './base';
 
@@ -7,8 +7,8 @@ export class XHRTransport extends BaseTransport {
   /**
    * @inheritDoc
    */
-  public async send(event: SentryEvent): Promise<XMLHttpRequest> {
-    return new Promise<XMLHttpRequest>((resolve, reject) => {
+  public async send(event: SentryEvent): Promise<SentryResponse> {
+    return new Promise<SentryResponse>((resolve, reject) => {
       const request = new XMLHttpRequest();
 
       request.onreadystatechange = () => {
@@ -17,7 +17,11 @@ export class XHRTransport extends BaseTransport {
         }
 
         if (request.status === 200) {
-          resolve(request);
+          resolve({
+            code: request.status,
+            event_id: event.event_id,
+            status: Status.fromHttpCode(request.status),
+          });
         }
 
         reject(request);

packages/browser/test/backend.test.ts

@@ -1,13 +1,15 @@
 import { expect } from 'chai';
-import { SentryEvent } from '../src';
+import { SentryEvent, SentryResponse, Status } from '../src';
 import { BrowserBackend } from '../src/backend';
 import { BaseTransport } from '../src/transports';
 
 class SimpleTransport extends BaseTransport {
-  public async send(event: SentryEvent): Promise<Response> {
-    return new Response(event.event_id, {
-      status: 200,
-    });
+  public async send(event: SentryEvent): Promise<SentryResponse> {
+    return {
+      code: 200,
+      event_id: event.event_id,
+      status: Status.fromHttpCode(200),
+    };
   }
 }
 
@@ -37,7 +39,7 @@ describe('BrowserBackend', () => {
     it('should call send() on provided transport', async () => {
       backend = new BrowserBackend({ dsn, transport: SimpleTransport });
       const status = await backend.sendEvent(testEvent);
-      expect(status).equal(200);
+      expect(status.code).equal(200);
     });
   });
 });

packages/browser/test/transports/fetch.test.ts

@@ -1,7 +1,6 @@
-import { Transport } from '@sentry/types';
 import { expect } from 'chai';
 import { SinonStub, stub } from 'sinon';
-import { FetchTransport } from '../../src/transports/fetch';
+import { Status, Transports } from '../../src';
 
 const testDSN = 'https://[email protected]/42';
 const transportUrl =
@@ -15,12 +14,12 @@ const payload = {
 };
 
 let fetch: SinonStub;
-let transport: Transport;
+let transport: Transports.BaseTransport;
 
 describe('FetchTransport', () => {
   beforeEach(() => {
     fetch = stub(window, 'fetch');
-    transport = new FetchTransport({ dsn: testDSN });
+    transport = new Transports.FetchTransport({ dsn: testDSN });
   });
 
   afterEach(() => {
@@ -33,14 +32,13 @@ describe('FetchTransport', () => {
 
   describe('send()', async () => {
     it('sends a request to Sentry servers', async () => {
-      const response = new Response('', {
-        status: 200,
-      });
+      const response = { status: 200 };
 
       fetch.returns(Promise.resolve(response));
 
       return transport.send(payload).then(res => {
-        expect(res.status).equal(200);
+        expect(res.code).equal(200);
+        expect(res.status).equal(Status.Success);
         expect(fetch.calledOnce).equal(true);
         expect(
           fetch.calledWith(transportUrl, {
@@ -54,9 +52,7 @@ describe('FetchTransport', () => {
     });
 
     it('rejects with non-200 status code', async () => {
-      const response = new Response('', {
-        status: 403,
-      });
+      const response = { status: 403 };
 
       fetch.returns(Promise.reject(response));
 

packages/browser/test/transports/xhr.test.ts

@@ -1,7 +1,6 @@
-import { Transport } from '@sentry/types';
 import { expect } from 'chai';
 import { fakeServer, SinonFakeServer } from 'sinon';
-import { XHRTransport } from '../../src/transports/xhr';
+import { Transports } from '../../src';
 
 const testDSN = 'https://[email protected]/42';
 const transportUrl =
@@ -15,13 +14,13 @@ const payload = {
 };
 
 let server: SinonFakeServer;
-let transport: Transport;
+let transport: Transports.BaseTransport;
 
 describe('XHRTransport', () => {
   beforeEach(() => {
     server = fakeServer.create();
     server.respondImmediately = true;
-    transport = new XHRTransport({ dsn: testDSN });
+    transport = new Transports.XHRTransport({ dsn: testDSN });
   });
 
   afterEach(() => {
@@ -37,7 +36,7 @@ describe('XHRTransport', () => {
       server.respondWith('POST', transportUrl, [200, {}, '']);
 
       return transport.send(payload).then(res => {
-        expect(res.status).equal(200);
+        expect(res.code).equal(200);
 
         const request = server.requests[0];
         expect(server.requests.length).equal(1);
@@ -46,16 +45,17 @@ describe('XHRTransport', () => {
       });
     });
 
-    it('rejects with non-200 status code', async () => {
+    it('rejects with non-200 status code', done => {
       server.respondWith('POST', transportUrl, [403, {}, '']);
 
-      return transport.send(payload).catch(res => {
+      transport.send(payload).catch(res => {
         expect(res.status).equal(403);
 
         const request = server.requests[0];
         expect(server.requests.length).equal(1);
         expect(request.method).equal('POST');
         expect(JSON.parse(request.requestBody)).deep.equal(payload);
+        done();
       });
     });
   });

packages/core/src/base.ts

@@ -1,10 +1,15 @@
 import { Scope } from '@sentry/hub';
-import { Breadcrumb, SdkInfo, SentryEvent } from '@sentry/types';
+import {
+  Breadcrumb,
+  SdkInfo,
+  SentryEvent,
+  SentryResponse,
+  Status,
+} from '@sentry/types';
 import { uuid4 } from '@sentry/utils/misc';
 import { truncate } from '@sentry/utils/string';
 import { DSN } from './dsn';
 import { Backend, Client, Options } from './interfaces';
-import { SendStatus } from './status';
 
 /**
  * Default maximum number of breadcrumbs added to an event. Can be overwritten
@@ -136,8 +141,11 @@ export abstract class BaseClient<B extends Backend, O extends Options>
   /**
    * @inheritDoc
    */
-  public async captureEvent(event: SentryEvent, scope?: Scope): Promise<void> {
-    await this.processEvent(
+  public async captureEvent(
+    event: SentryEvent,
+    scope?: Scope,
+  ): Promise<SentryResponse> {
+    return this.processEvent(
       event,
       async finalEvent => this.getBackend().sendEvent(finalEvent),
       scope,
@@ -198,8 +206,10 @@ export abstract class BaseClient<B extends Backend, O extends Options>
     return this.options;
   }
 
-  /** Returns the current used SDK version and name. */
-  protected abstract getSdkInfo(): SdkInfo;
+  /**
+   * @inheritDoc
+   */
+  public abstract getSdkInfo(): SdkInfo;
 
   /** Returns the current backend. */
   protected getBackend(): B {
@@ -290,38 +300,45 @@ export abstract class BaseClient<B extends Backend, O extends Options>
    */
   protected async processEvent(
     event: SentryEvent,
-    send: (finalEvent: SentryEvent) => Promise<number>,
+    send: (finalEvent: SentryEvent) => Promise<SentryResponse>,
     scope?: Scope,
-  ): Promise<SendStatus> {
+  ): Promise<SentryResponse> {
     if (!this.isEnabled()) {
-      return SendStatus.Skipped;
+      return {
+        code: -1,
+        event_id: event.event_id,
+        status: Status.Skipped,
+      };
     }
 
     const prepared = await this.prepareEvent(event, scope);
     const { shouldSend, beforeSend, afterSend } = this.getOptions();
     if (shouldSend && !shouldSend(prepared)) {
-      return SendStatus.Skipped;
+      return {
+        code: -1,
+        event_id: event.event_id,
+        status: Status.Skipped,
+      };
     }
 
     // TODO: Add breadcrumb with our own event?
     // Or should it be handled by the xhr/fetch integration itself?
     // Or maybe some other integration that'd use `afterSend`?
 
     const finalEvent = beforeSend ? beforeSend(prepared) : prepared;
-    const code = await send(finalEvent);
-    const status = SendStatus.fromHttpCode(code);
+    const response = await send(finalEvent);
 
-    if (status === SendStatus.RateLimit) {
+    if (response.status === Status.RateLimit) {
       // TODO: Handle rate limits and maintain a queue. For now, we require SDK
       // implementors to override this method and handle it themselves.
     }
 
     // TODO: Handle duplicates and backoffs
 
     if (afterSend) {
-      afterSend(finalEvent, status);
+      afterSend(finalEvent, response);
     }
 
-    return status;
+    return response;
   }
 }