support server in scenario and making requests to it

timfish · timfish · commit 120cc5b92e0e · 2024-01-09T16:42:09.000+01:00
diff --git a/dev-packages/node-integration-tests/src/index.ts b/dev-packages/node-integration-tests/src/index.ts
@@ -1,4 +1,6 @@
+import type { AddressInfo } from 'net';
 import type { BaseTransportOptions, Envelope, Transport, TransportMakeRequestResponse } from '@sentry/types';
+import type { Express } from 'express';
 
 /**
  * Debug logging transport
@@ -15,3 +17,15 @@ export function loggingTransport(_options: BaseTransportOptions): Transport {
     },
   };
 }
+
+/**
+ * Starts an express server and sends the port to the runner
+ */
+export function startExpressServerAndSendPortToRunner(app: Express): void {
+  const server = app.listen(0, () => {
+    const address = server.address() as AddressInfo;
+
+    // eslint-disable-next-line no-console
+    console.log(`{"port":${address.port}}`);
+  });
+}
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/server.ts b/dev-packages/node-integration-tests/suites/express/tracing/server.ts
@@ -1,3 +1,4 @@
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
 import * as Sentry from '@sentry/node';
 import cors from 'cors';
 import express from 'express';
@@ -11,6 +12,7 @@ Sentry.init({
   tracePropagationTargets: [/^(?!.*test).*$/],
   integrations: [new Sentry.Integrations.Http({ tracing: true }), new Sentry.Integrations.Express({ app })],
   tracesSampleRate: 1.0,
+  transport: loggingTransport,
 });
 
 app.use(Sentry.Handlers.requestHandler());
