@sentry/wizard 3.23.2 → 3.24.0

package/src/remix/sdk-setup.ts

@@ -15,18 +15,26 @@ import clack from '@clack/prompts';
 import chalk from 'chalk';
 import { gte, minVersion } from 'semver';
 
-// @ts-expect-error - magicast is ESM and TS complains about that. It works though
-import { builders, generateCode, loadFile, writeFile } from 'magicast';
-import { PackageDotJson, getPackageVersion } from '../utils/package-json';
-import { getInitCallInsertionIndex, hasSentryContent } from './utils';
+import {
+  builders,
+  generateCode,
+  loadFile,
+  parseModule,
+  writeFile,
+  // @ts-expect-error - magicast is ESM and TS complains about that. It works though
+} from 'magicast';
+import type { PackageDotJson } from '../utils/package-json';
+import { getPackageVersion } from '../utils/package-json';
+import {
+  getAfterImportsInsertionIndex,
+  hasSentryContent,
+  serverHasInstrumentationImport,
+} from './utils';
 import { instrumentRootRouteV1 } from './codemods/root-v1';
 import { instrumentRootRouteV2 } from './codemods/root-v2';
 import { instrumentHandleError } from './codemods/handle-error';
-import {
-  findCustomExpressServerImplementation,
-  instrumentExpressCreateRequestHandler,
-} from './codemods/express-server';
 import { getPackageDotJson } from '../utils/clack-utils';
+import { findCustomExpressServerImplementation } from './codemods/express-server';
 
 export type PartialRemixConfig = {
   unstable_dev?: boolean;
@@ -87,7 +95,8 @@ function insertClientInitCall(
   });
 
   const originalHooksModAST = originalHooksMod.$ast as Program;
-  const initCallInsertionIndex = getInitCallInsertionIndex(originalHooksModAST);
+  const initCallInsertionIndex =
+    getAfterImportsInsertionIndex(originalHooksModAST);
 
   originalHooksModAST.body.splice(
     initCallInsertionIndex,
@@ -98,26 +107,76 @@ function insertClientInitCall(
   );
 }
 
