sentry-cli 3.3.0__tar.gz → 3.3.1__tar.gz

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/Cargo.lock

@@ -3414,7 +3414,7 @@ dependencies = [
 
 [[package]]
 name = "sentry-cli"
-version = "3.3.0"
+version = "3.3.1"
 dependencies = [
  "anyhow",
  "anylog",

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 build = "build.rs"
 name = "sentry-cli"
-version = "3.3.0"
+version = "3.3.1"
 edition = "2021"
 rust-version = "1.91"
 

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry_cli
-Version: 3.3.0
+Version: 3.3.1
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry
@@ -50,7 +50,7 @@ Users who are using Sentry Self-Hosted versions older than 24.11.1 are encourage
 | **Sentry Self-Hosted Version** | **Newest Compatible Sentry CLI Version**                              |
 | ------------------------------ | --------------------------------------------------------------------- |
 | ≥ 24.11.1                      | [latest](https://github.com/getsentry/sentry-cli/releases/latest)     |
-| < 24.11.1                      | [2.58.4](https://github.com/getsentry/sentry-cli/releases/tag/2.58.4) |
+| < 24.11.1                      | [2.58.5](https://github.com/getsentry/sentry-cli/releases/tag/2.58.5) |
 
 Note that we can only provide support for officially-supported Sentry Self-Hosted versions. We will not backport fixes for older Sentry CLI versions, even if they should be compatible with your self-hosted version.
 

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/README.md

@@ -33,7 +33,7 @@ Users who are using Sentry Self-Hosted versions older than 24.11.1 are encourage
 | **Sentry Self-Hosted Version** | **Newest Compatible Sentry CLI Version**                              |
 | ------------------------------ | --------------------------------------------------------------------- |
 | ≥ 24.11.1                      | [latest](https://github.com/getsentry/sentry-cli/releases/latest)     |
-| < 24.11.1                      | [2.58.4](https://github.com/getsentry/sentry-cli/releases/tag/2.58.4) |
+| < 24.11.1                      | [2.58.5](https://github.com/getsentry/sentry-cli/releases/tag/2.58.5) |
 
 Note that we can only provide support for officially-supported Sentry Self-Hosted versions. We will not backport fixes for older Sentry CLI versions, even if they should be compatible with your self-hosted version.
 

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/sentry_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry_cli
-Version: 3.3.0
+Version: 3.3.1
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry
@@ -50,7 +50,7 @@ Users who are using Sentry Self-Hosted versions older than 24.11.1 are encourage
 | **Sentry Self-Hosted Version** | **Newest Compatible Sentry CLI Version**                              |
 | ------------------------------ | --------------------------------------------------------------------- |
 | ≥ 24.11.1                      | [latest](https://github.com/getsentry/sentry-cli/releases/latest)     |
-| < 24.11.1                      | [2.58.4](https://github.com/getsentry/sentry-cli/releases/tag/2.58.4) |
+| < 24.11.1                      | [2.58.5](https://github.com/getsentry/sentry-cli/releases/tag/2.58.5) |
 
 Note that we can only provide support for officially-supported Sentry Self-Hosted versions. We will not backport fixes for older Sentry CLI versions, even if they should be compatible with your self-hosted version.
 

sentry_cli-3.3.1/src/api/data_types/snapshots.rs

@@ -0,0 +1,86 @@
+//! Data types for the snapshots API.
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+const IMAGE_FILE_NAME_FIELD: &str = "image_file_name";
+const WIDTH_FIELD: &str = "width";
+const HEIGHT_FIELD: &str = "height";
+
+/// Response from the create snapshot endpoint.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateSnapshotResponse {
+    pub artifact_id: String,
+    pub image_count: u64,
+    pub snapshot_url: Option<String>,
+}
+
+// Keep in sync with https://github.com/getsentry/sentry/blob/master/src/sentry/preprod/snapshots/manifest.py
+/// Manifest describing a set of snapshot images for an app.
+#[derive(Debug, Serialize)]
+pub struct SnapshotsManifest {
+    pub app_id: String,
+    pub images: HashMap<String, ImageMetadata>,
+}
+
+// Keep in sync with https://github.com/getsentry/sentry/blob/master/src/sentry/preprod/snapshots/manifest.py
+/// Metadata for a single image in a snapshot manifest.
+///
+/// CLI-managed fields (`image_file_name`, `width`, `height`) override any
+/// identically named fields provided by user sidecar metadata.
+#[derive(Debug, Serialize)]
+pub struct ImageMetadata {
+    #[serde(flatten)]
+    data: HashMap<String, Value>,
+}
+
+impl ImageMetadata {
+    pub fn new(
+        image_file_name: String,
+        width: u32,
+        height: u32,
+        mut extra: HashMap<String, Value>,
+    ) -> Self {
+        extra.insert(
+            IMAGE_FILE_NAME_FIELD.to_owned(),
+            Value::String(image_file_name),
+        );
+        extra.insert(WIDTH_FIELD.to_owned(), Value::from(width));
+        extra.insert(HEIGHT_FIELD.to_owned(), Value::from(height));
+
+        Self { data: extra }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use serde_json::json;
+
+    #[test]
+    fn cli_managed_fields_override_sidecar_fields() {
+        let extra = serde_json::from_value(json!({
+            (IMAGE_FILE_NAME_FIELD): "from-sidecar.png",
+            (WIDTH_FIELD): 1,
+            (HEIGHT_FIELD): 2,
+            "custom": "keep-me"
+        }))
+        .unwrap();
+
+        let metadata = ImageMetadata::new("from-cli.png".to_owned(), 100, 200, extra);
+        let serialized = serde_json::to_value(metadata).unwrap();
+
+        let expected = json!({
+            (IMAGE_FILE_NAME_FIELD): "from-cli.png",
+            (WIDTH_FIELD): 100,
+            (HEIGHT_FIELD): 200,
+            "custom": "keep-me"
+        });
+
+        assert_eq!(serialized, expected);
+    }
+}

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/src/commands/build/snapshots.rs

@@ -1,14 +1,17 @@
 use std::collections::HashMap;
-use std::fs;
+use std::fs::File;
+use std::io::BufReader;
 use std::path::{Path, PathBuf};
 use std::str::FromStr as _;
 
 use anyhow::{Context as _, Result};
 use clap::{Arg, ArgMatches, Command};
 use console::style;
+use itertools::Itertools as _;
 use log::{debug, info, warn};
 use objectstore_client::{ClientBuilder, ExpirationPolicy, Usecase};
 use secrecy::ExposeSecret as _;
+use serde_json::Value;
 use sha2::{Digest as _, Sha256};
 use walkdir::WalkDir;
 
@@ -21,6 +24,7 @@ const EXPERIMENTAL_WARNING: &str =
     The command is subject to breaking changes, including removal, in any Sentry CLI release.";
 
 const IMAGE_EXTENSIONS: &[&str] = &["png", "jpg", "jpeg"];
+const MAX_PIXELS_PER_IMAGE: u64 = 40_000_000;
 
 pub fn make_command(command: Command) -> Command {
     command
@@ -52,6 +56,12 @@ struct ImageInfo {
     height: u32,
 }
 
+impl ImageInfo {
+    fn pixels(&self) -> u64 {
+        u64::from(self.width) * u64::from(self.height)
+    }
+}
+
 pub fn execute(matches: &ArgMatches) -> Result<()> {
     eprintln!("{EXPERIMENTAL_WARNING}");
 
@@ -88,6 +98,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         if images.len() == 1 { "file" } else { "files" }
     );
 
+    validate_image_sizes(&images)?;
+
     // Upload image files to objectstore
     println!(
         "{} Uploading {} image {}",
@@ -95,6 +107,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         style(images.len()).yellow(),
         if images.len() == 1 { "file" } else { "files" }
     );
+
     let manifest_entries = upload_images(images, &org, &project)?;
 
     // Build manifest from discovered images
@@ -174,11 +187,49 @@ fn collect_image_info(dir: &Path, path: &Path) -> Option<ImageInfo> {
     })
 }
 
-fn compute_sha256_hash(data: &[u8]) -> String {
+fn validate_image_sizes(images: &[ImageInfo]) -> Result<()> {
+    let mut violations = images
+        .iter()
+        .filter(|img| img.pixels() > MAX_PIXELS_PER_IMAGE)
+        .map(|img| {
+            let path = img.relative_path.display();
+            let width = img.width;
+            let height = img.height;
+            let pixels = img.pixels();
+
+            format!("  {path} ({width}x{height} = {pixels} pixels)")
+        })
+        .peekable();
+
+    if violations.peek().is_some() {
+        let violation_messages = violations.join("\n");
+
+        anyhow::bail!(
+            "The following images exceed the maximum pixel limit of {MAX_PIXELS_PER_IMAGE}:\n{violation_messages}",
+        );
+    }
+
+    Ok(())
+}
+
+fn compute_sha256_hash(path: &Path) -> Result<String> {
+    use std::io::Read as _;
+
+    let mut file = std::fs::File::open(path)
+        .with_context(|| format!("Failed to open image for hashing: {}", path.display()))?;
     let mut hasher = Sha256::new();
-    hasher.update(data);
+    let mut buffer = [0u8; 8192];
+    loop {
+        let bytes_read = file
+            .read(&mut buffer)
+            .with_context(|| format!("Failed to read image for hashing: {}", path.display()))?;
+        if bytes_read == 0 {
+            break;
+        }
+        hasher.update(&buffer[..bytes_read]);
+    }
     let result = hasher.finalize();
-    format!("{result:x}")
+    Ok(format!("{result:x}"))
 }
 
 fn is_hidden(root: &Path, path: &Path) -> bool {
@@ -196,6 +247,29 @@ fn is_image_file(path: &Path) -> bool {
         .unwrap_or(false)
 }
 
+/// Reads the companion JSON sidecar for an image, if it exists.
+///
+/// For an image at `path/to/button.png`, looks for `path/to/button.json`.
+/// Returns a map of all key-value pairs from the JSON file.
+fn read_sidecar_metadata(image_path: &Path) -> Result<HashMap<String, Value>> {
+    let sidecar_path = image_path.with_extension("json");
+    if !sidecar_path.is_file() {
+        return Ok(HashMap::new());
+    }
+
+    debug!("Reading sidecar metadata: {}", sidecar_path.display());
+
+    let sidecar_file = File::open(&sidecar_path)
+        .with_context(|| format!("Failed to open sidecar file {}", sidecar_path.display()))?;
+
+    serde_json::from_reader(BufReader::new(sidecar_file)).with_context(|| {
+        format!(
+            "Failed to read sidecar file {} as JSON",
+            sidecar_path.display()
+        )
+    })
+}
+
 fn upload_images(
     images: Vec<ImageInfo>,
     org: &str,
@@ -219,9 +293,22 @@ fn upload_images(
         .build()?;
 
     let mut scope = Usecase::new("preprod").scope();
-    for (key, value) in &options.objectstore.scopes {
-        scope = scope.push(key, value);
+    let (mut org_id, mut project_id): (Option<String>, Option<String>) = (None, None);
+    for (key, value) in options.objectstore.scopes.into_iter() {
+        scope = scope.push(&key, value.clone());
+        if key == "org" {
+            org_id = Some(value);
+        } else if key == "project" {
+            project_id = Some(value);
+        }
     }
+    let Some(org_id) = org_id else {
+        anyhow::bail!("Missing org in UploadOptions scope");
+    };
+    let Some(project_id) = project_id else {
+        anyhow::bail!("Missing project in UploadOptions scope");
+    };
+
     let session = scope.session(&client)?;
 
     let runtime = tokio::runtime::Builder::new_current_thread()
@@ -236,16 +323,20 @@ fn upload_images(
     for image in images {
         debug!("Processing image: {}", image.path.display());
 
-        let contents = fs::read(&image.path)
-            .with_context(|| format!("Failed to read image: {}", image.path.display()))?;
-        let hash = compute_sha256_hash(&contents);
+        let hash = compute_sha256_hash(&image.path)?;
+        let file = runtime
+            .block_on(tokio::fs::File::open(&image.path))
+            .with_context(|| {
+                format!("Failed to open image for upload: {}", image.path.display())
+            })?;
 
-        info!("Queueing {} as {hash}", image.relative_path.display());
+        let key = format!("{org_id}/{project_id}/{hash}");
+        info!("Queueing {} as {key}", image.relative_path.display());
 
         many_builder = many_builder.push(
             session
-                .put(contents)
-                .key(&hash)
+                .put_file(file)
+                .key(&key)
                 .expiration_policy(expiration),
         );
 
@@ -255,13 +346,15 @@ fn upload_images(
             .unwrap_or_default()
             .to_string_lossy()
             .into_owned();
+
+        let extra = read_sidecar_metadata(&image.path).unwrap_or_else(|err| {
+            warn!("Error reading sidecar metadata, ignoring it instead: {err:#}");
+            HashMap::new()
+        });
+
         manifest_entries.insert(
             hash,
-            ImageMetadata {
-                image_file_name,
-                width: image.width,
-                height: image.height,
-            },
+            ImageMetadata::new(image_file_name, image.width, image.height, extra),
         );
     }
 
@@ -288,3 +381,28 @@ fn upload_images(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_image(width: u32, height: u32) -> ImageInfo {
+        ImageInfo {
+            path: PathBuf::from("img.png"),
+            relative_path: PathBuf::from("img.png"),
+            width,
+            height,
+        }
+    }
+
+    #[test]
+    fn test_validate_image_sizes_at_limit_passes() {
+        assert!(validate_image_sizes(&[make_image(8000, 5000)]).is_ok());
+    }
+
+    #[test]
+    fn test_validate_image_sizes_over_limit_fails() {
+        let err = validate_image_sizes(&[make_image(8001, 5000)]).unwrap_err();
+        assert!(err.to_string().contains("exceed the maximum pixel limit"));
+    }
+}

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/src/commands/proguard/upload.rs

@@ -95,10 +95,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
     // them all up.
     for path in &paths {
         match ByteView::open(path) {
-            Ok(byteview) => match ProguardMapping::try_from(byteview) {
-                Ok(mapping) => mappings.push(mapping),
-                Err(e) => eprintln!("warning: ignoring proguard mapping '{path}': {e}"),
-            },
+            Ok(byteview) => mappings.push(ProguardMapping::from(byteview)),
             Err(ref err) if err.kind() == io::ErrorKind::NotFound => {
                 eprintln!(
                     "warning: proguard mapping '{path}' does not exist. This \

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/src/commands/proguard/uuid.rs

@@ -29,8 +29,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
 
     let byteview = ByteView::open(path)
         .with_context(|| format!("failed to open proguard mapping '{path}'"))?;
-    let mapping = ProguardMapping::try_from(byteview)
-        .with_context(|| format!("failed to parse proguard mapping '{path}'"))?;
+    let mapping = ProguardMapping::from(byteview);
 
     println!("{}", mapping.uuid());
     Ok(())

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/src/utils/dif.rs

@@ -380,24 +380,22 @@ impl<'a> DifFile<'a> {
     pub fn is_usable(&self) -> bool {
         match self {
             DifFile::Archive(_) => self.has_ids() && self.features().has_some(),
-            DifFile::Proguard(pg) => pg.get().has_line_info(),
+            DifFile::Proguard(..) => true,
         }
     }
 
     pub fn get_problem(&self) -> Option<&'static str> {
         if self.is_usable() {
-            None
-        } else {
-            Some(match self {
-                DifFile::Archive(..) => {
-                    if !self.has_ids() {
-                        "missing debug identifier, likely stripped"
-                    } else {
-                        "missing debug or unwind information"
-                    }
-                }
-                DifFile::Proguard(..) => "missing line information",
-            })
+            return None;
+        }
+
+        match self {
+            DifFile::Archive(..) => Some(if !self.has_ids() {
+                "missing debug identifier, likely stripped"
+            } else {
+                "missing debug or unwind information"
+            }),
+            DifFile::Proguard(..) => None,
         }
     }
 

{sentry_cli-3.3.0 → sentry_cli-3.3.1}/src/utils/proguard/mapping.rs

@@ -2,23 +2,16 @@ use std::borrow::Cow;
 use std::fmt::{Display, Formatter, Result as FmtResult};
 
 use symbolic::common::{ByteView, DebugId};
-use thiserror::Error;
 use uuid::Uuid;
 
 use crate::utils::chunks::Assemblable;
 
-#[derive(Debug, Error)]
-pub enum ProguardMappingError {
-    #[error("Proguard mapping does not contain line information")]
-    MissingLineInfo,
-}
-
 pub struct ProguardMapping<'a> {
     bytes: ByteView<'a>,
     uuid: Uuid,
 }
 
-impl<'a> ProguardMapping<'a> {
+impl ProguardMapping<'_> {
     /// Get the UUID of the mapping.
     pub fn uuid(&self) -> Uuid {
         self.uuid
@@ -29,31 +22,13 @@ impl<'a> ProguardMapping<'a> {
     pub fn force_uuid(&mut self, uuid: Uuid) {
         self.uuid = uuid;
     }
-
-    /// Create a new `ProguardMapping` from a `ByteView`.
-    /// Not public because we want to ensure that the `ByteView` contains line
-    /// information, and this method does not check for that. To create a
-    /// `ProguardMapping` externally, use the `TryFrom<ByteView>` implementation.
-    fn new(bytes: ByteView<'a>, uuid: Uuid) -> Self {
-        Self { bytes, uuid }
-    }
 }
 
-impl<'a> TryFrom<ByteView<'a>> for ProguardMapping<'a> {
-    type Error = ProguardMappingError;
-
-    /// Try to create a `ProguardMapping` from a `ByteView`.
-    /// The method returns an error if the mapping does not contain
-    /// line information.
-    fn try_from(value: ByteView<'a>) -> Result<Self, Self::Error> {
+impl<'a> From<ByteView<'a>> for ProguardMapping<'a> {
+    fn from(value: ByteView<'a>) -> Self {
         let mapping = ::proguard::ProguardMapping::new(&value);
-
-        if !mapping.has_line_info() {
-            return Err(ProguardMappingError::MissingLineInfo);
-        }
-
         let uuid = mapping.uuid();
-        Ok(ProguardMapping::new(value, uuid))
+        Self { bytes: value, uuid }
     }
 }
 

sentry_cli-3.3.0/src/api/data_types/snapshots.rs

@@ -1,31 +0,0 @@
-//! Data types for the snapshots API.
-
-use std::collections::HashMap;
-
-use serde::{Deserialize, Serialize};
-
-/// Response from the create snapshot endpoint.
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateSnapshotResponse {
-    pub artifact_id: String,
-    pub image_count: u64,
-    pub snapshot_url: Option<String>,
-}
-
-// Keep in sync with https://github.com/getsentry/sentry/blob/master/src/sentry/preprod/snapshots/manifest.py
-/// Manifest describing a set of snapshot images for an app.
-#[derive(Debug, Serialize)]
-pub struct SnapshotsManifest {
-    pub app_id: String,
-    pub images: HashMap<String, ImageMetadata>,
-}
-
-// Keep in sync with https://github.com/getsentry/sentry/blob/master/src/sentry/preprod/snapshots/manifest.py
-/// Metadata for a single image in a snapshot manifest.
-#[derive(Debug, Serialize)]
-pub struct ImageMetadata {
-    pub image_file_name: String,
-    pub width: u32,
-    pub height: u32,
-}