fix(bundle): resolve native Sentry release for OTA sourcemaps

Author: sunnylqm

cli.json

@@ -297,6 +297,30 @@
         },
         "dryRun": {
           "default": false
+        },
+        "sentry-release": {
+          "hasValue": true,
+          "description": "Sentry release for source map upload"
+        },
+        "sentryRelease": {
+          "hasValue": true,
+          "description": "Sentry release for source map upload"
+        },
+        "sentry-dist": {
+          "hasValue": true,
+          "description": "Sentry dist for source map upload"
+        },
+        "sentryDist": {
+          "hasValue": true,
+          "description": "Sentry dist for source map upload"
+        },
+        "sentry-flavor": {
+          "hasValue": true,
+          "description": "Android product flavor or variant for native Sentry release/dist"
+        },
+        "sentryFlavor": {
+          "hasValue": true,
+          "description": "Android product flavor or variant for native Sentry release/dist"
         }
       }
     },

src/bundle-runner.ts

@@ -9,6 +9,10 @@ import {
   spawnJavaScript,
   spawnJavaScriptSync,
 } from './utils/runtime';
+import {
+  resolveSentryReleaseAndDist,
+  type SentryReleaseOptions,
+} from './utils/sentry-release';
 
 const g2js = require('gradle-to-js/lib/parser');
 const properties = require('properties');
@@ -55,6 +59,23 @@ type ResolvedExpoCli = {
   usingExpo: boolean;
 };
 
