Merge branch 'main' into feat-screenshots

Author: krystofwoldrich

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 4.10.1
 
 ### Features
 
@@ -9,6 +9,8 @@
 ### Fixes
 
 - Android builds without ext config, auto create assets dir for modules ([#2652](https://github.com/getsentry/sentry-react-native/pull/2652))
+- Exit gracefully if source map file for collecting modules doesn't exist ([#2655](https://github.com/getsentry/sentry-react-native/pull/2655))
+- Create only one clean-up tasks for modules collection ([#2657](https://github.com/getsentry/sentry-react-native/pull/2657))
 
 ### Dependencies
 

package.json

@@ -2,7 +2,7 @@
   "name": "@sentry/react-native",
   "homepage": "https://github.com/getsentry/sentry-react-native",
   "repository": "https://github.com/getsentry/sentry-react-native",
-  "version": "4.10.0",
+  "version": "4.10.1",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",

scripts/collect-modules.sh

@@ -40,4 +40,4 @@ else
   modulesPaths="$MODULES_PATHS"
 fi
 
-$nodePath $collectModulesScript $sourceMap $modulesOutput $modulesPaths
+$nodePath "$collectModulesScript" "$sourceMap" "$modulesOutput" "$modulesPaths"

sentry.gradle

@@ -194,19 +194,24 @@ gradle.projectsEvaluated {
           }
           previousCliTask = cliTask
           cliTask.finalizedBy modulesTask
+        }
 
-          def modulesCleanUpTask = tasks.create(name: nameModulesCleanup, type: Delete) {
-              description = "clean up collected modules generated file"
-              group = 'sentry.io'
+        def modulesCleanUpTask = tasks.create(name: nameModulesCleanup, type: Delete) {
+            description = "clean up collected modules generated file"
+            group = 'sentry.io'
 
-              delete modulesOutput
-          }
+            delete modulesOutput
+        }
 
-          def packageTasks = tasks.findAll { task -> "package${variant}".equalsIgnoreCase(task.name) && task.enabled }
-          packageTasks.each { packageTask ->
-              packageTask.dependsOn modulesTask
-              packageTask.finalizedBy modulesCleanUpTask
-          }
+        def variantTaskName = variant.replaceAll("[\\s\\-()]", "") // variant is dev-release beta-release etc.
+        // task.name could be packageDev-debugRelease but in that case currentVariants == null
+        // because of the regex in `extractCurrentVariants` and this code doesn't run
+        def packageTasks = tasks.findAll {
+          task -> "package${variantTaskName}".equalsIgnoreCase(task.name) && task.enabled
+        }
+        packageTasks.each { packageTask ->
+            packageTask.dependsOn modulesTask
+            packageTask.finalizedBy modulesCleanUpTask
         }
 
         /** Delete sourcemap files */

src/js/tools/ModulesCollector.ts

@@ -1,6 +1,9 @@
 import { logger } from '@sentry/utils';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { posix, sep } from 'path';
+
+logger.enable();
+
 const { dirname, join, resolve, sep: posixSep } = posix;
 
 interface Package {
@@ -14,13 +17,17 @@ interface Package {
 export default class ModulesCollector {
 
   /** Collect method */
-  public static collect(sources: string[], modulesPaths: string[]): Record<string, string> {
+  public static collect(sources: unknown[], modulesPaths: string[]): Record<string, string> {
     const normalizedModulesPaths = modulesPaths.map((modulesPath) => resolve(modulesPath.split(sep).join(posixSep)));
 
     const infos: Record<string, string> = {};
     const seen: Record<string, true> = {};
 
-    sources.forEach((path: string) => {
+    sources.forEach((path: unknown) => {
+      if (typeof path !== 'string') {
+        return;
+      }
+
       let dir = path; // included source file path
       let candidate: Package | null = null;
 
@@ -60,7 +67,7 @@ export default class ModulesCollector {
             version: info.version,
           };
         } catch (error) {
-          logger.warn(`Failed to read ${pkgPath}`);
+          logger.error(`Failed to read ${pkgPath}`);
         }
 
         return upDirSearch(); // processed package.json file, continue up search
@@ -72,4 +79,65 @@ export default class ModulesCollector {
     return infos;
   }
 
+  /**
+   * Runs collection of modules.
+   */
+  public static run({
+    sourceMapPath,
+    outputModulesPath,
+    modulesPaths,
+    collect,
+  }: Partial<{
+    sourceMapPath: string,
+    outputModulesPath: string,
+    modulesPaths: string[],
+    collect: (sources: unknown[], modulesPaths: string[]) => Record<string, string>,
+  }>): void {
+    if (!sourceMapPath) {
+      logger.error('First argument `source-map-path` is missing!');
+      return;
+    }
+    if (!outputModulesPath) {
+      logger.error('Second argument `modules-output-path` is missing!');
+      return;
+    }
+    if (!modulesPaths || modulesPaths.length === 0) {
+      logger.error('Third argument `modules-paths` is missing!');
+      return;
+    }
+
+    logger.info('Reading source map from', sourceMapPath);
+    logger.info('Saving modules to', outputModulesPath);
+    logger.info('Resolving modules from paths', outputModulesPath);
+
+    if (!existsSync(sourceMapPath)) {
+      logger.error(`Source map file does not exist at ${sourceMapPath}`);
+      return;
+    }
+    for (const modulesPath of modulesPaths) {
+      if (!existsSync(modulesPath)) {
+        logger.error(`Modules path does not exist at ${modulesPath}`);
+        return;
+      }
+    }
+
+    const map: { sources?: unknown } = JSON.parse(readFileSync(sourceMapPath, 'utf8'));
+    if (!map.sources || !Array.isArray(map.sources)) {
+      logger.error(`Modules not collected. No sources found in the source map (${sourceMapPath})!`);
+      return;
+    }
+
+    const sources: unknown[] = map.sources;
+    const modules = collect
+      ? collect(sources, modulesPaths)
+      : ModulesCollector.collect(sources, modulesPaths);
+
+    const outputModulesDirPath = dirname(outputModulesPath);
+    if (!existsSync(outputModulesDirPath)) {
+      mkdirSync(outputModulesDirPath, { recursive: true });
+    }
+    writeFileSync(outputModulesPath, JSON.stringify(modules, null, 2));
+    logger.info(`Modules collected and saved to: ${outputModulesPath}`);
+  }
+
 }

src/js/tools/collectModules.ts

@@ -1,41 +1,12 @@
-import { logger } from '@sentry/utils';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname } from 'path';
-import { argv, exit } from 'process';
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { argv } from 'process';
 
 import ModulesCollector from './ModulesCollector';
 
-const sourceMapPath: string | undefined = argv[2]; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
-const outputModulesPath: string | undefined = argv[3]; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
-const modulesPaths: string[] = argv[4] // eslint-disable-line @typescript-eslint/no-unsafe-member-access
-  ? argv[4].split(',') // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+const sourceMapPath: string | undefined = argv[2];
+const outputModulesPath: string | undefined = argv[3];
+const modulesPaths: string[] = argv[4]
+  ? argv[4].split(',')
   : [];
 
-if (!sourceMapPath) {
-  exitGracefully('First argument `source-map-path` is missing!');
-}
-if (!outputModulesPath) {
-  exitGracefully('Second argument `modules-output-path` is missing!');
-}
-if (modulesPaths.length === 0) {
-  exitGracefully('Third argument `modules-paths` is missing!');
-}
-
-const map: { sources?: string[] } = JSON.parse(readFileSync(sourceMapPath, 'utf8'));
-if (!map.sources) {
-  exitGracefully(`Modules not collected. No sources found in the source map (${sourceMapPath})!`);
-}
-
-const sources: string[] = map.sources;
-const modules = ModulesCollector.collect(sources, modulesPaths);
-
-const outputModulesDirPath = dirname(outputModulesPath);
-if (!existsSync(outputModulesDirPath)) {
-  mkdirSync(outputModulesDirPath, { recursive: true });
-}
-writeFileSync(outputModulesPath, JSON.stringify(modules, null, 2));
-
-function exitGracefully(message: string): never {
-  logger.error(message);
-  exit(0);
-};
+ModulesCollector.run({ sourceMapPath, outputModulesPath, modulesPaths });

src/js/version.ts

@@ -1,3 +1,3 @@
 export const SDK_PACKAGE_NAME = 'npm:@sentry/react-native';
 export const SDK_NAME = 'sentry.javascript.react-native';
-export const SDK_VERSION = '4.10.0';
+export const SDK_VERSION = '4.10.1';

test/tools/collectModules.test.ts

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync, rmdirSync,unlinkSync } from 'fs';
+import { dirname } from 'path';
+
 import ModulesCollector from '../../src/js/tools/ModulesCollector';
 
 describe('collectModules', () => {
@@ -42,4 +45,71 @@ describe('collectModules', () => {
       'module-2': 'unknown'
     });
   });
+
+  test('should skip non string source value', () => {
+    const modules = ModulesCollector.collect(
+      [1, {}],
+      [
+        `${__dirname}/fixtures/root-module/modules`,
+      ],
+    );
+
+    expect(modules).toEqual({});
+  });
+
+  test('should gracefully return if source map does not exist', () => {
+    const mockCollect = jest.fn().mockReturnValue({});
+    ModulesCollector.run({
+      sourceMapPath: 'not-exist',
+      outputModulesPath: `${__dirname}/fixtures/mock.json`,
+      modulesPaths: [
+        `${__dirname}/fixtures/root-module/modules`,
+      ],
+      collect: mockCollect,
+    });
+
+    expect(mockCollect).not.toHaveBeenCalled();
+  });
+
+  test('should gracefully return if one of the modules paths does not exist', () => {
+    const mockCollect = jest.fn().mockReturnValue({});
+    ModulesCollector.run({
+      sourceMapPath: `${__dirname}/fixtures/mock.map`,
+      outputModulesPath: `${__dirname}/fixtures/mock.json`,
+      modulesPaths: [
+        `${__dirname}/fixtures/root-module/modules`,
+        'not-exist',
+      ],
+      collect: mockCollect,
+    });
+
+    expect(mockCollect).not.toHaveBeenCalled();
+  });
+
+  describe('write output json', () => {
+    const outputModulesPath = `${__dirname}/assets/output.json`;
+
+    const cleanUp = () => {
+      if (existsSync(outputModulesPath)) {
+        unlinkSync(outputModulesPath);
+        rmdirSync(dirname(outputModulesPath));
+      }
+    };
+
+    beforeEach(cleanUp);
+    afterEach(cleanUp);
+
+    test('should write output to file', () => {
+      ModulesCollector.run({
+        sourceMapPath: `${__dirname}/fixtures/mock.map`,
+        outputModulesPath,
+        modulesPaths: [
+          `${__dirname}/fixtures/root-module/modules`,
+        ],
+      });
+
+      expect(existsSync(outputModulesPath)).toEqual(true);
+      expect(readFileSync(outputModulesPath, 'utf8')).toEqual('{}');
+    });
+  });
 });

test/tools/fixtures/mock.map

@@ -0,0 +1,3 @@
+{
+  "sources": []
+}