@sentry/wizard 3.13.0 → 3.14.1

package/src/nextjs/nextjs-wizard.ts

@@ -7,11 +7,13 @@ import * as fs from 'fs';
 import { builders, generateCode, parseModule } from 'magicast';
 import * as path from 'path';
 
+import * as Sentry from '@sentry/node';
+
 import {
   abort,
   abortIfCancelled,
   addSentryCliConfig,
-  confirmContinueEvenThoughNoGitRepo,
+  confirmContinueIfNoOrDirtyGitRepo,
   ensurePackageIsInstalled,
   getOrAskForProjectData,
   getPackageDotJson,
@@ -19,7 +21,7 @@ import {
   isUsingTypeScript,
   printWelcome,
 } from '../utils/clack-utils';
-import { WizardOptions } from '../utils/types';
+import { SentryProjectData, WizardOptions } from '../utils/types';
 import {
   getNextjsConfigCjsAppendix,
   getNextjsConfigCjsTemplate,
@@ -31,88 +33,158 @@ import {
   getSentryExampleAppDirApiRoute,
   getSentryExamplePageContents,
 } from './templates';
+import { traceStep, withTelemetry } from '../telemetry';
+import { getPackageVersion, hasPackageInstalled } from '../utils/package-json';
+import { getNextJsVersionBucket } from './utils';
+
+export function runNextjsWizard(options: WizardOptions) {
+  return withTelemetry(
+    {
+      enabled: options.telemetryEnabled,
+      integration: 'nextjs',
+    },
+    () => runNextjsWizardWithTelemetry(options),
+  );
+}
 
-// eslint-disable-next-line complexity
-export async function runNextjsWizard(options: WizardOptions): Promise<void> {
+export async function runNextjsWizardWithTelemetry(
+  options: WizardOptions,
+): Promise<void> {
   printWelcome({
     wizardName: 'Sentry Next.js Wizard',
     promoCode: options.promoCode,
+    telemetryEnabled: options.telemetryEnabled,
   });
 
-  await confirmContinueEvenThoughNoGitRepo();
+  await confirmContinueIfNoOrDirtyGitRepo();
 
   const packageJson = await getPackageDotJson();
+
   await ensurePackageIsInstalled(packageJson, 'next', 'Next.js');
 
+  const nextVersion = getPackageVersion('next', packageJson);
+  Sentry.setTag('nextjs-version', getNextJsVersionBucket(nextVersion));
+
   const { selectedProject, authToken, selfHosted, sentryUrl } =
     await getOrAskForProjectData(options, 'javascript-nextjs');
 
+  const sdkAlreadyInstalled = hasPackageInstalled(
+    '@sentry/nextjs',
+    packageJson,
+  );
+  Sentry.setTag('sdk-already-installed', sdkAlreadyInstalled);
+
   await installPackage({
     packageName: '@sentry/nextjs',
     alreadyInstalled: !!packageJson?.dependencies?.['@sentry/nextjs'],
   });
 
-  const typeScriptDetected = isUsingTypeScript();
+  await traceStep('configure-sdk', async () =>
+    createOrMergeNextJsFiles(selectedProject, selfHosted, sentryUrl),
+  );
 
-  const configVariants = ['server', 'client', 'edge'] as const;
+  await traceStep('create-example-page', async () =>
+    createExamplePage(selfHosted, selectedProject, sentryUrl),
+  );
 
-  for (const configVariant of configVariants) {
-    const jsConfig = `sentry.${configVariant}.config.js`;
-    const tsConfig = `sentry.${configVariant}.config.ts`;
+  await addSentryCliConfig(authToken);
+
+  const mightBeUsingVercel = fs.existsSync(
+    path.join(process.cwd(), 'vercel.json'),
+  );
 
-    const jsConfigExists = fs.existsSync(path.join(process.cwd(), jsConfig));
-    const tsConfigExists = fs.existsSync(path.join(process.cwd(), tsConfig));
+  clack.outro(
+    `${chalk.green('Everything is set up!')}
 
-    let shouldWriteFile = true;
+   ${chalk.cyan(
+     'You can validate your setup by starting your dev environment (`next dev`) and visiting "/sentry-example-page".',
+   )}
+${
+  mightBeUsingVercel
+    ? `
+   ▲ It seems like you're using Vercel. We recommend using the Sentry Vercel integration: https://vercel.com/integrations/sentry
+`
+    : ''
+}
+   ${chalk.dim(
+     'If you encounter any issues, let us know here: https://github.com/getsentry/sentry-javascript/issues',
+   )}`,
+  );
+}
 
-    if (jsConfigExists || tsConfigExists) {
-      const existingConfigs = [];
+async function createOrMergeNextJsFiles(
+  selectedProject: SentryProjectData,
+  selfHosted: boolean,
+  sentryUrl: string,
+) {
+  const typeScriptDetected = isUsingTypeScript();
 
-      if (jsConfigExists) {
-        existingConfigs.push(jsConfig);
-      }
+  const configVariants = ['server', 'client', 'edge'] as const;
 
-      if (tsConfigExists) {
-        existingConfigs.push(tsConfig);
-      }
+  for (const configVariant of configVariants) {
+    await traceStep(`create-sentry-${configVariant}-config`, async () => {
+      const jsConfig = `sentry.${configVariant}.config.js`;
+      const tsConfig = `sentry.${configVariant}.config.ts`;
 
-      const overwriteExistingConfigs = await abortIfCancelled(
-        clack.confirm({
-          message: `Found existing Sentry ${configVariant} config (${existingConfigs.join(
-            ', ',
-          )}). Overwrite ${existingConfigs.length > 1 ? 'them' : 'it'}?`,
-        }),
-      );
+      const jsConfigExists = fs.existsSync(path.join(process.cwd(), jsConfig));
+      const tsConfigExists = fs.existsSync(path.join(process.cwd(), tsConfig));
 
-      shouldWriteFile = overwriteExistingConfigs;
+      let shouldWriteFile = true;
+
+      if (jsConfigExists || tsConfigExists) {
+        const existingConfigs = [];
 
-      if (overwriteExistingConfigs) {
         if (jsConfigExists) {
-          fs.unlinkSync(path.join(process.cwd(), jsConfig));
-          clack.log.warn(`Removed existing ${chalk.bold(jsConfig)}.`);
+          existingConfigs.push(jsConfig);
         }
+
         if (tsConfigExists) {
-          fs.unlinkSync(path.join(process.cwd(), tsConfig));
-          clack.log.warn(`Removed existing ${chalk.bold(tsConfig)}.`);
+          existingConfigs.push(tsConfig);
+        }
+
+        const overwriteExistingConfigs = await abortIfCancelled(
+          clack.confirm({
+            message: `Found existing Sentry ${configVariant} config (${existingConfigs.join(
+              ', ',
+            )}). Overwrite ${existingConfigs.length > 1 ? 'them' : 'it'}?`,
+          }),
+        );
+        Sentry.setTag(
+          `overwrite-${configVariant}-config`,
+          overwriteExistingConfigs,
+        );
+
+        shouldWriteFile = overwriteExistingConfigs;
+
+        if (overwriteExistingConfigs) {
+          if (jsConfigExists) {
+            fs.unlinkSync(path.join(process.cwd(), jsConfig));
+            clack.log.warn(`Removed existing ${chalk.bold(jsConfig)}.`);
+          }
+          if (tsConfigExists) {
+            fs.unlinkSync(path.join(process.cwd(), tsConfig));
+            clack.log.warn(`Removed existing ${chalk.bold(tsConfig)}.`);
+          }
         }
       }
-    }
 
-    if (shouldWriteFile) {
-      await fs.promises.writeFile(
-        path.join(process.cwd(), typeScriptDetected ? tsConfig : jsConfig),
-        getSentryConfigContents(
-          selectedProject.keys[0].dsn.public,
-          configVariant,
-        ),
-        { encoding: 'utf8', flag: 'w' },
-      );
-      clack.log.success(
-        `Created fresh ${chalk.bold(
-          typeScriptDetected ? tsConfig : jsConfig,
-        )}.`,
-      );
-    }
+      if (shouldWriteFile) {
+        await fs.promises.writeFile(
+          path.join(process.cwd(), typeScriptDetected ? tsConfig : jsConfig),
+          getSentryConfigContents(
+            selectedProject.keys[0].dsn.public,
+            configVariant,
+          ),
+          { encoding: 'utf8', flag: 'w' },
+        );
+        clack.log.success(
+          `Created fresh ${chalk.bold(
+            typeScriptDetected ? tsConfig : jsConfig,
+          )}.`,
+        );
+        Sentry.setTag(`created-${configVariant}-config`, true);
+      }
+    });
   }
 
   const sentryWebpackOptionsTemplate = getNextjsWebpackPluginOptionsTemplate(
@@ -126,162 +198,179 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
   const nextConfigJs = 'next.config.js';
   const nextConfigMjs = 'next.config.mjs';
 
-  const nextConfigJsExists = fs.existsSync(
-    path.join(process.cwd(), nextConfigJs),
-  );
-  const nextConfigMjsExists = fs.existsSync(
-    path.join(process.cwd(), nextConfigMjs),
-  );
-
-  if (!nextConfigJsExists && !nextConfigMjsExists) {
-    await fs.promises.writeFile(
+  await traceStep('setup-next-config', async () => {
+    const nextConfigJsExists = fs.existsSync(
       path.join(process.cwd(), nextConfigJs),
-      getNextjsConfigCjsTemplate(
-        sentryWebpackOptionsTemplate,
-        sentryBuildOptionsTemplate,
-      ),
-      { encoding: 'utf8', flag: 'w' },
-    );
-
-    clack.log.success(
-      `Created ${chalk.bold('next.config.js')} with Sentry configuration.`,
     );
-  }
-
-  if (nextConfigJsExists) {
-    const nextConfgiJsContent = fs.readFileSync(
-      path.join(process.cwd(), nextConfigJs),
-      'utf8',
+    const nextConfigMjsExists = fs.existsSync(
+      path.join(process.cwd(), nextConfigMjs),
     );
 
-    const probablyIncludesSdk =
-      nextConfgiJsContent.includes('@sentry/nextjs') &&
-      nextConfgiJsContent.includes('withSentryConfig');
-
-    let shouldInject = true;
-
-    if (probablyIncludesSdk) {
-      const injectAnyhow = await abortIfCancelled(
-        clack.confirm({
-          message: `${chalk.bold(
-            nextConfigJs,
-          )} already contains Sentry SDK configuration. Should the wizard modify it anyways?`,
-        }),
-      );
-
-      shouldInject = injectAnyhow;
-    }
+    if (!nextConfigJsExists && !nextConfigMjsExists) {
+      Sentry.setTag('next-config-strategy', 'create');
 
-    if (shouldInject) {
-      await fs.promises.appendFile(
+      await fs.promises.writeFile(
         path.join(process.cwd(), nextConfigJs),
-        getNextjsConfigCjsAppendix(
+        getNextjsConfigCjsTemplate(
           sentryWebpackOptionsTemplate,
           sentryBuildOptionsTemplate,
         ),
-        'utf8',
+        { encoding: 'utf8', flag: 'w' },
       );
 
       clack.log.success(
-        `Added Sentry configuration to ${chalk.bold(nextConfigJs)}. ${chalk.dim(
-          '(you probably want to clean this up a bit!)',
-        )}`,
+        `Created ${chalk.bold('next.config.js')} with Sentry configuration.`,
       );
     }
-  }
 
-  if (nextConfigMjsExists) {
-    const nextConfgiMjsContent = fs.readFileSync(
-      path.join(process.cwd(), nextConfigMjs),
-      'utf8',
-    );
+    if (nextConfigJsExists) {
+      Sentry.setTag('next-config-strategy', 'modify');
 
-    const probablyIncludesSdk =
-      nextConfgiMjsContent.includes('@sentry/nextjs') &&
-      nextConfgiMjsContent.includes('withSentryConfig');
+      const nextConfgiJsContent = fs.readFileSync(
+        path.join(process.cwd(), nextConfigJs),
+        'utf8',
+      );
 
-    let shouldInject = true;
+      const probablyIncludesSdk =
+        nextConfgiJsContent.includes('@sentry/nextjs') &&
+        nextConfgiJsContent.includes('withSentryConfig');
 
-    if (probablyIncludesSdk) {
-      const injectAnyhow = await abortIfCancelled(
-        clack.confirm({
-          message: `${chalk.bold(
-            nextConfigMjs,
-          )} already contains Sentry SDK configuration. Should the wizard modify it anyways?`,
-        }),
-      );
+      let shouldInject = true;
 
-      shouldInject = injectAnyhow;
-    }
+      if (probablyIncludesSdk) {
+        const injectAnyhow = await abortIfCancelled(
+          clack.confirm({
+            message: `${chalk.bold(
+              nextConfigJs,
+            )} already contains Sentry SDK configuration. Should the wizard modify it anyways?`,
+          }),
+        );
 
-    try {
-      if (shouldInject) {
-        const mod = parseModule(nextConfgiMjsContent);
-        mod.imports.$add({
-          from: '@sentry/nextjs',
-          imported: 'withSentryConfig',
-          local: 'withSentryConfig',
-        });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-        const expressionToWrap = generateCode(mod.exports.default.$ast).code;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        mod.exports.default = builders.raw(`withSentryConfig(
-      ${expressionToWrap},
-      ${sentryWebpackOptionsTemplate},
-      ${sentryBuildOptionsTemplate}
-)`);
-        const newCode = mod.generate().code;
+        shouldInject = injectAnyhow;
+      }
 
-        await fs.promises.writeFile(
-          path.join(process.cwd(), nextConfigMjs),
-          newCode,
-          {
-            encoding: 'utf8',
-            flag: 'w',
-          },
+      if (shouldInject) {
+        await fs.promises.appendFile(
+          path.join(process.cwd(), nextConfigJs),
+          getNextjsConfigCjsAppendix(
+            sentryWebpackOptionsTemplate,
+            sentryBuildOptionsTemplate,
+          ),
+          'utf8',
         );
+
         clack.log.success(
           `Added Sentry configuration to ${chalk.bold(
-            nextConfigMjs,
+            nextConfigJs,
           )}. ${chalk.dim('(you probably want to clean this up a bit!)')}`,
         );
       }
-    } catch {
-      clack.log.warn(
-        chalk.yellow(
-          `Something went wrong writing to ${chalk.bold(nextConfigMjs)}`,
-        ),
-      );
-      clack.log.info(
-        `Please put the following code snippet into ${chalk.bold(
-          nextConfigMjs,
-        )}: ${chalk.dim('You probably have to clean it up a bit.')}\n`,
-      );
 
-      // eslint-disable-next-line no-console
-      console.log(
-        getNextjsConfigEsmCopyPasteSnippet(
-          sentryWebpackOptionsTemplate,
-          sentryBuildOptionsTemplate,
-        ),
+      Sentry.setTag('next-config-mod-result', 'success');
+    }
+
+    if (nextConfigMjsExists) {
+      const nextConfgiMjsContent = fs.readFileSync(
+        path.join(process.cwd(), nextConfigMjs),
+        'utf8',
       );
 
-      const shouldContinue = await abortIfCancelled(
-        clack.confirm({
-          message: `Are you done putting the snippet above into ${chalk.bold(
+      const probablyIncludesSdk =
+        nextConfgiMjsContent.includes('@sentry/nextjs') &&
+        nextConfgiMjsContent.includes('withSentryConfig');
+
+      let shouldInject = true;
+
+      if (probablyIncludesSdk) {
+        const injectAnyhow = await abortIfCancelled(
+          clack.confirm({
+            message: `${chalk.bold(
+              nextConfigMjs,
+            )} already contains Sentry SDK configuration. Should the wizard modify it anyways?`,
+          }),
+        );
+
+        shouldInject = injectAnyhow;
+      }
+
+      try {
+        if (shouldInject) {
+          const mod = parseModule(nextConfgiMjsContent);
+          mod.imports.$add({
+            from: '@sentry/nextjs',
+            imported: 'withSentryConfig',
+            local: 'withSentryConfig',
+          });
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+          const expressionToWrap = generateCode(mod.exports.default.$ast).code;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          mod.exports.default = builders.raw(`withSentryConfig(
+      ${expressionToWrap},
+      ${sentryWebpackOptionsTemplate},
+      ${sentryBuildOptionsTemplate}
+)`);
+          const newCode = mod.generate().code;
+
+          await fs.promises.writeFile(
+            path.join(process.cwd(), nextConfigMjs),
+            newCode,
+            {
+              encoding: 'utf8',
+              flag: 'w',
+            },
+          );
+          clack.log.success(
+            `Added Sentry configuration to ${chalk.bold(
+              nextConfigMjs,
+            )}. ${chalk.dim('(you probably want to clean this up a bit!)')}`,
+          );
+
+          Sentry.setTag('next-config-mod-result', 'success');
+        }
+      } catch {
+        Sentry.setTag('next-config-mod-result', 'fail');
+        clack.log.warn(
+          chalk.yellow(
+            `Something went wrong writing to ${chalk.bold(nextConfigMjs)}`,
+          ),
+        );
+        clack.log.info(
+          `Please put the following code snippet into ${chalk.bold(
             nextConfigMjs,
-          )}?`,
-          active: 'Yes',
-          inactive: 'No, get me out of here',
-        }),
-      );
+          )}: ${chalk.dim('You probably have to clean it up a bit.')}\n`,
+        );
+
+        // eslint-disable-next-line no-console
+        console.log(
+          getNextjsConfigEsmCopyPasteSnippet(
+            sentryWebpackOptionsTemplate,
+            sentryBuildOptionsTemplate,
+          ),
+        );
+
+        const shouldContinue = await abortIfCancelled(
+          clack.confirm({
+            message: `Are you done putting the snippet above into ${chalk.bold(
+              nextConfigMjs,
+            )}?`,
+            active: 'Yes',
+            inactive: 'No, get me out of here',
+          }),
+        );
 
-      if (!shouldContinue) {
-        await abort();
+        if (!shouldContinue) {
+          await abort();
+        }
       }
     }
-  }
+  });
+}
 
+async function createExamplePage(
+  selfHosted: boolean,
+  selectedProject: SentryProjectData,
+  sentryUrl: string,
+): Promise<void> {
   const srcDir = path.join(process.cwd(), 'src');
   const maybePagesDirPath = path.join(process.cwd(), 'pages');
   const maybeSrcPagesDirPath = path.join(srcDir, 'pages');
@@ -316,6 +405,8 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
     });
   }
 
+  Sentry.setTag('nextjs-app-dir', !!appLocation);
+
   if (appLocation) {
     const examplePageContents = getSentryExamplePageContents({
       selfHosted,
@@ -415,28 +506,4 @@ export async function runNextjsWizard(options: WizardOptions): Promise<void> {
       )}.`,
     );
   }
-
-  await addSentryCliConfig(authToken);
-
-  const mightBeUsingVercel = fs.existsSync(
-    path.join(process.cwd(), 'vercel.json'),
-  );
-
-  clack.outro(
-    `${chalk.green('Everything is set up!')}
-
-   ${chalk.cyan(
-     'You can validate your setup by starting your dev environment (`next dev`) and visiting "/sentry-example-page".',
-   )}
-${
-  mightBeUsingVercel
-    ? `
-   ▲ It seems like you're using Vercel. We recommend using the Sentry Vercel integration: https://vercel.com/integrations/sentry
-`
-    : ''
-}
-   ${chalk.dim(
-     'If you encounter any issues, let us know here: https://github.com/getsentry/sentry-javascript/issues',
-   )}`,
-  );
 }

package/src/nextjs/utils.ts

@@ -0,0 +1,21 @@
+import { major, minVersion } from 'semver';
+
+export function getNextJsVersionBucket(version: string | undefined) {
+  if (!version) {
+    return 'none';
+  }
+
+  try {
+    const minVer = minVersion(version);
+    if (!minVer) {
+      return 'invalid';
+    }
+    const majorVersion = major(minVer);
+    if (majorVersion >= 11) {
+      return `${majorVersion}.x`;
+    }
+    return '<11.0.0';
+  } catch {
+    return 'unknown';
+  }
+}

package/src/remix/remix-wizard.ts

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 
 import {
   addSentryCliConfig,
-  confirmContinueEvenThoughNoGitRepo,
+  confirmContinueIfNoOrDirtyGitRepo,
   ensurePackageIsInstalled,
   getOrAskForProjectData,
   getPackageDotJson,
@@ -45,7 +45,7 @@ async function runRemixWizardWithTelemetry(
     telemetryEnabled: options.telemetryEnabled,
   });
 
-  await confirmContinueEvenThoughNoGitRepo();
+  await confirmContinueIfNoOrDirtyGitRepo();
 
   const remixConfig = await loadRemixConfig();
   const packageJson = await getPackageDotJson();
@@ -56,12 +56,10 @@ async function runRemixWizardWithTelemetry(
   const { selectedProject, authToken, sentryUrl } =
     await getOrAskForProjectData(options, 'javascript-remix');
 
-  await traceStep('Install Sentry SDK', () =>
-    installPackage({
-      packageName: '@sentry/remix',
-      alreadyInstalled: hasPackageInstalled('@sentry/remix', packageJson),
-    }),
-  );
+  await installPackage({
+    packageName: '@sentry/remix',
+    alreadyInstalled: hasPackageInstalled('@sentry/remix', packageJson),
+  });
 
   const dsn = selectedProject.keys[0].dsn.public;
 
@@ -107,7 +105,7 @@ async function runRemixWizardWithTelemetry(
 
   await traceStep('Initialize Sentry on server entry', async () => {
     try {
-      await initializeSentryOnEntryServer(dsn, isTS, isV2);
+      await initializeSentryOnEntryServer(dsn, isV2, isTS);
     } catch (e) {
       clack.log.warn(`Could not initialize Sentry on server entry.
   Please do it manually using instructions from https://docs.sentry.io/platforms/javascript/guides/remix/`);

package/src/remix/sdk-setup.ts

@@ -12,7 +12,7 @@ import * as url from 'url';
 // @ts-expect-error - clack is ESM and TS complains about that. It works though
 import clack from '@clack/prompts';
 import chalk from 'chalk';
-import { parse } from 'semver';
+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';
@@ -97,8 +97,17 @@ export function isRemixV2(
   packageJson: PackageDotJson,
 ): boolean {
   const remixVersion = getPackageVersion('@remix-run/react', packageJson);
-  const remixVersionMajor = remixVersion && parse(remixVersion)?.major;
-  const isV2Remix = remixVersionMajor && remixVersionMajor >= 2;
+  if (!remixVersion) {
+    return false;
+  }
+
+  const minVer = minVersion(remixVersion);
+
+  if (!minVer) {
+    return false;
+  }
+
+  const isV2Remix = gte(minVer, '2.0.0');
 
   return isV2Remix || remixConfig?.future?.v2_errorBoundary || false;
 }

package/src/sourcemaps/sourcemaps-wizard.ts

@@ -6,7 +6,7 @@ import * as Sentry from '@sentry/node';
 import {
   abort,
   abortIfCancelled,
-  confirmContinueEvenThoughNoGitRepo,
+  confirmContinueIfNoOrDirtyGitRepo,
   SENTRY_DOT_ENV_FILE,
   printWelcome,
   SENTRY_CLI_RC_FILE,
@@ -70,7 +70,7 @@ You can turn this off by running the wizard with the '--disable-telemetry' flag.
     return;
   }
 
-  await traceStep('detect-git', confirmContinueEvenThoughNoGitRepo);
+  await confirmContinueIfNoOrDirtyGitRepo();
 
   await traceStep('check-sdk-version', ensureMinimumSdkVersionIsInstalled);