+type SentryUploadArtifacts = {
+  bundlePath: string;
+  sourcemapPath: string;
+};
+
+type BuildSentrySourcemapsUploadArgsOptions = {
+  sentryCliPath: string;
+  bundlePath: string;
+  sourcemapPath: string;
+  release: string;
+  dist?: string;
+  stripPrefix?: string;
+  useStandaloneSourcemapsCommand?: boolean;
+};
+
+const ANDROID_SENTRY_BUNDLE_NAME = 'index.android.bundle';
+
 export function hasProjectDependency(
   dependencyName: string,
   projectRoot = process.cwd(),
@@ -557,27 +578,59 @@ export async function copyDebugidForSentry(
   fs.removeSync(path.join(outputFolder, `${bundleName}.txt.map`));
 }
 
-export function buildSentrySourcemapsUploadArgs(
-  sentryCliPath: string,
+export function prepareSentryUploadArtifacts(
   bundleName: string,
   outputFolder: string,
-  version: string,
+  platform: string,
+): SentryUploadArtifacts {
+  const bundlePath = path.join(outputFolder, bundleName);
+  const sourcemapPath = path.join(outputFolder, `${bundleName}.map`);
+
+  if (platform !== 'android' || bundleName === ANDROID_SENTRY_BUNDLE_NAME) {
+    return {
+      bundlePath,
+      sourcemapPath,
+    };
+  }
+
+  const androidBundlePath = path.join(outputFolder, ANDROID_SENTRY_BUNDLE_NAME);
+  const androidSourcemapPath = path.join(
+    outputFolder,
+    `${ANDROID_SENTRY_BUNDLE_NAME}.map`,
+  );
+  fs.copyFileSync(bundlePath, androidBundlePath);
+
+  const sourcemap = JSON.parse(
+    fs.readFileSync(sourcemapPath, 'utf8'),
+  ) as Record<string, unknown>;
+  sourcemap.file = ANDROID_SENTRY_BUNDLE_NAME;
+  fs.writeFileSync(androidSourcemapPath, JSON.stringify(sourcemap));
+
+  return {
+    bundlePath: androidBundlePath,
+    sourcemapPath: androidSourcemapPath,
+  };
+}
+
+export function buildSentrySourcemapsUploadArgs({
+  sentryCliPath,
+  bundlePath,
+  sourcemapPath,
+  release,
+  dist,
+  stripPrefix = process.cwd(),
   useStandaloneSourcemapsCommand = true,
-): string[] {
-  const uploadArgs = [
-    '--strip-prefix',
-    path.join(process.cwd(), outputFolder),
-    path.join(outputFolder, bundleName),
-    path.join(outputFolder, `${bundleName}.map`),
-  ];
+}: BuildSentrySourcemapsUploadArgsOptions): string[] {
+  const uploadArgs = ['--strip-prefix', stripPrefix, bundlePath, sourcemapPath];
 
   if (!useStandaloneSourcemapsCommand) {
     return [
       sentryCliPath,
       'releases',
       'files',
-      version,
+      release,
       'upload-sourcemaps',
+      ...(dist ? ['--dist', dist] : []),
       ...uploadArgs,
     ];
   }
@@ -587,7 +640,8 @@ export function buildSentrySourcemapsUploadArgs(
     'sourcemaps',
     'upload',
     '--release',
-    version,
+    release,
+    ...(dist ? ['--dist', dist] : []),
     ...uploadArgs,
   ];
 }
@@ -607,6 +661,8 @@ export async function uploadSourcemapForSentry(
   outputFolder: string,
   sourcemapOutput: string,
   version: string,
+  platform = '',
+  sentryOptions: SentryReleaseOptions = {},
 ): Promise<void> {
   if (!sourcemapOutput) {
     return;
@@ -626,27 +682,40 @@ export async function uploadSourcemapForSentry(
     return;
   }
 
+  const { release, dist } = await resolveSentryReleaseAndDist(
+    platform,
+    version,
+    sentryOptions,
+  );
+  const { bundlePath, sourcemapPath } = prepareSentryUploadArtifacts(
+    bundleName,
+    outputFolder,
+    platform,
+  );
+
   assertSuccessfulSyncProcess(
     spawnJavaScriptSync(
-      [sentryCliPath, 'releases', 'set-commits', version, '--auto'],
+      [sentryCliPath, 'releases', 'set-commits', release, '--auto'],
       {
         stdio: 'inherit',
       },
     ),
     sentryCliPath,
   );
-  console.log(t('sentryReleaseCreated', { version }));
+  console.log(t('sentryReleaseCreated', { version: release }));
 
   console.log(t('uploadingSourcemap'));
   assertSuccessfulSyncProcess(
     spawnJavaScriptSync(
-      buildSentrySourcemapsUploadArgs(
+      buildSentrySourcemapsUploadArgs({
         sentryCliPath,
-        bundleName,
-        outputFolder,
-        version,
-        supportsStandaloneSentrySourcemapsUpload(sentryCliPath),
-      ),
+        bundlePath,
+        sourcemapPath,
+        release,
+        dist,
+        useStandaloneSourcemapsCommand:
+          supportsStandaloneSentrySourcemapsUpload(sentryCliPath),
+      }),
       {
         stdio: 'inherit',
       },

src/bundle.ts

@@ -18,6 +18,7 @@ import {
   getOptionalStringOption,
   getStringOption,
 } from './utils/options';
+import type { SentryReleaseOptions } from './utils/sentry-release';
 import { versionCommands } from './versions';
 
 type NormalizedBundleOptions = {
@@ -41,6 +42,9 @@ type NormalizedBundleOptions = {
   packageVersionRange?: string;
   rollout?: string;
   dryRun: boolean;
+  sentryRelease?: string;
+  sentryDist?: string;
+  sentryFlavor?: string;
 };
 
 type PublishBundlePayload = {
@@ -56,6 +60,17 @@ type PublishBundlePayload = {
   dryRun?: boolean;
 };
 
+function getAliasedOptionalStringOption(
+  options: Record<string, unknown>,
+  key: string,
+  alias: string,
+): string | undefined {
+  return (
+    getOptionalStringOption(options, key) ??
+    getOptionalStringOption(options, alias)
+  );
+}
+
 function normalizeBundleOptions(
   translatedOptions: Record<string, unknown>,
   platform: string,
@@ -105,6 +120,21 @@ function normalizeBundleOptions(
     ),
     rollout: getOptionalStringOption(translatedOptions, 'rollout'),
     dryRun: getBooleanOption(translatedOptions, 'dryRun', false),
+    sentryRelease: getAliasedOptionalStringOption(
+      translatedOptions,
+      'sentry-release',
+      'sentryRelease',
+    ),
+    sentryDist: getAliasedOptionalStringOption(
+      translatedOptions,
+      'sentry-dist',
+      'sentryDist',
+    ),
+    sentryFlavor: getAliasedOptionalStringOption(
+      translatedOptions,
+      'sentry-flavor',
+      'sentryFlavor',
+    ),
   };
 }
 
@@ -114,6 +144,8 @@ async function uploadSentryArtifactsIfNeeded(
   intermediaDir: string,
   sourcemapOutput: string,
   versionName: string,
+  platform: Platform,
+  sentryOptions: SentryReleaseOptions,
 ): Promise<void> {
   if (!shouldUpload) {
     return;
@@ -125,6 +157,8 @@ async function uploadSentryArtifactsIfNeeded(
     intermediaDir,
     sourcemapOutput,
     versionName,
+    platform,
+    sentryOptions,
   );
 }
 
@@ -217,6 +251,12 @@ export const bundleCommands = {
         normalized.intermediaDir,
         sourcemapOutput,
         versionName,
+        platform,
+        {
+          sentryRelease: normalized.sentryRelease,
+          sentryDist: normalized.sentryDist,
+          sentryFlavor: normalized.sentryFlavor,
+        },
       );
       return;
     }
@@ -235,6 +275,12 @@ export const bundleCommands = {
           normalized.intermediaDir,
           sourcemapOutput,
           versionName,
+          platform,
+          {
+            sentryRelease: normalized.sentryRelease,
+            sentryDist: normalized.sentryDist,
+            sentryFlavor: normalized.sentryFlavor,
+          },
         );
       }
     }

src/provider.ts

@@ -90,6 +90,9 @@ export class CLIProviderImpl implements CLIProvider {
           expo: options.expo || false,
           rncli: options.rncli || false,
           hermes: options.hermes || false,
+          sentryRelease: options.sentryRelease,
+          sentryDist: options.sentryDist,
+          sentryFlavor: options.sentryFlavor,
         });
 
         const { bundleCommands } = await import('./bundle');

src/types.ts

@@ -56,6 +56,9 @@ export interface BundleOptions {
   expo?: boolean;
   rncli?: boolean;
   hermes?: boolean;
+  sentryRelease?: string;
+  sentryDist?: string;
+  sentryFlavor?: string;
 }
 
 export interface PublishOptions {