ref: Introduce Sentry.getSpan

HazAT · HazAT · commit a116d0f9f58d · 2020-06-15T11:53:05.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,7 @@
 - [core] feat: Export `makeMain` (#2665)
 - [core] fix: Call `bindClient` when creating new `Hub` to make integrations work automatically (#2665)
 - [gatsby] feat: Add @sentry/gatsby package (#2652)
+- [apm] feat: Add `Sentry.getSpan` to return the Span on the Scope (#2668)
 
 ## 5.17.0
 
diff --git a/packages/apm/src/hubextensions.ts b/packages/apm/src/hubextensions.ts
@@ -20,12 +20,12 @@ function traceHeaders(this: Hub): { [key: string]: string } {
 }
 
 /**
- * {@see Hub.getTransaction}
+ * {@see Hub.getSpan}
  */
-function getTransaction(this: Hub, callback: (transaction: Transaction) => void): void {
+function getSpan(this: Hub, callback: (span: Span) => void): void {
   const scope = this.getScope();
   if (scope) {
-    const span = scope.getSpan() as Transaction;
+    const span = scope.getSpan();
     if (span) {
       callback(span);
     }
@@ -109,8 +109,8 @@ export function addExtensionMethods(): void {
     if (!carrier.__SENTRY__.extensions.startSpan) {
       carrier.__SENTRY__.extensions.startSpan = startSpan;
     }
-    if (!carrier.__SENTRY__.extensions.getTransaction) {
-      carrier.__SENTRY__.extensions.getTransaction = getTransaction;
+    if (!carrier.__SENTRY__.extensions.getSpan) {
+      carrier.__SENTRY__.extensions.getSpan = getSpan;
     }
     if (!carrier.__SENTRY__.extensions.traceHeaders) {
       carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
diff --git a/packages/apm/src/span.ts b/packages/apm/src/span.ts
@@ -1,5 +1,5 @@
-import { Span as SpanInterface, SpanContext } from '@sentry/types';
-import { dropUndefinedKeys, timestampWithMs, uuid4 } from '@sentry/utils';
+import { Span as SpanInterface, SpanContext, Transaction } from '@sentry/types';
+import { dropUndefinedKeys, logger, timestampWithMs, uuid4 } from '@sentry/utils';
 
 import { SpanStatus } from './spanstatus';
 import { SpanRecorder } from './transaction';
@@ -153,6 +153,19 @@ export class Span implements SpanInterface, SpanContext {
     return span;
   }
 
+  /**
+   * @inheritDoc
+   */
+  public getTransaction(): Transaction {
+    const recorder = this.spanRecorder;
+    if (!recorder) {
+      logger.warn('This Span has no reference to a Transaction. Returning an instance to itself.');
+      logger.warn('It means that the Transaction has been sampled or the Span did not originate from a Transaction.');
+      return (this as unknown) as Transaction;
+    }
+    return recorder.spans[0] as Transaction;
+  }
+
   /**
    * Continues a trace from a string (usually the header).
    * @param traceparent Traceparent string
diff --git a/packages/apm/test/hub.test.ts b/packages/apm/test/hub.test.ts
@@ -11,22 +11,22 @@ describe('Hub', () => {
     jest.useRealTimers();
   });
 
-  describe('getTransaction', () => {
+  describe('getSpan', () => {
     test('simple invoke', () => {
       const hub = new Hub(new BrowserClient({ tracesSampleRate: 1 }));
       const transaction = hub.startTransaction({ name: 'foo' });
       hub.configureScope(scope => {
         scope.setSpan(transaction);
       });
-      hub.getTransaction(t => {
+      hub.getSpan(t => {
         expect(t).toBe(transaction);
       });
     });
 
     test('not invoke', () => {
       const hub = new Hub(new BrowserClient({ tracesSampleRate: 1 }));
       const transaction = hub.startTransaction({ name: 'foo' });
-      hub.getTransaction(_ => {
+      hub.getSpan(_ => {
         expect(true).toBe(false);
       });
       transaction.finish();
diff --git a/packages/apm/test/span.test.ts b/packages/apm/test/span.test.ts
@@ -366,6 +366,19 @@ describe('Span', () => {
     });
   });
 
+  test('getTransaction on Span from Transaction', () => {
+    const transaction = hub.startTransaction({ name: 'test' });
+    const childSpan = transaction.startChild();
+    childSpan.finish();
+    transaction.finish();
+    expect(childSpan.getTransaction()).toBe(transaction);
+  });
+
+  test('getTransaction on new Span()', () => {
+    const span = new Span({});
+    expect(span.getTransaction()).toBe(span);
+  });
+
   describe('getTraceContext', () => {
     test('should have status attribute undefined if no status tag is available', () => {
       const span = new Span({});
diff --git a/packages/hub/src/hub.ts b/packages/hub/src/hub.ts
@@ -383,8 +383,8 @@ export class Hub implements HubInterface {
   /**
    * @inheritDoc
    */
-  public getTransaction(callback: (transaction: Transaction) => void): void {
-    this._callExtensionMethod<void>('getTransaction', callback);
+  public getSpan(callback: (span: Span) => void): void {
+    this._callExtensionMethod<void>('getSpan', callback);
   }
 
   /**
diff --git a/packages/minimal/src/index.ts b/packages/minimal/src/index.ts
@@ -1,5 +1,14 @@
 import { getCurrentHub, Hub, Scope } from '@sentry/hub';
-import { Breadcrumb, CaptureContext, Event, Severity, Transaction, TransactionContext, User } from '@sentry/types';
+import {
+  Breadcrumb,
+  CaptureContext,
+  Event,
+  Severity,
+  Span,
+  Transaction,
+  TransactionContext,
+  User,
+} from '@sentry/types';
 
 /**
  * This calls a function on the current hub.
@@ -198,9 +207,9 @@ export function startTransaction(context: TransactionContext): Transaction {
 }
 
 /**
- * Callback to retrieve an ongoing Transaction in case there is one.
- * @param callback Will only be invoked in case there is an active transaction
+ * Callback that receives a Span if there is one on the Scope.
+ * @param callback Will only be invoked in case there is a Span on the Scope
  */
-export function getTransaction(callback: (transaction: Transaction) => void): void {
-  callOnHub<void>('getTransaction', callback);
+export function getSpan(callback: (span: Span) => void): void {
+  callOnHub<void>('getSpan', callback);
 }
diff --git a/packages/types/src/hub.ts b/packages/types/src/hub.ts
@@ -201,8 +201,8 @@ export interface Hub {
   startTransaction(context: TransactionContext): Transaction;
 
   /**
-   * Callback to retrieve an ongoing Transaction in case there is one.
-   * @param callback Will only be invoked in case there is an active transaction
+   * Callback that receives a Span if there is one on the Scope.
+   * @param callback Will only be invoked in case there is a Span on the Scope
    */
-  getTransaction(callback: (transaction: Transaction) => void): void;
+  getSpan(callback: (span: Span) => void): void;
 }
diff --git a/packages/types/src/span.ts b/packages/types/src/span.ts
@@ -1,3 +1,5 @@
+import { Transaction } from './transaction';
+
 /** Interface holding all properties that can be set on a Span on creation. */
 export interface SpanContext {
   /**
@@ -133,6 +135,11 @@ export interface Span extends SpanContext {
     spanContext?: Pick<SpanContext, Exclude<keyof SpanContext, 'spanId' | 'sampled' | 'traceId' | 'parentSpanId'>>,
   ): Span;
 
+  /**
+   * Retruns the reference to the root Span (Transaction).
+   */
+  getTransaction(): Transaction;
+
   /**
    * Determines whether span was successful (HTTP200)
    */
