Add node-core integration tests

Author: andreiborza

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

@@ -0,0 +1,40 @@
+module.exports = {
+  env: {
+    node: true,
+  },
+  extends: ['../../.eslintrc.js'],
+  overrides: [
+    {
+      files: ['utils/**/*.ts', 'src/**/*.ts'],
+      parserOptions: {
+        project: ['tsconfig.json'],
+        sourceType: 'module',
+      },
+    },
+    {
+      files: ['suites/**/*.ts', 'suites/**/*.mjs'],
+      parserOptions: {
+        project: ['tsconfig.test.json'],
+        sourceType: 'module',
+        ecmaVersion: 'latest',
+      },
+      globals: {
+        fetch: 'readonly',
+      },
+      rules: {
+        '@typescript-eslint/typedef': 'off',
+        // Explicitly allow ts-ignore with description for Node integration tests
+        // Reason: We run these tests on TS3.8 which doesn't support `@ts-expect-error`
+        '@typescript-eslint/ban-ts-comment': [
+          'error',
+          {
+            'ts-ignore': 'allow-with-description',
+            'ts-expect-error': true,
+          },
+        ],
+        // We rely on having imports after init() is called for OTEL
+        'import/first': 'off',
+      },
+    },
+  ],
+};

dev-packages/node-core-integration-tests/.gitignore

@@ -0,0 +1 @@
+suites/**/tmp_*

dev-packages/node-core-integration-tests/README.md

@@ -0,0 +1,49 @@
+# Integration Tests for Sentry Node.JS Core SDK with OpenTelemetry v2 dependencies
+
+## Structure
+
+```
+suites/
+|---- public-api/
+      |---- captureMessage/
+            |---- test.ts [assertions]
+            |---- scenario.ts [Sentry initialization and test subject]
+      |---- customTest/
+            |---- test.ts [assertions]
+            |---- scenario_1.ts [optional extra test scenario]
+            |---- scenario_2.ts [optional extra test scenario]
+            |---- server_with_mongo.ts [optional custom server]
+            |---- server_with_postgres.ts [optional custom server]
+```
+
+The tests are grouped by their scopes, such as `public-api` or `tracing`. In every group of tests, there are multiple
+folders containing test scenarios and assertions.
+
+`scenario.ts` contains the initialization logic and the test subject. By default, `{TEST_DIR}/scenario.ts` is used, but
+`runServer` also accepts an optional `scenarioPath` argument for non-standard usage.
+
+`test.ts` is required for each test case, and contains the server runner logic, request interceptors for Sentry
+requests, and assertions. Test server, interceptors and assertions are all run on the same Vitest thread.
+
+### Utilities
+
+`utils/` contains helpers and Sentry-specific assertions that can be used in (`test.ts`).
+
+Nock interceptors are internally used to capture envelope requests by `getEnvelopeRequest` and
+`getMultipleEnvelopeRequest` helpers. After capturing required requests, the interceptors are removed. Nock can manually
+be used inside the test cases to intercept requests but should be removed before the test ends, as not to cause
+flakiness.
+
+## Running Tests Locally
+
+Tests can be run locally with:
+
+`yarn test`
+
+To run tests with Vitest's watch mode:
+
+`yarn test:watch`
+
+To filter tests by their title:
+
+`yarn test -t "set different properties of a scope"`

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

@@ -0,0 +1,61 @@
+{
+  "name": "@sentry-internal/node-core-integration-tests",
+  "version": "9.27.0",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "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 && run-p clean:script",
+    "clean:script": "node scripts/clean.js",
+    "lint": "eslint . --format stylish",
+    "fix": "eslint . --format stylish --fix",
+    "type-check": "tsc",
+    "test": "vitest run",
+    "test:watch": "yarn test --watch"
+  },
+  "dependencies": {
+    "@nestjs/common": "11.0.16",
+    "@nestjs/core": "10.4.6",
+    "@nestjs/platform-express": "10.4.6",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^1.30.1",
+    "@opentelemetry/core": "^1.30.1",
+    "@opentelemetry/instrumentation": "^0.57.2",
+    "@opentelemetry/instrumentation-http": "0.57.2",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-trace-base": "^1.30.1",
+    "@opentelemetry/semantic-conventions": "^1.30.0",
+    "@sentry/core": "9.30.0",
+    "@sentry/node": "9.30.0",
+    "body-parser": "^1.20.3",
+    "cors": "^2.8.5",
+    "cron": "^3.1.6",
+    "express": "^4.21.1",
+    "http-terminator": "^3.2.0",
+    "nock": "^13.5.5",
+    "node-cron": "^3.0.3",
+    "node-schedule": "^2.1.1",
+    "proxy": "^2.1.1",
+    "reflect-metadata": "0.2.1",
+    "rxjs": "^7.8.1",
+    "winston": "^3.17.0",
+    "yargs": "^16.2.0"
+  },
+  "devDependencies": {
+    "@types/node-cron": "^3.0.11",
+    "@types/node-schedule": "^2.1.7",
+    "globby": "11"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}

