fix(aws-serverless): Support pnpm handler paths

Co-Authored-By: OpenAI Codex <codex@openai.com>

Author: msonnb

dev-packages/e2e-tests/test-applications/aws-serverless/src/stack.ts

@@ -27,14 +27,6 @@ function resolvePackagesDir(): string {
   return path.resolve(__dirname, '../../../../../packages');
 }
 
-function materializePackage(lambdaPath: string, packageName: string): void {
-  const packagePath = path.join(lambdaPath, 'node_modules', ...packageName.split('/'));
-  const resolvedPackagePath = fs.realpathSync(packagePath);
-
-  fs.rmSync(packagePath, { recursive: true, force: true });
-  fs.cpSync(resolvedPackagePath, packagePath, { recursive: true, dereference: true });
-}
-
 export class LocalLambdaStack extends Stack {
   constructor(scope: Construct, id: string, props: StackProps, hostIp: string) {
     console.log('[LocalLambdaStack] Creating local SAM Lambda Stack');
@@ -87,15 +79,6 @@ export class LocalLambdaStack extends Stack {
         dependencies[name] = `file:${relativePath.replace(/\\/g, '/')}`;
       }
 
-      const awsServerlessPackageJson = JSON.parse(
-        fs.readFileSync(path.join(packagesDir, 'aws-serverless', 'package.json'), 'utf8'),
-      ) as { dependencies: Record<string, string> };
-      const conventionsVersion = awsServerlessPackageJson.dependencies['@sentry/conventions'];
-      if (!conventionsVersion) {
-        throw new Error('[LocalLambdaStack] @sentry/aws-serverless does not declare @sentry/conventions');
-      }
-      dependencies['@sentry/conventions'] = conventionsVersion;
-
       console.log(`[LocalLambdaStack] Install dependencies for ${functionName}`);
 
       if (fs.existsSync(lockfilePath)) {
@@ -119,9 +102,6 @@ export class LocalLambdaStack extends Stack {
         stdio: 'inherit',
       });
 
-      // Lambda handler names cannot contain pnpm's `.pnpm` virtual-store path.
-      materializePackage(lambdaPath, '@sentry/aws-serverless');
-
       if (!process.env.NODE_VERSION) {
         throw new Error('[LocalLambdaStack] NODE_VERSION is not set');
       }

packages/aws-serverless/src/integration/awslambda.ts

@@ -1,18 +1,38 @@
 import type { IntegrationFn } from '@sentry/core';
 import { debug, defineIntegration, getCurrentScope, safeSetSpanJSONAttributes } from '@sentry/core';
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { sep, join } from 'node:path';
 import { DEBUG_BUILD } from '../debug-build';
 import { parseHandlerString, resolveHandlerFile } from '../handlerResolution';
 
 const SHIM_MODULE_ID = '@sentry/aws-serverless/run-lambda-handler';
 
+export function findHandlerShimFile(resolvedShimFile: string, nodeModulesPaths: string[] | null): string | undefined {
+  const nodeModulesMarker = `${sep}node_modules${sep}`;
+  const lastNodeModulesIndex = resolvedShimFile.lastIndexOf(nodeModulesMarker);
+  const packageRelativePath =
+    lastNodeModulesIndex < 0 ? undefined : resolvedShimFile.slice(lastNodeModulesIndex + nodeModulesMarker.length);
+
+  const logicalShimFiles = packageRelativePath
+    ? (nodeModulesPaths ?? []).map(nodeModulesPath => join(nodeModulesPath, packageRelativePath))
+    : [];
+
+  return [...logicalShimFiles, resolvedShimFile].find(shimFile => !shimFile.includes('..') && existsSync(shimFile));
+}
+
 function resolveShimFile(): string | undefined {
   try {
     // In the CJS build `require` exists; in the ESM build (and when running the TS source
     // directly, e.g. in tests) we create one. Rollup converts `import.meta.url` to an
     // equivalent for the CJS build, so both branches are always syntactically valid.
     const resolve = typeof require === 'function' ? require.resolve : createRequire(import.meta.url).resolve;
-    return resolve(SHIM_MODULE_ID);
+    const resolvedShimFile = resolve(SHIM_MODULE_ID);
+    const shimFile = findHandlerShimFile(resolvedShimFile, resolve.paths(SHIM_MODULE_ID));
+    if (!shimFile) {
+      DEBUG_BUILD && debug.warn(`Could not find a Lambda-compatible path for ${SHIM_MODULE_ID}.`);
+    }
+    return shimFile;
   } catch (error) {
     DEBUG_BUILD && debug.warn(`Could not resolve ${SHIM_MODULE_ID}, not instrumenting the Lambda handler.`, error);
     return undefined;

packages/aws-serverless/test/awslambda-integration.test.ts

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { awsLambdaIntegration, redirectLambdaHandler } from '../src/integration/awslambda';
+import { awsLambdaIntegration, findHandlerShimFile, redirectLambdaHandler } from '../src/integration/awslambda';
 
 const mockGetScopeData = vi.fn();
 
@@ -45,6 +45,34 @@ describe('redirectLambdaHandler', () => {
     expect(process.env._HANDLER).not.toContain('..');
   });
 
+  test('uses a logical package path when pnpm resolves the shim to an invalid virtual-store path', () => {
+    const nodeModulesPath = path.join(taskRoot, 'node_modules');
+    const logicalShimFile = path.join(
+      nodeModulesPath,
+      '@sentry',
+      'aws-serverless',
+      'build',
+      'npm',
+      'run-lambda-handler.mjs',
+    );
+    fs.mkdirSync(path.dirname(logicalShimFile), { recursive: true });
+    fs.writeFileSync(logicalShimFile, 'export const handler = () => {};');
+
+    const resolvedShimFile = path.join(
+      nodeModulesPath,
+      '.pnpm',
+      '@sentry+aws-serverless@file+..+..+packages+aws-serverless',
+      'node_modules',
+      '@sentry',
+      'aws-serverless',
+      'build',
+      'npm',
+      'run-lambda-handler.mjs',
+    );
+
+    expect(findHandlerShimFile(resolvedShimFile, [nodeModulesPath])).toBe(logicalShimFile);
+  });
+
   test('does nothing when LAMBDA_TASK_ROOT or _HANDLER are not set', () => {
     process.env._HANDLER = 'index.handler';