Expand setupOpenTelemetryTracer tests and enhance SentryCloudflareTracer error handling for optional tracer usage.

Author: cod1k

packages/cloudflare/src/opentelemetry/tracer.ts

@@ -1,26 +1,29 @@
-import type { Context, Span, SpanOptions, Tracer, TracerProvider } from '@opentelemetry/api';
-import { ProxyTracerProvider, trace } from '@opentelemetry/api';
+import type { Context, ProxyTracerProvider, Span, SpanOptions, Tracer, TracerProvider } from '@opentelemetry/api';
+import { trace } from '@opentelemetry/api';
 import { startInactiveSpan, startSpanManual } from '@sentry/core';
 
 /**
  * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.
  * This is not perfect but handles easy/common use cases.
  */
 export function setupOpenTelemetryTracer(): void {
-  const current = trace.getTracerProvider();
-  const delegate = current instanceof ProxyTracerProvider ? current.getDelegate() : current;
-  trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider(delegate));
+  const result = trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider());
+  if (result) {
+    return;
+  }
+  const current = trace.getTracerProvider() as ProxyTracerProvider;
+  current.setDelegate(new SentryCloudflareTraceProvider(current.getDelegate()));
 }
 
 class SentryCloudflareTraceProvider implements TracerProvider {
   private readonly _tracers: Map<string, Tracer> = new Map();
 
-  public constructor(private readonly _provider: TracerProvider) {}
+  public constructor(private readonly _provider?: TracerProvider) {}
 
   public getTracer(name: string, version?: string, options?: { schemaUrl?: string }): Tracer {
     const key = `${name}@${version || ''}:${options?.schemaUrl || ''}`;
     if (!this._tracers.has(key)) {
-      const tracer = this._provider.getTracer(key, version, options);
+      const tracer = this._provider?.getTracer?.(key, version, options);
       this._tracers.set(key, new SentryCloudflareTracer(tracer));
     }
 
@@ -30,9 +33,9 @@ class SentryCloudflareTraceProvider implements TracerProvider {
 }
 
 class SentryCloudflareTracer implements Tracer {
-  public constructor(private readonly _tracer: Tracer) {}
+  public constructor(private readonly _tracer?: Tracer) {}
   public startSpan(name: string, options?: SpanOptions): Span {
-    const topSpan = this._tracer.startSpan(name, options);
+    const topSpan = this._tracer?.startSpan?.(name, options);
     const sentrySpan = startInactiveSpan({
       name,
       ...options,
@@ -41,7 +44,18 @@ class SentryCloudflareTracer implements Tracer {
         'sentry.cloudflare_tracer': true,
       },
     });
+    if (!topSpan) {
+      return sentrySpan;
+    }
     return new Proxy(sentrySpan, {
+      set: (target, p, newValue, receiver) => {
+        try {
+          Reflect.set(topSpan, p, newValue, receiver);
+        } catch {
+          //
+        }
+        return Reflect.set(target, p, newValue);
+      },
       get: (target, p) => {
         const propertyValue = Reflect.get(target, p);
         if (typeof propertyValue !== 'function') {
@@ -55,7 +69,7 @@ class SentryCloudflareTracer implements Tracer {
           apply: (target, thisArg, argArray) => {
             try {
               Reflect.apply(proxyTo, topSpan, argArray);
-            } catch (e) {
+            } catch {
               //
             }
             return Reflect.apply(target, thisArg, argArray);

packages/cloudflare/test/opentelemetry.test.ts

@@ -1,7 +1,7 @@
 import { trace } from '@opentelemetry/api';
 import type { TransactionEvent } from '@sentry/core';
 import { startSpan } from '@sentry/core';
-import { beforeEach, describe, expect, test } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { init } from '../src/sdk';
 import { resetSdk } from './testUtils';
 
@@ -132,6 +132,60 @@ describe('opentelemetry compatibility', () => {
       'sentry.source': 'custom',
     });
 
+    expect(transactionEvent?.spans).toEqual([
+      expect.objectContaining({
+        description: 'otel span',
+        data: {
+          'sentry.cloudflare_tracer': true,
+          'sentry.origin': 'manual',
+        },
+      }),
+    ]);
+  });
+  test('Ensure that sentry spans works over other opentelemetry implementations', async () => {
+    const transactionEvents: TransactionEvent[] = [];
+    const end = vi.fn();
+    const _startSpan = vi.fn().mockImplementation(() => ({ end }));
+
+    const getTracer = vi.fn().mockImplementation(() => ({
+      startSpan: _startSpan,
+    }));
+    trace.setGlobalTracerProvider({
+      getTracer,
+    });
+
+    const client = init({
+      dsn: 'https://username@domain/123',
+      tracesSampleRate: 1,
+      beforeSendTransaction: event => {
+        transactionEvents.push(event);
+        return null;
+      },
+    });
+
+    const tracer = trace.getTracer('test');
+
+    expect(getTracer).toBeCalledWith('test@:', undefined, undefined);
+    startSpan({ name: 'sentry span' }, () => {
+      const span = tracer.startSpan('otel span');
+      span.end();
+    });
+    expect(_startSpan).toBeCalledWith('otel span', undefined);
+    expect(end).toBeCalled();
+
+    await client!.flush();
+
+    expect(transactionEvents).toHaveLength(1);
+    const [transactionEvent] = transactionEvents;
+
+    expect(transactionEvent?.spans?.length).toBe(1);
+    expect(transactionEvent?.transaction).toBe('sentry span');
+    expect(transactionEvent?.contexts?.trace?.data).toEqual({
+      'sentry.origin': 'manual',
+      'sentry.sample_rate': 1,
+      'sentry.source': 'custom',
+    });
+
     expect(transactionEvent?.spans).toEqual([
       expect.objectContaining({
         description: 'otel span',