dev-packages/node-core-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-core-integration-tests/scripts/clean.js

@@ -0,0 +1,19 @@
+const { execSync } = require('child_process');
+const globby = require('globby');
+const { dirname, join } = require('path');
+
+const cwd = join(__dirname, '..');
+const paths = globby.sync(['suites/**/docker-compose.yml'], { cwd }).map(path => join(cwd, dirname(path)));
+
+// eslint-disable-next-line no-console
+console.log('Cleaning up docker containers and volumes...');
+
+for (const path of paths) {
+  try {
+    // eslint-disable-next-line no-console
+    console.log(`docker compose down @ ${path}`);
+    execSync('docker compose down --volumes', { stdio: 'inherit', cwd: path });
+  } catch (_) {
+    //
+  }
+}

dev-packages/node-core-integration-tests/scripts/use-ts-3_8.js

@@ -0,0 +1,39 @@
+/* eslint-disable no-console */
+const { execSync } = require('child_process');
+const { join } = require('path');
+const { readFileSync, writeFileSync } = require('fs');
+
+const cwd = join(__dirname, '../../..');
+
+// Newer versions of the Express types use syntax that isn't supported by TypeScript 3.8.
+// We'll pin to the last version of those types that are compatible.
+console.log('Pinning Express types to old versions...');
+
+const packageJsonPath = join(cwd, 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+if (!packageJson.resolutions) packageJson.resolutions = {};
+packageJson.resolutions['@types/express'] = '4.17.13';
+packageJson.resolutions['@types/express-serve-static-core'] = '4.17.30';
+
+writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+const tsVersion = '3.8';
+
+console.log(`Installing typescript@${tsVersion}, and @types/node@14...`);
+
+execSync(`yarn add --dev --ignore-workspace-root-check typescript@${tsVersion} @types/node@^14`, {
+  stdio: 'inherit',
+  cwd,
+});
+
+console.log('Removing unsupported tsconfig options...');
+
+const baseTscConfigPath = join(cwd, 'packages/typescript/tsconfig.json');
+
+const tsConfig = require(baseTscConfigPath);
+
+// TS 3.8 fails build when it encounters a config option it does not understand, so we remove it :(
+delete tsConfig.compilerOptions.noUncheckedIndexedAccess;
+
+writeFileSync(baseTscConfigPath, JSON.stringify(tsConfig, null, 2));

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

@@ -0,0 +1,57 @@
+import type { BaseTransportOptions, Envelope, Transport, TransportMakeRequestResponse } from '@sentry/core';
+import type { Express } from 'express';
+import type { AddressInfo } from 'net';
+
+/**
+ * Debug logging transport
+ */
+export function loggingTransport(_options: BaseTransportOptions): Transport {
+  return {
+    send(request: Envelope): Promise<TransportMakeRequestResponse> {
+      // eslint-disable-next-line no-console
+      console.log(JSON.stringify(request));
+      return Promise.resolve({ statusCode: 200 });
+    },
+    flush(): PromiseLike<boolean> {
+      return new Promise(resolve => setTimeout(() => resolve(true), 1000));
+    },
+  };
+}
+
+/**
+ * Starts an express server and sends the port to the runner
+ * @param app Express app
+ * @param port Port to start the app on. USE WITH CAUTION! By default a random port will be chosen.
+ * Setting this port to something specific is useful for local debugging but dangerous for
+ * CI/CD environments where port collisions can cause flakes!
+ */
+export function startExpressServerAndSendPortToRunner(
+  app: Pick<Express, 'listen'>,
+  port: number | undefined = undefined,
+): void {
+  const server = app.listen(port || 0, () => {
+    const address = server.address() as AddressInfo;
+
+    // @ts-expect-error If we write the port to the app we can read it within route handlers in tests
+    app.port = port || address.port;
+
+    // eslint-disable-next-line no-console
+    console.log(`{"port":${port || address.port}}`);
+  });
+}
+
+/**
+ * Sends the port to the runner
+ */
+export function sendPortToRunner(port: number): void {
+  // eslint-disable-next-line no-console
+  console.log(`{"port":${port}}`);
+}
+
+/**
+ * Can be used to get the port of a running app, so requests can be sent to a server from within the server.
+ */
+export function getPortAppIsRunningOn(app: Express): number | undefined {
+  // @ts-expect-error It's not defined in the types but we'd like to read it.
+  return app.port;
+}

dev-packages/node-core-integration-tests/suites/breadcrumbs/process-thread/app.mjs

@@ -0,0 +1,33 @@
+import * as Sentry from '@sentry/node-core';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { Worker } from 'worker_threads';
+import { setupOtel } from '../../../utils/setupOtel.js';
+
+const __dirname = new URL('.', import.meta.url).pathname;
+
+const client = Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  integrations: [Sentry.childProcessIntegration({ captureWorkerErrors: false })],
+  transport: loggingTransport,
+});
+
+setupOtel(client);
+
+(async () => {
+  await new Promise(resolve => {
+    const child = spawn('sleep', ['a']);
+    child.on('error', resolve);
+    child.on('exit', resolve);
+  });
+
+  await new Promise(resolve => {
+    const worker = new Worker(join(__dirname, 'worker.mjs'));
+    worker.on('error', resolve);
+    worker.on('exit', resolve);
+  });
+
+  throw new Error('This is a test error');
+})();

