feat: Transports implementation

kamilogorek · kamilogorek · commit 7cb255d8c348 · 2018-06-25T10:47:24.000+02:00
diff --git a/packages/browser/package.json b/packages/browser/package.json
@@ -18,7 +18,8 @@
     "@sentry/core": "0.5.4",
     "@sentry/hub": "0.5.4",
     "@sentry/minimal": "0.5.4",
-    "@sentry/types": "0.5.4"
+    "@sentry/types": "0.5.4",
+    "@sentry/utils": "0.5.4"
   },
   "devDependencies": {
     "chai": "^4.1.2",
diff --git a/packages/browser/src/backend.ts b/packages/browser/src/backend.ts
@@ -1,10 +1,9 @@
-import { Backend, Options, SentryError } from '@sentry/core';
+import { Backend, DSN, Options, SentryError } from '@sentry/core';
 import { addBreadcrumb, captureEvent } from '@sentry/minimal';
 import { SentryEvent } from '@sentry/types';
-import { Raven, SendMethod } from './raven';
-
-/** Original raven send function. */
-const sendRavenEvent = Raven._sendProcessedPayload.bind(Raven) as SendMethod;
+import { supportsFetch, urlEncode } from '@sentry/utils';
+import { Raven } from './raven';
+import { FetchTransport, XHRTransport } from './transports';
 
 /**
  * Configuration options for the Sentry Browser SDK.
@@ -117,12 +116,56 @@ export class BrowserBackend implements Backend {
    * @inheritDoc
    */
   public async sendEvent(event: SentryEvent): Promise<number> {
-    return new Promise<number>(resolve => {
-      sendRavenEvent(event, error => {
-        // TODO: Check the response status code
-        resolve(error ? 500 : 200);
-      });
-    });
+    let dsn;
+
+    if (!this.options.dsn) {
+      throw new SentryError('Cannot sendEvent without a valid DSN');
+    } else {
+      dsn = new DSN(this.options.dsn);
+    }
+
+    const auth = {
+      sentry_client: `raven-js/${Raven.VERSION}`,
+      sentry_key: dsn.user,
+      sentry_secret: '',
+      sentry_version: '7',
+    };
+
+    if (dsn.pass) {
+      auth.sentry_secret = dsn.pass;
+    } else {
+      delete auth.sentry_secret;
+    }
+
+    const lastSlash = dsn.path.lastIndexOf('/');
+    const path = dsn.path.substr(1, lastSlash);
+
+    const _globalProject = dsn.path.substr(lastSlash + 1);
+    let globalServer = `//${dsn.host}${dsn.port ? `:${dsn.port}` : ''}`;
+
+    if (dsn.protocol) {
+      globalServer = `${dsn.protocol}':'${globalServer}`;
+    }
+
+    const _globalEndpoint = `${globalServer}/${path}api/${_globalProject}/store/`;
+
+    // Auth is intentionally sent as part of query string (NOT as custom HTTP header)
+    // to avoid preflight CORS requests
+    const url = `${_globalEndpoint}?${urlEncode(auth)}`;
+
+    const transport = this.options.transport
+      ? this.options.transport
+      : supportsFetch()
+        ? new FetchTransport({ url })
+        : new XHRTransport({ url });
+
+    // tslint:disable-next-line
+    debugger;
+
+    return transport
+      .send(event)
+      .then((response: Response | XMLHttpRequest) => response.status)
+      .catch((error: Response | XMLHttpRequest) => error.status);
   }
 
   /**
diff --git a/packages/browser/src/transports/fetch.ts b/packages/browser/src/transports/fetch.ts
@@ -0,0 +1,28 @@
+import { SentryEvent, Transport } from '@sentry/types';
+import { serialize, supportsReferrerPolicy } from '@sentry/utils';
+
+/** `fetch` based transport */
+export class FetchTransport implements Transport {
+  public constructor(public config: { url: string }) {}
+
+  /**
+   * @inheritDoc
+   */
+  public async send(event: SentryEvent): Promise<Response> {
+    const defaultOptions: RequestInit = {
+      body: serialize(event),
+      keepalive: true,
+      method: 'POST',
+      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
+      // https://caniuse.com/#feat=referrer-policy
+      // It doesn't. And it throw exception instead of ignoring this parameter...
+      // REF: https://github.com/getsentry/raven-js/issues/1233
+      referrerPolicy: (supportsReferrerPolicy()
+        ? 'origin'
+        : '') as ReferrerPolicy,
+    };
+
+    // TODO: Safe _window access
+    return window.fetch(this.config.url, defaultOptions);
+  }
+}
diff --git a/packages/browser/src/transports/index.ts b/packages/browser/src/transports/index.ts
@@ -0,0 +1,2 @@
+export { FetchTransport } from './fetch';
+export { XHRTransport } from './xhr';
diff --git a/packages/browser/src/transports/xhr.ts b/packages/browser/src/transports/xhr.ts
@@ -0,0 +1,31 @@
+import { SentryEvent, Transport } from '@sentry/types';
+import { serialize } from '@sentry/utils';
+
+/** `XHR` based transport */
+export class XHRTransport implements Transport {
+  public constructor(public config: { url: string }) {}
+
+  /**
+   * @inheritDoc
+   */
+  public async send(event: SentryEvent): Promise<XMLHttpRequest> {
+    return new Promise<XMLHttpRequest>((resolve, reject) => {
+      const request = new XMLHttpRequest();
+
+      request.onreadystatechange = () => {
+        if (request.readyState !== 4) {
+          return;
+        }
+
+        if (request.status === 200) {
+          resolve(request);
+        }
+
+        reject(request);
+      };
+
+      request.open('POST', this.config.url);
+      request.send(serialize(event));
+    });
+  }
+}
diff --git a/packages/core/package.json b/packages/core/package.json
@@ -17,7 +17,8 @@
   "dependencies": {
     "@sentry/hub": "0.5.4",
     "@sentry/minimal": "0.5.4",
-    "@sentry/types": "0.5.4"
+    "@sentry/types": "0.5.4",
+    "@sentry/utils": "0.5.4"
   },
   "devDependencies": {
     "jest": "^22.4.3",
diff --git a/packages/core/src/base.ts b/packages/core/src/base.ts
@@ -1,5 +1,6 @@
 import { Scope } from '@sentry/hub';
 import { Breadcrumb, SdkInfo, SentryEvent } from '@sentry/types';
+import { truncate, uuid4 } from '@sentry/utils';
 import { DSN } from './dsn';
 import { Backend, Client, Options } from './interfaces';
 import { SendStatus } from './status';
@@ -16,6 +17,11 @@ const DEFAULT_BREADCRUMBS = 30;
  */
 const MAX_BREADCRUMBS = 100;
 
+/**
+ * By default, truncates URL values to 250 chars
+ */
+const MAX_URL_LENGTH = 250;
+
 /** A class object that can instanciate Backend objects. */
 export interface BackendClass<B extends Backend, O extends Options> {
   new (options: O): B;
@@ -240,6 +246,23 @@ export abstract class BaseClient<B extends Backend, O extends Options>
       scope.applyToEvent(prepared, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));
     }
 
+    if (prepared.message) {
+      prepared.message = truncate(prepared.message, MAX_URL_LENGTH);
+    }
+    if (prepared.exception) {
+      const exception = prepared.exception.values[0];
+      if (exception.value) {
+        exception.value = truncate(exception.value, MAX_URL_LENGTH);
+      }
+    }
+
+    const request = prepared.request;
+    if (request && request.url) {
+      request.url = truncate(request.url, MAX_URL_LENGTH);
+    }
+
+    prepared.event_id = uuid4();
+
     return prepared;
   }
 
