@sentry/wizard 3.13.0 → 3.14.1

package/src/sveltekit/sdk-setup.ts

@@ -440,14 +440,14 @@ async function modifyViteConfig(
 
   const { org, project, url, selfHosted } = projectInfo;
 
+  const prettyViteConfigFilename = chalk.cyan(path.basename(viteConfigPath));
+
   try {
     const viteModule = parseModule(viteConfigContent);
 
     if (hasSentryContent(viteModule.$ast as t.Program)) {
       clack.log.warn(
-        `File ${chalk.cyan(
-          path.basename(viteConfigPath),
-        )} already contains Sentry code.
+        `File ${prettyViteConfigFilename} already contains Sentry code.
 Skipping adding Sentry functionality to.`,
       );
       Sentry.setTag(`modified-vite-cfg`, 'fail');
@@ -490,6 +490,9 @@ Skipping adding Sentry functionality to.`,
     );
     Sentry.captureException('Sveltekit Vite Config Modification Fail');
   }
+
+  clack.log.success(`Added Sentry code to ${prettyViteConfigFilename}`);
+  Sentry.setTag(`modified-vite-cfg`, 'success');
 }
 
 async function showFallbackViteCopyPasteSnippet(

package/src/sveltekit/sveltekit-wizard.ts

@@ -8,7 +8,7 @@ import {
   abort,
   abortIfCancelled,
   addSentryCliConfig,
-  confirmContinueEvenThoughNoGitRepo,
+  confirmContinueIfNoOrDirtyGitRepo,
   ensurePackageIsInstalled,
   getOrAskForProjectData,
   getPackageDotJson,
@@ -43,12 +43,11 @@ export async function runSvelteKitWizardWithTelemetry(
     telemetryEnabled: options.telemetryEnabled,
   });
 
-  await traceStep('detect-git', confirmContinueEvenThoughNoGitRepo);
+  await confirmContinueIfNoOrDirtyGitRepo();
 
   const packageJson = await getPackageDotJson();
-  await traceStep('detect-framework-version', () =>
-    ensurePackageIsInstalled(packageJson, '@sveltejs/kit', 'Sveltekit'),
-  );
+
+  await ensurePackageIsInstalled(packageJson, '@sveltejs/kit', 'Sveltekit');
 
   const kitVersion = getPackageVersion('@sveltejs/kit', packageJson);
   const kitVersionBucket = getKitVersionBucket(kitVersion);
@@ -91,14 +90,12 @@ export async function runSvelteKitWizardWithTelemetry(
   );
   Sentry.setTag('sdk-already-installed', sdkAlreadyInstalled);
 
-  await traceStep('install-sdk', () =>
-    installPackage({
-      packageName: '@sentry/sveltekit',
-      alreadyInstalled: sdkAlreadyInstalled,
-    }),
-  );
+  await installPackage({
+    packageName: '@sentry/sveltekit',
+    alreadyInstalled: sdkAlreadyInstalled,
+  });
 
-  await traceStep('add-cli-config', () => addSentryCliConfig(authToken));
+  await addSentryCliConfig(authToken);
 
   const svelteConfig = await traceStep('load-svelte-config', loadSvelteConfig);
 

package/src/telemetry.ts

@@ -6,7 +6,8 @@ import {
   makeNodeTransport,
   NodeClient,
   runWithAsyncContext,
-  trace,
+  setTag,
+  startSpan,
 } from '@sentry/node';
 import packageJson from '../package.json';
 
@@ -24,24 +25,29 @@ export async function withTelemetry<F>(
 
   makeMain(sentryHub);
 
-  const transaction = sentryHub.startTransaction({
-    name: 'sentry-wizard-execution',
-    status: 'ok',
-    op: 'wizard.flow',
-  });
-  sentryHub.getScope().setSpan(transaction);
   const sentrySession = sentryHub.startSession();
   sentryHub.captureSession();
 
   try {
-    return await runWithAsyncContext(() => callback());
+    return await startSpan(
+      {
+        name: 'sentry-wizard-execution',
+        status: 'ok',
+        op: 'wizard.flow',
+      },
+      async () => {
+        updateProgress('start');
+        const res = await runWithAsyncContext(callback);
+        updateProgress('finished');
+
+        return res;
+      },
+    );
   } catch (e) {
     sentryHub.captureException('Error during wizard execution.');
-    transaction.setStatus('internal_error');
     sentrySession.status = 'crashed';
     throw e;
   } finally {
-    transaction.finish();
     sentryHub.endSession();
     await sentryClient.flush(3000);
   }
@@ -92,5 +98,10 @@ function createSentryInstance(enabled: boolean, integration: string) {
 }
 
 export function traceStep<T>(step: string, callback: () => T): T {
-  return trace({ name: step, op: 'wizard.step' }, () => callback());
+  updateProgress(step);
+  return startSpan({ name: step, op: 'wizard.step' }, () => callback());
+}
+
+export function updateProgress(step: string) {
+  setTag('progress', step);
 }

package/src/utils/clack-utils.ts

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import * as childProcess from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { setInterval } from 'timers';
 import { URL } from 'url';
 import * as Sentry from '@sentry/node';
@@ -147,24 +148,73 @@ You can turn this off at any time by running ${chalk.cyanBright(
   clack.note(welcomeText);
 }
 
-export async function confirmContinueEvenThoughNoGitRepo(): Promise<void> {
+export async function confirmContinueIfNoOrDirtyGitRepo(): Promise<void> {
+  return traceStep('check-git-status', async () => {
+    if (!isInGitRepo()) {
+      const continueWithoutGit = await abortIfCancelled(
+        clack.confirm({
+          message:
+            'You are not inside a git repository. The wizard will create and update files. Do you want to continue anyway?',
+        }),
+      );
+
+      Sentry.setTag('continue-without-git', continueWithoutGit);
+
+      if (!continueWithoutGit) {
+        await abort(undefined, 0);
+      }
+    }
+
+    const uncommittedOrUntrackedFiles = getUncommittedOrUntrackedFiles();
+    if (uncommittedOrUntrackedFiles.length) {
+      clack.log.warn(
+        `You have uncommitted or untracked files in your repo:
+
+${uncommittedOrUntrackedFiles.join('\n')}
+
+The wizard will create and update files.`,
+      );
+      const continueWithDirtyRepo = await abortIfCancelled(
+        clack.confirm({
+          message: 'Do you want to continue anyway?',
+        }),
+      );
+
+      Sentry.setTag('continue-with-dirty-repo', continueWithDirtyRepo);
+
+      if (!continueWithDirtyRepo) {
+        await abort(undefined, 0);
+      }
+    }
+  });
+}
+
+function isInGitRepo() {
   try {
     childProcess.execSync('git rev-parse --is-inside-work-tree', {
       stdio: 'ignore',
     });
+    return true;
   } catch {
-    const continueWithoutGit = await abortIfCancelled(
-      clack.confirm({
-        message:
-          'You are not inside a git repository. The wizard will create and update files. Do you still want to continue?',
-      }),
-    );
+    return false;
+  }
+}
 
-    Sentry.setTag('continue-without-git', continueWithoutGit);
+function getUncommittedOrUntrackedFiles(): string[] {
+  try {
+    const gitStatus = childProcess
+      .execSync('git status --porcelain=v1')
+      .toString();
 
-    if (!continueWithoutGit) {
-      await abort(undefined, 0);
-    }
+    const files = gitStatus
+      .split(os.EOL)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((f) => `- ${f.split(/\s+/)[1]}`);
+
+    return files;
+  } catch {
+    return [];
   }
 }
 
@@ -207,123 +257,127 @@ export async function installPackage({
   alreadyInstalled: boolean;
   askBeforeUpdating?: boolean;
 }): Promise<void> {
-  if (alreadyInstalled && askBeforeUpdating) {
-    const shouldUpdatePackage = await abortIfCancelled(
-      clack.confirm({
-        message: `The ${chalk.bold.cyan(
-          packageName,
-        )} package is already installed. Do you want to update it to the latest version?`,
-      }),
-    );
+  return traceStep('install-package', async () => {
+    if (alreadyInstalled && askBeforeUpdating) {
+      const shouldUpdatePackage = await abortIfCancelled(
+        clack.confirm({
+          message: `The ${chalk.bold.cyan(
+            packageName,
+          )} package is already installed. Do you want to update it to the latest version?`,
+        }),
+      );
 
-    if (!shouldUpdatePackage) {
-      return;
+      if (!shouldUpdatePackage) {
+        return;
+      }
     }
-  }
-
-  const sdkInstallSpinner = clack.spinner();
 
-  const packageManager = await getPackageManager();
+    const sdkInstallSpinner = clack.spinner();
 
-  sdkInstallSpinner.start(
-    `${alreadyInstalled ? 'Updating' : 'Installing'} ${chalk.bold.cyan(
-      packageName,
-    )} with ${chalk.bold(packageManager.label)}.`,
-  );
+    const packageManager = await getPackageManager();
 
-  try {
-    await installPackageWithPackageManager(packageManager, packageName);
-  } catch (e) {
-    sdkInstallSpinner.stop('Installation failed.');
-    clack.log.error(
-      `${chalk.red(
-        'Encountered the following error during installation:',
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      )}\n\n${e}\n\n${chalk.dim(
-        'If you think this issue is caused by the Sentry wizard, let us know here:\nhttps://github.com/getsentry/sentry-wizard/issues',
-      )}`,
+    sdkInstallSpinner.start(
+      `${alreadyInstalled ? 'Updating' : 'Installing'} ${chalk.bold.cyan(
+        packageName,
+      )} with ${chalk.bold(packageManager.label)}.`,
     );
-    await abort();
-  }
 
-  sdkInstallSpinner.stop(
-    `${alreadyInstalled ? 'Updated' : 'Installed'} ${chalk.bold.cyan(
-      packageName,
-    )} with ${chalk.bold(packageManager.label)}.`,
-  );
+    try {
+      await installPackageWithPackageManager(packageManager, packageName);
+    } catch (e) {
+      sdkInstallSpinner.stop('Installation failed.');
+      clack.log.error(
+        `${chalk.red(
+          'Encountered the following error during installation:',
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        )}\n\n${e}\n\n${chalk.dim(
+          'If you think this issue is caused by the Sentry wizard, let us know here:\nhttps://github.com/getsentry/sentry-wizard/issues',
+        )}`,
+      );
+      await abort();
+    }
+
+    sdkInstallSpinner.stop(
+      `${alreadyInstalled ? 'Updated' : 'Installed'} ${chalk.bold.cyan(
+        packageName,
+      )} with ${chalk.bold(packageManager.label)}.`,
+    );
+  });
 }
 
 export async function addSentryCliConfig(
   authToken: string,
   setupConfig: CliSetupConfig = sourceMapsCliSetupConfig,
 ): Promise<void> {
-  const configExists = fs.existsSync(
-    path.join(process.cwd(), setupConfig.filename),
-  );
-  if (configExists) {
-    const configContents = fs.readFileSync(
+  return traceStep('add-sentry-cli-config', async () => {
+    const configExists = fs.existsSync(
       path.join(process.cwd(), setupConfig.filename),
-      'utf8',
     );
-
-    if (setupConfig.likelyAlreadyHasAuthToken(configContents)) {
-      clack.log.warn(
-        `${chalk.bold(
-          setupConfig.filename,
-        )} already has auth token. Will not add one.`,
+    if (configExists) {
+      const configContents = fs.readFileSync(
+        path.join(process.cwd(), setupConfig.filename),
+        'utf8',
       );
+
+      if (setupConfig.likelyAlreadyHasAuthToken(configContents)) {
+        clack.log.warn(
+          `${chalk.bold(
+            setupConfig.filename,
+          )} already has auth token. Will not add one.`,
+        );
+      } else {
+        try {
+          await fs.promises.writeFile(
+            path.join(process.cwd(), setupConfig.filename),
+            `${configContents}\n${setupConfig.tokenContent(authToken)}\n`,
+            { encoding: 'utf8', flag: 'w' },
+          );
+          clack.log.success(
+            chalk.greenBright(
+              `Added auth token to ${chalk.bold(
+                setupConfig.filename,
+              )} for you to test uploading ${setupConfig.name} locally.`,
+            ),
+          );
+        } catch {
+          clack.log.warning(
+            `Failed to add auth token to ${chalk.bold(
+              setupConfig.filename,
+            )}. Uploading ${
+              setupConfig.name
+            } during build will likely not work locally.`,
+          );
+        }
+      }
     } else {
       try {
         await fs.promises.writeFile(
           path.join(process.cwd(), setupConfig.filename),
-          `${configContents}\n${setupConfig.tokenContent(authToken)}\n`,
+          `${setupConfig.tokenContent(authToken)}\n`,
           { encoding: 'utf8', flag: 'w' },
         );
         clack.log.success(
           chalk.greenBright(
-            `Added auth token to ${chalk.bold(
+            `Created ${chalk.bold(
               setupConfig.filename,
-            )} for you to test uploading ${setupConfig.name} locally.`,
+            )} with auth token for you to test uploading ${
+              setupConfig.name
+            } locally.`,
           ),
         );
       } catch {
         clack.log.warning(
-          `Failed to add auth token to ${chalk.bold(
+          `Failed to create ${chalk.bold(
             setupConfig.filename,
-          )}. Uploading ${
+          )} with auth token. Uploading ${
             setupConfig.name
           } during build will likely not work locally.`,
         );
       }
     }
-  } else {
-    try {
-      await fs.promises.writeFile(
-        path.join(process.cwd(), setupConfig.filename),
-        `${setupConfig.tokenContent(authToken)}\n`,
-        { encoding: 'utf8', flag: 'w' },
-      );
-      clack.log.success(
-        chalk.greenBright(
-          `Created ${chalk.bold(
-            setupConfig.filename,
-          )} with auth token for you to test uploading ${
-            setupConfig.name
-          } locally.`,
-        ),
-      );
-    } catch {
-      clack.log.warning(
-        `Failed to create ${chalk.bold(
-          setupConfig.filename,
-        )} with auth token. Uploading ${
-          setupConfig.name
-        } during build will likely not work locally.`,
-      );
-    }
-  }
 
-  await addAuthTokenFileToGitIgnore(setupConfig.filename);
+    await addAuthTokenFileToGitIgnore(setupConfig.filename);
+  });
 }
 
 export async function addDotEnvSentryBuildPluginFile(
@@ -418,26 +472,40 @@ async function addAuthTokenFileToGitIgnore(filename: string): Promise<void> {
   }
 }
 
+/**
+ * Checks if @param packageId is listed as a dependency in @param packageJson.
+ * If not, it will ask users if they want to continue without the package.
+ *
+ * Use this function to check if e.g. a the framework of the SDK is installed
+ *
+ * @param packageJson the package.json object
+ * @param packageId the npm name of the package
+ * @param packageName a human readable name of the package
+ */
 export async function ensurePackageIsInstalled(
   packageJson: PackageDotJson,
   packageId: string,
   packageName: string,
-) {
-  if (!hasPackageInstalled(packageId, packageJson)) {
-    Sentry.setTag('package-installed', false);
-    const continueWithoutPackage = await abortIfCancelled(
-      clack.confirm({
-        message: `${packageName} does not seem to be installed. Do you still want to continue?`,
-        initialValue: false,
-      }),
-    );
+): Promise<void> {
+  return traceStep('ensure-package-installed', async () => {
+    const installed = hasPackageInstalled(packageId, packageJson);
+
+    Sentry.setTag(`${packageName.toLowerCase()}-installed`, installed);
+
+    if (!installed) {
+      Sentry.setTag(`${packageName.toLowerCase()}-installed`, false);
+      const continueWithoutPackage = await abortIfCancelled(
+        clack.confirm({
+          message: `${packageName} does not seem to be installed. Do you still want to continue?`,
+          initialValue: false,
+        }),
+      );
 
-    if (!continueWithoutPackage) {
-      await abort(undefined, 0);
+      if (!continueWithoutPackage) {
+        await abort(undefined, 0);
+      }
     }
-  } else {
-    Sentry.setTag('package-installed', true);
-  }
+  });
 }
 
 export async function getPackageDotJson(): Promise<PackageDotJson> {
@@ -457,7 +525,9 @@ export async function getPackageDotJson(): Promise<PackageDotJson> {
     packageJson = JSON.parse(packageJsonFileContents);
   } catch {
     clack.log.error(
-      'Unable to parse your package.json. Make sure it has a valid format!',
+      `Unable to parse your ${chalk.cyan(
+        'package.json',
+      )}. Make sure it has a valid format!`,
     );
 
     await abort();

package/src/utils/package-manager.ts

@@ -4,6 +4,9 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { promisify } from 'util';
 
+import * as Sentry from '@sentry/node';
+import { traceStep } from '../telemetry';
+
 export interface PackageManager {
   name: string;
   label: string;
@@ -50,13 +53,16 @@ export const NPM: PackageManager = {
 export const packageManagers = [BUN, YARN, PNPM, NPM];
 
 export function detectPackageManger(): PackageManager | null {
-  for (const packageManager of packageManagers) {
-    if (fs.existsSync(path.join(process.cwd(), packageManager.lockFile))) {
-      return packageManager;
+  return traceStep('detect-package-manager', () => {
+    for (const packageManager of packageManagers) {
+      if (fs.existsSync(path.join(process.cwd(), packageManager.lockFile))) {
+        Sentry.setTag('package-manager', packageManager.name);
+        return packageManager;
+      }
     }
-  }
-  // We make the default NPM - it's weird if we don't find any lock file
-  return null;
+    Sentry.setTag('package-manager', 'not-detected');
+    return null;
+  });
 }
 
 export async function installPackageWithPackageManager(