test(node): Ensure outgoing http & fetch are tested in esm & cjs

dev-packages/node-integration-tests/.eslintrc.js

@@ -18,6 +18,9 @@ module.exports = {
         sourceType: 'module',
         ecmaVersion: 'latest',
       },
+      globals: {
+        fetch: 'readonly',
+      },
       rules: {
         '@typescript-eslint/typedef': 'off',
         // Explicitly allow ts-ignore with description for Node integration tests

dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/instrument.mjs

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+  tracesSampleRate: 0.0,
+  // Ensure this gets a correct hint
+  beforeBreadcrumb(breadcrumb, hint) {
+    breadcrumb.data = breadcrumb.data || {};
+    const req = hint?.request;
+    breadcrumb.data.ADDED_PATH = req?.path;
+    return breadcrumb;
+  },
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts → dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/scenario.mjs

@@ -1,16 +1,8 @@
 import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
-Sentry.init({
-  dsn: 'https://[email protected]/1337',
-  release: '1.0',
-  tracePropagationTargets: [/\/v0/, 'v1'],
-  tracesSampleRate: 1.0,
-  integrations: [],
-  transport: loggingTransport,
-});
+async function run() {
+  Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
 
-async function run(): Promise<void> {
   await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
   await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
   await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
@@ -19,5 +11,4 @@ async function run(): Promise<void> {
   Sentry.captureException(new Error('foo'));
 }
 
-// eslint-disable-next-line @typescript-eslint/no-floating-promises
 run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/test.ts

@@ -1,78 +1,80 @@
-import { describe, expect, test } from 'vitest';
-import { createRunner } from '../../../../utils/runner';
+import { describe, expect } from 'vitest';
+import { createEsmAndCjsTests } from '../../../../utils/runner';
 import { createTestServer } from '../../../../utils/server';
 
 describe('outgoing fetch', () => {
-  test('outgoing fetch requests create breadcrumbs', async () => {
-    const [SERVER_URL, closeTestServer] = await createTestServer().start();
+  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('outgoing fetch requests create breadcrumbs xxx', async () => {
+      const [SERVER_URL, closeTestServer] = await createTestServer().start();
 
-    await createRunner(__dirname, 'scenario.ts')
-      .withEnv({ SERVER_URL })
-      .ensureNoErrorOutput()
-      .expect({
-        event: {
-          breadcrumbs: [
-            {
-              message: 'manual breadcrumb',
-              timestamp: expect.any(Number),
-            },
-            {
-              category: 'http',
-              data: {
-                'http.method': 'GET',
-                url: `${SERVER_URL}/api/v0`,
-                status_code: 404,
-                ADDED_PATH: '/api/v0',
+      await createRunner()
+        .withEnv({ SERVER_URL })
+        .expect({
+          event: {
+            breadcrumbs: [
+              {
+                message: 'manual breadcrumb',
+                timestamp: expect.any(Number),
               },
-              timestamp: expect.any(Number),
-              type: 'http',
-            },
-            {
-              category: 'http',
-              data: {
-                'http.method': 'GET',
-                url: `${SERVER_URL}/api/v1`,
-                status_code: 404,
-                ADDED_PATH: '/api/v1',
+              {
+                category: 'http',
+                data: {
+                  'http.method': 'GET',
+                  url: `${SERVER_URL}/api/v0`,
+                  status_code: 404,
+                  ADDED_PATH: '/api/v0',
+                },
+                timestamp: expect.any(Number),
+                type: 'http',
               },
-              timestamp: expect.any(Number),
-              type: 'http',
-            },
-            {
-              category: 'http',
-              data: {
-                'http.method': 'GET',
-                url: `${SERVER_URL}/api/v2`,
-                status_code: 404,
-                ADDED_PATH: '/api/v2',
+              {
+                category: 'http',
+                data: {
+                  'http.method': 'GET',
+                  url: `${SERVER_URL}/api/v1`,
+                  status_code: 404,
+                  ADDED_PATH: '/api/v1',
+                },
+                timestamp: expect.any(Number),
+                type: 'http',
               },
-              timestamp: expect.any(Number),
-              type: 'http',
-            },
-            {
-              category: 'http',
-              data: {
-                'http.method': 'GET',
-                url: `${SERVER_URL}/api/v3`,
-                status_code: 404,
-                ADDED_PATH: '/api/v3',
+              {
+                category: 'http',
+                data: {
+                  'http.method': 'GET',
+                  url: `${SERVER_URL}/api/v2`,
+                  status_code: 404,
+                  ADDED_PATH: '/api/v2',
+                },
+                timestamp: expect.any(Number),
+                type: 'http',
               },
-              timestamp: expect.any(Number),
-              type: 'http',
-            },
-          ],
-          exception: {
-            values: [
               {
-                type: 'Error',
-                value: 'foo',
+                category: 'http',
+                data: {
+                  'http.method': 'GET',
+                  url: `${SERVER_URL}/api/v3`,
+                  status_code: 404,
+                  ADDED_PATH: '/api/v3',
+                },
+                timestamp: expect.any(Number),
+                type: 'http',
               },
             ],
+            exception: {
+              values: [
+                {
+                  type: 'Error',
+                  value: 'foo',
+                },
+              ],
+            },
           },
-        },
-      })
-      .start()
-      .completed();
-    closeTestServer();
+        })
+        .start()
+        .completed();
+
+      closeTestServer();
+    });
   });
 });

dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/instrument.mjs

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [Sentry.nativeNodeFetchIntegration({ spans: false })],
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/scenario.mjs

@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+
+async function run() {
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/test.ts

@@ -1,49 +1,50 @@
-import { describe, expect, test } from 'vitest';
-import { createRunner } from '../../../../utils/runner';
+import { describe, expect } from 'vitest';
+import { createEsmAndCjsTests } from '../../../../utils/runner';
 import { createTestServer } from '../../../../utils/server';
 
 describe('outgoing fetch', () => {
-  test('outgoing fetch requests are correctly instrumented with tracing & spans are disabled', async () => {
-    expect.assertions(11);
+  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('outgoing fetch requests are correctly instrumented with tracing & spans are disabled', async () => {
+      expect.assertions(11);
 
-    const [SERVER_URL, closeTestServer] = await createTestServer()
-      .get('/api/v0', headers => {
-        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
-        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
-        expect(headers['baggage']).toEqual(expect.any(String));
-      })
-      .get('/api/v1', headers => {
-        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
-        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
-        expect(headers['baggage']).toEqual(expect.any(String));
-      })
-      .get('/api/v2', headers => {
-        expect(headers['baggage']).toBeUndefined();
-        expect(headers['sentry-trace']).toBeUndefined();
-      })
-      .get('/api/v3', headers => {
-        expect(headers['baggage']).toBeUndefined();
-        expect(headers['sentry-trace']).toBeUndefined();
-      })
-      .start();
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/api/v0', headers => {
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+          expect(headers['baggage']).toEqual(expect.any(String));
+        })
+        .get('/api/v1', headers => {
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+          expect(headers['baggage']).toEqual(expect.any(String));
+        })
+        .get('/api/v2', headers => {
+          expect(headers['baggage']).toBeUndefined();
+          expect(headers['sentry-trace']).toBeUndefined();
+        })
+        .get('/api/v3', headers => {
+          expect(headers['baggage']).toBeUndefined();
+          expect(headers['sentry-trace']).toBeUndefined();
+        })
+        .start();
 
-    await createRunner(__dirname, 'scenario.ts')
-      .withEnv({ SERVER_URL })
-      .ensureNoErrorOutput()
-      .expect({
-        event: {
-          exception: {
-            values: [
-              {
-                type: 'Error',
-                value: 'foo',
-              },
-            ],
+      await createRunner()
+        .withEnv({ SERVER_URL })
+        .expect({
+          event: {
+            exception: {
+              values: [
+                {
+                  type: 'Error',
+                  value: 'foo',
+                },
+              ],
+            },
           },
-        },
-      })
-      .start()
-      .completed();
-    closeTestServer;
+        })
+        .start()
+        .completed();
+      closeTestServer;
+    });
   });
 });

dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/instrument.mjs

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/scenario.mjs

@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+
+async function run() {
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+run();