sentry-options 1.2.2__tar.gz → 1.2.4__tar.gz

{sentry_options-1.2.2 → sentry_options-1.2.4}/Cargo.lock

@@ -435,7 +435,7 @@ dependencies = [
 
 [[package]]
 name = "example"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "anyhow",
  "sentry-options",
@@ -996,6 +996,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "num"
 version = "0.4.3"
@@ -1437,7 +1446,7 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sentry-options"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "arc-swap",
  "criterion",
@@ -1447,11 +1456,12 @@ dependencies = [
  "sha1",
  "tempfile",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
 name = "sentry-options-cli"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "chrono",
  "clap",
@@ -1461,12 +1471,14 @@ dependencies = [
  "serde_yaml",
  "tempfile",
  "thiserror",
+ "tracing",
+ "tracing-subscriber",
  "walkdir",
 ]
 
 [[package]]
 name = "sentry-options-python"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "pyo3",
  "sentry-options",
@@ -1475,7 +1487,7 @@ dependencies = [
 
 [[package]]
 name = "sentry-options-validation"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -1485,6 +1497,7 @@ dependencies = [
  "serde_json",
  "tempfile",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -1566,6 +1579,15 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -1676,6 +1698,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.2"
@@ -1756,14 +1787,26 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.41"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
  "pin-project-lite",
+ "tracing-attributes",
  "tracing-core",
 ]
 
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tracing-core"
 version = "0.1.36"
@@ -1771,6 +1814,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
@@ -1843,6 +1912,12 @@ dependencies = [
  "vsimd",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"

{sentry_options-1.2.2 → sentry_options-1.2.4}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "3"
 members = ["sentry-options-validation", "clients/rust", "clients/python"]
 
 [workspace.package]
-version = "1.2.2"
+version = "1.2.4"
 edition = "2024"
 repository = "https://github.com/getsentry/sentry-options"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-sentry-options-validation = { path = "sentry-options-validation", version = "1.2.2" }
+sentry-options-validation = { path = "sentry-options-validation", version = "1.2.4" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.145"
 anyhow = "1.0.100"
@@ -19,3 +19,4 @@ jsonschema = "0.36.0"
 sha1 = "0.10"
 arc-swap = "1.9.1"
 chrono = { version = "0.4.45", default-features = false, features = ["std", "clock"] }
+tracing = "0.1.44"

{sentry_options-1.2.2 → sentry_options-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry_options
-Version: 1.2.2
+Version: 1.2.4
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython

{sentry_options-1.2.2 → sentry_options-1.2.4}/clients/python/uv.lock

@@ -126,7 +126,7 @@ wheels = [
 
 [[package]]
 name = "sentry-options"
-version = "1.2.2"
+version = "1.2.4"
 source = { editable = "." }
 
 [package.optional-dependencies]

{sentry_options-1.2.2 → sentry_options-1.2.4}/clients/rust/Cargo.toml

@@ -13,6 +13,7 @@ thiserror.workspace = true
 sha1.workspace = true
 arc-swap.workspace = true
 num = "0.4.3"
+tracing.workspace = true
 
 [dev-dependencies]
 tempfile.workspace = true

{sentry_options-1.2.2 → sentry_options-1.2.4}/clients/rust/src/features.rs

@@ -6,7 +6,6 @@
 use num::bigint::{BigInt, Sign};
 use std::cell::Cell;
 use std::collections::HashMap;
-use std::sync::OnceLock;
 
 use serde_json::Value;
 use sha1::{Digest, Sha1};
@@ -88,7 +87,7 @@ impl FeatureContext {
     /// The result is cached and reset when identity fields or context data change.
     /// When no identity fields are set, all context keys are used (non-deterministic
     /// rollout across contexts with different keys).
-    /// The id value is mostly used to id % 100 < rollout.
+    /// The id value is mostly used to id % 100 <= rollout.
     pub fn id(&self) -> u64 {
         if let Some(id) = self.cached_id.get() {
             return id;
@@ -229,7 +228,7 @@ impl Segment {
         if self.rollout >= 100 {
             return true;
         }
-        context.id() % 100 < self.rollout
+        context.id() % 100 <= self.rollout
     }
 }
 
@@ -256,96 +255,113 @@ impl Condition {
     }
 
     fn matches(&self, context: &FeatureContext) -> bool {
-        let Some(ctx_val) = context.get(&self.property) else {
-            return false;
-        };
-        match &self.operator {
+        let ctx_val = context.get(&self.property);
+        let result = match &self.operator {
             OperatorKind::In => eval_in(ctx_val, &self.value),
-            OperatorKind::NotIn => !eval_in(ctx_val, &self.value),
+            OperatorKind::NotIn => eval_in(ctx_val, &self.value).map(|m| !m),
             OperatorKind::Contains => eval_contains(ctx_val, &self.value),
-            OperatorKind::NotContains => !eval_contains(ctx_val, &self.value),
+            OperatorKind::NotContains => eval_contains(ctx_val, &self.value).map(|m| !m),
             OperatorKind::Equals => eval_equals(ctx_val, &self.value),
-            OperatorKind::NotEquals => !eval_equals(ctx_val, &self.value),
+            OperatorKind::NotEquals => eval_equals(ctx_val, &self.value).map(|m| !m),
             OperatorKind::Matches => eval_matches(ctx_val, &self.value),
-            OperatorKind::NotMatches => !eval_matches(ctx_val, &self.value),
-        }
+            OperatorKind::NotMatches => eval_matches(ctx_val, &self.value).map(|m| !m),
+        };
+        // A comparison that cannot be made is a non-match even when negated:
+        // flagpole raises for these, and the exception is caught above the
+        // evaluator rather than inverted.
+        result.unwrap_or(false)
     }
 }
 
-/// Check if a scalar context value is contained in a condition array.
+/// For scalar ctx_val, check if it's contained in the condition array.
+/// For array ctx_val, check if there is any intersection with the condition array.
 /// String comparison is case-insensitive.
-fn eval_in(ctx_val: &Value, condition_val: &Value) -> bool {
-    let Some(arr) = condition_val.as_array() else {
-        return false;
-    };
+///
+/// `None` means the comparison could not be made.
+fn eval_in(ctx_val: Option<&Value>, condition_val: &Value) -> Option<bool> {
+    let arr = condition_val.as_array()?;
+    match ctx_val {
+        None => Some(false),
+        Some(Value::Object(_)) => None,
+        Some(Value::Array(ctx_arr)) => Some(ctx_arr.iter().any(|v| scalar_in(v, arr))),
+        Some(scalar) => Some(scalar_in(scalar, arr)),
+    }
+}
+
+fn scalar_in(ctx_val: &Value, arr: &[Value]) -> bool {
     match ctx_val {
         Value::String(s) => {
             let s_lower = s.to_lowercase();
             arr.iter()
                 .any(|v| v.as_str().is_some_and(|cv| cv.to_lowercase() == s_lower))
         }
-        Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                arr.iter().any(|v| v.as_i64().is_some_and(|cv| cv == i))
-            } else if let Some(f) = n.as_f64() {
-                arr.iter().any(|v| v.as_f64().is_some_and(|cv| cv == f))
-            } else {
-                false
-            }
-        }
+        Value::Number(n) => arr
+            .iter()
+            .any(|v| v.as_number().is_some_and(|cv| numbers_equal(n, cv))),
         Value::Bool(b) => arr.iter().any(|v| v.as_bool().is_some_and(|cv| cv == *b)),
         _ => false,
     }
 }
 
+/// Compare two JSON numbers regardless of their type (int vs float)
+/// 1 == 1, 1.0 == 1, and 1.0 == 1.0
+fn numbers_equal(a: &serde_json::Number, b: &serde_json::Number) -> bool {
+    // !f64 as opposed to (i64 || u64)
+    if !a.is_f64() && !b.is_f64() {
+        return a == b;
+    }
+    // mismatched types are cast to float
+    matches!((a.as_f64(), b.as_f64()), (Some(x), Some(y)) if x == y)
+}
+
 /// Check if a context array contains a condition scalar value.
 /// String comparison is case-insensitive.
-fn eval_contains(ctx_val: &Value, condition_val: &Value) -> bool {
-    let Some(ctx_arr) = ctx_val.as_array() else {
-        return false;
-    };
+///
+/// A property that is missing or is not a list cannot be searched at all, so
+/// `not_contains` does not grant the feature for it either.
+fn eval_contains(ctx_val: Option<&Value>, condition_val: &Value) -> Option<bool> {
+    let ctx_arr = ctx_val?.as_array()?;
     match condition_val {
         Value::String(s) => {
             let s_lower = s.to_lowercase();
+            Some(
+                ctx_arr
+                    .iter()
+                    .any(|v| v.as_str().is_some_and(|cv| cv.to_lowercase() == s_lower)),
+            )
+        }
+        Value::Number(n) => Some(
             ctx_arr
                 .iter()
-                .any(|v| v.as_str().is_some_and(|cv| cv.to_lowercase() == s_lower))
-        }
-        Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                ctx_arr.iter().any(|v| v.as_i64().is_some_and(|cv| cv == i))
-            } else if let Some(f) = n.as_f64() {
-                ctx_arr.iter().any(|v| v.as_f64().is_some_and(|cv| cv == f))
-            } else {
-                false
-            }
-        }
-        Value::Bool(b) => ctx_arr
-            .iter()
-            .any(|v| v.as_bool().is_some_and(|cv| cv == *b)),
-        _ => false,
+                .any(|v| v.as_number().is_some_and(|cv| numbers_equal(n, cv))),
+        ),
+        Value::Bool(b) => Some(
+            ctx_arr
+                .iter()
+                .any(|v| v.as_bool().is_some_and(|cv| cv == *b)),
+        ),
+        _ => None,
     }
 }
 
 /// Check if a context value equals a condition value.
+/// A missing property equals nothing, and is not treated as unusable.
+fn eval_equals(ctx_val: Option<&Value>, condition_val: &Value) -> Option<bool> {
+    Some(match ctx_val {
+        Some(ctx_val) => values_equal(ctx_val, condition_val),
+        None => false,
+    })
+}
+
 /// Scalars are compared directly (strings case-insensitively).
 /// Arrays are compared element-wise with matching length.
-fn eval_equals(ctx_val: &Value, condition_val: &Value) -> bool {
+fn values_equal(ctx_val: &Value, condition_val: &Value) -> bool {
     match (ctx_val, condition_val) {
         (Value::String(a), Value::String(b)) => a.to_lowercase() == b.to_lowercase(),
-        (Value::Number(a), Value::Number(b)) => {
-            // Compare as i64 first, fall back to f64
-            if let (Some(ai), Some(bi)) = (a.as_i64(), b.as_i64()) {
-                ai == bi
-            } else if let (Some(af), Some(bf)) = (a.as_f64(), b.as_f64()) {
-                af == bf
-            } else {
-                false
-            }
-        }
+        (Value::Number(a), Value::Number(b)) => numbers_equal(a, b),
         (Value::Bool(a), Value::Bool(b)) => a == b,
         (Value::Array(a), Value::Array(b)) => {
-            a.len() == b.len() && a.iter().zip(b.iter()).all(|(av, bv)| eval_equals(av, bv))
+            a.len() == b.len() && a.iter().zip(b.iter()).all(|(av, bv)| values_equal(av, bv))
         }
         _ => false,
     }
@@ -399,71 +415,21 @@ fn glob_star_match(pattern: &str, value: &str) -> bool {
 /// Check if a string context value matches any pattern in the condition array.
 /// Patterns use star-only glob semantics; comparison is case-insensitive.
 /// Returns false for non-string context values.
-fn eval_matches(ctx_val: &Value, condition_val: &Value) -> bool {
-    let Some(s) = ctx_val.as_str() else {
-        return false;
-    };
-    let Some(arr) = condition_val.as_array() else {
-        return false;
-    };
-    arr.iter().any(|v| {
-        v.as_str()
-            .is_some_and(|pattern| glob_star_match(pattern, s))
-    })
-}
-
-#[derive(Debug, PartialEq)]
-enum DebugLogLevel {
-    None,
-    Parse,
-    Match,
-    All,
-}
-
-static DEBUG_LOG_LEVEL: OnceLock<DebugLogLevel> = OnceLock::new();
-static DEBUG_MATCH_SAMPLE_RATE: OnceLock<u64> = OnceLock::new();
-
-fn debug_log_level() -> &'static DebugLogLevel {
-    DEBUG_LOG_LEVEL.get_or_init(|| {
-        match std::env::var("SENTRY_OPTIONS_FEATURE_DEBUG_LOG")
-            .as_deref()
-            .unwrap_or("")
-        {
-            "all" => DebugLogLevel::All,
-            "parse" => DebugLogLevel::Parse,
-            "match" => DebugLogLevel::Match,
-            _ => DebugLogLevel::None,
-        }
-    })
-}
-
-fn debug_match_sample_rate() -> u64 {
-    *DEBUG_MATCH_SAMPLE_RATE.get_or_init(|| {
-        std::env::var("SENTRY_OPTIONS_FEATURE_DEBUG_LOG_SAMPLE_RATE")
-            .ok()
-            .and_then(|v| v.parse::<f64>().ok())
-            .map(|r| (r.clamp(0.0, 1.0) * 1000.0) as u64)
-            .unwrap_or(1000)
-    })
-}
-
-fn debug_log_parse(msg: &str) {
-    match debug_log_level() {
-        DebugLogLevel::Parse | DebugLogLevel::All => eprintln!("[sentry-options/parse] {msg}"),
-        _ => {}
-    }
-}
-
-fn debug_log_match(feature: &str, result: bool, context_id: u64) {
-    match debug_log_level() {
-        DebugLogLevel::Match | DebugLogLevel::All
-            if context_id % 1000 < debug_match_sample_rate() =>
-        {
-            eprintln!(
-                "[sentry-options/match] feature='{feature}' result={result} context_id={context_id}"
-            );
+fn eval_matches(ctx_val: Option<&Value>, condition_val: &Value) -> Option<bool> {
+    let arr = condition_val.as_array()?;
+    match ctx_val {
+        // A container cannot be glob matched against.
+        Some(Value::Array(_) | Value::Object(_)) => None,
+        None => Some(false),
+        Some(scalar) => {
+            let Some(s) = scalar.as_str() else {
+                return Some(false);
+            };
+            Some(arr.iter().any(|v| {
+                v.as_str()
+                    .is_some_and(|pattern| glob_star_match(pattern, s))
+            }))
         }
-        _ => {}
     }
 }
 
@@ -494,24 +460,29 @@ impl FeatureChecker {
         let feature_val = match opts.get(&self.namespace, &key) {
             Ok(v) => v,
             Err(e) => {
-                debug_log_parse(&format!("Failed to get feature '{key}': {e}"));
+                tracing::debug!(key = %key, error = %e, "Failed to get feature");
                 return false;
             }
         };
 
         let feature = match Feature::from_json(&feature_val) {
             Some(f) => {
-                debug_log_parse(&format!("Parsed feature '{key}'"));
+                tracing::debug!(key = %key, "Parsed feature");
                 f
             }
             None => {
-                debug_log_parse(&format!("Failed to parse feature '{key}'"));
+                tracing::debug!(key = %key, "Failed to parse feature");
                 return false;
             }
         };
 
         let result = feature.matches(context);
-        debug_log_match(feature_name, result, context.id());
+        tracing::debug!(
+            feature = feature_name,
+            result,
+            context_id = context.id(),
+            "Feature match result"
+        );
         result
     }
 }
@@ -823,6 +794,97 @@ mod tests {
         assert!(!check(&opts, "organizations:test-feature", &ctx2));
     }
 
+    #[test]
+    fn test_condition_in_list_property_matches_on_overlap() {
+        let cond = r#"{"property": "plan_family", "operator": "in", "value": ["business"]}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("plan_family", json!(["enterprise business", "Business"]));
+        assert!(check(&opts, "organizations:test-feature", &ctx));
+
+        let mut ctx2 = FeatureContext::new();
+        ctx2.insert("plan_family", json!(["team"]));
+        assert!(!check(&opts, "organizations:test-feature", &ctx2));
+
+        let mut ctx3 = FeatureContext::new();
+        ctx3.insert("plan_family", json!([]));
+        assert!(!check(&opts, "organizations:test-feature", &ctx3));
+    }
+
+    #[test]
+    fn test_condition_not_in_list_property_requires_no_overlap() {
+        let cond = r#"{"property": "plan_family", "operator": "not_in", "value": ["business"]}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("plan_family", json!(["enterprise business", "business"]));
+        assert!(!check(&opts, "organizations:test-feature", &ctx));
+
+        let mut ctx2 = FeatureContext::new();
+        ctx2.insert("plan_family", json!(["team"]));
+        assert!(check(&opts, "organizations:test-feature", &ctx2));
+    }
+
+    #[test]
+    fn test_condition_in_list_property_no_type_coercion() {
+        let cond = r#"{"property": "org_id", "operator": "in", "value": ["123"]}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("org_id", json!([123]));
+        assert!(!check(&opts, "organizations:test-feature", &ctx));
+
+        let int_cond = r#"{"property": "org_id", "operator": "in", "value": [123]}"#;
+        let (int_opts, _t2) = setup_feature_options(&feature_json(true, 100, int_cond));
+        assert!(check(&int_opts, "organizations:test-feature", &ctx));
+    }
+
+    #[test]
+    fn test_condition_in_matches_across_int_and_float() {
+        let cond = r#"{"property": "org_id", "operator": "in", "value": [123.0]}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("org_id", json!(123));
+        assert!(check(&opts, "organizations:test-feature", &ctx));
+
+        let mut list_ctx = FeatureContext::new();
+        list_ctx.insert("org_id", json!([123]));
+        assert!(check(&opts, "organizations:test-feature", &list_ctx));
+
+        let mut ctx2 = FeatureContext::new();
+        ctx2.insert("org_id", json!(124));
+        assert!(!check(&opts, "organizations:test-feature", &ctx2));
+    }
+
+    #[test]
+    fn test_condition_in_large_ints_compare_exactly() {
+        // 2^53 + 1 and 2^53 collide as f64, so ints must not round-trip through it.
+        let cond = r#"{"property": "org_id", "operator": "in", "value": [9007199254740993]}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("org_id", json!(9007199254740992i64));
+        assert!(!check(&opts, "organizations:test-feature", &ctx));
+
+        let mut ctx2 = FeatureContext::new();
+        ctx2.insert("org_id", json!(9007199254740993i64));
+        assert!(check(&opts, "organizations:test-feature", &ctx2));
+
+        // Above i64::MAX, where as_i64() gives up but the values are still exact.
+        let big = r#"{"property": "org_id", "operator": "in", "value": [18446744073709551615]}"#;
+        let (big_opts, _t2) = setup_feature_options(&feature_json(true, 100, big));
+
+        let mut ctx3 = FeatureContext::new();
+        ctx3.insert("org_id", json!(18446744073709551614u64));
+        assert!(!check(&big_opts, "organizations:test-feature", &ctx3));
+
+        let mut ctx4 = FeatureContext::new();
+        ctx4.insert("org_id", json!(18446744073709551615u64));
+        assert!(check(&big_opts, "organizations:test-feature", &ctx4));
+    }
+
     #[test]
     fn test_condition_contains() {
         let cond = r#"{"property": "tags", "operator": "contains", "value": "beta"}"#;
@@ -837,6 +899,30 @@ mod tests {
         assert!(!check(&opts, "organizations:test-feature", &ctx2));
     }
 
+    #[test]
+    fn test_condition_contains_matches_across_int_and_float() {
+        let int_cond = r#"{"property": "ids", "operator": "contains", "value": 123}"#;
+        let (int_opts, _t) = setup_feature_options(&feature_json(true, 100, int_cond));
+
+        let float_cond = r#"{"property": "ids", "operator": "contains", "value": 123.0}"#;
+        let (float_opts, _t2) = setup_feature_options(&feature_json(true, 100, float_cond));
+
+        let mut int_ctx = FeatureContext::new();
+        int_ctx.insert("ids", json!([123]));
+        let mut float_ctx = FeatureContext::new();
+        float_ctx.insert("ids", json!([123.0]));
+
+        // Matches regardless of which side holds the float.
+        assert!(check(&int_opts, "organizations:test-feature", &int_ctx));
+        assert!(check(&int_opts, "organizations:test-feature", &float_ctx));
+        assert!(check(&float_opts, "organizations:test-feature", &int_ctx));
+        assert!(check(&float_opts, "organizations:test-feature", &float_ctx));
+
+        let mut other = FeatureContext::new();
+        other.insert("ids", json!([124]));
+        assert!(!check(&int_opts, "organizations:test-feature", &other));
+    }
+
     #[test]
     fn test_condition_equals() {
         let cond = r#"{"property": "plan", "operator": "equals", "value": "enterprise"}"#;
@@ -851,6 +937,21 @@ mod tests {
         assert!(!check(&opts, "organizations:test-feature", &ctx2));
     }
 
+    #[test]
+    fn test_condition_equals_large_ints_compare_exactly() {
+        // Above i64::MAX these used to collapse into f64 and compare equal.
+        let cond = r#"{"property": "org_id", "operator": "equals", "value": 18446744073709551615}"#;
+        let (opts, _t) = setup_feature_options(&feature_json(true, 100, cond));
+
+        let mut ctx = FeatureContext::new();
+        ctx.insert("org_id", json!(18446744073709551614u64));
+        assert!(!check(&opts, "organizations:test-feature", &ctx));
+
+        let mut ctx2 = FeatureContext::new();
+        ctx2.insert("org_id", json!(18446744073709551615u64));
+        assert!(check(&opts, "organizations:test-feature", &ctx2));
+    }
+
     #[test]
     fn test_condition_equals_bool() {
         let cond = r#"{"property": "is_free", "operator": "equals", "value": true}"#;
@@ -1404,4 +1505,76 @@ mod tests {
         ctx.insert("org_id", json!(123));
         assert!(check(&opts, "organizations:test-feature", &ctx));
     }
+
+    #[test]
+    fn test_id_string_is_stable() {
+        for (value, expected) in [
+            (json!("sentry"), "sentry"),
+            (json!(123), "123"),
+            (json!(-7), "-7"),
+            (json!(true), "True"),
+            (json!(false), "False"),
+            (json!(null), "None"),
+            (json!(1.0), "1.0"),
+            (json!(1.5), "1.5"),
+            (json!(["a", "b"]), "[a, b]"),
+            (json!([1, 2]), "[1, 2]"),
+            (json!([]), "[]"),
+        ] {
+            assert_eq!(value_to_id_string(&value), expected, "for {value}");
+        }
+    }
+
+    fn condition_matches(operator: &str, value: &str, ctx: &FeatureContext) -> bool {
+        let json = format!(r#"{{"property": "prop", "operator": "{operator}", "value": {value}}}"#);
+        Condition::from_json(&serde_json::from_str(&json).unwrap())
+            .expect("condition should parse")
+            .matches(ctx)
+    }
+
+    #[test]
+    fn test_missing_property_matches_only_negated_conditions() {
+        let ctx = FeatureContext::new();
+        for (operator, value, expected) in [
+            ("in", "[1]", false),
+            ("not_in", "[1]", true),
+            ("equals", "1", false),
+            ("not_equals", "1", true),
+            ("matches", r#"["a"]"#, false),
+            ("not_matches", r#"["a"]"#, true),
+            // `contains` has no list to search, so neither form matches.
+            ("contains", r#""a""#, false),
+            ("not_contains", r#""a""#, false),
+        ] {
+            assert_eq!(
+                condition_matches(operator, value, &ctx),
+                expected,
+                "{operator}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_unusable_property_type_matches_neither_form() {
+        let mut map = FeatureContext::new();
+        map.insert("prop", json!({"k": "v"}));
+        let mut scalar = FeatureContext::new();
+        scalar.insert("prop", json!("a"));
+        let mut list = FeatureContext::new();
+        list.insert("prop", json!(["b"]));
+
+        for (operator, value, ctx) in [
+            ("in", "[1]", &map),
+            ("not_in", "[1]", &map),
+            ("contains", r#""a""#, &scalar),
+            ("not_contains", r#""a""#, &scalar),
+            ("matches", r#"["b"]"#, &list),
+            ("not_matches", r#"["b"]"#, &list),
+        ] {
+            assert!(!condition_matches(operator, value, ctx), "{operator}");
+        }
+
+        // A usable list that lacks the value still matches when negated.
+        assert!(condition_matches("not_contains", r#""a""#, &list));
+    }
 }

{sentry_options-1.2.2 → sentry_options-1.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sentry_options"
-version = "1.2.2"
+version = "1.2.4"
 description = "Python client for sentry-options using Rust validation"
 license = "Apache-2.0"
 requires-python = ">=3.11"

{sentry_options-1.2.2 → sentry_options-1.2.4}/sentry-options-validation/Cargo.toml

@@ -15,9 +15,7 @@ jsonschema.workspace = true
 tempfile.workspace = true
 arc-swap.workspace = true
 chrono.workspace = true
+tracing.workspace = true
 
 [dev-dependencies]
 tempfile.workspace = true
-
-[features]
-default = []

{sentry_options-1.2.2 → sentry_options-1.2.4}/sentry-options-validation/src/feature-schema-defs.json

@@ -28,6 +28,11 @@
       "description": {
         "type": "string",
         "description": "Human-readable description of the feature."
+      },
+      "experiment_mode": {
+        "type": ["string", "null"],
+        "enum": ["simple", null],
+        "description": "When set, the flag is treated as an experiment with exposure tracking. Does not affect evaluation."
       }
     },
     "required": ["owner", "segments", "created_at"],

{sentry_options-1.2.2 → sentry_options-1.2.4}/sentry-options-validation/src/lib.rs

@@ -611,10 +611,11 @@ impl SchemaRegistry {
         }
 
         for key in &unknown_keys {
-            eprintln!(
-                "sentry-options: Ignoring unknown option '{}' in namespace '{}'. \
-                 This is expected during deployments when values are updated before schemas.",
-                key, namespace
+            tracing::warn!(
+                key = %key,
+                namespace = %namespace,
+                "Ignoring unknown option. This is expected during deployments when \
+                 values are updated before schemas.",
             );
         }
 
@@ -693,7 +694,7 @@ impl ValuesStoreBuilder {
     pub fn build(self) -> ValidationResult<ValuesStore> {
         let values_dir = &self.values_dir;
         if !should_suppress_missing_dir_errors() && fs::metadata(values_dir).is_err() {
-            eprintln!("Values directory does not exist: {}", values_dir.display());
+            tracing::warn!(path = %values_dir.display(), "Values directory does not exist");
         }
 
         let baseline = Instant::now();
@@ -826,10 +827,10 @@ impl ValuesStore {
     }
 
     fn log_refresh_error(&self, error: &ValidationError) {
-        eprintln!(
-            "Failed to reload values from {}: {}",
-            self.values_dir.display(),
-            error
+        tracing::error!(
+            path = %self.values_dir.display(),
+            error = %error,
+            "Failed to reload values",
         );
     }
 
@@ -845,6 +846,7 @@ impl ValuesStore {
             return Ok(false);
         }
 
+        let reload_start = Instant::now();
         let result = self.registry.load_values_json(&self.values_dir);
 
         // Publish the new snapshot before bumping the timestamp. The CAS below
@@ -856,6 +858,16 @@ impl ValuesStore {
         // architectures.
         let new_generated_at = match result {
             Ok((new_values, generated_at)) => {
+                let elapsed_ms = reload_start.elapsed().as_millis();
+                for namespace in new_values.keys() {
+                    tracing::info!(
+                        path = %self.values_dir.display(),
+                        namespace = %namespace,
+                        elapsed_ms,
+                        "Reloaded values",
+                    );
+                }
+
                 self.values.store(Arc::new(new_values));
                 self.last_mtimes.store(Arc::new(current_mtimes));
                 Ok(generated_at)
@@ -894,10 +906,18 @@ impl ValuesStore {
                                     callback(ns, delay)
                                 }))
                             {
-                                eprintln!("Propagation callback panicked for {ns}: {:?}", e);
+                                tracing::error!(
+                                    namespace = %ns,
+                                    error = ?e,
+                                    "Propagation callback panicked",
+                                );
                             }
                         }
-                        None => eprintln!("Bad generated_at for {ns}: {ts}"),
+                        None => tracing::warn!(
+                            namespace = %ns,
+                            generated_at = %ts,
+                            "Bad generated_at timestamp",
+                        ),
                     }
                 }
             }
@@ -2277,6 +2297,65 @@ Error: \"version\" is a required property"
                 schema.validate_option("feature.organizations:fury-mode", &json!({"segments": []}));
             assert!(matches!(result, Err(ValidationError::ValueError { .. })));
         }
+
+        #[test]
+        fn test_validate_values_feature_with_experiment_mode() {
+            let temp_dir = TempDir::new().unwrap();
+            create_test_schema(&temp_dir, "test", FEATURE_SCHEMA);
+            let registry = SchemaRegistry::from_directory(temp_dir.path()).unwrap();
+
+            let result = registry.validate_values(
+                "test",
+                &json!({
+                    "feature.organizations:fury-mode": {
+                        "owner": {"team": "hybrid-cloud"},
+                        "segments": [],
+                        "created_at": "2024-01-01",
+                        "experiment_mode": "simple"
+                    }
+                }),
+            );
+            assert!(result.is_ok());
+        }
+
+        #[test]
+        fn test_validate_values_feature_with_invalid_experiment_mode_fails() {
+            let temp_dir = TempDir::new().unwrap();
+            create_test_schema(&temp_dir, "test", FEATURE_SCHEMA);
+            let registry = SchemaRegistry::from_directory(temp_dir.path()).unwrap();
+
+            let result = registry.validate_values(
+                "test",
+                &json!({
+                    "feature.organizations:fury-mode": {
+                        "owner": {"team": "hybrid-cloud"},
+                        "segments": [],
+                        "created_at": "2024-01-01",
+                        "experiment_mode": "not-a-real-mode"
+                    }
+                }),
+            );
+            assert!(matches!(result, Err(ValidationError::ValueError { .. })));
+        }
+
+        #[test]
+        fn test_validate_values_feature_without_experiment_mode_still_valid() {
+            let temp_dir = TempDir::new().unwrap();
+            create_test_schema(&temp_dir, "test", FEATURE_SCHEMA);
+            let registry = SchemaRegistry::from_directory(temp_dir.path()).unwrap();
+
+            let result = registry.validate_values(
+                "test",
+                &json!({
+                    "feature.organizations:fury-mode": {
+                        "owner": {"team": "hybrid-cloud"},
+                        "segments": [],
+                        "created_at": "2024-01-01"
+                    }
+                }),
+            );
+            assert!(result.is_ok());
+        }
     }
 
     mod store_tests {