@@ -275,6 +298,10 @@ export abstract class BaseClient<B extends Backend, O extends Options>
       return SendStatus.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);
@@ -284,6 +311,8 @@ export abstract class BaseClient<B extends Backend, O extends Options>
       // implementors to override this method and handle it themselves.
     }
 
+    // TODO: Handle duplicates and backoffs
+
     if (afterSend) {
       afterSend(finalEvent, status);
     }
diff --git a/packages/core/src/interfaces.ts b/packages/core/src/interfaces.ts
@@ -1,5 +1,5 @@
 import { Scope } from '@sentry/hub';
-import { Breadcrumb, Integration, SentryEvent } from '@sentry/types';
+import { Breadcrumb, Integration, SentryEvent, Transport } from '@sentry/types';
 import { DSN } from './dsn';
 import { SendStatus } from './status';
 
@@ -39,6 +39,11 @@ export interface Options {
     | Integration[]
     | ((integrations: Integration[]) => Integration[]);
 
+  /**
+   * Transport object that should be used to send events to Sentry
+   */
+  transport?: Transport;
+
   /**
    * The release identifier used when uploading respective source maps. Specify
    * this value to allow Sentry to resolve the correct source maps when
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
@@ -127,3 +127,11 @@ export interface Integration {
   handler?: any;
   install(): void;
 }
+
+/** TODO */
+export interface Transport {
+  config: {
+    url: string;
+  };
+  send(event: SentryEvent): Promise<Response | XMLHttpRequest>;
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
@@ -1,10 +1,13 @@
 export { forget, filterAsync } from './async';
 export { mkdirp, mkdirpSync } from './fs';
-export { clone, deserialize, fill, serialize } from './object';
+export { clone, deserialize, fill, serialize, urlEncode } from './object';
 export { Store } from './store';
 export { isError, isErrorEvent, isDOMError, isDOMException } from './is';
+export { truncate, uuid4 } from './string';
 export {
-  supportsErrorEvent,
   supportsDOMError,
   supportsDOMException,
+  supportsErrorEvent,
+  supportsFetch,
+  supportsReferrerPolicy,
 } from './supports';
diff --git a/packages/utils/src/object.ts b/packages/utils/src/object.ts
@@ -67,3 +67,15 @@ export function fill(
     track.push([source, name, orig]);
   }
 }
+
+/**
+ * Encodes given object into url-friendly format
+ *
+ * @param object An object that contains serializable values
+ * @returns string Encoded
+ */
+export function urlEncode(object: { [key: string]: any }): string {
+  return Object.keys(object)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)
+    .join('&');
+}
diff --git a/packages/utils/src/string.ts b/packages/utils/src/string.ts
@@ -0,0 +1,72 @@
+/**
+ * Encodes given object into url-friendly format
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string
+ * @returns string Encoded
+ */
+
+export function truncate(str: string, max: number): string {
+  if (max === 0) {
+    return str;
+  }
+  return str.length <= max ? str : `${str.substr(0, max)}\u2026`;
+}
+
+/**
+ * Extended Window interface that allows for Crypto API usage in IE browsers
+ */
+interface MsCryptoWindow extends Window {
+  msCrypto?: Crypto;
+}
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+export function uuid4(): string {
+  // TODO: Safe window access
+  const crypto = window.crypto || (window as MsCryptoWindow).msCrypto;
+
+  if (!(crypto === void 0) && crypto.getRandomValues) {
+    // Use window.crypto API if available
+    const arr = new Uint16Array(8);
+    crypto.getRandomValues(arr);
+
+    // set 4 in byte 7
+    // tslint:disable-next-line:no-bitwise
+    arr[3] = (arr[3] & 0xfff) | 0x4000;
+    // set 2 most significant bits of byte 9 to '10'
+    // tslint:disable-next-line:no-bitwise
+    arr[4] = (arr[4] & 0x3fff) | 0x8000;
+
+    const pad = (num: number): string => {
+      let v = num.toString(16);
+      while (v.length < 4) {
+        v = `0${v}`;
+      }
+      return v;
+    };
+
+    return (
+      pad(arr[0]) +
+      pad(arr[1]) +
+      pad(arr[2]) +
+      pad(arr[3]) +
+      pad(arr[4]) +
+      pad(arr[5]) +
+      pad(arr[6]) +
+      pad(arr[7])
+    );
+  } else {
+    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      // tslint:disable-next-line:no-bitwise
+      const r = (Math.random() * 16) | 0;
+      // tslint:disable-next-line:no-bitwise
+      const v = c === 'x' ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+}
diff --git a/packages/utils/src/supports.ts b/packages/utils/src/supports.ts
diff --git a/packages/utils/test/object.test.ts b/packages/utils/test/object.test.ts
diff --git a/packages/utils/test/string.test.ts b/packages/utils/test/string.test.ts

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+export { FetchTransport } from './fetch';`
	`2`	`+export { XHRTransport } from './xhr';`