fix circular dependency & tests

Author: mydea

packages/core/test/lib/utils/spanUtils.test.ts

@@ -234,7 +234,7 @@ describe('getRootSpan', () => {
     expect(getRootSpan(root)).toBe(root);
   });
 
-  it('returns the root span of a child span xxx', () => {
+  it('returns the root span of a child span', () => {
     startSpan({ name: 'outer' }, root => {
       startSpan({ name: 'inner' }, inner => {
         expect(getRootSpan(inner)).toBe(root);

packages/opentelemetry/src/propagator.ts

@@ -29,6 +29,7 @@ import {
 import { DEBUG_BUILD } from './debug-build';
 import { getScopesFromContext, setScopesOnContext } from './utils/contextData';
 import { getDynamicSamplingContextFromSpan } from './utils/dynamicSamplingContext';
+import { getSamplingDecision } from './utils/getSamplingDecision';
 import { setIsSetup } from './utils/setupCheck';
 
 /** Get the Sentry propagation context from a span context. */
@@ -319,44 +320,6 @@ export function continueTraceAsRemoteSpan<T>(
   return context.with(ctxWithSpanContext, callback);
 }
 
-/**
- * OpenTelemetry only knows about SAMPLED or NONE decision,
- * but for us it is important to differentiate between unset and unsampled.
- *
- * Both of these are identified as `traceFlags === TracegFlags.NONE`,
- * but we additionally look at a special trace state to differentiate between them.
- */
-export function getSamplingDecision(spanContext: SpanContext): boolean | undefined {
-  const { traceFlags, traceState } = spanContext;
-
-  const sampledNotRecording = traceState ? traceState.get(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING) === '1' : false;
-
-  // If trace flag is `SAMPLED`, we interpret this as sampled
-  // If it is `NONE`, it could mean either it was sampled to be not recorder, or that it was not sampled at all
-  // For us this is an important difference, sow e look at the SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING
-  // to identify which it is
-  if (traceFlags === TraceFlags.SAMPLED) {
-    return true;
-  }
-
-  if (sampledNotRecording) {
-    return false;
-  }
-
-  // Fall back to DSC as a last resort, that may also contain `sampled`...
-  const dscString = traceState ? traceState.get(SENTRY_TRACE_STATE_DSC) : undefined;
-  const dsc = dscString ? baggageHeaderToDynamicSamplingContext(dscString) : undefined;
-
-  if (dsc?.sampled === 'true') {
-    return true;
-  }
-  if (dsc?.sampled === 'false') {
-    return false;
-  }
-
-  return undefined;
-}
-
 /** Try to get the existing baggage header so we can merge this in. */
 function getExistingBaggage(carrier: unknown): string | undefined {
   try {

packages/opentelemetry/src/sampler.ts

@@ -9,7 +9,8 @@ import { logger } from '@sentry/utils';
 import { SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from './constants';
 
 import { DEBUG_BUILD } from './debug-build';
-import { getPropagationContextFromSpan, getSamplingDecision } from './propagator';
+import { getPropagationContextFromSpan } from './propagator';
+import { getSamplingDecision } from './utils/getSamplingDecision';
 import { setIsSetup } from './utils/setupCheck';
 
 /**

packages/opentelemetry/src/trace.ts

@@ -14,11 +14,12 @@ import {
   spanToJSON,
 } from '@sentry/core';
 import type { Client, Scope } from '@sentry/types';
-import { continueTraceAsRemoteSpan, getSamplingDecision, makeTraceState } from './propagator';
+import { continueTraceAsRemoteSpan, makeTraceState } from './propagator';
 
 import type { OpenTelemetryClient, OpenTelemetrySpanContext } from './types';
 import { getContextFromScope, getScopesFromContext } from './utils/contextData';
 import { getDynamicSamplingContextFromSpan } from './utils/dynamicSamplingContext';
+import { getSamplingDecision } from './utils/getSamplingDecision';
 
 /**
  * Wraps a function with a transaction/span and finishes the span after the function is done.

packages/opentelemetry/src/utils/dynamicSamplingContext.ts

@@ -7,8 +7,8 @@ import {
 import type { DynamicSamplingContext } from '@sentry/types';
 import { baggageHeaderToDynamicSamplingContext } from '@sentry/utils';
 import { SENTRY_TRACE_STATE_DSC } from '../constants';
-import { getSamplingDecision } from '../propagator';
 import type { AbstractSpan } from '../types';
+import { getSamplingDecision } from './getSamplingDecision';
 import { parseSpanDescription } from './parseSpanDescription';
 import { spanHasAttributes, spanHasName } from './spanTypes';
 

packages/opentelemetry/src/utils/getSamplingDecision.ts

@@ -0,0 +1,42 @@
+import type { SpanContext } from '@opentelemetry/api';
+import { TraceFlags } from '@opentelemetry/api';
+import { baggageHeaderToDynamicSamplingContext } from '@sentry/utils';
+import { SENTRY_TRACE_STATE_DSC, SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from '../constants';
+
+/**
+ * OpenTelemetry only knows about SAMPLED or NONE decision,
+ * but for us it is important to differentiate between unset and unsampled.
+ *
+ * Both of these are identified as `traceFlags === TracegFlags.NONE`,
+ * but we additionally look at a special trace state to differentiate between them.
+ */
+export function getSamplingDecision(spanContext: SpanContext): boolean | undefined {
+  const { traceFlags, traceState } = spanContext;
+
+  const sampledNotRecording = traceState ? traceState.get(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING) === '1' : false;
+
+  // If trace flag is `SAMPLED`, we interpret this as sampled
+  // If it is `NONE`, it could mean either it was sampled to be not recorder, or that it was not sampled at all
+  // For us this is an important difference, sow e look at the SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING
+  // to identify which it is
+  if (traceFlags === TraceFlags.SAMPLED) {
+    return true;
+  }
+
+  if (sampledNotRecording) {
+    return false;
+  }
+
+  // Fall back to DSC as a last resort, that may also contain `sampled`...
+  const dscString = traceState ? traceState.get(SENTRY_TRACE_STATE_DSC) : undefined;
+  const dsc = dscString ? baggageHeaderToDynamicSamplingContext(dscString) : undefined;
+
+  if (dsc?.sampled === 'true') {
+    return true;
+  }
+  if (dsc?.sampled === 'false') {
+    return false;
+  }
+
+  return undefined;
+}

packages/opentelemetry/test/propagator.test.ts

@@ -11,8 +11,9 @@ import { suppressTracing } from '@opentelemetry/core';
 import { addTracingExtensions, withScope } from '@sentry/core';
 
 import { SENTRY_BAGGAGE_HEADER, SENTRY_SCOPES_CONTEXT_KEY, SENTRY_TRACE_HEADER } from '../src/constants';
-import { SentryPropagator, getSamplingDecision, makeTraceState } from '../src/propagator';
+import { SentryPropagator, makeTraceState } from '../src/propagator';
 import { getScopesFromContext } from '../src/utils/contextData';
+import { getSamplingDecision } from '../src/utils/getSamplingDecision';
 import { cleanupOtel, mockSdkInit } from './helpers/mockSdkInit';
 
 beforeAll(() => {

packages/opentelemetry/test/trace.test.ts

@@ -18,12 +18,13 @@ import {
   withScope,
 } from '@sentry/core';
 import type { Event, Scope } from '@sentry/types';
-import { getSamplingDecision, makeTraceState } from '../src/propagator';
+import { makeTraceState } from '../src/propagator';
 
 import { continueTrace, startInactiveSpan, startSpan, startSpanManual } from '../src/trace';
 import type { AbstractSpan } from '../src/types';
 import { getDynamicSamplingContextFromSpan } from '../src/utils/dynamicSamplingContext';
 import { getActiveSpan } from '../src/utils/getActiveSpan';
+import { getSamplingDecision } from '../src/utils/getSamplingDecision';
 import { getSpanKind } from '../src/utils/getSpanKind';
 import { spanHasAttributes, spanHasName } from '../src/utils/spanTypes';
 import { cleanupOtel, mockSdkInit } from './helpers/mockSdkInit';
@@ -307,7 +308,7 @@ describe('trace', () => {
       expect(getActiveSpan()).toBe(undefined);
     });
 
-    it('allows to force a transaction with forceTransaction=true xxx', async () => {
+    it('allows to force a transaction with forceTransaction=true', async () => {
       const client = getClient()!;
       const transactionEvents: Event[] = [];