[NEXT] Frontend -> Client (#1323)

* fix: This can be null under some circumstances

* ref: Rename Frontend to Client

* ref: ClientBase -> BaseClient

* ref: Remove client and pass options instead

* ref: Add correct type checks for raven-js send

Author: HazAT

packages/browser/README.md

@@ -67,9 +67,9 @@ If you don't want to use a global static instance of Sentry, you can create one
 yourself:
 
 ```javascript
-import { BrowserFrontend } from '@sentry/browser';
+import { BrowserClient } from '@sentry/browser';
 
-const client = new BrowserFrontend({
+const client = new BrowserClient({
   dsn: '__DSN__',
   // ...
 });

packages/browser/src/backend.ts

@@ -1,4 +1,4 @@
-import { Backend, Frontend, Options, SentryError } from '@sentry/core';
+import { Backend, Options, SentryError } from '@sentry/core';
 import {
   addBreadcrumb,
   captureEvent,
@@ -11,12 +11,13 @@ import { Raven, SendMethod } from './raven';
 const sendRavenEvent = Raven._sendProcessedPayload.bind(Raven) as SendMethod;
 
 /** Normalizes the event so it is consistent with our domain interface. */
-function normalizeRavenEvent(event: SentryEvent): SentryEvent {
-  const ex = (event.exception || {}) as { values?: SentryException[] };
-  if (ex && ex.values) {
+function normalizeRavenEvent(event?: SentryEvent): SentryEvent | undefined {
+  const ex = ((event && event.exception) || {}) as {
+    values?: SentryException[];
+  };
+  if (event && ex && ex.values) {
     event.exception = ex.values;
   }
-
   return event;
 }
 
@@ -32,7 +33,7 @@ function prepareEventForRaven(event: SentryEvent): SentryEvent {
 
 /**
  * Configuration options for the Sentry Browser SDK.
- * @see BrowserFrontend for more information.
+ * @see BrowserClient for more information.
  */
 export interface BrowserOptions extends Options {
   /**
@@ -65,43 +66,41 @@ export interface BrowserOptions extends Options {
 
 /** The Sentry Browser SDK Backend. */
 export class BrowserBackend implements Backend {
-  /** Handle to the SDK frontend for callbacks. */
-  private readonly frontend: Frontend<BrowserOptions>;
-
   /** Creates a new browser backend instance. */
-  public constructor(frontend: Frontend<BrowserOptions>) {
-    this.frontend = frontend;
-  }
+  public constructor(private readonly options: BrowserOptions) {}
 
   /**
    * @inheritDoc
    */
   public install(): boolean {
-    // We are only called by the frontend if the SDK is enabled and a valid DSN
+    // We are only called by the client if the SDK is enabled and a valid DSN
     // has been configured. If no DSN is present, this indicates a programming
     // error.
-    const dsn = this.frontend.getDSN();
+    const dsn = this.options.dsn;
     if (!dsn) {
       throw new SentryError(
         'Invariant exception: install() must not be called when disabled',
       );
     }
 
-    Raven.config(dsn.toString(), this.frontend.getOptions()).install();
+    Raven.config(dsn, this.options).install();
 
     // Hook into Raven's breadcrumb mechanism. This allows us to intercept both
-    // breadcrumbs created internally by Raven and pass them to the Frontend
+    // breadcrumbs created internally by Raven and pass them to the Client
     // first, before actually capturing them.
     Raven.setBreadcrumbCallback(breadcrumb => {
       addBreadcrumb(breadcrumb);
       return false;
     });
 
     // Hook into Raven's internal event sending mechanism. This allows us to
-    // pass events to the frontend, before they will be sent back here for
+    // pass events to the client, before they will be sent back here for
     // actual submission.
     Raven._sendProcessedPayload = event => {
-      captureEvent(normalizeRavenEvent(event));
+      const normalizedEvent = normalizeRavenEvent(event);
+      if (normalizedEvent) {
+        captureEvent(normalizedEvent);
+      }
     };
 
     return true;
@@ -117,9 +116,12 @@ export class BrowserBackend implements Backend {
       Raven._sendProcessedPayload = evt => {
         event = evt;
       };
-
       Raven.captureException(exception);
-      return normalizeRavenEvent(event);
+      const normalizedEvent = normalizeRavenEvent(event);
+      if (normalizedEvent) {
+        return normalizedEvent;
+      }
+      throw new SentryError('Event was undefined when it should be an event');
     } finally {
       Raven._sendProcessedPayload = originalSend;
     }
@@ -135,9 +137,12 @@ export class BrowserBackend implements Backend {
       Raven._sendProcessedPayload = evt => {
         event = evt;
       };
-
       Raven.captureMessage(message);
-      return normalizeRavenEvent(event);
+      const normalizedEvent = normalizeRavenEvent(event);
+      if (normalizedEvent) {
+        return normalizedEvent;
+      }
+      throw new SentryError('Event was undefined when it should be an event');
     } finally {
       Raven._sendProcessedPayload = originalSend;
     }

packages/browser/src/frontend.ts renamed to packages/browser/src/client.ts

@@ -1,18 +1,15 @@
-import { FrontendBase } from '@sentry/core';
+import { BaseClient } from '@sentry/core';
 import { SdkInfo } from '@sentry/shim';
 import { BrowserBackend, BrowserOptions } from './backend';
 import { Raven } from './raven';
 
 /**
- * The Sentry Browser SDK Frontend.
+ * The Sentry Browser SDK Client.
  *
  * @see BrowserOptions for documentation on configuration options.
  * @see SentryClient for usage documentation.
  */
-export class BrowserFrontend extends FrontendBase<
-  BrowserBackend,
-  BrowserOptions
-> {
+export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * Creates a new Browser SDK instance.
    *

packages/browser/src/index.ts

@@ -27,5 +27,5 @@ export {
 } from '@sentry/shim';
 
 export { BrowserBackend, BrowserOptions } from './backend';
-export { BrowserFrontend } from './frontend';
-export { init, getCurrentFrontend } from './sdk';
+export { BrowserClient } from './client';
+export { init, getCurrentClient } from './sdk';

packages/browser/src/sdk.ts

@@ -1,7 +1,7 @@
 import { initAndBind } from '@sentry/core';
-import { getCurrentClient } from '@sentry/shim';
+import { getCurrentClient as shimGetCurrentClient } from '@sentry/shim';
 import { BrowserOptions } from './backend';
-import { BrowserFrontend } from './frontend';
+import { BrowserClient } from './client';
 
 /**
  * The Sentry Browser SDK Client.
@@ -47,10 +47,10 @@ import { BrowserFrontend } from './frontend';
  * @see BrowserOptions for documentation on configuration options.
  */
 export function init(options: BrowserOptions): void {
-  initAndBind(BrowserFrontend, options);
+  initAndBind(BrowserClient, options);
 }
 
-/** Returns the current BrowserFrontend, if any. */
-export function getCurrentFrontend(): BrowserFrontend {
-  return getCurrentClient() as BrowserFrontend;
+/** Returns the current BrowserClient, if any. */
+export function getCurrentClient(): BrowserClient {
+  return shimGetCurrentClient() as BrowserClient;
 }

packages/browser/test/index.test.ts

@@ -4,7 +4,7 @@ import { spy, stub } from 'sinon';
 import {
   addBreadcrumb,
   BrowserBackend,
-  BrowserFrontend,
+  BrowserClient,
   captureEvent,
   captureException,
   captureMessage,
@@ -29,7 +29,7 @@ describe('SentryBrowser', () => {
     let s: sinon.SinonSpy;
 
     beforeEach(() => {
-      s = spy(BrowserFrontend.prototype, 'setContext');
+      s = spy(BrowserClient.prototype, 'setContext');
     });
 
     afterEach(() => {
@@ -70,7 +70,7 @@ describe('SentryBrowser', () => {
 
     it('should record auto breadcrumbs', done => {
       pushScope(
-        new BrowserFrontend({
+        new BrowserClient({
           afterSend: (event: SentryEvent) => {
             expect(event.breadcrumbs!).to.have.lengthOf(3);
             done();
@@ -110,7 +110,7 @@ describe('SentryBrowser', () => {
 
     it('should capture an exception', done => {
       pushScope(
-        new BrowserFrontend({
+        new BrowserClient({
           afterSend: (event: SentryEvent) => {
             expect(event.exception).to.not.be.undefined;
             expect(event.exception![0]).to.not.be.undefined;
@@ -132,7 +132,7 @@ describe('SentryBrowser', () => {
 
     it('should capture a message', done => {
       pushScope(
-        new BrowserFrontend({
+        new BrowserClient({
           afterSend: (event: SentryEvent) => {
             expect(event.message).to.equal('test');
             expect(event.exception).to.be.undefined;
@@ -147,7 +147,7 @@ describe('SentryBrowser', () => {
 
     it('should capture an event', done => {
       pushScope(
-        new BrowserFrontend({
+        new BrowserClient({
           afterSend: (event: SentryEvent) => {
             expect(event.message).to.equal('test');
             expect(event.exception).to.be.undefined;

packages/core/README.md

@@ -18,7 +18,7 @@ building Sentry JavaScript SDKs, like `@sentry/node` or `@sentry/browser`.
 
 TODO
 
-## Specializing the Frontend
+## Specializing the Client
 
 TODO
 

packages/core/src/base.ts

@@ -1,6 +1,6 @@
 import { Breadcrumb, Context, SdkInfo, SentryEvent } from '@sentry/shim';
 import { DSN } from './dsn';
-import { Backend, Frontend, Options, Scope } from './interfaces';
+import { Backend, Client, Options, Scope } from './interfaces';
 import { SendStatus } from './status';
 
 /**
@@ -17,49 +17,49 @@ const MAX_BREADCRUMBS = 100;
 
 /** A class object that can instanciate Backend objects. */
 export interface BackendClass<B extends Backend, O extends Options> {
-  new (frontend: Frontend<O>): B;
+  new (options: O): B;
 }
 
 /**
- * Base implementation for all JavaScript SDK frontends.
+ * Base implementation for all JavaScript SDK clients.
  *
  * Call the constructor with the corresponding backend constructor and options
- * specific to the frontend subclass. To access these options later, use
- * {@link Frontend.getOptions}. Also, the Backend instance is available via
- * {@link Frontend.getBackend}.
+ * specific to the client subclass. To access these options later, use
+ * {@link Client.getOptions}. Also, the Backend instance is available via
+ * {@link Client.getBackend}.
  *
  * Subclasses must implement one abstract method: {@link getSdkInfo}. It must
  * return the unique name and the version of the SDK.
  *
  * If a DSN is specified in the options, it will be parsed and stored. Use
- * {@link Frontend.getDSN} to retrieve the DSN at any moment. In case the DSN is
+ * {@link Client.getDSN} to retrieve the DSN at any moment. In case the DSN is
  * invalid, the constructor will throw a {@link SentryException}. Note that
  * without a valid DSN, the SDK will not send any events to Sentry.
  *
  * Before sending an event via the backend, it is passed through
- * {@link FrontendBase.prepareEvent} to add SDK information and scope data
+ * {@link BaseClient.prepareEvent} to add SDK information and scope data
  * (breadcrumbs and context). To add more custom information, override this
  * method and extend the resulting prepared event.
  *
  * To issue automatically created events (e.g. via instrumentation), use
- * {@link Frontend.captureEvent}. It will prepare the event and pass it through
+ * {@link Client.captureEvent}. It will prepare the event and pass it through
  * the callback lifecycle. To issue auto-breadcrumbs, use
- * {@link Frontend.addBreadcrumb}.
+ * {@link Client.addBreadcrumb}.
  *
  * @example
- * class NodeFrontend extends FrontendBase<NodeBackend, NodeOptions> {
+ * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {
  *   public constructor(options: NodeOptions) {
  *     super(NodeBackend, options);
  *   }
  *
  *   // ...
  * }
  */
-export abstract class FrontendBase<B extends Backend, O extends Options>
-  implements Frontend<O> {
+export abstract class BaseClient<B extends Backend, O extends Options>
+  implements Client<O> {
   /**
    * The backend used to physically interact in the enviornment. Usually, this
-   * will correspond to the frontend. When composing SDKs, however, the Backend
+   * will correspond to the client. When composing SDKs, however, the Backend
    * from the root SDK will be used.
    */
   private readonly backend: B;
@@ -76,7 +76,7 @@ export abstract class FrontendBase<B extends Backend, O extends Options>
   /**
    * A scope instance containing breadcrumbs and context, used if none is
    * specified to the public methods. This is specifically used in standalone
-   * mode, when the Frontend is directly instanciated by the user.
+   * mode, when the Client is directly instanciated by the user.
    */
   private readonly internalScope: Scope;
 
@@ -87,13 +87,13 @@ export abstract class FrontendBase<B extends Backend, O extends Options>
   private installed?: boolean;
 
   /**
-   * Initializes this frontend instance.
+   * Initializes this client instance.
    *
    * @param backendClass A constructor function to create the backend.
-   * @param options Options for the frontend.
+   * @param options Options for the client.
    */
   protected constructor(backendClass: BackendClass<B, O>, options: O) {
-    this.backend = new backendClass(this);
+    this.backend = new backendClass(options);
     this.options = options;
 
     if (options.dsn) {
@@ -259,7 +259,7 @@ export abstract class FrontendBase<B extends Backend, O extends Options>
    * Adds common information to events.
    *
    * The information includes release and environment from `options`, SDK
-   * information returned by {@link FrontendBase.getSdkInfo}, as well as
+   * information returned by {@link BaseClient.getSdkInfo}, as well as
    * breadcrumbs and context (extra, tags and user) from the scope.
    *
    * Information that is already present in the event is never overwritten. For

packages/core/src/index.ts

@@ -1,5 +1,5 @@
-export { BackendClass, FrontendBase } from './base';
+export { BackendClass, BaseClient } from './base';
 export { DSN, DSNComponents, DSNLike, DSNProtocol } from './dsn';
 export { SentryError } from './error';
-export { Backend, Frontend, LogLevel, Options, Scope } from './interfaces';
-export { initAndBind, FrontendClass } from './sdk';
+export { Backend, Client, LogLevel, Options, Scope } from './interfaces';
+export { initAndBind, ClientClass } from './sdk';