port BaseBackend to BaseClient

Author: Lms24

packages/core/src/baseclient.ts

@@ -28,15 +28,21 @@ import {
   uuid4,
 } from '@sentry/utils';
 
+import { initAPIDetails } from './api';
 import { Backend, BackendClass } from './basebackend';
 import { IS_DEBUG_BUILD } from './flags';
 import { IntegrationIndex, setupIntegrations } from './integration';
+import { createEventEnvelope, createSessionEnvelope } from './request';
+import { NewTransport } from './transports/base';
+import { NoopTransport } from './transports/noop';
 
 const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
 
 /**
  * Base implementation for all JavaScript SDK clients.
  *
+ * TODO: refactor doc w.r.t. Backend
+ *
  * Call the constructor with the corresponding backend constructor and options
  * specific to the client subclass. To access these options later, use
  * {@link Client.getOptions}. Also, the Backend instance is available via
@@ -71,6 +77,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
    * The backend used to physically interact in the environment. Usually, this
    * will correspond to the client. When composing SDKs, however, the Backend
    * from the root SDK will be used.
+   * TODO: DELETE
    */
   protected readonly _backend: B;
 
@@ -86,19 +93,30 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
   /** Number of calls being processed */
   protected _numProcessing: number = 0;
 
+  /** Cached transport used internally. */
+  protected _transport: Transport;
+
+  /** New v7 Transport that is initialized alongside the old one */
+  protected _newTransport?: NewTransport;
+
   /**
    * Initializes this client instance.
    *
    * @param backendClass A constructor function to create the backend.
    * @param options Options for the client.
    */
   protected constructor(backendClass: BackendClass<B, O>, options: O) {
+    // TODO: Delete
     this._backend = new backendClass(options);
     this._options = options;
 
     if (options.dsn) {
       this._dsn = makeDsn(options.dsn);
+    } else {
+      IS_DEBUG_BUILD && logger.warn('No DSN provided, client will not do anything.');
     }
+
+    this._transport = this._setupTransport();
   }
 
   /**
@@ -115,8 +133,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
     let eventId: string | undefined = hint && hint.event_id;
 
     this._process(
-      this._getBackend()
-        .eventFromException(exception, hint)
+      this.eventFromException(exception, hint)
         .then(event => this._captureEvent(event, hint, scope))
         .then(result => {
           eventId = result;
@@ -132,9 +149,10 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
   public captureMessage(message: string, level?: Severity, hint?: EventHint, scope?: Scope): string | undefined {
     let eventId: string | undefined = hint && hint.event_id;
 
+    // TODO: refactor
     const promisedEvent = isPrimitive(message)
-      ? this._getBackend().eventFromMessage(String(message), level, hint)
-      : this._getBackend().eventFromException(message, hint);
+      ? this.eventFromMessage(String(message), level, hint)
+      : this.eventFromException(message, hint);
 
     this._process(
       promisedEvent
@@ -204,7 +222,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
    * @inheritDoc
    */
   public getTransport(): Transport {
-    return this._getBackend().getTransport();
+    return this._transport;
   }
 
   /**
@@ -249,6 +267,72 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
     }
   }
 
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  public eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event> {
+    throw new SentryError('Client has to implement `eventFromException` method');
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public eventFromMessage(_message: string, _level?: Severity, _hint?: EventHint): PromiseLike<Event> {
+    throw new SentryError('Client has to implement `eventFromMessage` method');
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public sendEvent(event: Event): void {
+    // TODO(v7): Remove the if-else
+    if (
+      this._newTransport &&
+      this._options.dsn &&
+      this._options._experiments &&
+      this._options._experiments.newTransport
+    ) {
+      const api = initAPIDetails(this._options.dsn, this._options._metadata, this._options.tunnel);
+      const env = createEventEnvelope(event, api);
+      void this._newTransport.send(env).then(null, reason => {
+        IS_DEBUG_BUILD && logger.error('Error while sending event:', reason);
+      });
+    } else {
+      void this._transport.sendEvent(event).then(null, reason => {
+        IS_DEBUG_BUILD && logger.error('Error while sending event:', reason);
+      });
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public sendSession(session: Session): void {
+    if (!this._transport.sendSession) {
+      IS_DEBUG_BUILD && logger.warn("Dropping session because custom transport doesn't implement sendSession");
+      return;
+    }
+
+    // TODO(v7): Remove the if-else
+    if (
+      this._newTransport &&
+      this._options.dsn &&
+      this._options._experiments &&
+      this._options._experiments.newTransport
+    ) {
+      const api = initAPIDetails(this._options.dsn, this._options._metadata, this._options.tunnel);
+      const [env] = createSessionEnvelope(session, api);
+      void this._newTransport.send(env).then(null, reason => {
+        IS_DEBUG_BUILD && logger.error('Error while sending session:', reason);
+      });
+    } else {
+      void this._transport.sendSession(session).then(null, reason => {
+        IS_DEBUG_BUILD && logger.error('Error while sending session:', reason);
+      });
+    }
+  }
+
   /** Updates existing session based on the provided event */
   protected _updateSessionFromEvent(session: Session, event: Event): void {
     let crashed = false;
@@ -284,7 +368,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
 
   /** Deliver captured session to Sentry */
   protected _sendSession(session: Session): void {
-    this._getBackend().sendSession(session);
+    this.sendSession(session);
   }
 
   /**
@@ -317,7 +401,9 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
     });
   }
 
-  /** Returns the current backend. */
+  /** Returns the current backend.
+   * TODO: DELETE
+   */
   protected _getBackend(): B {
     return this._backend;
   }
@@ -490,8 +576,9 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
    * Tells the backend to send this event
    * @param event The Sentry event to send
    */
+  // TODO: refactor: get rid of method?
   protected _sendEvent(event: Event): void {
-    this._getBackend().sendEvent(event);
+    this.sendEvent(event);
   }
 
   /**
@@ -582,7 +669,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
           this._updateSessionFromEvent(session, processedEvent);
         }
 
-        this._sendEvent(processedEvent);
+        this.sendEvent(processedEvent);
         return processedEvent;
       })
       .then(null, reason => {
@@ -618,6 +705,13 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
       },
     );
   }
+
+  /**
+   * Sets up the transport so it can be used later to send requests.
+   */
+  protected _setupTransport(): Transport {
+    return new NoopTransport();
+  }
 }
 
 /**