add compatibility & tests

Author: mydea

packages/cloudflare/src/client.ts

@@ -36,6 +36,19 @@ interface BaseCloudflareOptions {
    * @default true
    */
   enableDedupe?: boolean;
+
+  /**
+   * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
+   * via a custom trace provider.
+   * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
+   * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
+   * This should be good enough for many, but not all integrations.
+   *
+   * If you want to opt-out of setting up the OpenTelemetry compatibility tracer, set this to `true`.
+   *
+   * @default false
+   */
+  skipOpenTelemetrySetup?: boolean;
 }
 
 /**

packages/cloudflare/src/opentelemetry/tracer.ts

@@ -26,7 +26,14 @@ class SentryCloudflareTraceProvider implements TracerProvider {
 
 class SentryCloudflareTracer implements Tracer {
   public startSpan(name: string, options?: SpanOptions): Span {
-    return startInactiveSpan({ name, ...options });
+    return startInactiveSpan({
+      name,
+      ...options,
+      attributes: {
+        ...options?.attributes,
+        'sentry.cloudflare_tracer': true,
+      },
+    });
   }
 
   /**
@@ -46,11 +53,15 @@ class SentryCloudflareTracer implements Tracer {
     context?: unknown,
     fn?: F,
   ): ReturnType<F> {
-    const opts = typeof options === 'object' && options !== null ? options : {};
+    const opts = (typeof options === 'object' && options !== null ? options : {}) as SpanOptions;
 
     const spanOpts = {
       name,
       ...opts,
+      attributes: {
+        ...opts.attributes,
+        'sentry.cloudflare_tracer': true,
+      },
     };
 
     const callback = (

packages/cloudflare/src/sdk.ts

@@ -51,7 +51,16 @@ export function init(options: CloudflareOptions): CloudflareClient | undefined {
     transport: options.transport || makeCloudflareTransport,
   };
 
-  setupOpenTelemetryTracer();
+  /**
+   * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
+   * via a custom trace provider.
+   * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
+   * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
+   * This should be good enough for many, but not all integrations.
+   */
+  if (!options.skipOpenTelemetrySetup) {
+    setupOpenTelemetryTracer();
+  }
 
   return initAndBind(CloudflareClient, clientOptions) as CloudflareClient;
 }

packages/cloudflare/test/opentelemetry.test.ts

@@ -0,0 +1,145 @@
+import { trace } from '@opentelemetry/api';
+import type { TransactionEvent } from '@sentry/core';
+import { startSpan } from '@sentry/core';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { init } from '../src/sdk';
+import { resetSdk } from './testUtils';
+
+describe('opentelemetry compatibility', () => {
+  beforeEach(() => {
+    resetSdk();
+  });
+
+  test('should not capture spans emitted via @opentelemetry/api when skipOpenTelemetrySetup is true', async () => {
+    const transactionEvents: TransactionEvent[] = [];
+
+    const client = init({
+      dsn: 'https://username@domain/123',
+      tracesSampleRate: 1,
+      skipOpenTelemetrySetup: true,
+      beforeSendTransaction: event => {
+        transactionEvents.push(event);
+        return null;
+      },
+    });
+
+    const tracer = trace.getTracer('test');
+    const span = tracer.startSpan('test');
+    span.end();
+
+    await client!.flush();
+
+    tracer.startActiveSpan('test 2', { attributes: { 'test.attribute': 'test' } }, span2 => {
+      const span = tracer.startSpan('test 3', { attributes: { 'test.attribute': 'test2' } });
+      span.end();
+      span2.end();
+    });
+
+    await client!.flush();
+
+    expect(transactionEvents).toHaveLength(0);
+  });
+
+  test('should capture spans emitted via @opentelemetry/api', async () => {
+    const transactionEvents: TransactionEvent[] = [];
+
+    const client = init({
+      dsn: 'https://username@domain/123',
+      tracesSampleRate: 1,
+      beforeSendTransaction: event => {
+        transactionEvents.push(event);
+        return null;
+      },
+    });
+
+    const tracer = trace.getTracer('test');
+    const span = tracer.startSpan('test');
+    span.end();
+
+    await client!.flush();
+
+    tracer.startActiveSpan('test 2', { attributes: { 'test.attribute': 'test' } }, span2 => {
+      const span = tracer.startSpan('test 3', { attributes: { 'test.attribute': 'test2' } });
+      span.end();
+      span2.end();
+    });
+
+    await client!.flush();
+
+    expect(transactionEvents).toHaveLength(2);
+    const [transactionEvent, transactionEvent2] = transactionEvents;
+
+    expect(transactionEvent?.spans?.length).toBe(0);
+    expect(transactionEvent?.transaction).toBe('test');
+    expect(transactionEvent?.contexts?.trace?.data).toEqual({
+      'sentry.cloudflare_tracer': true,
+      'sentry.origin': 'manual',
+      'sentry.sample_rate': 1,
+      'sentry.source': 'custom',
+    });
+
+    expect(transactionEvent2?.spans?.length).toBe(1);
+    expect(transactionEvent2?.transaction).toBe('test 2');
+    expect(transactionEvent2?.contexts?.trace?.data).toEqual({
+      'sentry.cloudflare_tracer': true,
+      'sentry.origin': 'manual',
+      'sentry.sample_rate': 1,
+      'sentry.source': 'custom',
+      'test.attribute': 'test',
+    });
+
+    expect(transactionEvent2?.spans).toEqual([
+      expect.objectContaining({
+        description: 'test 3',
+        data: {
+          'sentry.cloudflare_tracer': true,
+          'sentry.origin': 'manual',
+          'test.attribute': 'test2',
+        },
+      }),
+    ]);
+  });
+
+  test('opentelemetry spans should interop with Sentry spans', async () => {
+    const transactionEvents: TransactionEvent[] = [];
+
+    const client = init({
+      dsn: 'https://username@domain/123',
+      tracesSampleRate: 1,
+      beforeSendTransaction: event => {
+        transactionEvents.push(event);
+        return null;
+      },
+    });
+
+    const tracer = trace.getTracer('test');
+
+    startSpan({ name: 'sentry span' }, () => {
+      const span = tracer.startSpan('otel span');
+      span.end();
+    });
+
+    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',
+        data: {
+          'sentry.cloudflare_tracer': true,
+          'sentry.origin': 'manual',
+        },
+      }),
+    ]);
+  });
+});

packages/cloudflare/test/sdk.test.ts

@@ -1,9 +1,14 @@
 import * as SentryCore from '@sentry/core';
-import { describe, expect, test, vi } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { CloudflareClient } from '../src/client';
 import { init } from '../src/sdk';
+import { resetSdk } from './testUtils';
 
 describe('init', () => {
+  beforeEach(() => {
+    resetSdk();
+  });
+
   test('should call initAndBind with the correct options', () => {
     const initAndBindSpy = vi.spyOn(SentryCore, 'initAndBind');
     const client = init({});

packages/cloudflare/test/testUtils.ts

@@ -0,0 +1,21 @@
+import { context, propagation, trace } from '@opentelemetry/api';
+import { getCurrentScope, getGlobalScope, getIsolationScope } from '@sentry/core';
+
+function resetGlobals(): void {
+  getCurrentScope().clear();
+  getCurrentScope().setClient(undefined);
+  getIsolationScope().clear();
+  getGlobalScope().clear();
+}
+
+function cleanupOtel(): void {
+  // Disable all globally registered APIs
+  trace.disable();
+  context.disable();
+  propagation.disable();
+}
+
+export function resetSdk(): void {
+  resetGlobals();
+  cleanupOtel();
+}