@sentry/wizard 3.39.0 → 3.41.0

package/src/flutter/code-tools.ts

@@ -0,0 +1,284 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as Sentry from '@sentry/node';
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+import {
+  sentryImport,
+  pubspecOptions,
+  sentryProperties,
+  initSnippet,
+} from './templates';
+import { featureSelectionPrompt } from '../utils/clack-utils';
+
+/**
+ * Recursively finds a file per name in subfolders.
+ * @param dir - The directory to start searching.
+ * @param name - The name of the file including path extension.
+ * @returns The path to the main.dart file or null if not found.
+ */
+export function findFile(dir: string, name: string): string | null {
+  const files: string[] = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const fullPath: string = path.join(dir, file);
+    const stats: fs.Stats = fs.statSync(fullPath);
+
+    if (stats.isDirectory()) {
+      const result: string | null = findFile(fullPath, name);
+      if (result) {
+        return result;
+      }
+    } else if (file === name) {
+      return fullPath;
+    }
+  }
+
+  return null;
+}
+
+export function patchPubspec(
+  pubspecFile: string | null,
+  sentryDartFlutterVersion: string,
+  sentryDartPluginVersion: string,
+  project: string,
+  org: string,
+): boolean {
+  try {
+    if (!pubspecFile) {
+      throw new Error('pubspec.yaml is not provided or invalid.');
+    }
+
+    let pubspecContent = fs.readFileSync(pubspecFile, 'utf8');
+
+    if (!pubspecContent.includes('sentry_flutter:')) {
+      const dependenciesIndex = getDependenciesLocation(pubspecContent);
+
+      pubspecContent =
+        pubspecContent.slice(0, dependenciesIndex) +
+        `  sentry_flutter: ${sentryDartFlutterVersion}\n` +
+        pubspecContent.slice(dependenciesIndex);
+
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold('sentry_flutter')} added to pubspec.yaml`,
+        ),
+      );
+    } else {
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold('sentry_flutter')} is already included in pubspec.yaml`,
+        ),
+      );
+    }
+
+    if (!pubspecContent.includes('sentry_dart_plugin:')) {
+      const devDependenciesIndex = getDevDependenciesLocation(pubspecContent);
+      pubspecContent =
+        pubspecContent.slice(0, devDependenciesIndex) +
+        `  sentry_dart_plugin: ${sentryDartPluginVersion}\n` +
+        pubspecContent.slice(devDependenciesIndex);
+
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold('sentry_dart_plugin')} added to pubspec.yaml`,
+        ),
+      );
+    } else {
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold(
+            'sentry_dart_plugin',
+          )} is already included in pubspec.yaml`,
+        ),
+      );
+    }
+
+    if (!pubspecContent.includes('sentry:')) {
+      pubspecContent += '\n';
+      pubspecContent += pubspecOptions(project, org);
+
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold('sentry plugin configuration')} added to pubspec.yaml`,
+        ),
+      );
+    } else {
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold(
+            'sentry plugin configuration',
+          )} is already included in pubspec.yaml`,
+        ),
+      );
+    }
+
+    fs.writeFileSync(pubspecFile, pubspecContent, 'utf8');
+
+    return true;
+  } catch (error) {
+    clack.log.warn(`Failed to read/write ${chalk.cyan('pubspec.yaml')} file.`);
+    Sentry.captureException(error);
+    return false;
+  }
+}
+
+export function addProperties(pubspecFile: string | null, authToken: string) {
+  try {
+    if (!pubspecFile) {
+      throw new Error('pubspec.yaml is not provided or invalid.');
+    }
+
+    const pubspecDir = path.dirname(pubspecFile);
+    const sentryPropertiesFileName = 'sentry.properties';
+    const sentryPropertiesFile = path.join(
+      pubspecDir,
+      sentryPropertiesFileName,
+    );
+    const sentryPropertiesContent = sentryProperties(authToken);
+
+    fs.writeFileSync(sentryPropertiesFile, sentryPropertiesContent, 'utf8');
+
+    const gitignoreFile = path.join(pubspecDir, '.gitignore');
+    if (fs.existsSync(gitignoreFile)) {
+      fs.appendFileSync(gitignoreFile, `\n${sentryPropertiesFileName}\n`);
+    } else {
+      fs.writeFileSync(gitignoreFile, `${sentryPropertiesFileName}\n`, 'utf8');
+    }
+    return true;
+  } catch (error) {
+    clack.log.warn(`Failed to read/write ${chalk.cyan('pubspec.yaml')} file.`);
+    Sentry.captureException(error);
+    return false;
+  }
+}
+
+export async function patchMain(
+  mainFile: string | null,
+  dsn: string,
+  canEnableProfiling: boolean,
+): Promise<boolean> {
+  try {
+    if (!mainFile) {
+      throw new Error('pubspec.yaml is not provided or invalid.');
+    }
+
+    let mainContent = fs.readFileSync(mainFile, 'utf8');
+    if (
+      /import\s+['"]package[:]sentry_flutter\/sentry_flutter\.dart['"];?/i.test(
+        mainContent,
+      )
+    ) {
+      // sentry is already configured
+      clack.log.success(
+        chalk.greenBright(
+          `${chalk.bold('main.dart')} already has Sentry configured.`,
+        ),
+      );
+      return true;
+    }
+
+    const features = [
+      {
+        id: 'tracing',
+        prompt: `Do you want to enable ${chalk.bold(
+          'Tracing',
+        )} to track the performance of your application?`,
+        enabledHint: 'recommended',
+      },
+    ];
+    if (canEnableProfiling) {
+      features.push({
+        id: 'profiling',
+        prompt: `Do you want to enable ${chalk.bold(
+          'Profiling',
+        )} to analyze CPU usage and optimize performance-critical code on iOS & macOS?`,
+        enabledHint: 'recommended, tracing must be enabled',
+      });
+    }
+
+    const selectedFeatures = await featureSelectionPrompt(features);
+    const normalizedSelectedFeatures = {
+      tracing: selectedFeatures.tracing ?? false,
+      profiling: selectedFeatures.profiling ?? false,
+    };
+    mainContent = patchMainContent(
+      dsn,
+      mainContent,
+      normalizedSelectedFeatures,
+    );
+
+    fs.writeFileSync(mainFile, mainContent, 'utf8');
+
+    clack.log.success(
+      chalk.greenBright(
+        `Patched ${chalk.bold(
+          'main.dart',
+        )} with the Sentry setup and test error snippet.`,
+      ),
+    );
+
+    return true;
+  } catch (error) {
+    clack.log.warn(`Failed to read/write ${chalk.cyan('main.dart')} file.`);
+    Sentry.captureException(error);
+    return false;
+  }
+}
+
+export function patchMainContent(
+  dsn: string,
+  mainContent: string,
+  selectedFeatures: {
+    tracing: boolean;
+    profiling: boolean;
+  },
+): string {
+  const importIndex = getLastImportLineLocation(mainContent);
+  mainContent =
+    mainContent.slice(0, importIndex) +
+    sentryImport +
+    mainContent.slice(importIndex);
+
+  // Find and replace `runApp(...)`
+  mainContent = mainContent.replace(
+    /runApp\(([\s\S]*?)\);/g, // Match the `runApp(...)` invocation
+    (_, runAppArgs) => initSnippet(dsn, selectedFeatures, runAppArgs as string),
+  );
+
+  // Make the `main` function async if it's not already
+  mainContent = mainContent.replace(
+    /void\s+main\(\)\s*\{/g,
+    'Future<void> main() async {',
+  );
+
+  return mainContent;
+}
+
+export function getLastImportLineLocation(sourceCode: string): number {
+  const importRegex = /import\s+['"].*['"].*;/gim;
+  return getLastReqExpLocation(sourceCode, importRegex);
+}
+
+export function getDependenciesLocation(sourceCode: string): number {
+  const dependencyRegex = /^dependencies:\s*$/gim;
+  return getLastReqExpLocation(sourceCode, dependencyRegex);
+}
+
+export function getDevDependenciesLocation(sourceCode: string): number {
+  const dependencyRegex = /^dev_dependencies:\s*$/gim;
+  return getLastReqExpLocation(sourceCode, dependencyRegex);
+}
+
+// Helper
+
+function getLastReqExpLocation(sourceCode: string, regExp: RegExp): number {
+  let match = regExp.exec(sourceCode);
+  let importIndex = 0;
+  while (match) {
+    importIndex = match.index + match[0].length + 1;
+    match = regExp.exec(sourceCode);
+  }
+  return importIndex;
+}

package/src/flutter/flutter-wizard.ts

@@ -0,0 +1,164 @@
+import { WizardOptions } from '../utils/types';
+import * as Sentry from '@sentry/node';
+import * as codetools from './code-tools';
+import * as fs from 'fs';
+import * as path from 'path';
+import { showCopyPasteInstructions } from '../utils/clack-utils';
+import { pubspecSnippetColored, initSnippetColored } from './templates';
+import { fetchSdkVersion } from '../utils/release-registry';
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+
+import {
+  confirmContinueIfNoOrDirtyGitRepo,
+  getOrAskForProjectData,
+  printWelcome,
+} from '../utils/clack-utils';
+
+import { traceStep, withTelemetry } from '../telemetry';
+import { findFile } from './code-tools';
+
+export async function runFlutterWizard(options: WizardOptions): Promise<void> {
+  return withTelemetry(
+    {
+      enabled: options.telemetryEnabled,
+      integration: 'flutter',
+      wizardOptions: options,
+    },
+    () => runFlutterWizardWithTelemetry(options),
+  );
+}
+
+async function runFlutterWizardWithTelemetry(
+  options: WizardOptions,
+): Promise<void> {
+  printWelcome({
+    wizardName: 'Sentry Flutter Wizard',
+    promoCode: options.promoCode,
+  });
+
+  await confirmContinueIfNoOrDirtyGitRepo();
+
+  const { selectedProject, selfHosted, sentryUrl, authToken } =
+    await getOrAskForProjectData(options, 'flutter');
+
+  const projectDir = process.cwd();
+  const pubspecFile = path.join(projectDir, 'pubspec.yaml');
+  if (!fs.existsSync(pubspecFile)) {
+    clack.log.error(
+      `Could not find ${chalk.cyan(
+        'pubspec.yaml',
+      )}. Make sure you run the wizard in the projects root folder.`,
+    );
+    return;
+  }
+
+  // ======== STEP 1. Add sentry_flutter and sentry_dart_plugin to pubspec.yaml ============
+
+  clack.log.step(
+    `Adding ${chalk.bold('Sentry')} to your apps ${chalk.cyan(
+      'pubspec.yaml',
+    )} file.`,
+  );
+
+  const flutterVersion = await fetchSdkVersion('sentry.dart.flutter');
+  const flutterVersionOrAny = flutterVersion ? `^${flutterVersion}` : 'any';
+
+  const pluginVersion = await fetchSdkVersion('sentry.dart.plugin');
+  const pluginVersionOrAny = pluginVersion ? `^${pluginVersion}` : 'any';
+
+  const pubspecPatched = traceStep('Patch pubspec.yaml', () =>
+    codetools.patchPubspec(
+      pubspecFile,
+      flutterVersionOrAny,
+      pluginVersionOrAny,
+      selectedProject.slug,
+      selectedProject.organization.slug,
+    ),
+  );
+  if (!pubspecPatched) {
+    clack.log.warn(
+      `Could not patch ${chalk.cyan(
+        'pubspec.yaml',
+      )}. Add the dependencies to it.`,
+    );
+    await showCopyPasteInstructions(
+      'pubspec.yaml',
+      pubspecSnippetColored(
+        flutterVersionOrAny,
+        pluginVersionOrAny,
+        selectedProject.slug,
+        selectedProject.organization.slug,
+      ),
+      'This ensures the Sentry SDK and plugin can be imported.',
+    );
+  }
+  Sentry.setTag('pubspec-patched', pubspecPatched);
+
+  // ======== STEP 2. Add sentry.properties with auth token ============
+
+  const propertiesAdded = traceStep('Add sentry.properties', () =>
+    codetools.addProperties(pubspecFile, authToken),
+  );
+  if (!propertiesAdded) {
+    clack.log.warn(
+      `We could not add ${chalk.cyan(
+        'sentry.properties',
+      )} file in your project directory in order to provide an auth token for Sentry CLI. You'll have to add it manually, or you can set the SENTRY_AUTH_TOKEN environment variable instead. See https://docs.sentry.io/cli/configuration/#auth-token for more information.`,
+    );
+  } else {
+    clack.log.info(
+      `We created ${chalk.cyan(
+        'sentry.properties',
+      )} file in your project directory in order to provide an auth token for Sentry CLI.\nIt was also added to your ".gitignore" file.\nAt your CI enviroment, you can set the SENTRY_AUTH_TOKEN environment variable instead. See https://docs.sentry.io/cli/configuration/#auth-token for more information.`,
+    );
+  }
+  Sentry.setTag('sentry-properties-added', pubspecPatched);
+
+  // ======== STEP 3. Patch main.dart with setup and a test error snippet ============
+
+  clack.log.step(
+    `Patching ${chalk.cyan('main.dart')} with setup and test error snippet.`,
+  );
+
+  const mainFile = findFile(`${projectDir}/lib`, 'main.dart');
+  const dsn = selectedProject.keys[0].dsn.public;
+  const canEnableProfiling =
+    fs.existsSync(`${projectDir}/ios`) || fs.existsSync(`${projectDir}/macos`);
+
+  const mainPatched = await traceStep('Patch main.dart', () =>
+    codetools.patchMain(mainFile, dsn, canEnableProfiling),
+  );
+  if (!mainPatched) {
+    clack.log.warn(
+      `Could not patch ${chalk.cyan(
+        'main.dart',
+      )} file. Place the following code snippet within the apps main function.`,
+    );
+    await showCopyPasteInstructions(
+      'main.dart',
+      initSnippetColored(dsn),
+      'This ensures the Sentry SDK is ready to capture errors.',
+    );
+  }
+  Sentry.setTag('main-patched', mainPatched);
+
+  // ======== OUTRO ========
+
+  const issuesPageLink = selfHosted
+    ? `${sentryUrl}organizations/${selectedProject.organization.slug}/issues/?project=${selectedProject.id}`
+    : `https://${selectedProject.organization.slug}.sentry.io/issues/?project=${selectedProject.id}`;
+
+  clack.outro(`
+    ${chalk.greenBright('Successfully installed the Sentry Flutter SDK!')}
+    
+    ${chalk.cyan(
+      `You can validate your setup by launching your application and checking Sentry issues page afterwards
+    ${issuesPageLink}`,
+    )}
+    
+    Check out the SDK documentation for further configuration:
+    https://docs.sentry.io/platforms/flutter/
+  `);
+}

package/src/flutter/templates.ts

@@ -0,0 +1,90 @@
+import { makeCodeSnippet } from '../utils/clack-utils';
+
+export const sentryImport = `import 'package:sentry_flutter/sentry_flutter.dart';\n`;
+
+export function pubspecOptions(project: string, org: string): string {
+  return `sentry:
+  upload_debug_symbols: true
+  upload_source_maps: true
+  project: ${project}
+  org: ${org}
+`;
+}
+
+export function sentryProperties(authToken: string): string {
+  return `auth_token=${authToken}`;
+}
+
+export function initSnippet(
+  dsn: string,
+  selectedFeaturesMap: {
+    tracing: boolean;
+    profiling: boolean;
+  },
+  runApp: string,
+): string {
+  let snippet = `await SentryFlutter.init(
+    (options) {
+      options.dsn = '${dsn}';`;
+
+  if (selectedFeaturesMap.tracing) {
+    snippet += `
+      // Set tracesSampleRate to 1.0 to capture 100% of transactions for tracing.
+      // We recommend adjusting this value in production.
+      options.tracesSampleRate = 1.0;`;
+  }
+
+  if (selectedFeaturesMap.profiling && selectedFeaturesMap.tracing) {
+    snippet += `
+      // The sampling rate for profiling is relative to tracesSampleRate
+      // Setting to 1.0 will profile 100% of sampled transactions:
+      options.profilesSampleRate = 1.0;`;
+  }
+
+  snippet += `
+    },
+    appRunner: () => runApp(SentryWidget(child: ${runApp})),
+  );
+  // TODO: Remove this line after sending the first sample event to sentry.
+  await Sentry.captureException(Exception('This is a sample exception.'));`;
+
+  return snippet;
+}
+
+export function pubspecSnippetColored(
+  sentryVersion: string,
+  pluginVersion: string,
+  project: string,
+  org: string,
+): string {
+  const snippet = `dependencies:
+  sentry_flutter: ${sentryVersion}
+
+dev_dependencies:
+  sentry_dart_plugin: ${pluginVersion}
+  
+${pubspecOptions(project, org)}`;
+
+  return makeCodeSnippet(true, (_unchanged, plus, _minus) => {
+    return plus(snippet);
+  });
+}
+
+export function initSnippetColored(dsn: string): string {
+  const snippet = `import 'package:sentry_flutter/sentry_flutter.dart';
+
+Future<void>main() async {
+  await SentryFlutter.init(
+    (options) {
+      options.dsn = '${dsn}';
+      // Set tracesSampleRate to 1.0 to capture 100% of transactions for tracing.
+      // We recommend adjusting this value in production.
+      options.tracesSampleRate = 1.0;
+    },
+    appRunner: () => runApp(SentryWidget(child: YourApp())),
+  )
+}`;
+  return makeCodeSnippet(true, (_unchanged, plus, _minus) => {
+    return plus(snippet);
+  });
+}

package/src/nextjs/nextjs-wizard.ts

@@ -65,10 +65,12 @@ export function runNextjsWizard(options: WizardOptions) {
 export async function runNextjsWizardWithTelemetry(
   options: WizardOptions,
 ): Promise<void> {
+  const { promoCode, telemetryEnabled, forceInstall } = options;
+
   printWelcome({
     wizardName: 'Sentry Next.js Wizard',
-    promoCode: options.promoCode,
-    telemetryEnabled: options.telemetryEnabled,
+    promoCode,
+    telemetryEnabled,
   });
 
   const typeScriptDetected = isUsingTypeScript();
@@ -96,6 +98,7 @@ export async function runNextjsWizardWithTelemetry(
       packageName: '@sentry/nextjs@^8',
       packageNameDisplayLabel: '@sentry/nextjs',
       alreadyInstalled: !!packageJson?.dependencies?.['@sentry/nextjs'],
+      forceInstall,
     });
 
   await traceStep('configure-sdk', async () => {

package/src/nuxt/nuxt-wizard.ts

@@ -50,10 +50,12 @@ export function runNuxtWizard(options: WizardOptions) {
 export async function runNuxtWizardWithTelemetry(
   options: WizardOptions,
 ): Promise<void> {
+  const { promoCode, telemetryEnabled, forceInstall } = options;
+
   printWelcome({
     wizardName: 'Sentry Nuxt Wizard',
-    promoCode: options.promoCode,
-    telemetryEnabled: options.telemetryEnabled,
+    promoCode,
+    telemetryEnabled,
   });
 
   await confirmContinueIfNoOrDirtyGitRepo();
@@ -95,7 +97,7 @@ export async function runNuxtWizardWithTelemetry(
 
   const packageManager = await getPackageManager();
 
-  await addNuxtOverrides(packageJson, packageManager, minVer);
+  await addNuxtOverrides(packageJson, packageManager, minVer, forceInstall);
 
   const sdkAlreadyInstalled = hasPackageInstalled('@sentry/nuxt', packageJson);
   Sentry.setTag('sdk-already-installed', sdkAlreadyInstalled);
@@ -104,6 +106,7 @@ export async function runNuxtWizardWithTelemetry(
     packageName: '@sentry/nuxt',
     alreadyInstalled: sdkAlreadyInstalled,
     packageManager,
+    forceInstall,
   });
 
   await addDotEnvSentryBuildPluginFile(authToken);

package/src/nuxt/sdk-setup.ts

@@ -250,6 +250,7 @@ export async function addNuxtOverrides(
   packageJson: PackageDotJson,
   packageManager: PackageManager,
   nuxtMinVer: SemVer | null,
+  forceInstall?: boolean,
 ) {
   const isPNPM = PNPM.detect();
 
@@ -306,6 +307,7 @@ export async function addNuxtOverrides(
         packageName: 'import-in-the-middle',
         alreadyInstalled: iitmAlreadyInstalled,
         packageManager,
+        forceInstall,
       });
     }
   }

package/src/react-native/react-native-wizard.ts

@@ -111,10 +111,12 @@ export async function runReactNativeWizardWithTelemetry(
     return runReactNativeUninstall(options);
   }
 
+  const { promoCode, telemetryEnabled, forceInstall } = options;
+
   printWelcome({
     wizardName: 'Sentry React Native Wizard',
-    promoCode: options.promoCode,
-    telemetryEnabled: options.telemetryEnabled,
+    promoCode,
+    telemetryEnabled,
   });
 
   await confirmContinueIfNoOrDirtyGitRepo();
@@ -147,6 +149,7 @@ Or setup using ${chalk.cyan(
   await installPackage({
     packageName: RN_SDK_PACKAGE,
     alreadyInstalled: hasPackageInstalled(RN_SDK_PACKAGE, packageJson),
+    forceInstall,
   });
   const sdkVersion = getPackageVersion(
     RN_SDK_PACKAGE,

package/src/remix/remix-wizard.ts

@@ -52,10 +52,12 @@ export async function runRemixWizard(options: WizardOptions): Promise<void> {
 async function runRemixWizardWithTelemetry(
   options: WizardOptions,
 ): Promise<void> {
+  const { promoCode, telemetryEnabled, forceInstall } = options;
+
   printWelcome({
     wizardName: 'Sentry Remix Wizard',
-    promoCode: options.promoCode,
-    telemetryEnabled: options.telemetryEnabled,
+    promoCode,
+    telemetryEnabled,
   });
 
   await confirmContinueIfNoOrDirtyGitRepo();
@@ -73,6 +75,7 @@ async function runRemixWizardWithTelemetry(
     packageName: '@sentry/remix@^8',
     packageNameDisplayLabel: '@sentry/remix',
     alreadyInstalled: hasPackageInstalled('@sentry/remix', packageJson),
+    forceInstall,
   });
 
   const dsn = selectedProject.keys[0].dsn.public;