do tests work now?

Author: msonnb

packages/aws-serverless/scripts/buildLambdaLayer.ts

@@ -48,6 +48,7 @@ async function buildLambdaLayer(): Promise<void> {
   fsForceMkdirSync('./build/aws/dist-serverless/extensions');
   fs.copyFileSync('./src/lambda-extension/sentry-extension', './build/aws/dist-serverless/extensions/sentry-extension');
   fs.chmodSync('./build/aws/dist-serverless/extensions/sentry-extension', 0o755);
+  fs.chmodSync('./build/aws/dist-serverless/sentry-extension/index.js', 0o755);
 
   const zipFilename = `sentry-node-serverless-${version}.zip`;
   console.log(`Creating final layer zip file ${zipFilename}.`);

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

@@ -1,5 +1,6 @@
 import * as http from 'node:http';
 import { buffer } from 'node:stream/consumers';
+import { dsnStringToIngestEndpoint } from './utils';
 
 /**
  * The Extension API Client.
@@ -109,9 +110,7 @@ export class AwsLambdaExtension {
           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/`;
+          const upstreamSentryUrl = dsnStringToIngestEndpoint(header.dsn || '');
 
           console.log('tunneling to sentry', { upstreamSentryUrl });
           console.log('headers', req.headers);

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

@@ -0,0 +1,143 @@
+/** Supported Sentry transport protocols in a Dsn. */
+export type DsnProtocol = 'http' | 'https';
+
+/** Primitive components of a Dsn. */
+interface DsnComponents {
+  /** Protocol used to connect to Sentry. */
+  protocol: DsnProtocol;
+  /** Public authorization key. */
+  publicKey?: string;
+  /** Private authorization key (deprecated, optional). */
+  pass?: string;
+  /** Hostname of the Sentry instance. */
+  host: string;
+  /** Port of the Sentry instance. */
+  port?: string;
+  /** Sub path/ */
+  path?: string;
+  /** Project ID */
+  projectId: string;
+}
+
+interface Package {
+  name: string;
+  version: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+interface SdkInfo {
+  name?: string;
+  version?: string;
+  integrations?: string[];
+  packages?: Package[];
+  settings?: {
+    infer_ip?: 'auto' | 'never';
+  };
+}
+
+const SENTRY_API_VERSION = '7';
+
+/**
+ * Converts a Dsn string to the ingest endpoint URL.
+ *
+ * @param dsnString A Dsn as string
+ * @returns The ingest endpoint URL
+ */
+export function dsnStringToIngestEndpoint(dsnString: string): string {
+  const dsn = dsnFromString(dsnString);
+  if (!dsn) {
+    throw new Error(`Invalid Sentry Dsn: ${dsnString}`);
+  }
+  return getEnvelopeEndpointWithUrlEncodedAuth(dsn);
+}
+
+/** Returns the prefix to construct Sentry ingestion API endpoints. */
+function getBaseApiEndpoint(dsn: DsnComponents): string {
+  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
+  const port = dsn.port ? `:${dsn.port}` : '';
+  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
+}
+
+/** Returns the ingest API endpoint for target. */
+function _getIngestEndpoint(dsn: DsnComponents): string {
+  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
+}
+
+/** Returns a URL-encoded string with auth config suitable for a query string. */
+function _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {
+  const params: Record<string, string> = {
+    sentry_version: SENTRY_API_VERSION,
+  };
+
+  if (dsn.publicKey) {
+    // We send only the minimum set of required information. See
+    // https://github.com/getsentry/sentry-javascript/issues/2572.
+    params.sentry_key = dsn.publicKey;
+  }
+
+  if (sdkInfo) {
+    params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;
+  }
+
+  return new URLSearchParams(params).toString();
+}
+
+/**
+ * Returns the envelope endpoint URL with auth in the query string.
+ *
+ * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
+ */
+function getEnvelopeEndpointWithUrlEncodedAuth(dsn: DsnComponents, tunnel?: string, sdkInfo?: SdkInfo): string {
+  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
+}
+
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+
+/**
+ * Parses a Dsn from a given string.
+ *
+ * @param str A Dsn as string
+ * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
+ */
+function dsnFromString(str: string): DsnComponents | undefined {
+  const match = DSN_REGEX.exec(str);
+
+  if (!match) {
+    // eslint-disable-next-line no-console
+    console.error(`Invalid Sentry Dsn: ${str}`);
+
+    return undefined;
+  }
+
+  const [protocol, publicKey, pass = '', host = '', port = '', lastPath = ''] = match.slice(1);
+  let path = '';
+  let projectId = lastPath;
+
+  const split = projectId.split('/');
+  if (split.length > 1) {
+    path = split.slice(0, -1).join('/');
+    projectId = split.pop() as string;
+  }
+
+  if (projectId) {
+    const projectMatch = projectId.match(/^\d+/);
+    if (projectMatch) {
+      projectId = projectMatch[0];
+    }
+  }
+
+  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, publicKey });
+}
+
+function dsnFromComponents(components: DsnComponents): DsnComponents {
+  return {
+    protocol: components.protocol,
+    publicKey: components.publicKey || '',
+    pass: components.pass || '',
+    host: components.host,
+    port: components.port || '',
+    path: components.path || '',
+    projectId: components.projectId,
+  };
+}