improvements

Author: msonnb

dev-packages/rollup-utils/bundleHelpers.mjs

@@ -53,7 +53,7 @@ export function makeBaseBundleConfig(options) {
       },
     },
     context: 'window',
-    plugins: [rrwebBuildPlugin, markAsBrowserBuildPlugin],
+    plugins: [rrwebBuildPlugin, markAsBrowserBuildPlugin, licensePlugin],
   };
 
   // used by `@sentry/wasm` & pluggable integrations from core/browser (bundles which need to be combined with a stand-alone SDK bundle)
@@ -87,14 +87,23 @@ export function makeBaseBundleConfig(options) {
       // code to add after the CJS wrapper
       footer: '}(window));',
     },
-    plugins: [rrwebBuildPlugin, markAsBrowserBuildPlugin],
+    plugins: [rrwebBuildPlugin, markAsBrowserBuildPlugin, licensePlugin],
   };
 
   const workerBundleConfig = {
     output: {
       format: 'esm',
     },
-    plugins: [commonJSPlugin, makeTerserPlugin()],
+    plugins: [commonJSPlugin, makeTerserPlugin(), licensePlugin],
+    // Don't bundle any of Node's core modules
+    external: builtinModules,
+  };
+
+  const awsLambdaExtensionBundleConfig = {
+    output: {
+      format: 'esm',
+    },
+    plugins: [commonJSPlugin],
     // Don't bundle any of Node's core modules
     external: builtinModules,
   };
@@ -110,14 +119,15 @@ export function makeBaseBundleConfig(options) {
       strict: false,
       esModule: false,
     },