@@ -36,4 +38,4 @@ app.get(['/test/arr/:id', /\/test\/arr[0-9]*\/required(path)?(\/optionalPath)?\/
 
 app.use(Sentry.Handlers.errorHandler());
 
-export default app;
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/test.ts b/dev-packages/node-integration-tests/suites/express/tracing/test.ts
@@ -1,89 +1,101 @@
-import { TestEnv, assertSentryTransaction } from '../../../utils/index';
+import { assertSentryTransaction, createRunner } from '../../../utils/runner';
 
-test('should create and send transactions for Express routes and spans for middlewares.', async () => {
-  const env = await TestEnv.init(__dirname, `${__dirname}/server.ts`);
-  const envelope = await env.getEnvelopeRequest({ url: `${env.url}/express`, envelopeType: 'transaction' });
-
-  expect(envelope).toHaveLength(3);
-
-  assertSentryTransaction(envelope[2], {
-    contexts: {
-      trace: {
-        data: {
-          url: '/test/express',
-          'http.response.status_code': 200,
-        },
-        op: 'http.server',
-        status: 'ok',
-        tags: {
-          'http.status_code': '200',
-        },
-      },
-    },
-    spans: [
-      {
-        description: 'corsMiddleware',
-        op: 'middleware.express.use',
+test('should create and send transactions for Express routes and spans for middlewares.', done => {
+  createRunner(__dirname, 'server.ts')
+    .expect({
+      transaction: transaction => {
+        assertSentryTransaction(transaction, {
+          contexts: {
+            trace: {
+              span_id: expect.any(String),
+              trace_id: expect.any(String),
+              data: {
+                url: '/test/express',
+                'http.response.status_code': 200,
+              },
+              op: 'http.server',
+              status: 'ok',
+              tags: {
+                'http.status_code': '200',
+              },
+            },
+          },
+          spans: [
+            expect.objectContaining({
+              description: 'corsMiddleware',
+              op: 'middleware.express.use',
+            }),
+          ],
+        });
       },
-    ],
-  });
+    })
+    .start(done)
+    .makeRequest('get', '/test/express');
 });
 
-test('should set a correct transaction name for routes specified in RegEx', async () => {
-  const env = await TestEnv.init(__dirname, `${__dirname}/server.ts`);
-  const envelope = await env.getEnvelopeRequest({ url: `${env.url}/regex`, envelopeType: 'transaction' });
-
-  expect(envelope).toHaveLength(3);
-
-  assertSentryTransaction(envelope[2], {
-    transaction: 'GET /\\/test\\/regex/',
-    transaction_info: {
-      source: 'route',
-    },
-    contexts: {
-      trace: {
-        data: {
-          url: '/test/regex',
-          'http.response.status_code': 200,
-        },
-        op: 'http.server',
-        status: 'ok',
-        tags: {
-          'http.status_code': '200',
-        },
+test('should set a correct transaction name for routes specified in RegEx', done => {
+  createRunner(__dirname, 'server.ts')
+    .expect({
+      transaction: transaction => {
+        assertSentryTransaction(transaction, {
+          transaction: 'GET /\\/test\\/regex/',
+          transaction_info: {
+            source: 'route',
+          },
+          contexts: {
+            trace: {
+              trace_id: expect.any(String),
+              span_id: expect.any(String),
+              data: {
+                url: '/test/regex',
+                'http.response.status_code': 200,
+              },
+              op: 'http.server',
+              status: 'ok',
+              tags: {
+                'http.status_code': '200',
+              },
+            },
+          },
+        });
       },
-    },
-  });
+    })
+    .start(done)
+    .makeRequest('get', '/test/regex');
 });
 
 test.each([['array1'], ['array5']])(
   'should set a correct transaction name for routes consisting of arrays of routes',
-  async segment => {
-    const env = await TestEnv.init(__dirname, `${__dirname}/server.ts`);
-    const envelope = await env.getEnvelopeRequest({ url: `${env.url}/${segment}`, envelopeType: 'transaction' });
-
-    expect(envelope).toHaveLength(3);
-
-    assertSentryTransaction(envelope[2], {
-      transaction: 'GET /test/array1,/\\/test\\/array[2-9]',
-      transaction_info: {
-        source: 'route',
-      },
-      contexts: {
-        trace: {
-          data: {
-            url: `/test/${segment}`,
-            'http.response.status_code': 200,
-          },
-          op: 'http.server',
-          status: 'ok',
-          tags: {
-            'http.status_code': '200',
-          },
+  ((segment: string, done: () => void) => {
+    createRunner(__dirname, 'server.ts')
+      .expect({
+        transaction: transaction => {
+          assertSentryTransaction(transaction, {
+            transaction: 'GET /test/array1,/\\/test\\/array[2-9]',
+            transaction_info: {
+              source: 'route',
+            },
+            contexts: {
+              trace: {
+                trace_id: expect.any(String),
+                span_id: expect.any(String),
+                data: {
+                  url: `/test/${segment}`,
+                  'http.response.status_code': 200,
+                },
+                op: 'http.server',
+                status: 'ok',
+                tags: {
+                  'http.status_code': '200',
+                },
+              },
+            },
+          });
         },
-      },
-    });
-  },
+      })
+      .start(done)
+      .makeRequest('get', `/test/${segment}`);
+  }) as any,
 );
 
 test.each([
@@ -95,29 +107,33 @@ test.each([
   ['arr55/required/lastParam'],
   ['arr/requiredPath/optionalPath/'],
   ['arr/requiredPath/optionalPath/lastParam'],
-])('should handle more complex regexes in route arrays correctly', async segment => {
-  const env = await TestEnv.init(__dirname, `${__dirname}/server.ts`);
-  const envelope = await env.getEnvelopeRequest({ url: `${env.url}/${segment}`, envelopeType: 'transaction' });
-
-  expect(envelope).toHaveLength(3);
-
-  assertSentryTransaction(envelope[2], {
-    transaction: 'GET /test/arr/:id,/\\/test\\/arr[0-9]*\\/required(path)?(\\/optionalPath)?\\/(lastParam)?',
-    transaction_info: {
-      source: 'route',
-    },
-    contexts: {
-      trace: {
-        data: {
-          url: `/test/${segment}`,
-          'http.response.status_code': 200,
-        },
-        op: 'http.server',
-        status: 'ok',
-        tags: {
-          'http.status_code': '200',
-        },
+])('should handle more complex regexes in route arrays correctly', ((segment: string, done: () => void) => {
+  createRunner(__dirname, 'server.ts')
+    .expect({
+      transaction: transaction => {
+        assertSentryTransaction(transaction, {
+          transaction: 'GET /test/arr/:id,/\\/test\\/arr[0-9]*\\/required(path)?(\\/optionalPath)?\\/(lastParam)?',
+          transaction_info: {
+            source: 'route',
+          },
+          contexts: {
+            trace: {
+              trace_id: expect.any(String),
+              span_id: expect.any(String),
+              data: {
+                url: `/test/${segment}`,
+                'http.response.status_code': 200,
+              },
+              op: 'http.server',
+              status: 'ok',
+              tags: {
+                'http.status_code': '200',
+              },
+            },
+          },
+        });
       },
-    },
-  });
-});
+    })
+    .start(done)
+    .makeRequest('get', `/test/${segment}`);
+}) as any);
diff --git a/dev-packages/node-integration-tests/utils/runner.ts b/dev-packages/node-integration-tests/utils/runner.ts
@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { join } from 'path';
 import type { Envelope, EnvelopeItemType, Event, SerializedSession } from '@sentry/types';
+import axios from 'axios';
 
 export function assertSentryEvent(actual: Event, expected: Event): void {
   expect(actual).toMatchObject({
@@ -16,6 +17,17 @@ export function assertSentrySession(actual: SerializedSession, expected: Partial
   });
 }
 
+export function assertSentryTransaction(actual: Event, expected: Partial<Event>): void {
+  expect(actual).toMatchObject({
+    event_id: expect.any(String),
+    timestamp: expect.anything(),
+    start_timestamp: expect.anything(),
+    spans: expect.any(Array),
+    type: 'transaction',
+    ...expected,
+  });
+}
+
 type Expected =
   | {
       event: (event: Event) => void;
@@ -57,6 +69,7 @@ export function createRunner(...paths: string[]) {
     start: function (done?: (e?: unknown) => void) {
       const expectedEnvelopeCount = expectedEnvelopes.length;
       let envelopeCount = 0;
+      let serverPort: number | undefined;
 
       const child = spawn('node', [...flags, testPath]);
 
@@ -69,6 +82,17 @@ export function createRunner(...paths: string[]) {
         done?.(e);
       });
 
+      async function waitForServerPort(timeout = 10_000): Promise<void> {
+        let remaining = timeout;
+        while (serverPort === undefined) {
+          await new Promise<void>(resolve => setTimeout(resolve, 100));
+          remaining -= 100;
+          if (remaining < 0) {
+            throw new Error('Timed out waiting for server port');
+          }
+        }
+      }
+
       function checkDone(): void {
         envelopeCount++;
         if (envelopeCount === expectedEnvelopeCount) {
@@ -81,6 +105,12 @@ export function createRunner(...paths: string[]) {
         // Lines can have leading '[something] [{' which we need to remove
         const cleanedLine = line.replace(/^.*?] \[{"/, '[{"');
 
+        if (cleanedLine.startsWith('{"port":')) {
+          const { port } = JSON.parse(cleanedLine) as { port: number };
+          serverPort = port;
+          return;
+        }
+
         if (!cleanedLine.startsWith('[{')) {
           return;
         }
@@ -156,6 +186,25 @@ export function createRunner(...paths: string[]) {
         childHasExited: function (): boolean {
           return hasExited;
         },
+        makeRequest: async function <T>(
+          method: 'get' | 'post',
+          path: string,
+          headers: Record<string, string> = {},
+        ): Promise<T | undefined> {
+          try {
+            await waitForServerPort();
+
+            const url = `http://localhost:${serverPort}${path}`;
+            if (method === 'get') {
+              return (await axios.get(url, { headers })).data;
+            } else {
+              return (await axios.post(url, { headers })).data;
+            }
+          } catch (e) {
+            done?.(e);
+            return undefined;
+          }
+        },
       };
     },
   };
diff --git a/packages/node/src/integrations/anr/worker.ts b/packages/node/src/integrations/anr/worker.ts
@@ -47,6 +47,7 @@ async function sendAbnormalSession(): Promise<void> {
     updateSession(session, { status: 'abnormal', abnormal_mechanism: 'anr_foreground' });
 
     const envelope = createSessionEnvelope(session, options.dsn, options.sdkMetadata);
+    // Log the envelope so to aid in testing
     log(JSON.stringify(envelope));
 
     await transport.send(envelope);
@@ -118,6 +119,7 @@ async function sendAnrEvent(frames?: StackFrame[], traceContext?: TraceContext):
   };
 
   const envelope = createEventEnvelope(event, options.dsn, options.sdkMetadata);
+  // Log the envelope so to aid in testing
   log(JSON.stringify(envelope));
 
   await transport.send(envelope);
