refactor(build): Use --metadata parameter for flexible key-value metadata (EME-XXX)

Replace specific --gradle-plugin-version and --fastlane-plugin-version
parameters with a more general --metadata parameter that accepts key-value
pairs. This allows for flexible metadata inclusion in build uploads without
requiring new CLI parameters for each metadata type.

Usage: --metadata gradle-plugin=4.12.0 --metadata fastlane-plugin=1.2.3

Metadata is written to .sentry-cli-metadata.txt in uploaded archives in a
sorted, deterministic format for consistent checksums.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: runningcode

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### Improvements
 
-- The `sentry-cli build upload` command now accepts `--gradle-plugin-version` and `--fastlane-plugin-version` parameters to track plugin versions ([#2994](https://github.com/getsentry/sentry-cli/pull/2994)). These versions are written to the `.sentry-cli-metadata.txt` file in uploaded build archives, enabling the backend to store plugin version information for size analysis and build distribution tracking.
+- The `sentry-cli build upload` command now accepts a `--metadata` parameter to include custom metadata in build uploads ([#2994](https://github.com/getsentry/sentry-cli/pull/2994)). Metadata can be specified as key-value pairs (e.g., `--metadata gradle-plugin=4.12.0 --metadata fastlane-plugin=1.2.3`) and is written to the `.sentry-cli-metadata.txt` file in uploaded build archives, enabling the backend to store metadata for size analysis and build distribution tracking.
 - The `sentry-cli build upload` command now automatically detects the correct branch or tag reference in non-PR GitHub Actions workflows ([#2976](https://github.com/getsentry/sentry-cli/pull/2976)). Previously, `--head-ref` was only auto-detected for pull request workflows. Now it works for push, release, and other workflow types by using the `GITHUB_REF_NAME` environment variable.
 
 ## 2.58.2

src/commands/build/upload.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 use std::io::Write as _;
 use std::path::Path;
 
@@ -107,14 +108,11 @@ pub fn make_command(command: Command) -> Command {
                 .help("The release notes to use for the upload.")
         )
         .arg(
-            Arg::new("gradle_plugin_version")
-                .long("gradle-plugin-version")
-                .help("The version of the Sentry Gradle plugin used to build the artifact.")
-        )
-        .arg(
-            Arg::new("fastlane_plugin_version")
-                .long("fastlane-plugin-version")
-                .help("The version of the Sentry Fastlane plugin used to build the artifact.")
+            Arg::new("metadata")
+                .long("metadata")
+                .value_name("KEY=VALUE")
+                .help("Custom metadata to include in the build upload (e.g., --metadata gradle-plugin=4.12.0). Can be specified multiple times.")
+                .action(ArgAction::Append)
         )
 }
 
@@ -290,10 +288,24 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 
     let build_configuration = matches.get_one("build_configuration").map(String::as_str);
     let release_notes = matches.get_one("release_notes").map(String::as_str);
-    let gradle_plugin_version = matches.get_one("gradle_plugin_version").map(String::as_str);
-    let fastlane_plugin_version = matches
-        .get_one("fastlane_plugin_version")
-        .map(String::as_str);
+
+    // Parse metadata key-value pairs
+    let metadata: HashMap<String, String> = matches
+        .get_many::<String>("metadata")
+        .map(|values| {
+            values
+                .filter_map(|s| {
+                    let parts: Vec<&str> = s.splitn(2, '=').collect();
+                    if parts.len() == 2 {
+                        Some((parts[0].to_string(), parts[1].to_string()))
+                    } else {
+                        warn!("Ignoring invalid metadata format: {s}. Expected format: KEY=VALUE");
+                        None
+                    }
+                })
+                .collect()
+        })
+        .unwrap_or_default();
 
     let api = Api::current();
     let authenticated_api = api.authenticated()?;
@@ -316,22 +328,15 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 
         let normalized_zip = if path.is_file() {
             debug!("Normalizing file: {}", path.display());
-            handle_file(
-                path,
-                &byteview,
-                gradle_plugin_version,
-                fastlane_plugin_version,
-            )?
+            handle_file(path, &byteview, &metadata)?
         } else if path.is_dir() {
             debug!("Normalizing directory: {}", path.display());
-            handle_directory(path, gradle_plugin_version, fastlane_plugin_version).with_context(
-                || {
-                    format!(
-                        "Failed to generate uploadable bundle for directory {}",
-                        path.display()
-                    )
-                },
-            )?
+            handle_directory(path, &metadata).with_context(|| {
+                format!(
+                    "Failed to generate uploadable bundle for directory {}",
+                    path.display()
+                )
+            })?
         } else {
             Err(anyhow!(
                 "Path {} is neither a file nor a directory, cannot upload",
@@ -424,28 +429,19 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 fn handle_file(
     path: &Path,
     byteview: &ByteView,
-    gradle_plugin_version: Option<&str>,
-    fastlane_plugin_version: Option<&str>,
+    metadata: &HashMap<String, String>,
 ) -> Result<TempFile> {
     // Handle IPA files by converting them to XCArchive
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
     if is_zip_file(byteview) && is_ipa_file(byteview)? {
         debug!("Converting IPA file to XCArchive structure");
         let archive_temp_dir = TempDir::create()?;
         return ipa_to_xcarchive(path, byteview, &archive_temp_dir)
-            .and_then(|path| {
-                handle_directory(&path, gradle_plugin_version, fastlane_plugin_version)
-            })
+            .and_then(|path| handle_directory(&path, metadata))
             .with_context(|| format!("Failed to process IPA file {}", path.display()));
     }
 
-    normalize_file(
-        path,
-        byteview,
-        gradle_plugin_version,
-        fastlane_plugin_version,
-    )
-    .with_context(|| {
+    normalize_file(path, byteview, metadata).with_context(|| {
         format!(
             "Failed to generate uploadable bundle for file {}",
             path.display()
@@ -502,8 +498,7 @@ fn validate_is_supported_build(path: &Path, bytes: &[u8]) -> Result<()> {
 fn normalize_file(
     path: &Path,
     bytes: &[u8],
-    gradle_plugin_version: Option<&str>,
-    fastlane_plugin_version: Option<&str>,
+    metadata: &HashMap<String, String>,
 ) -> Result<TempFile> {
     debug!("Creating normalized zip for file: {}", path.display());
 
@@ -528,29 +523,20 @@ fn normalize_file(
     zip.start_file(file_name, options)?;
     zip.write_all(bytes)?;
 
-    write_version_metadata(&mut zip, gradle_plugin_version, fastlane_plugin_version)?;
+    write_version_metadata(&mut zip, metadata)?;
 
     zip.finish()?;
     debug!("Successfully created normalized zip for file");
     Ok(temp_file)
 }
 
-fn handle_directory(
-    path: &Path,
-    gradle_plugin_version: Option<&str>,
-    fastlane_plugin_version: Option<&str>,
-) -> Result<TempFile> {
+fn handle_directory(path: &Path, metadata: &HashMap<String, String>) -> Result<TempFile> {
     let temp_dir = TempDir::create()?;
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
     if is_apple_app(path)? {
         handle_asset_catalogs(path, temp_dir.path());
     }
-    normalize_directory(
-        path,
-        temp_dir.path(),
-        gradle_plugin_version,
-        fastlane_plugin_version,
-    )
+    normalize_directory(path, temp_dir.path(), metadata)
 }
 
 /// Returns artifact url if upload was successful.
@@ -686,7 +672,7 @@ mod tests {
         fs::create_dir_all(test_dir.join("Products"))?;
         fs::write(test_dir.join("Products").join("app.txt"), "test content")?;
 
-        let result_zip = normalize_directory(&test_dir, temp_dir.path(), None, None)?;
+        let result_zip = normalize_directory(&test_dir, temp_dir.path(), &HashMap::new())?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
         let file = archive.by_index(0)?;
@@ -702,7 +688,7 @@ mod tests {
         let xcarchive_path = Path::new("tests/integration/_fixtures/build/archive.xcarchive");
 
         // Process the XCArchive directory
-        let result = handle_directory(xcarchive_path, None, None)?;
+        let result = handle_directory(xcarchive_path, &HashMap::new())?;
 
         // Verify the resulting zip contains parsed assets
         let zip_file = fs::File::open(result.path())?;
@@ -735,7 +721,7 @@ mod tests {
         let byteview = ByteView::open(ipa_path)?;
 
         // Process the IPA file - this should work even without asset catalogs
-        let result = handle_file(ipa_path, &byteview, None, None)?;
+        let result = handle_file(ipa_path, &byteview, &HashMap::new())?;
 
         let zip_file = fs::File::open(result.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
@@ -772,7 +758,7 @@ mod tests {
         let symlink_path = test_dir.join("Products").join("app_link.txt");
         symlink("app.txt", &symlink_path)?;
 
-        let result_zip = normalize_directory(&test_dir, temp_dir.path(), None, None)?;
+        let result_zip = normalize_directory(&test_dir, temp_dir.path(), &HashMap::new())?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
 
@@ -813,8 +799,11 @@ mod tests {
         fs::create_dir_all(test_dir.join("Products"))?;
         fs::write(test_dir.join("Products").join("app.txt"), "test content")?;
 
-        let result_zip =
-            normalize_directory(&test_dir, temp_dir.path(), Some("4.12.0"), Some("1.2.3"))?;
+        let mut metadata = HashMap::new();
+        metadata.insert("gradle-plugin".to_string(), "4.12.0".to_string());
+        metadata.insert("fastlane-plugin".to_string(), "1.2.3".to_string());
+
+        let result_zip = normalize_directory(&test_dir, temp_dir.path(), &metadata)?;
         let zip_file = fs::File::open(result_zip.path())?;
         let mut archive = ZipArchive::new(zip_file)?;
 
@@ -827,12 +816,12 @@ mod tests {
             "Metadata should contain sentry-cli-version"
         );
         assert!(
-            metadata_content.contains("gradle-plugin-version: 4.12.0"),
-            "Metadata should contain gradle-plugin-version"
+            metadata_content.contains("gradle-plugin: 4.12.0"),
+            "Metadata should contain gradle-plugin"
         );
         assert!(
-            metadata_content.contains("fastlane-plugin-version: 1.2.3"),
-            "Metadata should contain fastlane-plugin-version"
+            metadata_content.contains("fastlane-plugin: 1.2.3"),
+            "Metadata should contain fastlane-plugin"
         );
         Ok(())
     }

src/utils/build/normalize.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 #[cfg(not(windows))]
 use std::fs;
 use std::fs::File;
@@ -94,17 +95,19 @@ fn metadata_file_options() -> SimpleFileOptions {
 
 pub fn write_version_metadata<W: std::io::Write + std::io::Seek>(
     zip: &mut ZipWriter<W>,
-    gradle_plugin_version: Option<&str>,
-    fastlane_plugin_version: Option<&str>,
+    metadata: &HashMap<String, String>,
 ) -> Result<()> {
     let version = get_version();
     zip.start_file(".sentry-cli-metadata.txt", metadata_file_options())?;
     writeln!(zip, "sentry-cli-version: {version}")?;
-    if let Some(gradle_version) = gradle_plugin_version {
-        writeln!(zip, "gradle-plugin-version: {gradle_version}")?;
-    }
-    if let Some(fastlane_version) = fastlane_plugin_version {
-        writeln!(zip, "fastlane-plugin-version: {fastlane_version}")?;
+
+    // Write metadata in sorted order for deterministic output
+    let mut keys: Vec<_> = metadata.keys().collect();
+    keys.sort();
+    for key in keys {
+        if let Some(value) = metadata.get(key) {
+            writeln!(zip, "{key}: {value}")?;
+        }
     }
     Ok(())
 }
@@ -115,8 +118,7 @@ pub fn write_version_metadata<W: std::io::Write + std::io::Seek>(
 pub fn normalize_directory(
     path: &Path,
     parsed_assets_path: &Path,
-    gradle_plugin_version: Option<&str>,
-    fastlane_plugin_version: Option<&str>,
+    metadata: &HashMap<String, String>,
 ) -> Result<TempFile> {
     debug!("Creating normalized zip for directory: {}", path.display());
 
@@ -146,7 +148,7 @@ pub fn normalize_directory(
         )?;
     }
 
-    write_version_metadata(&mut zip, gradle_plugin_version, fastlane_plugin_version)?;
+    write_version_metadata(&mut zip, metadata)?;
 
     zip.finish()?;
     debug!("Successfully created normalized zip for directory with {file_count} files");