feat(am): Introduce startTransaction

packages/apm/src/hubextensions.ts

@@ -1,7 +1,8 @@
 import { getMainCarrier, Hub } from '@sentry/hub';
-import { SpanContext } from '@sentry/types';
+import { SpanContext, TransactionContext } from '@sentry/types';
 
 import { Span } from './span';
+import { Transaction } from './transaction';
 
 /** Returns all trace headers that are currently on the top scope. */
 function traceHeaders(): { [key: string]: string } {
@@ -26,43 +27,51 @@ function traceHeaders(): { [key: string]: string } {
  *
  * @param spanContext Properties with which the span should be created
  */
-function startSpan(spanContext?: SpanContext): Span {
+function startSpan(spanOrTransactionContext: SpanContext | TransactionContext): Span {
   // @ts-ignore
   const hub = this as Hub;
   const scope = hub.getScope();
   const client = hub.getClient();
-  let span;
 
-  // This flag determines if we already added the span as a child to the span that currently lives on the scope
-  // If we do not have this, we will add it later on twice to the span recorder and therefore have too many spans
-  let addedAsChild = false;
+  let newSpanContext = spanOrTransactionContext;
 
+  // We create an empty Span always in case there is nothing on the scope
+  let parentSpan = new Span();
   if (scope) {
-    const parentSpan = scope.getSpan() as Span;
+    // If there is a Span on the Scope we use the span_id / trace_id
+    // To define the parent <-> child relationship
+    parentSpan = scope.getSpan() as Span;
     if (parentSpan) {
-      span = parentSpan.child(spanContext);
-      addedAsChild = true;
+      const { span_id, trace_id } = parentSpan.getTraceContext();
+      newSpanContext = {
+        parentSpanId: span_id,
+        traceId: trace_id,
+        ...spanOrTransactionContext,
+      };
     }
   }
 
-  if (!span) {
-    span = new Span(spanContext, hub);
-  }
+  // We are dealing with a Transaction
+  if ((newSpanContext as TransactionContext).name) {
+    const transaction = new Transaction(newSpanContext as TransactionContext, hub);
 
-  // We only roll the dice on sampling for "root" spans (transactions) because the childs inherit this state
-  if (span.sampled === undefined && span.isRootSpan()) {
-    const sampleRate = (client && client.getOptions().tracesSampleRate) || 0;
-    span.sampled = Math.random() < sampleRate;
-  }
+    // We only roll the dice on sampling for "root" spans (transactions) because the childs inherit this state
+    if (transaction.sampled === undefined) {
+      const sampleRate = (client && client.getOptions().tracesSampleRate) || 0;
+      transaction.sampled = Math.random() < sampleRate;
+    }
+
+    // We only want to create a span list if we sampled the transaction
+    // in case we will discard the span anyway because sampled == false, we safe memory and do not store child spans
+    if (transaction.sampled) {
+      const experimentsOptions = (client && client.getOptions()._experiments) || {};
+      transaction.initSpanRecorder(experimentsOptions.maxSpans as number);
+    }
 
-  // We only want to create a span list if we sampled the transaction
-  // in case we will discard the span anyway because sampled == false, we safe memory and do not store child spans
-  if (span.sampled && !addedAsChild) {
-    const experimentsOptions = (client && client.getOptions()._experiments) || {};
-    span.initSpanRecorder(experimentsOptions.maxSpans as number);
+    return transaction;
   }
 
-  return span;
+  return new Span(newSpanContext);
 }
 
 /**

packages/apm/src/integrations/tracing.ts

@@ -11,6 +11,7 @@ import {
 
 import { Span as SpanClass } from '../span';
 import { SpanStatus } from '../spanstatus';
+import { Transaction } from '../transaction';
 
 /**
  * Options for Tracing integration
@@ -132,7 +133,7 @@ export class Tracing implements Integration {
    */
   private static _getCurrentHub?: () => Hub;
 
-  private static _activeTransaction?: Span;
+  private static _activeTransaction?: Transaction;
 
   private static _currentIndex: number = 1;
 
@@ -202,6 +203,8 @@ export class Tracing implements Integration {
       logger.warn(`[Tracing] We added a reasonable default for you: ${defaultTracingOrigins}`);
     }
 
+    Tracing._startTrace();
+
     // Starting pageload transaction
     if (global.location && global.location.href) {
       // Use `${global.location.href}` as transaction name
@@ -407,6 +410,26 @@ export class Tracing implements Integration {
     logger.log(args);
   }
 
+  /**
+   * TODO
+   */
+  private static _startTrace(): void {
+    const _getCurrentHub = Tracing._getCurrentHub;
+    if (!_getCurrentHub) {
+      return;
+    }
+
+    const hub = _getCurrentHub();
+    if (!hub) {
+      return;
+    }
+
+    const trace = hub.startSpan({});
+    hub.configureScope((scope: Scope) => {
+      scope.setSpan(trace);
+    });
+  }
+
   /**
    * Starts a Transaction waiting for activity idle to finish
    */
@@ -430,15 +453,8 @@ export class Tracing implements Integration {
 
     Tracing._activeTransaction = hub.startSpan({
       ...spanContext,
-      transaction: name,
-    });
-
-    // We set the transaction on the scope so if there are any other spans started outside of this integration
-    // we also add them to this transaction.
-    // Once the idle transaction is finished, we make sure to remove it again.
-    hub.configureScope((scope: Scope) => {
-      scope.setSpan(Tracing._activeTransaction);
-    });
+      name,
+    }) as Transaction;
 
     // The reason we do this here is because of cached responses
     // If we start and transaction without an activity it would never finish since there is no activity
@@ -454,11 +470,11 @@ export class Tracing implements Integration {
    * Finshes the current active transaction
    */
   public static finishIdleTransaction(): void {
-    const active = Tracing._activeTransaction as SpanClass;
+    const active = Tracing._activeTransaction;
     if (active) {
       Tracing._addPerformanceEntries(active);
-      Tracing._log('[Tracing] finishIdleTransaction', active.transaction);
-      active.finish(/*trimEnd*/ true);
+      Tracing._log('[Tracing] finishIdleTransaction', active.name);
+      active.finish(undefined, /*trimEnd*/ true);
       Tracing._resetActiveTransaction();
     }
   }
@@ -487,7 +503,7 @@ export class Tracing implements Integration {
         op: 'browser',
       });
       span.startTimestamp = timeOrigin + Tracing._msToSec(entry[`${event}Start`]);
-      span.timestamp = timeOrigin + Tracing._msToSec(entry[`${event}End`]);
+      span.endTimestamp = timeOrigin + Tracing._msToSec(entry[`${event}End`]);
     }
 
     // tslint:disable-next-line: completed-docs
@@ -497,14 +513,14 @@ export class Tracing implements Integration {
         op: 'browser',
       });
       request.startTimestamp = timeOrigin + Tracing._msToSec(entry.requestStart);
-      request.timestamp = timeOrigin + Tracing._msToSec(entry.responseEnd);
+      request.endTimestamp = timeOrigin + Tracing._msToSec(entry.responseEnd);
 
       const response = parent.child({
         description: 'response',
         op: 'browser',
       });
       response.startTimestamp = timeOrigin + Tracing._msToSec(entry.responseStart);
-      response.timestamp = timeOrigin + Tracing._msToSec(entry.responseEnd);
+      response.endTimestamp = timeOrigin + Tracing._msToSec(entry.responseEnd);
     }
 
     let entryScriptSrc: string | undefined;
@@ -554,7 +570,7 @@ export class Tracing implements Integration {
               op: entry.entryType,
             });
             mark.startTimestamp = timeOrigin + startTime;
