@sentry/wizard 3.38.0 → 3.40.0

package/e2e-tests/tests/sveltekit.test.ts

@@ -41,7 +41,14 @@ export async function handleError({ error, event }) {
 }
 `;
 
-async function runWizardOnSvelteKitProject(projectDir: string, integration: Integration, fileModificationFn?: (projectDir: string, integration: Integration) => unknown) {
+async function runWizardOnSvelteKitProject(
+  projectDir: string,
+  integration: Integration,
+  fileModificationFn?: (
+    projectDir: string,
+    integration: Integration,
+  ) => unknown,
+) {
   const wizardInstance = startWizardInstance(integration, projectDir);
   let packageManagerPrompted = false;
 
@@ -49,9 +56,7 @@ async function runWizardOnSvelteKitProject(projectDir: string, integration: Inte
     fileModificationFn(projectDir, integration);
 
     // As we modified project, we have a warning prompt before we get the package manager prompt
-    await wizardInstance.waitForOutput(
-      'Do you want to continue anyway?',
-    );
+    await wizardInstance.waitForOutput('Do you want to continue anyway?');
 
     packageManagerPrompted = await wizardInstance.sendStdinAndWaitForOutput(
       [KEYS.ENTER],
@@ -59,7 +64,7 @@ async function runWizardOnSvelteKitProject(projectDir: string, integration: Inte
     );
   } else {
     packageManagerPrompted = await wizardInstance.waitForOutput(
-      'Please select your package manager'
+      'Please select your package manager',
     );
   }
 
@@ -72,7 +77,7 @@ async function runWizardOnSvelteKitProject(projectDir: string, integration: Inte
       'to track the performance of your application?',
       {
         timeout: 240_000,
-      }
+      },
     ));
 
   const replayOptionPrompted =
@@ -100,10 +105,14 @@ async function runWizardOnSvelteKitProject(projectDir: string, integration: Inte
   wizardInstance.kill();
 }
 
-function checkSvelteKitProject(projectDir: string, integration: Integration, options?: {
-  devModeExpectedOutput: string;
-  prodModeExpectedOutput: string;
-}) {
+function checkSvelteKitProject(
+  projectDir: string,
+  integration: Integration,
+  options?: {
+    devModeExpectedOutput: string;
+    prodModeExpectedOutput: string;
+  },
+) {
   test('should have the correct package.json', () => {
     checkPackageJson(projectDir, integration);
   });
@@ -113,14 +122,21 @@ function checkSvelteKitProject(projectDir: string, integration: Integration, opt
   });
 
   test('example page exists', () => {
-    checkFileExists(path.resolve(projectDir, 'src/routes/sentry-example/+page.svelte'));
-    checkFileExists(path.resolve(projectDir, 'src/routes/sentry-example/+server.js'));
+    checkFileExists(
+      path.resolve(projectDir, 'src/routes/sentry-example/+page.svelte'),
+    );
+    checkFileExists(
+      path.resolve(projectDir, 'src/routes/sentry-example/+server.js'),
+    );
   });
 
   test('vite.config contains sentry plugin', () => {
-    checkFileContents(path.resolve(projectDir, 'vite.config.ts'), `plugins: [sentrySvelteKit({
+    checkFileContents(
+      path.resolve(projectDir, 'vite.config.ts'),
+      `plugins: [sentrySvelteKit({
         sourceMapsUploadOptions: {
-`);
+`,
+    );
   });
 
   test('hook files created', () => {
@@ -129,15 +145,22 @@ function checkSvelteKitProject(projectDir: string, integration: Integration, opt
   });
 
   test('builds successfully', async () => {
-    await checkIfBuilds(projectDir, 'Successfully uploaded source maps to Sentry');
+    await checkIfBuilds(projectDir);
   });
 
   test('runs on dev mode correctly', async () => {
-    await checkIfRunsOnDevMode(projectDir, options?.devModeExpectedOutput || 'ready in');
+    await checkIfRunsOnDevMode(
+      projectDir,
+      options?.devModeExpectedOutput || 'ready in',
+    );
   });
 
   test('runs on prod mode correctly', async () => {
-    await checkIfRunsOnProdMode(projectDir, options?.prodModeExpectedOutput || 'to expose', 'preview');
+    await checkIfRunsOnProdMode(
+      projectDir,
+      options?.prodModeExpectedOutput || 'to expose',
+      'preview',
+    );
   });
 }
 
@@ -161,10 +184,9 @@ describe('Sveltekit', () => {
     checkSvelteKitProject(projectDir, integration);
 
     test('hooks.client.ts contains sentry', () => {
-      checkFileContents(
-        path.resolve(projectDir, 'src/hooks.client.ts'),
-        [`import * as Sentry from '@sentry/sveltekit';`,
-          `Sentry.init({
+      checkFileContents(path.resolve(projectDir, 'src/hooks.client.ts'), [
+        `import * as Sentry from '@sentry/sveltekit';`,
+        `Sentry.init({
   dsn: '${TEST_ARGS.PROJECT_DSN}',
 
   tracesSampleRate: 1.0,
@@ -179,22 +201,24 @@ describe('Sveltekit', () => {
 
   // If you don't want to use Session Replay, just remove the line below:
   integrations: [replayIntegration()],
-});`, 'export const handleError = handleErrorWithSentry(']);
+});`,
+        'export const handleError = handleErrorWithSentry(',
+      ]);
     });
 
     test('hooks.server.ts contains sentry', () => {
-      checkFileContents(
-        path.resolve(projectDir, 'src/hooks.server.ts'),
-        [
-          `import * as Sentry from '@sentry/sveltekit';`,
-          `Sentry.init({
+      checkFileContents(path.resolve(projectDir, 'src/hooks.server.ts'), [
+        `import * as Sentry from '@sentry/sveltekit';`,
+        `Sentry.init({
   dsn: '${TEST_ARGS.PROJECT_DSN}',
 
   tracesSampleRate: 1.0,
 
   // uncomment the line below to enable Spotlight (https://spotlightjs.com)
   // spotlight: import.meta.env.DEV,
-});`, 'export const handleError = handleErrorWithSentry();']);
+});`,
+        'export const handleError = handleErrorWithSentry();',
+      ]);
     });
   });
 
@@ -206,17 +230,21 @@ describe('Sveltekit', () => {
     );
 
     beforeAll(async () => {
-      await runWizardOnSvelteKitProject(projectDir, integration, (projectDir) => {
-        createFile(
-          path.resolve(projectDir, 'src/hooks.server.ts'),
-          SERVER_HOOK_TEMPLATE,
-        )
-
-        createFile(
-          path.resolve(projectDir, 'src/hooks.client.ts'),
-          CLIENT_HOOK_TEMPLATE,
-        )
-      });
+      await runWizardOnSvelteKitProject(
+        projectDir,
+        integration,
+        (projectDir) => {
+          createFile(
+            path.resolve(projectDir, 'src/hooks.server.ts'),
+            SERVER_HOOK_TEMPLATE,
+          );
+
+          createFile(
+            path.resolve(projectDir, 'src/hooks.client.ts'),
+            CLIENT_HOOK_TEMPLATE,
+          );
+        },
+      );
     });
 
     afterAll(() => {
@@ -229,27 +257,28 @@ describe('Sveltekit', () => {
     // These are removed from the common tests as the content is different
     // when the hooks are merged instead of created from the template
     test('hooks.client.ts contains sentry instrumentation', () => {
-      checkFileContents(
-        path.resolve(projectDir, 'src/hooks.client.ts'),
-        [`import * as Sentry from '@sentry/sveltekit';`,
-          `Sentry.init({
+      checkFileContents(path.resolve(projectDir, 'src/hooks.client.ts'), [
+        `import * as Sentry from '@sentry/sveltekit';`,
+        `Sentry.init({
     dsn: "${TEST_ARGS.PROJECT_DSN}",
     tracesSampleRate: 1,
     replaysSessionSampleRate: 0.1,
     replaysOnErrorSampleRate: 1,
     integrations: [Sentry.replayIntegration()]
-})`, 'export const handleError = Sentry.handleErrorWithSentry(']);
+})`,
+        'export const handleError = Sentry.handleErrorWithSentry(',
+      ]);
     });
 
     test('hooks.server.ts contains sentry init', () => {
-      checkFileContents(
-        path.resolve(projectDir, 'src/hooks.server.ts'),
-        [`import * as Sentry from '@sentry/sveltekit';`,
-          `Sentry.init({
+      checkFileContents(path.resolve(projectDir, 'src/hooks.server.ts'), [
+        `import * as Sentry from '@sentry/sveltekit';`,
+        `Sentry.init({
     dsn: "${TEST_ARGS.PROJECT_DSN}",
     tracesSampleRate: 1
-})`, 'export const handleError = Sentry.handleErrorWithSentry();']);
+})`,
+        'export const handleError = Sentry.handleErrorWithSentry();',
+      ]);
     });
   });
 });
-

package/e2e-tests/utils/index.ts

@@ -80,6 +80,36 @@ export class WizardTestEnv {
     return outputPromise;
   }
 
+  /**
+   * Waits for the task to exit with a given `statusCode`.
+   *
+   * @returns a promise that resolves to `true` if the run ends with the status
+   * code, or it rejects when the `timeout` was reached.
+   */
+  waitForStatusCode(
+    statusCode: number | null,
+    options: {
+      /** Timeout in ms */
+      timeout?: number;
+    } = {},
+  ) {
+    const { timeout } = {
+      timeout: 60_000,
+      ...options,
+    };
+
+    return new Promise<boolean>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Timeout waiting for status code: ${statusCode}`));
+      }, timeout);
+
+      this.taskHandle.on('exit', (code: number | null) => {
+        clearTimeout(timeoutId);
+        resolve(code === statusCode);
+      });
+    });
+  }
+
   /**
    * Waits for the provided output with `.includes()` logic.
    *
@@ -317,16 +347,46 @@ export function checkEnvBuildPlugin(projectDir: string) {
   );
 }
 
+/**
+ * Check if the sentry.properties contains the auth token
+ * @param projectDir
+ */
+export function checkSentryProperties(projectDir: string) {
+  checkFileContents(
+    `${projectDir}/sentry.properties`,
+    `auth_token=${TEST_ARGS.AUTH_TOKEN}`,
+  );
+}
+
 /**
  * Check if the project builds
+ * Check if the project builds and ends with status code 0.
  * @param projectDir
  */
