test(node): New Node integration test runner (#10117)

Adds a new Node integration test runner that runs the scenario in its
own Node process and reads the envelope back from stdout.

I have converted all the `Anr` and `LocalVariables` tests to use this
new format.

## How to use

First, in your test scenario, you need to set the transport to the
`loggingTransport` from `@sentry-internal/node-integration-tests`. This
will cause envelopes to be logged to stdout as a single line of JSON:
```ts
import * as Sentry from '@sentry/node';
import { loggingTransport } from '@sentry-internal/node-integration-tests';

Sentry.init({
  dsn: 'https://[email protected]/1337',
  transport: loggingTransport,
});
```

Then in your test, use the `createRunner` function to create your test.
The `createRunner` args are the path segments to the scenario. If you
pass a typescript entry file, `-r ts-node/register` gets added to the
node args.

Every `expect` call adds an expected envelope item. Currently you can
expect `event`, `transaction` and `session` but it's easy to add extra
type-safe expectations. You must add an `expect` for every envelope
**item** that will be sent and they must be in the correct order or an
error is thrown and the test fails. The expect
`event`/`transaction`/`session` can be a callback or an object that will
be tested against the received envelope.

If you don't care about specific types of envelope item, you can ignore
them:
```ts
createRunner(__dirname, 'basic.js')
  .ignore('session', 'sessions')
  .expect(//...
```

If you pass `done` to `start`, `done` will be called when all the
envelope items have matched the expected and `done` will be passed any
errors that occur which ends the test without waiting for the timeout.

## Example

Here is an Anr test that ensures we get the expected session envelope
followed by the expected event envelope:
```ts
import { assertSentryEvent, assertSentrySession, createRunner } from '../../utils/runner';

const EXPECTED_ANR_EVENT = {
  // Ensure we have context
  contexts: {
    trace: {
      span_id: expect.any(String),
      trace_id: expect.any(String),
    },
    device: {
      arch: expect.any(String),
    },
    app: {
      app_start_time: expect.any(String),
    },
    os: {
      name: expect.any(String),
    },
    culture: {
      timezone: expect.any(String),
    },
  },
  // and an exception that is our ANR
  exception: {
    values: [
      {
        type: 'ApplicationNotResponding',
        value: 'Application Not Responding for at least 200 ms',
        mechanism: { type: 'ANR' },
        stacktrace: {
          frames: expect.arrayContaining([
            {
              colno: expect.any(Number),
              lineno: expect.any(Number),
              filename: expect.any(String),
              function: '?',
              in_app: true,
            },
            {
              colno: expect.any(Number),
              lineno: expect.any(Number),
              filename: expect.any(String),
              function: 'longWork',
              in_app: true,
            },
          ]),
        },
      },
    ],
  },
};

test('Anr with session', done => {
  createRunner(__dirname, 'basic-session.js')
    .expect({ session: { status: 'abnormal', abnormal_mechanism: 'anr_foreground' } })
    .expect({ event:  EXPECTED_ANR_EVENT })
    .start(done);
});
```

It's also possible to pass flags to node via the `withFlags()` function:
```ts
  test('With --inspect',done => {
    createRunner(__dirname, 'basic.mjs')
      .withFlags('--inspect')
      .expect({ event: EXPECTED_ANR_EVENT })
      .start(done);
  });
```

Author: timfish

.github/workflows/build.yml

@@ -35,6 +35,7 @@ env:
 
   # packages/utils/cjs and packages/utils/esm: Symlinks to the folders inside of `build`, needed for tests
   CACHED_BUILD_PATHS: |
+    ${{ github.workspace }}/dev-packages/*/build
     ${{ github.workspace }}/packages/*/build
     ${{ github.workspace }}/packages/ember/*.d.ts
     ${{ github.workspace }}/packages/gatsby/*.d.ts

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

@@ -6,7 +6,7 @@ module.exports = {
   extends: ['../../.eslintrc.js'],
   overrides: [
     {
-      files: ['utils/**/*.ts'],
+      files: ['utils/**/*.ts', 'src/**/*.ts'],
       parserOptions: {
         project: ['tsconfig.json'],
         sourceType: 'module',

dev-packages/node-integration-tests/package.json

@@ -6,7 +6,14 @@
     "node": ">=10"
   },
   "private": true,
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/types/src/index.d.ts",
   "scripts": {
+    "build": "run-s build:transpile build:types",
+    "build:dev": "yarn build",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:types": "tsc -p tsconfig.types.json",
     "clean": "rimraf -g **/node_modules",
     "prisma:init": "(cd suites/tracing/prisma-orm && ts-node ./setup.ts)",
     "prisma:init:new": "(cd suites/tracing-new/prisma-orm && ts-node ./setup.ts)",
@@ -15,12 +22,14 @@
     "type-check": "tsc",
     "pretest": "run-s --silent prisma:init prisma:init:new",
     "test": "ts-node ./utils/run-tests.ts",
+    "jest": "jest --config ./jest.config.js",
     "test:watch": "yarn test --watch"
   },
   "dependencies": {
     "@prisma/client": "3.15.2",
     "@sentry/node": "7.93.0",
     "@sentry/tracing": "7.93.0",
+    "@sentry/types": "7.93.0",
     "@types/mongodb": "^3.6.20",
     "@types/mysql": "^2.15.21",
     "@types/pg": "^8.6.5",

dev-packages/node-integration-tests/rollup.npm.config.mjs

@@ -0,0 +1,3 @@
+import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeNPMConfigVariants(makeBaseNPMConfig());

dev-packages/node-integration-tests/src/index.ts

@@ -0,0 +1,31 @@
+import type { AddressInfo } from 'net';
+import type { BaseTransportOptions, Envelope, Transport, TransportMakeRequestResponse } from '@sentry/types';
+import type { Express } from 'express';
+
+/**
+ * Debug logging transport
+ */
+export function loggingTransport(_options: BaseTransportOptions): Transport {
+  return {
+    send(request: Envelope): Promise<void | TransportMakeRequestResponse> {
+      // eslint-disable-next-line no-console
+      console.log(JSON.stringify(request));
+      return Promise.resolve({ statusCode: 200 });
+    },
+    flush(): PromiseLike<boolean> {
+      return Promise.resolve(true);
+    },
+  };
+}
+
+/**
+ * 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}}`);
+  });
+}

dev-packages/node-integration-tests/suites/anr/basic-session.js

@@ -11,11 +11,11 @@ Sentry.init({
   dsn: 'https://[email protected]/1337',
   release: '1.0',
   debug: true,
-  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 200 })],
+  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 100 })],
 });
 
 function longWork() {
-  for (let i = 0; i < 100; i++) {
+  for (let i = 0; i < 20; i++) {
     const salt = crypto.randomBytes(128).toString('base64');
     // eslint-disable-next-line no-unused-vars
     const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');

dev-packages/node-integration-tests/suites/anr/basic.js

@@ -12,11 +12,11 @@ Sentry.init({
   release: '1.0',
   debug: true,
   autoSessionTracking: false,
-  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 200 })],
+  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 100 })],
 });
 
 function longWork() {
-  for (let i = 0; i < 100; i++) {
+  for (let i = 0; i < 20; i++) {
     const salt = crypto.randomBytes(128).toString('base64');
     // eslint-disable-next-line no-unused-vars
     const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');

dev-packages/node-integration-tests/suites/anr/basic.mjs

@@ -12,11 +12,11 @@ Sentry.init({
   release: '1.0',
   debug: true,
   autoSessionTracking: false,
-  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 200 })],
+  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 100 })],
 });
 
 function longWork() {
-  for (let i = 0; i < 100; i++) {
+  for (let i = 0; i < 20; i++) {
     const salt = crypto.randomBytes(128).toString('base64');
     // eslint-disable-next-line no-unused-vars
     const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');

dev-packages/node-integration-tests/suites/anr/forked.js

@@ -12,11 +12,11 @@ Sentry.init({
   release: '1.0',
   debug: true,
   autoSessionTracking: false,
-  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 200 })],
+  integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true, anrThreshold: 100 })],
 });
 
 function longWork() {
-  for (let i = 0; i < 100; i++) {
+  for (let i = 0; i < 20; i++) {
     const salt = crypto.randomBytes(128).toString('base64');
     // eslint-disable-next-line no-unused-vars
     const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');

dev-packages/node-integration-tests/suites/anr/legacy.js

@@ -15,9 +15,9 @@ Sentry.init({
 });
 
 // eslint-disable-next-line deprecation/deprecation
-Sentry.enableAnrDetection({ captureStackTrace: true, anrThreshold: 200 }).then(() => {
+Sentry.enableAnrDetection({ captureStackTrace: true, anrThreshold: 100 }).then(() => {
   function longWork() {
-    for (let i = 0; i < 100; i++) {
+    for (let i = 0; i < 20; i++) {
       const salt = crypto.randomBytes(128).toString('base64');
       // eslint-disable-next-line no-unused-vars
       const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');