dev-packages/node-core-integration-tests/suites/breadcrumbs/process-thread/test.ts

@@ -0,0 +1,50 @@
+import type { Event } from '@sentry/core';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+const EVENT = {
+  // and an exception that is our ANR
+  exception: {
+    values: [
+      {
+        type: 'Error',
+        value: 'This is a test error',
+      },
+    ],
+  },
+  breadcrumbs: [
+    {
+      timestamp: expect.any(Number),
+      category: 'child_process',
+      message: "Child process exited with code '1'",
+      level: 'warning',
+      data: {
+        spawnfile: 'sleep',
+      },
+    },
+    {
+      timestamp: expect.any(Number),
+      category: 'worker_thread',
+      message: "Worker thread errored with 'Worker error'",
+      level: 'error',
+      data: {
+        threadId: expect.any(Number),
+      },
+    },
+  ],
+};
+
+conditionalTest({ min: 20 })('should capture process and thread breadcrumbs', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('ESM', async () => {
+    await createRunner(__dirname, 'app.mjs')
+      .withMockSentryServer()
+      .expect({ event: EVENT as Event })
+      .start()
+      .completed();
+  });
+});

dev-packages/node-core-integration-tests/suites/breadcrumbs/process-thread/worker.mjs

@@ -0,0 +1 @@
+throw new Error('Worker error');

dev-packages/node-core-integration-tests/suites/child-process/child.js

@@ -0,0 +1,3 @@
+setTimeout(() => {
+  throw new Error('Test error');
+}, 1000);

dev-packages/node-core-integration-tests/suites/child-process/child.mjs

@@ -0,0 +1,3 @@
+setTimeout(() => {
+  throw new Error('Test error');
+}, 1000);

dev-packages/node-core-integration-tests/suites/child-process/fork.js

@@ -0,0 +1,20 @@
+const Sentry = require('@sentry/node-core');
+const { loggingTransport } = require('@sentry-internal/node-core-integration-tests');
+const path = require('path');
+const { fork } = require('child_process');
+const { setupOtel } = require('../../utils/setupOtel.js');
+
+const client = Sentry.init({
+  debug: true,
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  transport: loggingTransport,
+});
+
+setupOtel(client);
+
+fork(path.join(__dirname, 'child.mjs'));
+
+setTimeout(() => {
+  throw new Error('Exiting main process');
+}, 3000);