-function insertServerInitCall(
-  dsn: string,
-  originalHooksMod: ProxifiedModule<any>,
-) {
+export async function createServerInstrumentationFile(dsn: string) {
+  // create an empty file named `instrument.server.mjs`
+  const instrumentationFile = 'instrumentation.server.mjs';
+  const instrumentationFileMod = parseModule('');
+
+  instrumentationFileMod.imports.$add({
+    from: '@sentry/remix',
+    imported: '*',
+    local: 'Sentry',
+  });
+
   const initCall = builders.functionCall('Sentry.init', {
     dsn,
     tracesSampleRate: 1.0,
+    autoInstrumentRemix: true,
   });
 
-  const originalHooksModAST = originalHooksMod.$ast as Program;
+  const instrumentationFileModAST = instrumentationFileMod.$ast as Program;
 
-  const initCallInsertionIndex = getInitCallInsertionIndex(originalHooksModAST);
+  const initCallInsertionIndex = getAfterImportsInsertionIndex(
+    instrumentationFileModAST,
+  );
 
-  originalHooksModAST.body.splice(
+  instrumentationFileModAST.body.splice(
     initCallInsertionIndex,
     0,
     // @ts-expect-error - string works here because the AST is proxified by magicast
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     generateCode(initCall).code,
   );
+
+  await writeFile(instrumentationFileModAST, instrumentationFile);
+
+  return instrumentationFile;
+}
+
+export async function insertServerInstrumentationFile(dsn: string) {
+  const instrumentationFile = await createServerInstrumentationFile(dsn);
+
+  const expressServerPath = await findCustomExpressServerImplementation();
+
+  if (!expressServerPath) {
+    return false;
+  }
+
+  const originalExpressServerMod = await loadFile(expressServerPath);
+
+  if (
+    serverHasInstrumentationImport(
+      expressServerPath,
+      originalExpressServerMod.$code,
+    )
+  ) {
+    clack.log.warn(
+      `File ${chalk.cyan(
+        path.basename(expressServerPath),
+      )} already contains instrumentation import.
+Skipping adding instrumentation functionality to ${chalk.cyan(
+        path.basename(expressServerPath),
+      )}.`,
+    );
+
+    return true;
+  }
+
+  originalExpressServerMod.$code = `import './${instrumentationFile}';\n${originalExpressServerMod.$code}`;
+
+  fs.writeFileSync(expressServerPath, originalExpressServerMod.$code);
+
+  return true;
 }
 
 export function isRemixV2(
@@ -294,8 +353,56 @@ export async function initializeSentryOnEntryClient(
   );
 }
 
-export async function initializeSentryOnEntryServer(
-  dsn: string,
+export async function updateStartScript(instrumentationFile: string) {
+  const packageJson = await getPackageDotJson();
+
+  if (!packageJson.scripts || !packageJson.scripts.start) {
+    throw new Error(
+      "Couldn't find a `start` script in your package.json. Please add one manually.",
+    );
+  }
+
+  if (packageJson.scripts.start.includes('NODE_OPTIONS')) {
+    clack.log.warn(
+      `Found existing NODE_OPTIONS in ${chalk.cyan(
+        'start',
+      )} script. Skipping adding Sentry initialization.`,
+    );
+
+    return;
+  }
+
+  if (
+    !packageJson.scripts.start.includes('remix-serve') &&
+    // Adding a following empty space not to match a path that includes `node`
+    !packageJson.scripts.start.includes('node ')
+  ) {
+    clack.log.warn(
+      `Found a ${chalk.cyan('start')} script that doesn't use ${chalk.cyan(
+        'remix-serve',
+      )} or ${chalk.cyan('node')}. Skipping adding Sentry initialization.`,
+    );
+
+    return;
+  }
+
+  const startCommand = packageJson.scripts.start;
+
+  packageJson.scripts.start = `NODE_OPTIONS='--import ./${instrumentationFile}' ${startCommand}`;
+
+  await fs.promises.writeFile(
+    path.join(process.cwd(), 'package.json'),
+    JSON.stringify(packageJson, null, 2),
+  );
+
+  clack.log.success(
+    `Successfully updated ${chalk.cyan('start')} script in ${chalk.cyan(
+      'package.json',
+    )} to include Sentry initialization on start.`,
+  );
+}
+
+export async function instrumentSentryOnEntryServer(
   isV2: boolean,
   isTS: boolean,
 ): Promise<void> {
@@ -319,8 +426,6 @@ export async function initializeSentryOnEntryServer(
     local: 'Sentry',
   });
 
-  insertServerInitCall(dsn, originalEntryServerMod);
-
   if (isV2) {
     const handleErrorInstrumented = instrumentHandleError(
       originalEntryServerMod,
@@ -347,16 +452,3 @@ export async function initializeSentryOnEntryServer(
     )}.`,
   );
 }
-
-export async function instrumentExpressServer() {
-  const expressServerPath = await findCustomExpressServerImplementation();
-
-  if (!expressServerPath) {
-    clack.log.warn(
-      `Could not find custom Express server implementation. Please instrument it manually.`,
-    );
-    return;
-  }
-
-  await instrumentExpressCreateRequestHandler(expressServerPath);
-}

package/src/remix/templates.ts

@@ -6,6 +6,6 @@ export const ERROR_BOUNDARY_TEMPLATE_V2 = `const ErrorBoundary = () => {
 `;
 
 export const HANDLE_ERROR_TEMPLATE_V2 = `function handleError(error, { request }) {
-  Sentry.captureRemixServerException(error, 'remix.server', request);
+  Sentry.captureRemixServerException(error, 'remix.server', request, true);
 }
 `;

package/src/remix/utils.ts

@@ -7,16 +7,23 @@ import clack from '@clack/prompts';
 import chalk from 'chalk';
 import { PackageDotJson, hasPackageInstalled } from '../utils/package-json';
 
-// Copied from sveltekit wizard
+export const POSSIBLE_SERVER_INSTRUMENTATION_PATHS = [
+  './instrumentation',
+  './instrumentation.server',
+];
+
 export function hasSentryContent(
   fileName: string,
   fileContent: string,
+  expectedContent = '@sentry/remix',
 ): boolean {
-  const includesContent = fileContent.includes('@sentry/remix');
+  const includesContent = fileContent.includes(expectedContent);
 
   if (includesContent) {
     clack.log.warn(
-      `File ${chalk.cyan(path.basename(fileName))} already contains Sentry code.
+      `File ${chalk.cyan(
+        path.basename(fileName),
+      )} already contains ${expectedContent}.
 Skipping adding Sentry functionality to ${chalk.cyan(
         path.basename(fileName),
       )}.`,
@@ -26,14 +33,57 @@ Skipping adding Sentry functionality to ${chalk.cyan(
   return includesContent;
 }
 
+export function serverHasInstrumentationImport(
+  serverFileName: string,
+  serverFileContent: string,
+): boolean {
+  const includesServerInstrumentationImport =
+    POSSIBLE_SERVER_INSTRUMENTATION_PATHS.some((path) =>
+      serverFileContent.includes(path),
+    );
+
+  if (includesServerInstrumentationImport) {
+    clack.log.warn(
+      `File ${chalk.cyan(
+        path.basename(serverFileName),
+      )} already contains instrumentation import.
+Skipping adding instrumentation functionality to ${chalk.cyan(
+        path.basename(serverFileName),
+      )}.`,
+    );
+  }
+
+  return includesServerInstrumentationImport;
+}
+
 /**
- * We want to insert the init call on top of the file but after all import statements
+ * We want to insert the init call on top of the file, before any other imports.
  */
-export function getInitCallInsertionIndex(
+export function getBeforeImportsInsertionIndex(
   originalHooksModAST: Program,
 ): number {
-  for (let x = originalHooksModAST.body.length - 1; x >= 0; x--) {
-    if (originalHooksModAST.body[x].type === 'ImportDeclaration') {
+  for (let x = 0; x < originalHooksModAST.body.length - 1; x++) {
+    if (
+      originalHooksModAST.body[x].type === 'ImportDeclaration' &&
+      // @ts-expect-error - source is available in body
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      originalHooksModAST.body[x].source.value === '@sentry/remix'
+    ) {
+      return x + 1;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * We want to insert the handleError function just after all imports
+ */
+export function getAfterImportsInsertionIndex(
+  originalEntryServerModAST: Program,
+): number {
+  for (let x = originalEntryServerModAST.body.length - 1; x >= 0; x--) {
+    if (originalEntryServerModAST.body[x].type === 'ImportDeclaration') {
       return x + 1;
     }
   }