ref: Move public interfaces to @sentry/types package (#1889)

* fix: Events created from exception shouldnt have top-level message attribute (#1831)
* Use SyncPromise internally & Remove deprecated API & Trim Public API (#1858)
* ref: Move PromiseBuffer and Error to utils package
* ref: Remove all async api
* ref: Remove invokeClientAsync function
* feat: Finish Node SDK
* feat: SyncPromise implementation
* fix: Browser SDK
* fix: beforeSend callback
* fix: Core tests
* fix: linting and tests
* fix: browser npm package + add error for manual tests
* meta: Remove deprecations
* fix: Typedocs and public exposed functions
* meta: Changelog
* Apply suggestions from code review
* ref: Move public interfaces to types package
* fix: Tests
* fix: Small type issues
* ref: Remove scope listeners
* fix: Add flush to interface
* ref: Remove interfaces from core

Author: HazAT

CHANGELOG.md

@@ -10,7 +10,7 @@ since we removed some methods from the public API and removed some classes from
 
 - **breaking** [node] fix: Events created from exception shouldn't have top-level message attribute
 - [utils] ref: Update wrap method to hide internal sentry flags
-- [utils] fix: Make internal Sentry flags non-enumerable in fill util
+- [utils] fix: Make internal Sentry flags non-enumerable in fill utils
 - [utils] ref: Move `SentryError` + `PromiseBuffer` to utils
 - **breaking** [core] ref: Use `SyncPromise` internally, this reduces memory pressure by a lot.
 - **breaking** [browser] ref: Removed `BrowserBackend` from default export.

packages/browser/rollup.config.js

@@ -66,7 +66,7 @@ export default [
       interop: false,
       sourcemap: true,
     },
-    external: ['@sentry/core', '@sentry/hub', '@sentry/minimal'],
+    external: ['@sentry/core', '@sentry/hub', '@sentry/minimal', 'tslib'],
     plugins: [
       typescript({
         tsconfig: 'tsconfig.build.json',

packages/browser/src/backend.ts

@@ -1,5 +1,5 @@
-import { BaseBackend, Options } from '@sentry/core';
-import { SentryEvent, SentryEventHint, Severity, Transport } from '@sentry/types';
+import { BaseBackend } from '@sentry/core';
+import { Event, EventHint, Options, Severity, Transport } from '@sentry/types';
 import { isDOMError, isDOMException, isError, isErrorEvent, isPlainObject } from '@sentry/utils/is';
 import { supportsBeacon, supportsFetch } from '@sentry/utils/supports';
 import { SyncPromise } from '@sentry/utils/syncpromise';
@@ -56,8 +56,8 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * @inheritDoc
    */
-  public eventFromException(exception: any, hint?: SentryEventHint): SyncPromise<SentryEvent> {
-    let event: SentryEvent;
+  public eventFromException(exception: any, hint?: EventHint): SyncPromise<Event> {
+    let event: Event;
 
     if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {
       // If it is an ErrorEvent with `error` property, extract it to get actual Error
@@ -108,7 +108,7 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * This is an internal helper function that creates an event.
    */
-  private buildEvent(event: SentryEvent, hint?: SentryEventHint): SentryEvent {
+  private buildEvent(event: Event, hint?: EventHint): Event {
     return {
       ...event,
       event_id: hint && hint.event_id,
@@ -125,12 +125,8 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
   /**
    * @inheritDoc
    */
-  public eventFromMessage(
-    message: string,
-    level: Severity = Severity.Info,
-    hint?: SentryEventHint,
-  ): SyncPromise<SentryEvent> {
-    const event: SentryEvent = {
+  public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): SyncPromise<Event> {
+    const event: Event = {
       event_id: hint && hint.event_id,
       level,
       message,

packages/browser/src/client.ts

@@ -1,5 +1,5 @@
 import { API, BaseClient, Scope } from '@sentry/core';
-import { DsnLike, SentryEvent, SentryEventHint } from '@sentry/types';
+import { DsnLike, Event, EventHint } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { SyncPromise } from '@sentry/utils/syncpromise';
@@ -50,7 +50,7 @@ export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * @inheritDoc
    */
-  protected prepareEvent(event: SentryEvent, scope?: Scope, hint?: SentryEventHint): SyncPromise<SentryEvent | null> {
+  protected prepareEvent(event: Event, scope?: Scope, hint?: EventHint): SyncPromise<Event | null> {
     event.platform = event.platform || 'javascript';
     event.sdk = {
       ...event.sdk,

packages/browser/src/index.ts

@@ -2,9 +2,9 @@ export {
   Breadcrumb,
   Request,
   SdkInfo,
-  SentryEvent,
-  SentryException,
-  SentryResponse,
+  Event,
+  Exception,
+  Response,
   Severity,
   StackFrame,
   Stacktrace,

packages/browser/src/integrations/breadcrumbs.ts

@@ -1,5 +1,5 @@
 import { API, getCurrentHub } from '@sentry/core';
-import { Breadcrumb, Integration, SentryBreadcrumbHint, Severity } from '@sentry/types';
+import { Breadcrumb, BreadcrumbHint, Integration, Severity } from '@sentry/types';
 import { isFunction, isString } from '@sentry/utils/is';
 import { logger } from '@sentry/utils/logger';
 import { getEventDescription, getGlobalObject, parseUrl } from '@sentry/utils/misc';
@@ -454,9 +454,9 @@ export class Breadcrumbs implements Integration {
   /**
    * Helper that checks if integration is enabled on the client.
    * @param breadcrumb Breadcrumb
-   * @param hint SentryBreadcrumbHint
+   * @param hint BreadcrumbHint
    */
-  public static addBreadcrumb(breadcrumb: Breadcrumb, hint?: SentryBreadcrumbHint): void {
+  public static addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {
     if (getCurrentHub().getIntegration(Breadcrumbs)) {
       getCurrentHub().addBreadcrumb(breadcrumb, hint);
     }

packages/browser/src/integrations/globalhandlers.ts

@@ -1,5 +1,5 @@
 import { getCurrentHub } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { safeNormalize, serialize } from '@sentry/utils/object';
 import { truncate } from '@sentry/utils/string';
@@ -83,11 +83,11 @@ export class GlobalHandlers implements Integration {
   }
 
   /**
-   * This function creates an SentryEvent from an TraceKitStackTrace.
+   * This function creates an Event from an TraceKitStackTrace.
    *
-   * @param stacktrace TraceKitStackTrace to be converted to an SentryEvent.
+   * @param stacktrace TraceKitStackTrace to be converted to an Event.
    */
-  private eventFromGlobalHandler(stacktrace: TraceKitStackTrace): SentryEvent {
+  private eventFromGlobalHandler(stacktrace: TraceKitStackTrace): Event {
     const event = eventFromStacktrace(stacktrace);
 
     const data: { [key: string]: string } = {
@@ -102,7 +102,7 @@ export class GlobalHandlers implements Integration {
       data.name = stacktrace.name;
     }
 
-    const newEvent: SentryEvent = {
+    const newEvent: Event = {
       ...event,
       exception: {
         ...event.exception,

packages/browser/src/integrations/helpers.ts

@@ -1,5 +1,5 @@
 import { captureException, getCurrentHub, withScope } from '@sentry/core';
-import { Mechanism, SentryEvent, SentryWrappedFunction } from '@sentry/types';
+import { Event as SentryEvent, Mechanism, WrappedFunction } from '@sentry/types';
 import { isFunction } from '@sentry/utils/is';
 import { htmlTreeAsString } from '@sentry/utils/misc';
 import { safeNormalize } from '@sentry/utils/object';
@@ -36,11 +36,11 @@ export function ignoreNextOnError(): void {
  * @hidden
  */
 export function wrap(
-  fn: SentryWrappedFunction,
+  fn: WrappedFunction,
   options: {
     mechanism?: Mechanism;
   } = {},
-  before?: SentryWrappedFunction,
+  before?: WrappedFunction,
 ): any {
   if (!isFunction(fn)) {
     return fn;
@@ -63,7 +63,7 @@ export function wrap(
     return fn;
   }
 
-  const sentryWrapped: SentryWrappedFunction = function(this: any): void {
+  const sentryWrapped: WrappedFunction = function(this: any): void {
     if (before && isFunction(before)) {
       before.apply(this, arguments);
     }

packages/browser/src/integrations/linkederrors.ts

@@ -1,5 +1,5 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import { Integration, SentryEvent, SentryEventHint, SentryException } from '@sentry/types';
+import { Event, EventHint, Exception, Integration } from '@sentry/types';
 import { exceptionFromStacktrace } from '../parsers';
 import { computeStackTrace } from '../tracekit';
 
@@ -47,7 +47,7 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   public setupOnce(): void {
-    addGlobalEventProcessor((event: SentryEvent, hint?: SentryEventHint) => {
+    addGlobalEventProcessor((event: Event, hint?: EventHint) => {
       const self = getCurrentHub().getIntegration(LinkedErrors);
       if (self) {
         return self.handler(event, hint);
@@ -59,7 +59,7 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public handler(event: SentryEvent, hint?: SentryEventHint): SentryEvent | null {
+  public handler(event: Event, hint?: EventHint): Event | null {
     if (!event.exception || !event.exception.values || !hint || !(hint.originalException instanceof Error)) {
       return event;
     }
@@ -71,7 +71,7 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public walkErrorTree(error: ExtendedError, key: string, stack: SentryException[] = []): SentryException[] {
+  public walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {
     if (!(error[key] instanceof Error) || stack.length + 1 >= this.limit) {
       return stack;
     }

packages/browser/src/integrations/pluggable/ember.ts

@@ -1,5 +1,5 @@
 import { captureException, captureMessage, getCurrentHub, Scope, withScope } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
 import { getGlobalObject } from '@sentry/utils/misc';
 
@@ -81,7 +81,7 @@ export class Ember implements Integration {
    * @param scope The scope currently used.
    */
   private addIntegrationToSdkInfo(scope: Scope): void {
-    scope.addEventProcessor((event: SentryEvent) => {
+    scope.addEventProcessor((event: Event) => {
       if (event.sdk) {
         const integrations = event.sdk.integrations || [];
         event.sdk = {

packages/browser/src/integrations/pluggable/vue.ts

@@ -1,5 +1,5 @@
 import { captureException, getCurrentHub, withScope } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { isPlainObject, isUndefined } from '@sentry/utils/is';
 import { logger } from '@sentry/utils/logger';
 import { getGlobalObject } from '@sentry/utils/misc';
@@ -92,7 +92,7 @@ export class Vue implements Integration {
             scope.setExtra(key, metadata[key]);
           });
 
-          scope.addEventProcessor((event: SentryEvent) => {
+          scope.addEventProcessor((event: Event) => {
             if (event.sdk) {
               const integrations = event.sdk.integrations || [];
               event.sdk = {

packages/browser/src/integrations/trycatch.ts

@@ -1,4 +1,4 @@
-import { Integration, SentryWrappedFunction } from '@sentry/types';
+import { Integration, WrappedFunction } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { fill } from '@sentry/utils/object';
 import { breadcrumbEventHandler, keypressEventHandler, wrap } from './helpers';
@@ -124,7 +124,7 @@ export class TryCatch implements Integration {
           this,
           eventName,
           wrap(
-            (fn as any) as SentryWrappedFunction,
+            (fn as any) as WrappedFunction,
             {
               mechanism: {
                 data: {
@@ -152,7 +152,7 @@ export class TryCatch implements Integration {
         fn: EventListenerObject,
         options?: boolean | EventListenerOptions,
       ): () => void {
-        let callback = (fn as any) as SentryWrappedFunction;
+        let callback = (fn as any) as WrappedFunction;
         try {
           callback = callback && (callback.__sentry_wrapped__ || callback);
         } catch (e) {

packages/browser/src/integrations/useragent.ts

@@ -1,5 +1,5 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import { Integration, SentryEvent } from '@sentry/types';
+import { Event, Integration } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils/misc';
 
 const global = getGlobalObject() as Window;
@@ -20,7 +20,7 @@ export class UserAgent implements Integration {
    * @inheritDoc
    */
   public setupOnce(): void {
-    addGlobalEventProcessor((event: SentryEvent) => {
+    addGlobalEventProcessor((event: Event) => {
       if (getCurrentHub().getIntegration(UserAgent)) {
         if (!global.navigator || !global.location) {
           return event;

packages/browser/src/parsers.ts

@@ -1,4 +1,4 @@
-import { SentryEvent, SentryException, StackFrame } from '@sentry/types';
+import { Event, Exception, StackFrame } from '@sentry/types';
 import { limitObjectDepthToSize, serializeKeysToEventMessage } from '@sentry/utils/object';
 import { includes } from '@sentry/utils/string';
 import { md5 } from './md5';
@@ -11,10 +11,10 @@ const STACKTRACE_LIMIT = 50;
  * @param stacktrace TraceKitStackTrace that will be converted to an exception
  * @hidden
  */
-export function exceptionFromStacktrace(stacktrace: TraceKitStackTrace): SentryException {
+export function exceptionFromStacktrace(stacktrace: TraceKitStackTrace): Exception {
   const frames = prepareFramesForEvent(stacktrace.stack);
 
-  const exception: SentryException = {
+  const exception: Exception = {
     type: stacktrace.name,
     value: stacktrace.message,
   };
@@ -34,9 +34,9 @@ export function exceptionFromStacktrace(stacktrace: TraceKitStackTrace): SentryE
 /**
  * @hidden
  */
-export function eventFromPlainObject(exception: {}, syntheticException: Error | null): SentryEvent {
+export function eventFromPlainObject(exception: {}, syntheticException: Error | null): Event {
   const exceptionKeys = Object.keys(exception).sort();
-  const event: SentryEvent = {
+  const event: Event = {
     extra: {
       __serialized__: limitObjectDepthToSize(exception),
     },
@@ -58,7 +58,7 @@ export function eventFromPlainObject(exception: {}, syntheticException: Error |
 /**
  * @hidden
  */
-export function eventFromStacktrace(stacktrace: TraceKitStackTrace): SentryEvent {
+export function eventFromStacktrace(stacktrace: TraceKitStackTrace): Event {
   const exception = exceptionFromStacktrace(stacktrace);
 
   return {
@@ -113,7 +113,7 @@ export function prepareFramesForEvent(stack: TraceKitStackFrame[]): StackFrame[]
  * @param type Type of the exception.
  * @hidden
  */
-export function addExceptionTypeValue(event: SentryEvent, value?: string, type?: string): void {
+export function addExceptionTypeValue(event: Event, value?: string, type?: string): void {
   event.exception = event.exception || {};
   event.exception.values = event.exception.values || [];
   event.exception.values[0] = event.exception.values[0] || {};

packages/browser/src/transports/base.ts

@@ -1,5 +1,5 @@
 import { API } from '@sentry/core';
-import { SentryResponse, Transport, TransportOptions } from '@sentry/types';
+import { Response, Transport, TransportOptions } from '@sentry/types';
 import { SentryError } from '@sentry/utils/error';
 import { PromiseBuffer } from '@sentry/utils/promisebuffer';
 
@@ -11,7 +11,7 @@ export abstract class BaseTransport implements Transport {
   public url: string;
 
   /** A simple buffer holding all requests. */
-  protected readonly buffer: PromiseBuffer<SentryResponse> = new PromiseBuffer(30);
+  protected readonly buffer: PromiseBuffer<Response> = new PromiseBuffer(30);
 
   public constructor(public options: TransportOptions) {
     this.url = new API(this.options.dsn).getStoreEndpointWithUrlEncodedAuth();
@@ -20,7 +20,7 @@ export abstract class BaseTransport implements Transport {
   /**
    * @inheritDoc
    */
-  public async sendEvent(_: string): Promise<SentryResponse> {
+  public async sendEvent(_: string): Promise<Response> {
     throw new SentryError('Transport Class has to implement `sendEvent` method');
   }
 

packages/browser/src/transports/beacon.ts

@@ -1,4 +1,4 @@
-import { SentryResponse, Status } from '@sentry/types';
+import { Response, Status } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { BaseTransport } from './base';
 
@@ -9,7 +9,7 @@ export class BeaconTransport extends BaseTransport {
   /**
    * @inheritDoc
    */
-  public async sendEvent(body: string): Promise<SentryResponse> {
+  public async sendEvent(body: string): Promise<Response> {
     const result = global.navigator.sendBeacon(this.url, body);
 
     return this.buffer.add(

packages/browser/src/transports/fetch.ts

@@ -1,4 +1,4 @@
-import { SentryResponse, Status } from '@sentry/types';
+import { Response, Status } from '@sentry/types';
 import { getGlobalObject } from '@sentry/utils/misc';
 import { supportsReferrerPolicy } from '@sentry/utils/supports';
 import { BaseTransport } from './base';
@@ -10,7 +10,7 @@ export class FetchTransport extends BaseTransport {
   /**
    * @inheritDoc
    */
-  public async sendEvent(body: string): Promise<SentryResponse> {
+  public async sendEvent(body: string): Promise<Response> {
     const defaultOptions: RequestInit = {
       body,
       method: 'POST',

packages/browser/src/transports/xhr.ts

@@ -1,14 +1,14 @@
-import { SentryResponse, Status } from '@sentry/types';
+import { Response, Status } from '@sentry/types';
 import { BaseTransport } from './base';
 
 /** `XHR` based transport */
 export class XHRTransport extends BaseTransport {
   /**
    * @inheritDoc
    */
-  public async sendEvent(body: string): Promise<SentryResponse> {
+  public async sendEvent(body: string): Promise<Response> {
     return this.buffer.add(
-      new Promise<SentryResponse>((resolve, reject) => {
+      new Promise<Response>((resolve, reject) => {
         const request = new XMLHttpRequest();
 
         request.onreadystatechange = () => {