sentry-cli 2.40.0__tar.gz → 2.41.0__tar.gz

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/Cargo.lock

@@ -1635,9 +1635,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memmap2"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
 dependencies = [
  "libc",
 ]
@@ -2561,7 +2561,7 @@ dependencies = [
 
 [[package]]
 name = "sentry-cli"
-version = "2.40.0"
+version = "2.41.0"
 dependencies = [
  "anyhow",
  "anylog",
@@ -2900,9 +2900,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "symbolic"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1ef4ac5c889f15a5adf61b10b6bc68b19172938243a697c9730e754e97ff0da"
+checksum = "691b8bd52ccf372a4cce381e62663530e0b96fb5f10e83477a8ec7d5cf421979"
 dependencies = [
  "symbolic-common",
  "symbolic-debuginfo",
@@ -2912,9 +2912,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-common"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ba5365997a4e375660bed52f5b42766475d5bc8ceb1bb13fea09c469ea0f49"
+checksum = "13a4dfe4bbeef59c1f32fc7524ae7c95b9e1de5e79a43ce1604e181081d71b0c"
 dependencies = [
  "debugid",
  "memmap2",
@@ -2925,9 +2925,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-debuginfo"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ac2369b402eaa9c4ce0409094d803e7ee6b253c8bfe76d6057e13a4028d625"
+checksum = "474423ce25f811471ec4bd826511510df8a8895f6babd98f64524eda4a3978f4"
 dependencies = [
  "debugid",
  "elementtree",
@@ -2957,9 +2957,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-il2cpp"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0048a96ed9341aa445084c5449b83f0c0e93710ba876662417bd92d7be780070"
+checksum = "c69a83048f5c49290be14a65c49eae124e51c175bfb81c75b520827e8bfc7526"
 dependencies = [
  "indexmap",
  "serde_json",
@@ -2969,9 +2969,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-ppdb"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26c140c509e924792a140bc215cbd6851aef9036e06031f57370dbefb0ac4c51"
+checksum = "b4af715d3f52faa38f3acb92c33b4de6546c45565d9a5214338e22e040d6141e"
 dependencies = [
  "flate2",
  "indexmap",
@@ -2985,9 +2985,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-symcache"
-version = "12.12.3"
+version = "12.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63018a17d8c6c18ef70072572a41d79abfe4016a6222260cb93a865801c83d8"
+checksum = "68bf7bed4c5afea4766625b420a523a071a5142c61c0c7706a098a7b54823345"
 dependencies = [
  "indexmap",
  "symbolic-common",

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Armin Ronacher <armin.ronacher@active-4.com>"]
 build = "build.rs"
 name = "sentry-cli"
-version = "2.40.0"
+version = "2.41.0"
 edition = "2021"
 rust-version = "1.80"
 
@@ -66,7 +66,7 @@ serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.93"
 sha1_smol = { version = "1.0.0", features = ["serde"] }
 sourcemap = { version = "9.1.2", features = ["ram_bundle"] }
-symbolic = { version = "12.12.3", features = ["debuginfo-serde", "il2cpp"] }
+symbolic = { version = "12.13.3", features = ["debuginfo-serde", "il2cpp"] }
 thiserror = "1.0.38"
 url = "2.3.1"
 username = "0.2.0"

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sentry_cli
-Version: 2.40.0
+Version: 2.41.0
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/sentry_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sentry_cli
-Version: 2.40.0
+Version: 2.41.0
 Summary: A command line utility to work with Sentry.
 Home-page: https://github.com/getsentry/sentry-cli
 Author: Sentry

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/sentry_cli.egg-info/SOURCES.txt

@@ -106,7 +106,6 @@ src/utils/appcenter.rs
 src/utils/args.rs
 src/utils/cordova.rs
 src/utils/dif.rs
-src/utils/dif_upload.rs
 src/utils/event.rs
 src/utils/file_search.rs
 src/utils/file_upload.rs
@@ -137,6 +136,8 @@ src/utils/chunks/mod.rs
 src/utils/chunks/options.rs
 src/utils/chunks/types.rs
 src/utils/chunks/upload.rs
+src/utils/dif_upload/error.rs
+src/utils/dif_upload/mod.rs
 src/utils/proguard/mapping.rs
 src/utils/proguard/mod.rs
 src/utils/proguard/upload.rs

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/api/data_types/chunking/compression.rs

@@ -1,16 +1,18 @@
 use std::fmt;
 
-use serde::{Deserialize, Deserializer};
+use serde::Deserialize;
 
-#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default, Deserialize)]
+#[serde(rename_all = "lowercase")]
 pub enum ChunkCompression {
-    /// No compression should be applied
-    #[default]
-    Uncompressed = 0,
     /// GZIP compression (including header)
     Gzip = 10,
     /// Brotli compression
     Brotli = 20,
+    /// No compression should be applied
+    #[default]
+    #[serde(other)]
+    Uncompressed = 0,
 }
 
 impl ChunkCompression {
@@ -32,17 +34,3 @@ impl fmt::Display for ChunkCompression {
         }
     }
 }
-
-impl<'de> Deserialize<'de> for ChunkCompression {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Ok(match String::deserialize(deserializer)?.as_str() {
-            "gzip" => ChunkCompression::Gzip,
-            "brotli" => ChunkCompression::Brotli,
-            // We do not know this compression, so we assume no compression
-            _ => ChunkCompression::Uncompressed,
-        })
-    }
-}

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/api/mod.rs

@@ -379,11 +379,10 @@ impl Api {
         // Curl stores a raw pointer to the stringified checksum internally. We first
         // transform all checksums to string and keep them in scope until the request
         // has completed. The original iterator is not needed anymore after this.
-        let stringified_chunks: Vec<_> = chunks
+        let stringified_chunks = chunks
             .into_iter()
             .map(T::as_ref)
-            .map(|&(checksum, data)| (checksum.to_string(), data))
-            .collect();
+            .map(|&(checksum, data)| (checksum.to_string(), data));
 
         let mut form = curl::easy::Form::new();
         for (ref checksum, data) in stringified_chunks {

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/commands/debug_files/bundle_jvm.rs

@@ -12,6 +12,7 @@ use std::collections::BTreeMap;
 use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
+use std::sync::Arc;
 use symbolic::debuginfo::sourcebundle::SourceFileType;
 
 pub fn make_command(command: Command) -> Command {
@@ -97,7 +98,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                 SourceFile {
                     url,
                     path: source.path.clone(),
-                    contents: source.contents.clone(),
+                    contents: Arc::new(source.contents.clone()),
                     ty: SourceFileType::Source,
                     headers: BTreeMap::new(),
                     messages: vec![],

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/commands/debug_files/bundle_sources.rs

@@ -32,7 +32,7 @@ pub fn make_command(command: Command) -> Command {
 }
 
 fn is_dsym(path: &Path) -> bool {
-    path.extension().map_or(false, |e| e == "dSYM")
+    path.extension().is_some_and(|e| e == "dSYM")
 }
 
 fn get_sane_parent(path: &Path) -> &Path {

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/commands/files/upload.rs

@@ -3,6 +3,7 @@ use std::ffi::OsStr;
 use std::fs;
 use std::io::Read;
 use std::path::Path;
+use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::{bail, format_err, Result};
@@ -205,7 +206,7 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
                     SourceFile {
                         url,
                         path: source.path.clone(),
-                        contents: source.contents.clone(),
+                        contents: Arc::new(source.contents.clone()),
                         ty: SourceFileType::Source,
                         headers: headers.clone(),
                         messages: vec![],

sentry_cli-2.41.0/src/utils/dif_upload/error.rs

@@ -0,0 +1,66 @@
+//! Error types for the dif_upload module.
+
+use anyhow::Result;
+use indicatif::HumanBytes;
+use thiserror::Error;
+
+/// Represents an error that makes a DIF invalid.
+#[derive(Debug, Error)]
+pub enum ValidationError {
+    #[error("Invalid format")]
+    InvalidFormat,
+    #[error("Invalid features")]
+    InvalidFeatures,
+    #[error("Invalid debug ID")]
+    InvalidDebugId,
+    #[error(
+        "Debug file's size ({}) exceeds the maximum allowed size ({})",
+        HumanBytes(*size as u64),
+        HumanBytes(*max_size)
+    )]
+    TooLarge { size: usize, max_size: u64 },
+}
+
+/// Handles a DIF validation error by logging it to console
+/// at the appropriate log level. Or, if the error should stop
+/// the upload, it will return an error, that can be propagated
+/// to the caller.
+pub fn handle(dif_name: &str, error: &ValidationError) -> Result<()> {
+    let message = format!("{}: {}", dif_name, error);
+    match error {
+        ValidationError::InvalidFormat
+        | ValidationError::InvalidFeatures
+        | ValidationError::InvalidDebugId => log::debug!("Skipping {message}"),
+        ValidationError::TooLarge { .. } => {
+            anyhow::bail!("Upload failed due to error in debug file {message}")
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use rstest::rstest;
+
+    #[rstest]
+    #[case(ValidationError::InvalidFormat)]
+    #[case(ValidationError::InvalidFeatures)]
+    #[case(ValidationError::InvalidDebugId)]
+    fn test_handle_should_not_error(#[case] error: ValidationError) {
+        let result = handle("test", &error);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_handle_should_error() {
+        let error = ValidationError::TooLarge {
+            size: 1000,
+            max_size: 100,
+        };
+        let result = handle("test", &error);
+        assert!(result.is_err());
+    }
+}

sentry_cli-2.40.0/src/utils/dif_upload.rs → sentry_cli-2.41.0/src/utils/dif_upload/mod.rs

@@ -1,6 +1,8 @@
 //! Searches, processes and uploads debug information files (DIFs). See
 //! `DifUpload` for more information.
 
+mod error;
+
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet};
 use std::convert::TryInto;
@@ -18,7 +20,6 @@ use std::time::Duration;
 
 use anyhow::{bail, format_err, Error, Result};
 use console::style;
-use indicatif::HumanBytes;
 use log::{debug, info, warn};
 use sha1_smol::Digest;
 use symbolic::common::{Arch, AsSelf, ByteView, DebugId, SelfCell, Uuid};
@@ -32,6 +33,7 @@ use which::which;
 use zip::result::ZipError;
 use zip::{write::FileOptions, ZipArchive, ZipWriter};
 
+use self::error::ValidationError;
 use crate::api::{Api, ChunkServerOptions, ChunkUploadCapability};
 use crate::config::Config;
 use crate::constants::{DEFAULT_MAX_DIF_SIZE, DEFAULT_MAX_WAIT};
@@ -589,10 +591,7 @@ fn find_uuid_plists(
     //        └─ DWARF
     //           └─ App
     let plist_name = format!("{:X}.plist", uuid.as_hyphenated());
-    let plist = match source.get_relative(format!("../{}", &plist_name)) {
-        Some(plist) => plist,
-        None => return None,
-    };
+    let plist = source.get_relative(format!("../{}", &plist_name))?;
 
     let mut plists = BTreeMap::new();
     plists.insert(plist_name, plist);
@@ -656,14 +655,14 @@ fn search_difs(options: &DifUpload) -> Result<Vec<DifMatch<'static>>> {
 
             if Archive::peek(&buffer) != FileFormat::Unknown {
                 let mut difs =
-                    collect_object_dif(source, name, buffer, options, &mut age_overrides);
+                    collect_object_dif(source, name, buffer, options, &mut age_overrides)?;
                 collected.append(difs.as_mut());
             } else if BcSymbolMap::test(&buffer) {
-                if let Some(dif) = collect_auxdif(name, buffer, options, AuxDifKind::BcSymbolMap) {
+                if let Some(dif) = collect_auxdif(name, buffer, options, AuxDifKind::BcSymbolMap)? {
                     collected.push(dif);
                 }
             } else if buffer.starts_with(b"<?xml") {
-                if let Some(dif) = collect_auxdif(name, buffer, options, AuxDifKind::UuidMap) {
+                if let Some(dif) = collect_auxdif(name, buffer, options, AuxDifKind::UuidMap)? {
                     collected.push(dif);
                 }
             };
@@ -729,7 +728,7 @@ fn collect_auxdif<'a>(
     buffer: ByteView<'static>,
     options: &DifUpload,
     kind: AuxDifKind,
-) -> Option<DifMatch<'a>> {
+) -> Result<Option<DifMatch<'a>>> {
     let file_stem = Path::new(&name)
         .file_stem()
         .map(|stem| stem.to_string_lossy())
@@ -746,7 +745,7 @@ fn collect_auxdif<'a>(
                     name = name
                 );
             }
-            return None;
+            return Ok(None);
         }
     };
     let dif_result = match kind {
@@ -762,16 +761,17 @@ fn collect_auxdif<'a>(
                 name = name,
                 err = err
             );
-            return None;
+            return Ok(None);
         }
     };
 
     // Skip this file if we don't want to process it.
-    if !options.validate_dif(&dif) {
-        return None;
+    if let Err(e) = options.validate_dif(&dif) {
+        error::handle(&name, &e)?;
+        return Ok(None);
     }
 
-    Some(dif)
+    Ok(Some(dif))
 }
 
 /// Processes and [`DifSource`] which is expected to be an object file.
@@ -781,7 +781,7 @@ fn collect_object_dif<'a>(
     buffer: ByteView<'static>,
     options: &DifUpload,
     age_overrides: &mut BTreeMap<Uuid, u32>,
-) -> Vec<DifMatch<'a>> {
+) -> Result<Vec<DifMatch<'a>>> {
     let mut collected = Vec::with_capacity(2);
 
     // Try to parse a potential object file. If this is not possible,
@@ -796,7 +796,7 @@ fn collect_object_dif<'a>(
         format == FileFormat::Pe && options.valid_format(DifFormat::Object(FileFormat::Pdb));
 
     if !should_override_age && !options.valid_format(DifFormat::Object(format)) {
-        return collected;
+        return Ok(collected);
     }
 
     debug!("trying to parse dif {}", name);
@@ -804,7 +804,7 @@ fn collect_object_dif<'a>(
         Ok(archive) => archive,
         Err(e) => {
             warn!("Skipping invalid debug file {}: {}", name, e);
-            return collected;
+            return Ok(collected);
         }
     };
 
@@ -836,7 +836,9 @@ fn collect_object_dif<'a>(
         // If this is a PE file with an embedded Portable PDB, we extract and process the PPDB separately.
         if let Object::Pe(pe) = &object {
             if let Ok(Some(ppdb_dif)) = extract_embedded_ppdb(pe, name.as_str()) {
-                if options.validate_dif(&ppdb_dif) {
+                if let Err(e) = options.validate_dif(&ppdb_dif) {
+                    error::handle(&ppdb_dif.name, &e)?;
+                } else {
                     collected.push(ppdb_dif);
                 }
             }
@@ -878,14 +880,15 @@ fn collect_object_dif<'a>(
         };
 
         // Skip this file if we don't want to process it.
-        if !options.validate_dif(&dif) {
+        if let Err(e) = options.validate_dif(&dif) {
+            error::handle(&name, &e)?;
             continue;
         }
 
         collected.push(dif);
     }
 
-    collected
+    Ok(collected)
 }
 
 /// Resolves BCSymbolMaps and replaces hidden symbols in a `DifMatch` using
@@ -1691,7 +1694,7 @@ impl<'a> DifUpload<'a> {
 
     /// Determines if this file extension matches the search criteria.
     fn valid_extension(&self, ext: Option<&OsStr>) -> bool {
-        self.extensions.is_empty() || ext.map_or(false, |e| self.extensions.contains(e))
+        self.extensions.is_empty() || ext.is_some_and(|e| self.extensions.contains(e))
     }
 
     /// Determines if this [`DifFormat`] matches the search criteria.
@@ -1723,21 +1726,13 @@ impl<'a> DifUpload<'a> {
     }
 
     /// Checks if a file is too large and logs skip message if so.
-    fn valid_size(&self, name: &str, size: usize) -> bool {
+    fn valid_size(&self, size: usize) -> bool {
         let file_size: Result<u64, _> = size.try_into();
-        let too_large = match file_size {
-            Ok(file_size) => file_size > self.max_file_size,
-            Err(_) => true,
-        };
-        if too_large {
-            warn!(
-                "Skipping debug file since it exceeds {}: {} ({})",
-                HumanBytes(self.max_file_size),
-                name,
-                HumanBytes(file_size.unwrap_or(u64::MAX)),
-            );
+
+        match file_size {
+            Ok(file_size) => file_size <= self.max_file_size,
+            Err(_) => false, // Definitely too big
         }
-        !too_large
     }
 
     /// Validates DIF on whether it should be processed.
@@ -1745,33 +1740,28 @@ impl<'a> DifUpload<'a> {
     /// This takes all the filters configured in the [`DifUpload`] into account and returns
     /// whether a file should be skipped or not.  It also takes care of logging such a skip
     /// if required.
-    fn validate_dif(&self, dif: &DifMatch) -> bool {
-        // Skip if we didn't want this kind of DIF.
+    fn validate_dif(&self, dif: &DifMatch) -> Result<(), ValidationError> {
         if !self.valid_format(dif.format()) {
-            debug!("skipping {} because of format", dif.name);
-            return false;
+            return Err(ValidationError::InvalidFormat);
         }
 
-        // Skip if this DIF does not have features we want.
         if !self.valid_features(dif) {
-            debug!("skipping {} because of features", dif.name);
-            return false;
+            return Err(ValidationError::InvalidFeatures);
         }
 
-        // Skip if this DIF has no DebugId or we are only looking for certain IDs.
         let id = dif.debug_id.unwrap_or_default();
         if id.is_nil() || !self.valid_id(id) {
-            debug!("skipping {} because of debugid", dif.name);
-            return false;
+            return Err(ValidationError::InvalidDebugId);
         }
 
-        // Skip if file exceeds the maximum allowed file size.
-        if !self.valid_size(&dif.name, dif.data().len()) {
-            debug!("skipping {} because of size", dif.name);
-            return false;
+        if !self.valid_size(dif.data().len()) {
+            return Err(ValidationError::TooLarge {
+                size: dif.data().len(),
+                max_size: self.max_file_size,
+            });
         }
 
-        true
+        Ok(())
     }
 
     fn into_chunk_options(self, server_options: ChunkServerOptions) -> ChunkOptions<'a> {

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/utils/file_search.rs

@@ -136,7 +136,7 @@ impl ReleaseFileSearch {
 
         for result in builder.build() {
             let file = result?;
-            if file.file_type().map_or(false, |t| t.is_dir()) {
+            if file.file_type().is_some_and(|t| t.is_dir()) {
                 continue;
             }
             pb.set_message(&format!("{}", file.path().display()));

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/utils/file_upload.rs

@@ -42,7 +42,7 @@ pub fn initialize_legacy_release_upload(context: &UploadContext) -> Result<()> {
     // if a project is provided which is technically unnecessary for the
     // legacy upload though it will unlikely to be what users want.
     if context.project.is_some()
-        && context.chunk_upload_options.map_or(false, |x| {
+        && context.chunk_upload_options.is_some_and(|x| {
             x.supports(ChunkUploadCapability::ArtifactBundles)
                 || x.supports(ChunkUploadCapability::ArtifactBundlesV2)
         })
@@ -119,7 +119,7 @@ impl fmt::Display for LogLevel {
 pub struct SourceFile {
     pub url: String,
     pub path: PathBuf,
-    pub contents: Vec<u8>,
+    pub contents: Arc<Vec<u8>>,
     pub ty: SourceFileType,
     /// A map of headers attached to the source file.
     ///
@@ -134,7 +134,7 @@ pub struct SourceFile {
 impl SourceFile {
     /// Calculates and returns the SHA1 checksum of the file.
     pub fn checksum(&self) -> Result<Digest> {
-        get_sha1_checksum(&*self.contents)
+        get_sha1_checksum(&**self.contents)
     }
 
     /// Returns the value of the "debug-id" header.
@@ -670,7 +670,9 @@ mod tests {
                 let file = SourceFile {
                     url: format!("~/{name}"),
                     path: format!("tests/integration/_fixtures/{name}").into(),
-                    contents: std::fs::read(format!("tests/integration/_fixtures/{name}")).unwrap(),
+                    contents: std::fs::read(format!("tests/integration/_fixtures/{name}"))
+                        .unwrap()
+                        .into(),
                     ty: SourceFileType::SourceMap,
                     headers: Default::default(),
                     messages: Default::default(),

{sentry_cli-2.40.0 → sentry_cli-2.41.0}/src/utils/sourcemaps/inject.rs

@@ -284,7 +284,7 @@ pub fn find_matching_paths(candidate_paths: &[String], expected_path: &str) -> V
         while candidate_segments
             .peek()
             .zip(expected_segments.peek())
-            .map_or(false, |(x, y)| x == y)
+            .is_some_and(|(x, y)| x == y)
         {
             candidate_segments.next();
             expected_segments.next();