test(aws-lambda): Add basic lambda layer e2e test (#12279)

Add an e2e (or rather integration) test for our AWS lambda
layer bundle. The motivation for this test is that we broke the layer
during the initial v8 releases (multiple times for different reasons)
without us noticing this in tests. Simply because we never tested the
bundled SDK code that we create and publish for the lambda layer.

Author: Lms24

.github/workflows/build.yml

@@ -993,6 +993,7 @@ jobs:
           [
             'angular-17',
             'angular-18',
+            'aws-lambda-layer',
             'cloudflare-astro',
             'node-express',
             'create-react-app',

dev-packages/e2e-tests/test-applications/aws-lambda-layer/.npmrc

@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873

dev-packages/e2e-tests/test-applications/aws-lambda-layer/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "node-express-app",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "copy:layer": "cp -r ./../../../../packages/aws-serverless/build/aws/dist-serverless/nodejs/node_modules/ ./node_modules",
+    "start": "node src/run.js",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "test:build": "pnpm install && pnpm copy:layer",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@playwright/test": "^1.41.1",
+    "wait-port": "1.0.4"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}

dev-packages/e2e-tests/test-applications/aws-lambda-layer/playwright.config.ts

@@ -0,0 +1,79 @@
+import type { PlaywrightTestConfig } from '@playwright/test';
+import { devices } from '@playwright/test';
+
+// Fix urls not resolving to localhost on Node v17+
+// See: https://github.com/axios/axios/issues/3821#issuecomment-1413727575
+import { setDefaultResultOrder } from 'dns';
+setDefaultResultOrder('ipv4first');
+
+const eventProxyPort = 3031;
+const lambdaPort = 3030;
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+const config: PlaywrightTestConfig = {
+  testDir: './tests',
+  /* Maximum time one test can run for. */
+  timeout: 150_000,
+  expect: {
+    /**
+     * Maximum time expect() should wait for the condition to be met.
+     * For example in `await expect(locator).toHaveText();`
+     */
+    timeout: 5000,
+  },
+  /* Run tests in files in parallel */
+  fullyParallel: true,
+  /* Fail the build on CI if you accidentally left test.only in the source code. */
+  forbidOnly: !!process.env.CI,
+  /* Retry on CI only */
+  retries: 0,
+  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+  reporter: 'list',
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
+    actionTimeout: 0,
+
+    /* Base URL to use in actions like `await page.goto('/')`. */
+    baseURL: `http://localhost:${lambdaPort}`,
+
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: 'on-first-retry',
+  },
+
+  /* Configure projects for major browsers */
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+      },
+    },
+    // For now we only test Chrome!
+    // {
+    //   name: 'firefox',
+    //   use: {
+    //     ...devices['Desktop Firefox'],
+    //   },
+    // },
+    // {
+    //   name: 'webkit',
+    //   use: {
+    //     ...devices['Desktop Safari'],
+    //   },
+    // },
+  ],
+
+  /* Run your local dev server before starting the tests */
+  webServer: [
+    {
+      command: `node start-event-proxy.mjs && pnpm wait-port ${eventProxyPort}`,
+      port: eventProxyPort,
+      stdout: 'pipe',
+    },
+  ],
+};
+
+export default config;

dev-packages/e2e-tests/test-applications/aws-lambda-layer/src/lambda-function.js

@@ -0,0 +1,19 @@
+const Sentry = require('@sentry/aws-serverless');
+
+const http = require('http');
+
+function handle() {
+  Sentry.startSpanManual({ name: 'aws-lambda-layer-test-txn', op: 'test' }, span => {
+    http.get('http://example.com', res => {
+      res.on('data', d => {
+        process.stdout.write(d);
+      });
+
+      res.on('end', () => {
+        span.end();
+      });
+    });
+  });
+}
+
+module.exports = { handle };

dev-packages/e2e-tests/test-applications/aws-lambda-layer/src/run-lambda.js

@@ -0,0 +1,2 @@
+const { handle } = require('./lambda-function');
+handle();

dev-packages/e2e-tests/test-applications/aws-lambda-layer/src/run.js

@@ -0,0 +1,16 @@
+const child_process = require('child_process');
+
+child_process.execSync('node ./src/run-lambda.js', {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    LAMBDA_TASK_ROOT: '.',
+    _HANDLER: 'handle',
+
+    NODE_OPTIONS: '--require @sentry/aws-serverless/dist/awslambda-auto',
+    SENTRY_DSN: 'http://public@localhost:3031/1337',
+    SENTRY_TRACES_SAMPLE_RATE: '1.0',
+    SENTRY_DEBUG: 'true',
+  },
+  cwd: process.cwd(),
+});

dev-packages/e2e-tests/test-applications/aws-lambda-layer/start-event-proxy.mjs

@@ -0,0 +1,7 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'aws-serverless-lambda-layer',
+  forwardToSentry: false,
+});

