feat: CR

Author: HazAT

packages/hub/test/spancontext.test.ts

@@ -11,6 +11,7 @@ describe('Span', () => {
     expect(from._parent._spanId).toEqual('bbbbbbbbbbbbbbbb');
     expect(from._traceId).toEqual('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
     expect(from._spanId).not.toEqual('bbbbbbbbbbbbbbbb');
+    expect(from._recorded).toEqual(false);
   });
 
   test('fromTraceparent - invalid', () => {
@@ -22,4 +23,10 @@ describe('Span', () => {
       `{"span_id":"bbbbbbbbbbbbbbbb","trace_id":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}`,
     );
   });
+
+  test('toJSON with parent', () => {
+    const spanA = new Span('a', 'b');
+    const spanB = new Span('c', 'd', false, spanA);
+    expect(JSON.stringify(spanB)).toEqual(`{"parent":{"span_id":"b","trace_id":"a"},"span_id":"d","trace_id":"c"}`);
+  });
 });

packages/integrations/src/tracing.ts

@@ -1,5 +1,5 @@
 import { EventProcessor, Hub, Integration } from '@sentry/types';
-import { fill, getGlobalObject, isMatchingPattern, SentryError, supportsNativeFetch } from '@sentry/utils';
+import { consoleSandbox, fill, getGlobalObject, isMatchingPattern, supportsNativeFetch } from '@sentry/utils';
 
 /** JSDoc */
 interface TracingOptions {
@@ -36,8 +36,18 @@ export class Tracing implements Integration {
    * @param _options TracingOptions
    */
   public constructor(private readonly _options: TracingOptions) {
-    if (!_options.tracingOrigins || !Array.isArray(_options.tracingOrigins) || _options.tracingOrigins.length === 0) {
-      throw new SentryError('You need to define `tracingOrigins` in the options. Set an array of urls to trace.');
+    if (!Array.isArray(_options.tracingOrigins) || _options.tracingOrigins.length === 0) {
+      consoleSandbox(() => {
+        const defaultTracingOrigins = ['localhost', /^\//];
+        // tslint:disable: no-unsafe-any
+        // @ts-ignore
+        console.warning(
+          'Sentry: You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.',
+        );
+        // @ts-ignore
+        console.warning(`Sentry: We added a reasonable default for you: ${defaultTracingOrigins}`);
+        // tslint:enable: no-unsafe-any
+      });
     }
   }
 
@@ -55,6 +65,11 @@ export class Tracing implements Integration {
       getGlobalObject<Window>().addEventListener('DOMContentLoaded', () => {
         Tracing.startTrace(getCurrentHub(), getGlobalObject<Window>().location.href);
       });
+      getGlobalObject<Window>().document.onreadystatechange = () => {
+        if (document.readyState === 'complete') {
+          Tracing.startTrace(getCurrentHub(), getGlobalObject<Window>().location.href);
+        }
+      };
     }
   }
 
@@ -104,17 +119,18 @@ export class Tracing implements Integration {
           const self = getCurrentHub().getIntegration(Tracing);
           if (self && self._xhrUrl) {
             const headers = getCurrentHub().traceHeaders();
-            let whiteListed = false;
+            let whiteList = false;
+
             // tslint:disable-next-line: prefer-for-of
             for (let index = 0; index < self._options.tracingOrigins.length; index++) {
               const whiteListUrl = self._options.tracingOrigins[index];
-              whiteListed = isMatchingPattern(self._xhrUrl, whiteListUrl);
-              if (whiteListed) {
+              whiteList = isMatchingPattern(self._xhrUrl, whiteListUrl);
+              if (whiteList) {
                 break;
               }
             }
 
-            if (whiteListed && this.setRequestHeader) {
+            if (whiteList && this.setRequestHeader) {
               Object.keys(headers).forEach(key => {
                 this.setRequestHeader(key, headers[key]);
               });

packages/node/src/handlers.ts

@@ -294,7 +294,7 @@ export function errorHandler(): (
       return;
     }
     withScope(scope => {
-      if (isString(_req.headers['sentry-trace'])) {
+      if (_req.headers && isString(_req.headers['sentry-trace'])) {
         const span = Span.fromTraceparent(_req.headers['sentry-trace'] as string);
         scope.setSpan(span);
       }

packages/utils/src/syncpromise.ts

@@ -3,11 +3,11 @@ import { isThenable } from './is';
 /** SyncPromise internal states */
 enum States {
   /** Pending */
-  P = 'P',
+  PENDING = 'PENDING',
   /** Resolved / OK */
-  O = 'O',
+  RESOLVED = 'RESOLVED',
   /** Rejected / Error */
-  E = 'E',
+  REJECTED = 'REJECTED',
 }
 
 /** JSDoc */
@@ -31,7 +31,7 @@ type Reject = (value?: any) => void;
 /** JSDoc */
 export class SyncPromise<T> implements PromiseLike<T> {
   /** JSDoc */
-  private _state: States = States.P;
+  private _state: States = States.PENDING;
   /** JSDoc */
   private _handlers: Array<Handler<T, any>> = [];
   /** JSDoc */
@@ -47,17 +47,17 @@ export class SyncPromise<T> implements PromiseLike<T> {
 
   /** JSDoc */
   private readonly _resolve = (value: T) => {
-    this._setResult(value, States.O);
+    this._setResult(value, States.RESOLVED);
   };
 
   /** JSDoc */
   private readonly _reject = (reason: any) => {
-    this._setResult(reason, States.E);
+    this._setResult(reason, States.REJECTED);
   };
 
   /** JSDoc */
   private readonly _setResult = (value: T | any, state: States) => {
-    if (this._state !== States.P) {
+    if (this._state !== States.PENDING) {
       return;
     }
 
@@ -74,11 +74,11 @@ export class SyncPromise<T> implements PromiseLike<T> {
 
   /** JSDoc */
   private readonly _executeHandlers = () => {
-    if (this._state === States.P) {
+    if (this._state === States.PENDING) {
       return;
     }
 
-    if (this._state === States.E) {
+    if (this._state === States.REJECTED) {
       // tslint:disable-next-line:no-unsafe-any
       this._handlers.forEach(h => h.onFail && h.onFail(this._value));
     } else {