-    plugins: [sucrasePlugin, nodeResolvePlugin, cleanupPlugin, licensePlugin],
+    plugins: [sucrasePlugin, nodeResolvePlugin, cleanupPlugin],
     treeshake: 'smallest',
   };
 
   const bundleTypeConfigMap = {
     standalone: standAloneBundleConfig,
     addon: addOnBundleConfig,
     'node-worker': workerBundleConfig,
+    'lambda-extension': awsLambdaExtensionBundleConfig,
   };
 
   return deepMerge.all([sharedBundleConfig, bundleTypeConfigMap[bundleType], packageSpecificConfig || {}], {

packages/aws-serverless/package.json

@@ -79,7 +79,7 @@
   },
   "scripts": {
     "build": "run-p build:transpile build:types",
-    "build:layer": "yarn ts-node scripts/buildLambdaLayer.ts",
+    "build:layer": "rollup -c rollup.lambda-extension.config.mjs && yarn ts-node scripts/buildLambdaLayer.ts",
     "build:dev": "run-p build:transpile build:types",
     "build:transpile": "rollup -c rollup.npm.config.mjs && yarn build:layer",
     "build:types": "run-s build:types:core build:types:downlevel",

packages/aws-serverless/rollup.lambda-extension.config.mjs

@@ -0,0 +1,18 @@
+import { makeBaseBundleConfig, makeBundleConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default [
+  ...makeBundleConfigVariants(
+    makeBaseBundleConfig({
+      bundleType: 'lambda-extension',
+      entrypoints: ['src/sentry-extension/index.ts'],
+      outputFileBase: () => 'index',
+      packageSpecificConfig: {
+        output: {
+          dir: 'build/aws/dist-serverless/sentry-extension',
+          sourcemap: false,
+        },
+      },
+    }),
+    { variants: ['.js'] },
+  ),
+];

packages/aws-serverless/rollup.npm.config.mjs

@@ -6,7 +6,7 @@ export default [
       // TODO: `awslambda-auto.ts` is a file which the lambda layer uses to automatically init the SDK. Does it need to be
       // in the npm package? Is it possible that some people are using it themselves in the same way the layer uses it (in
       // which case removing it would be a breaking change)? Should it stay here or not?
-      entrypoints: ['src/index.ts', 'src/awslambda-auto.ts', 'src/sentry-extension/index.ts'],
+      entrypoints: ['src/index.ts', 'src/awslambda-auto.ts'],
       // packages with bundles have a different build directory structure
       hasBundles: true,
       packageSpecificConfig: {

packages/aws-serverless/scripts/buildLambdaLayer.ts

@@ -46,11 +46,6 @@ async function buildLambdaLayer(): Promise<void> {
   replaceSDKSource();
 
   fsForceMkdirSync('./build/aws/dist-serverless/extensions');
-  fsForceMkdirSync('./build/aws/dist-serverless/sentry-extension');
-  fs.renameSync(
-    './build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/esm/sentry-extension',
-    './build/aws/dist-serverless/sentry-extension',
-  );
   fs.copyFileSync('./src/extensions/sentry-extension', './build/aws/dist-serverless/extensions/sentry-extension');
   fs.chmodSync('./build/aws/dist-serverless/extensions/sentry-extension', 0o755);
 
@@ -81,7 +76,6 @@ async function pruneNodeModules(): Promise<void> {
     './build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/cjs/index.js',
     './build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/cjs/awslambda-auto.js',
     './build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/esm/awslambda-auto.js',
-    './build/aws/dist-serverless/nodejs/node_modules/@sentry/aws-serverless/build/npm/esm/sentry-extension/index.js',
   ];
 
   const { fileList } = await nodeFileTrace(entrypoints);

packages/aws-serverless/src/extensions/sentry-extension

@@ -1,12 +1,8 @@
 #!/bin/bash
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: MIT-0
-
 set -euo pipefail
 
 OWN_FILENAME="$(basename $0)"
 LAMBDA_EXTENSION_NAME="$OWN_FILENAME" # (external) extension name has to match the filename
 
-echo "${LAMBDA_EXTENSION_NAME}  launching extension"
 unset NODE_OPTIONS
 exec "/opt/${LAMBDA_EXTENSION_NAME}/index.js"

packages/aws-serverless/src/init.ts

@@ -25,7 +25,13 @@ export function init(options: NodeOptions = {}): NodeClient | undefined {
     ...options,
   };
 
-  applySdkMetadata(opts, 'aws-serverless', ['aws-serverless'], getSDKSource());
+  const sdkSource = getSDKSource();
+
+  if (sdkSource === 'aws-lambda-layer' && !opts.tunnel) {
+    opts.tunnel = 'http://localhost:9000/envelope';
+  }
+
+  applySdkMetadata(opts, 'aws-serverless', ['aws-serverless'], sdkSource);
 
   return initWithoutDefaultIntegrations(opts);
 }

packages/aws-serverless/src/sentry-extension/aws-lambda-extension.ts

@@ -0,0 +1,140 @@
+import * as http from 'node:http';
+import { buffer } from 'node:stream/consumers';
+
+/**
+ * The Extension API Client.
+ */
+export class AwsLambdaExtension {
+  private readonly _baseUrl: string;
+  private _extensionId: string | null;
+
+  public constructor() {
+    this._baseUrl = `http://${process.env.AWS_LAMBDA_RUNTIME_API}/2020-01-01/extension`;
+    this._extensionId = null;
+  }
+
+  /**
+   * Register this extension as an external extension with AWS.
+   * @returns The extension identifier, or null if the extension was not registered.
+   */
+  public async register(): Promise<string | null> {
+    const res = await fetch(`${this._baseUrl}/register`, {
+      method: 'POST',
+      body: JSON.stringify({
+        events: ['INVOKE', 'SHUTDOWN'],
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+        'Lambda-Extension-Name': 'sentry-extension',
+      },
+    });
+
+    if (!res.ok) {
+      throw new Error(`Failed to register with the extension API: ${await res.text()}`);
+    }
+
+    this._extensionId = res.headers.get('lambda-extension-identifier');
+    return res.headers.get('lambda-extension-identifier');
+  }
+
+  /**
+   * Advances the extension to the next event.
+   * @param extensionId The extension identifier.
+   * @returns The event data, or null if the extension is not ready to process events.
+   */
+  public async next(): Promise<void> {
+    if (!this._extensionId) {
+      throw new Error('Extension ID is not set');
+    }
+
+    const res = await fetch(`${this._baseUrl}/event/next`, {
+      headers: {
+        'Lambda-Extension-Identifier': this._extensionId,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!res.ok) {
+      throw new Error(`Failed to advance to next event: ${await res.text()}`);
+    }
+
+    const event = await res.json();
+
+    console.log('EXTENSION EVENT', event);
+  }
+
+  /**
+   * Reports an error to the extension API.
+   * @param extensionId The extension identifier.
+   * @param phase The phase of the extension.
+   * @param err The error to report.
+   */
+  public async error(phase: string, err: Error): Promise<never> {
+    if (!this._extensionId) {
+      throw new Error('Extension ID is not set');
+    }
+
+    const errorType = `Extension.${err.name || 'UnknownError'}`;
+
+    const res = await fetch(`${this._baseUrl}/${phase}/error`, {
+      method: 'POST',
+      body: JSON.stringify({
+        errorMessage: err.message || err.toString(),
+        errorType,
+        stackTrace: [err.stack],
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+        'Lambda-Extension-Identifier': this._extensionId,
+        'Lambda-Extension-Function-Error': errorType,
+      },
+    });
+
+    if (!res.ok) {
+      throw new Error(`Failed to report error: ${await res.text()}`);
+    }
+
+    throw err;
+  }
+
+  /**
+   * Starts the Sentry tunnel.
+   */
+  public startSentryTunnel(): void {
+    const server = http.createServer(async (req, res) => {
+      if (req.url?.startsWith('/envelope')) {
+        try {
+          const buf = await buffer(req);
+          const envelopeBytes = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          const envelope = new TextDecoder().decode(envelopeBytes);
+          const piece = envelope.split('\n')[0];
+          const header = JSON.parse(piece ?? '{}') as { dsn?: string };
+          const dsn = new URL(header.dsn || '');
+          const projectId = dsn.pathname.replace('/', '');
+          const upstreamSentryUrl = `https://${dsn.hostname}/api/${projectId}/envelope/`;
+
+          console.log('tunneling to sentry', { upstreamSentryUrl });
+          console.log('headers', req.headers);
+
+          fetch(upstreamSentryUrl, {
+            method: 'POST',
+            body: envelopeBytes,
+          }).catch(err => {
+            console.error('error tunneling to sentry', err);
+          });
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({}));
+        } catch (e) {
+          console.error('error tunneling to sentry', e);
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'error tunneling to sentry' }));
+        }
+      }
+    });
+
+    server.listen(9000, () => {
+      console.log('server listening on port 9000');
+    });
+  }
+}