-export async function checkIfBuilds(
+export async function checkIfBuilds(projectDir: string) {
+  const testEnv = new WizardTestEnv('npm', ['run', 'build'], {
+    cwd: projectDir,
+  });
+
+  await expect(
+    testEnv.waitForStatusCode(0, {
+      timeout: 120_000,
+    }),
+  ).resolves.toBe(true);
+}
+
+/**
+ * Check if the flutter project builds
+ * @param projectDir
+ */
+export async function checkIfFlutterBuilds(
   projectDir: string,
   expectedOutput: string,
+  debug = false,
 ) {
-  const testEnv = new WizardTestEnv('npm', ['run', 'build'], {
+  const testEnv = new WizardTestEnv('flutter', ['build', 'web'], {
     cwd: projectDir,
+    debug: debug,
   });
 
   await expect(

package/lib/Constants.ts

@@ -1,6 +1,7 @@
 /** Key value should be the same here */
 export enum Integration {
   reactNative = 'reactNative',
+  flutter = 'flutter',
   ios = 'ios',
   android = 'android',
   cordova = 'cordova',
@@ -41,6 +42,8 @@ export function getIntegrationDescription(type: string): string {
       return 'Android';
     case Integration.reactNative:
       return 'React Native';
+    case Integration.flutter:
+      return 'Flutter';
     case Integration.cordova:
       return 'Cordova';
     case Integration.electron:
@@ -66,6 +69,8 @@ export function mapIntegrationToPlatform(type: string): string | undefined {
       return 'android';
     case Integration.reactNative:
       return 'react-native';
+    case Integration.flutter:
+      return 'flutter';
     case Integration.cordova:
       return 'cordova';
     case Integration.electron:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/wizard",
-  "version": "3.38.0",
+  "version": "3.40.0",
   "homepage": "https://github.com/getsentry/sentry-wizard",
   "repository": "https://github.com/getsentry/sentry-wizard",
   "description": "Sentry wizard helping you to configure your project",

package/src/apple/apple-wizard.ts

@@ -109,7 +109,7 @@ async function runAppleWizardWithTelementry(
   const availableTargets = xcProject.getAllTargets();
 
   if (availableTargets.length == 0) {
-    clack.log.error(`No suttable target found in ${xcodeProjFile}`);
+    clack.log.error(`No suitable target found in ${xcodeProjFile}`);
     Sentry.setTag('No-Target', true);
     await abort();
     return;

package/src/apple/xcode-manager.ts

@@ -10,7 +10,7 @@ import * as templates from './templates';
 import * as path from 'path';
 const xcode = require('xcode');
 
-interface ProjetFile {
+interface ProjectFile {
   key: string;
   path: string;
 }
@@ -190,7 +190,7 @@ export class XcodeProject {
   projectPath: string;
   project: any;
   objects: any;
-  files: ProjetFile[] | undefined;
+  files: ProjectFile[] | undefined;
 
   public constructor(projectPath: string) {
     this.projectPath = projectPath;
@@ -282,7 +282,7 @@ export class XcodeProject {
       .filter((f: string) => f.length > 0) as string[];
   }
 
-  projectFiles(): ProjetFile[] {
+  projectFiles(): ProjectFile[] {
     if (this.files === undefined) {
       const proj = this.project.getFirstProject();
       const mainGroupKey = proj.firstProject.mainGroup;
@@ -292,8 +292,8 @@ export class XcodeProject {
     return this.files;
   }
 
-  buildGroup(group: any, path = ''): ProjetFile[] {
-    const result: ProjetFile[] = [];
+  buildGroup(group: any, path = ''): ProjectFile[] {
+    const result: ProjectFile[] = [];
     for (const child of group.children) {
       if (this.objects.PBXFileReference[child.value]) {
         const fileReference = this.objects.PBXFileReference[child.value];

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;
+}