Bring APM implementation up to date with python

kamilogorek · kamilogorek · commit 3601e3d4c339 · 2019-11-01T11:27:53.000+01:00
diff --git a/packages/hub/src/hub.ts b/packages/hub/src/hub.ts
@@ -35,6 +35,14 @@ declare module 'domain' {
   }
 }
 
+/**
+ * Checks whether given value is instance of Span
+ * @param span value to check
+ */
+function isSpanInstance(span: unknown): span is Span {
+  return span instanceof Span;
+}
+
 /**
  * API compatibility version of this hub.
  *
@@ -382,9 +390,9 @@ export class Hub implements HubInterface {
    * @inheritDoc
    */
   public traceHeaders(): { [key: string]: string } {
-    const top = this.getStackTop();
-    if (top.scope && top.client) {
-      const span = top.scope.getSpan();
+    const scope = this.getScope();
+    if (scope) {
+      const span = scope.getSpan();
       if (span) {
         return {
           'sentry-trace': span.toTraceparent(),
@@ -397,18 +405,36 @@ export class Hub implements HubInterface {
   /**
    * @inheritDoc
    */
-  public startSpan(spanContext?: SpanContext): Span {
-    const top = this.getStackTop();
+  public startSpan(spanOrSpanContext?: Span | SpanContext): Span {
+    const scope = this.getScope();
+    const client = this.getClient();
+    let span;
+
+    if (!isSpanInstance(spanOrSpanContext)) {
+      if (scope) {
+        const parentSpan = scope.getSpan();
+        if (parentSpan) {
+          span = parentSpan.child(spanOrSpanContext);
+        }
+      }
+    }
 
-    if (top.scope) {
-      const span = top.scope.getSpan();
+    if (!isSpanInstance(span)) {
+      span = new Span(spanOrSpanContext, this);
+    }
 
-      if (span) {
-        return span.child(spanContext);
-      }
+    if (span.sampled === undefined && span.transaction !== undefined) {
+      const sampleRate = (client && client.getOptions().tracesSampleRate) || 0;
+      span.sampled = Math.random() < sampleRate;
+    }
+
+    if (span.sampled) {
+      const experimentsOptions = (client && client.getOptions()._experiments) || {};
+      const maxSpans = experimentsOptions.maxSpans || 1000;
+      span.initFinishedSpans(maxSpans);
     }
 
-    return new Span(spanContext);
+    return span;
   }
 }
 
diff --git a/packages/hub/src/span.ts b/packages/hub/src/span.ts
@@ -1,9 +1,51 @@
+// tslint:disable:max-classes-per-file
+
 import { Span as SpanInterface, SpanContext } from '@sentry/types';
-import { timestampWithMs, uuid4 } from '@sentry/utils';
+import { logger, timestampWithMs, uuid4 } from '@sentry/utils';
 
 import { getCurrentHub, Hub } from './hub';
 
-export const TRACEPARENT_REGEXP = /^[ \t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \t]*$/;
+export const TRACEPARENT_REGEXP = new RegExp(
+  '^[ \\t]*' + // whitespace
+  '([0-9a-f]{32})?' + // trace_id
+  '-?([0-9a-f]{16})?' + // span_id
+  '-?([01])?' + // sampled
+    '[ \\t]*$', // whitespace
+);
+
+/**
+ * Keeps track of finished spans for a given transaction
+ */
+class SpanRecorder {
+  private readonly _maxlen: number;
+  private _openSpanCount: number = 0;
+  public finishedSpans: Span[] = [];
+
+  public constructor(maxlen: number) {
+    this._maxlen = maxlen;
+  }
+
+  /**
+   * This is just so that we don't run out of memory while recording a lot
+   * of spans. At some point we just stop and flush out the start of the
+   * trace tree (i.e.the first n spans with the smallest
+   * start_timestamp).
+   */
+  public startSpan(span: Span): void {
+    this._openSpanCount += 1;
+    if (this._openSpanCount > this._maxlen) {
+      span.spanRecorder = undefined;
+    }
+  }
+
+  /**
+   * Appends a span to finished spans table
+   * @param span Span to be added
+   */
+  public finishSpan(span: Span): void {
+    this.finishedSpans.push(span);
+  }
+}
 
 /**
  * Span contains all data about a span
@@ -32,7 +74,7 @@ export class Span implements SpanInterface, SpanContext {
   /**
    * @inheritDoc
    */
-  public readonly sampled?: boolean;
+  public sampled?: boolean;
 
   /**
    * Timestamp when the span was created.
@@ -72,7 +114,7 @@ export class Span implements SpanInterface, SpanContext {
   /**
    * List of spans that were finalized
    */
-  public finishedSpans: Span[] = [];
+  public spanRecorder?: SpanRecorder;
 
   public constructor(spanContext?: SpanContext, hub?: Hub) {
     if (hub instanceof Hub) {
@@ -112,6 +154,17 @@ export class Span implements SpanInterface, SpanContext {
     }
   }
 
+  /**
+   * Attaches SpanRecorder to the span itself
+   * @param maxlen maximum number of spans that can be recorded
+   */
+  public initFinishedSpans(maxlen: number): void {
+    if (!this.spanRecorder) {
+      this.spanRecorder = new SpanRecorder(maxlen);
+    }
+    this.spanRecorder.startSpan(this);
+  }
+
   /**
    * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.
    * Also the `sampled` decision will be inherited.
@@ -124,7 +177,7 @@ export class Span implements SpanInterface, SpanContext {
       traceId: this._traceId,
     });
 
-    span.finishedSpans = this.finishedSpans;
+    span.spanRecorder = this.spanRecorder;
 
     return span;
   }
@@ -208,26 +261,41 @@ export class Span implements SpanInterface, SpanContext {
    * Sets the finish timestamp on the current span
    */
   public finish(): string | undefined {
-    // Don't allow for finishing more than once
-    if (typeof this.timestamp === 'number') {
+    // This transaction is already finished, so we should not flush it again.
+    if (this.timestamp !== undefined) {
       return undefined;
     }
 
     this.timestamp = timestampWithMs();
-    this.finishedSpans.push(this);
 
-    // Don't send non-transaction spans
-    if (typeof this.transaction !== 'string') {
+    if (this.spanRecorder === undefined) {
+      return undefined;
+    }
+
+    this.spanRecorder.finishSpan(this);
+
+    if (this.transaction === undefined) {
+      // If this has no transaction set we assume there's a parent
+      // transaction for this span that would be flushed out eventually.
+      return undefined;
+    }
+
+    if (this.sampled === undefined) {
+      // At this point a `sampled === undefined` should have already been
+      // resolved to a concrete decision. If `sampled` is `undefined`, it's
+      // likely that somebody used `Sentry.startSpan(...)` on a
+      // non-transaction span and later decided to make it a transaction.
+      logger.warn('Discarding transaction Span without sampling decision');
       return undefined;
     }
 
-    // TODO: if sampled do what?
-    const finishedSpans = this.finishedSpans.filter(s => s !== this);
-    this.finishedSpans = [];
+    const finishedSpans = !this.spanRecorder ? [] : this.spanRecorder.finishedSpans.filter(s => s !== this);
 
     return this._hub.captureEvent({
+      // TODO: Is this necessary? We already do store contextx in in applyToEvent,
+      // so maybe we can move `getTraceContext` call there as well?
       contexts: { trace: this.getTraceContext() },
-      spans: finishedSpans.length > 0 ? finishedSpans : undefined,
+      spans: finishedSpans,
       start_timestamp: this.startTimestamp,
       timestamp: this.timestamp,
       transaction: this.transaction,
diff --git a/packages/types/src/hub.ts b/packages/types/src/hub.ts
@@ -173,14 +173,11 @@ export interface Hub {
   traceHeaders(): { [key: string]: string };
 
   /**
-   * This functions starts a span. If just a `SpanContext` is passed and there is already a Span
-   * on the Scope, the created Span will have a reference to the one on the Scope.
-   * If a Span is on the current Scope it is considered a `transaction`.
-   * When using the second parameter it will set the created Span on the Scope (replacing whats there).
-   * This can be used as a shortcut to not set it manually on the Scope.
+   * This functions starts a span. If argument passed is of type `Span`, it'll run sampling on it if configured
+   * and attach a `SpanRecorder`. If it's of type `SpanContext` and there is already a `Span` on the Scope,
+   * the created Span will have a reference to it and become it's child. Otherwise it'll crete a new `Span`.
    *
-   * @param spanContext Properties with which the span should be created
-   * @param bindOnScope Determines if the started span will be set on the Scope
+   * @param span Already constructed span which should be started or properties with which the span should be created
    */
-  startSpan(spanContext?: SpanContext, bindOnScope?: boolean): Span;
+  startSpan(span?: Span | SpanContext): Span;
 }
diff --git a/packages/types/src/options.ts b/packages/types/src/options.ts
@@ -78,6 +78,9 @@ export interface Options {
   /** A global sample rate to apply to all events (0 - 1). */
   sampleRate?: number;
 
+  /** A global sample rate to apply to all transactions (0 - 1). */
+  tracesSampleRate?: number;
+
   /** Attaches stacktraces to pure capture message / log integrations */
   attachStacktrace?: boolean;
 
@@ -110,4 +113,8 @@ export interface Options {
    * @returns The breadcrumb that will be added | null.
    */
   beforeBreadcrumb?(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): Breadcrumb | null;
+
+  _experiments?: {
+    [key: string]: any;
+  };
 }