dev-packages/e2e-tests/test-applications/aws-lambda-layer/tests/basic.test.ts

@@ -0,0 +1,36 @@
+import * as child_process from 'child_process';
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Lambda layer SDK bundle sends events', async ({ request }) => {
+  const transactionEventPromise = waitForTransaction('aws-serverless-lambda-layer', transactionEvent => {
+    return transactionEvent?.transaction === 'aws-lambda-layer-test-txn';
+  });
+
+  await new Promise<void>(resolve =>
+    setTimeout(() => {
+      resolve();
+    }, 1000),
+  );
+
+  child_process.execSync('pnpm start', {
+    stdio: 'ignore',
+  });
+
+  const transactionEvent = await transactionEventPromise;
+
+  // shows the SDK sent a transaction
+  expect(transactionEvent.transaction).toEqual('aws-lambda-layer-test-txn');
+
+  // shows that the Otel Http instrumentation is working
+  expect(transactionEvent.spans).toHaveLength(1);
+  expect(transactionEvent.spans![0]).toMatchObject({
+    data: expect.objectContaining({
+      'sentry.op': 'http.client',
+      'sentry.origin': 'auto.http.otel.http',
+      url: 'http://example.com/',
+    }),
+    description: 'GET http://example.com/',
+    op: 'http.client',
+  });
+});

dev-packages/test-utils/src/event-proxy-server.ts

@@ -17,6 +17,11 @@ interface EventProxyServerOptions {
   port: number;
   /** The name for the proxy server used for referencing it with listener functions */
   proxyServerName: string;
+  /**
+   * Whether or not to forward the event to sentry. @default `true`
+   * This is helpful when you can't register a tunnel in the SDK setup (e.g. lambda layer without Sentry.init call)
+   */
+  forwardToSentry?: boolean;
 }
 
 interface SentryRequestCallbackData {
@@ -56,7 +61,9 @@ export async function startEventProxyServer(options: EventProxyServerOptions): P
 
       const envelopeHeader: EnvelopeItem[0] = JSON.parse(proxyRequestBody.split('\n')[0]);
 
-      if (!envelopeHeader.dsn) {
+      const shouldForwardEventToSentry = options.forwardToSentry != null ? options.forwardToSentry : true;
+
+      if (!envelopeHeader.dsn && shouldForwardEventToSentry) {
         // eslint-disable-next-line no-console
         console.log(
           '[event-proxy-server] Warn: No dsn on envelope header. Maybe a client-report was received. Proxy request body:',
@@ -69,6 +76,23 @@ export async function startEventProxyServer(options: EventProxyServerOptions): P
         return;
       }
 
+      if (!shouldForwardEventToSentry) {
+        const data: SentryRequestCallbackData = {
+          envelope: parseEnvelope(proxyRequestBody),
+          rawProxyRequestBody: proxyRequestBody,
+          rawSentryResponseBody: '',
+          sentryResponseStatusCode: 200,
+        };
+        eventCallbackListeners.forEach(listener => {
+          listener(Buffer.from(JSON.stringify(data)).toString('base64'));
+        });
+
+        proxyResponse.writeHead(200);
+        proxyResponse.write('{}', 'utf-8');
+        proxyResponse.end();
+        return;
+      }
+
       const { origin, pathname, host } = new URL(envelopeHeader.dsn as string);
 
       const projectId = pathname.substring(1);
@@ -269,7 +293,13 @@ async function registerCallbackServerPort(serverName: string, port: string): Pro
   await writeFile(tmpFilePath, port, { encoding: 'utf8' });
 }
 
-function retrieveCallbackServerPort(serverName: string): Promise<string> {
-  const tmpFilePath = path.join(os.tmpdir(), `${TEMP_FILE_PREFIX}${serverName}`);
-  return readFile(tmpFilePath, 'utf8');
+async function retrieveCallbackServerPort(serverName: string): Promise<string> {
+  try {
+    const tmpFilePath = path.join(os.tmpdir(), `${TEMP_FILE_PREFIX}${serverName}`);
+    return await readFile(tmpFilePath, 'utf8');
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.log('Could not read callback server port', e);
+    throw e;
+  }
 }

packages/aws-serverless/package.json

@@ -76,9 +76,10 @@
   },
   "scripts": {
     "build": "run-p build:transpile build:types build:bundle",
-    "build:bundle": "yarn ts-node scripts/buildLambdaLayer.ts",
+    "build:bundle": "yarn build:layer",
+    "build:layer": "yarn ts-node scripts/buildLambdaLayer.ts",
     "build:dev": "run-p build:transpile build:types",
-    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:transpile": "rollup -c rollup.npm.config.mjs && yarn build:layer",
     "build:types": "run-s build:types:core build:types:downlevel",
     "build:types:core": "tsc -p tsconfig.types.json",
     "build:types:downlevel": "yarn downlevel-dts build/npm/types build/npm/types-ts3.8 --to ts3.8",