-            mark.timestamp = mark.startTimestamp + duration;
+            mark.endTimestamp = mark.startTimestamp + duration;
             if (tracingInitMarkStartTime === undefined && entry.name === 'sentry-tracing-init') {
               tracingInitMarkStartTime = mark.startTimestamp;
             }
@@ -567,7 +583,7 @@ export class Tracing implements Integration {
                 transactionSpan.spanRecorder.spans.map((finishedSpan: SpanClass) => {
                   if (finishedSpan.description && finishedSpan.description.indexOf(resourceName) !== -1) {
                     finishedSpan.startTimestamp = timeOrigin + startTime;
-                    finishedSpan.timestamp = finishedSpan.startTimestamp + duration;
+                    finishedSpan.endTimestamp = finishedSpan.startTimestamp + duration;
                   }
                 });
               }
@@ -577,10 +593,10 @@ export class Tracing implements Integration {
                 op: `resource`,
               });
               resource.startTimestamp = timeOrigin + startTime;
-              resource.timestamp = resource.startTimestamp + duration;
+              resource.endTimestamp = resource.startTimestamp + duration;
               // We remember the entry script end time to calculate the difference to the first init mark
               if (entryScriptStartEndTime === undefined && (entryScriptSrc || '').includes(resourceName)) {
-                entryScriptStartEndTime = resource.timestamp;
+                entryScriptStartEndTime = resource.endTimestamp;
               }
             }
             break;
@@ -595,7 +611,7 @@ export class Tracing implements Integration {
         op: `script`,
       });
       evaluation.startTimestamp = entryScriptStartEndTime;
-      evaluation.timestamp = tracingInitMarkStartTime;
+      evaluation.endTimestamp = tracingInitMarkStartTime;
     }
 
     Tracing._performanceCursor = Math.max(performance.getEntries().length - 1, 0);
@@ -727,7 +743,7 @@ export class Tracing implements Integration {
             }
           });
         }
-        if (Tracing.options.debug && Tracing.options.debug.spanDebugTimingInfo) {
+        if (Tracing.options && Tracing.options.debug && Tracing.options.debug.spanDebugTimingInfo) {
           Tracing._addSpanDebugInfo(span);
         }
         span.finish();