feat(tracing): Replace println/eprintln with tracing

Cargo.toml

@@ -34,3 +34,4 @@ sentry = { version = "0.46", default-features = false }
 chrono = "0.4"
 openssl = { version = "0.10", features = ["vendored"] }
 sha1 = "0.10"
+tracing = "0.1.41"

clients/rust/Cargo.toml

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

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};
@@ -345,61 +344,6 @@ fn eval_equals(ctx_val: &Value, condition_val: &Value) -> bool {
     }
 }
 
-#[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}"
-                );
-            }
-        }
-        _ => {}
-    }
-}
-
 /// A handle for checking feature flags within a specific namespace.
 pub struct FeatureChecker {
     namespace: String,
@@ -427,24 +371,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
     }
 }

sentry-options-cli/Cargo.toml

@@ -16,6 +16,8 @@ sentry-options-validation.workspace = true
 thiserror.workspace = true
 walkdir = "2.5.0"
 tempfile.workspace = true
+tracing.workspace = true
+tracing-subscriber = { version = "0.3.19", features = ["fmt"] }
 
 [dev-dependencies]
 tempfile.workspace = true

sentry-options-cli/src/main.rs

@@ -218,7 +218,7 @@ fn cli_validate_schema(schemas: String, quiet: bool) -> Result<()> {
     SchemaRegistry::from_directory(Path::new(&schemas))?;
 
     if !quiet {
-        println!("Schema validation successful");
+        tracing::info!("Schema validation successful");
     }
     Ok(())
 }
@@ -229,7 +229,7 @@ fn cli_validate_values(schemas: String, root: String, quiet: bool) -> Result<()>
     ensure_no_duplicate_keys(&grouped)?;
 
     if !quiet {
-        println!("Values validation successful");
+        tracing::info!("Values validation successful");
     }
     Ok(())
 }
@@ -252,7 +252,7 @@ fn cli_write(args: WriteArgs, quiet: bool) -> Result<()> {
             write_json(PathBuf::from(&out_path), json_outputs)?;
 
             if !quiet {
-                println!("Successfully wrote {} output files", num_files);
+                tracing::info!(num_files, "Successfully wrote output files");
             }
         }
         OutputFormat::Configmap => {
@@ -276,11 +276,12 @@ fn cli_write(args: WriteArgs, quiet: bool) -> Result<()> {
 
             if !quiet {
                 match out_path {
-                    Some(path) => eprintln!("Successfully wrote ConfigMap to {}", path.display()),
-                    None => eprintln!(
-                        "Successfully generated ConfigMap: sentry-options-{}",
-                        namespace
-                    ),
+                    Some(path) => {
+                        tracing::info!(path = %path.display(), "Successfully wrote ConfigMap")
+                    }
+                    None => {
+                        tracing::info!(name = %format!("sentry-options-{namespace}"), "Successfully generated ConfigMap")
+                    }
                 }
             }
         }
@@ -292,7 +293,7 @@ fn cli_fetch_schemas(config: String, out: String, quiet: bool) -> Result<()> {
     let config = repo_schema_config::RepoSchemaConfigs::from_file(Path::new(&config))?;
     schema_retriever::fetch_all_schemas(&config, Path::new(&out), quiet)?;
     if !quiet {
-        println!("Successfully fetched schemas to {}", out);
+        tracing::info!(path = %out, "Successfully fetched schemas");
     }
     Ok(())
 }
@@ -329,7 +330,7 @@ fn cli_validate_schema_changes(
     )?;
 
     if !quiet {
-        eprintln!("Schema validation passed");
+        tracing::info!("Schema validation passed");
     }
 
     Ok(())
@@ -342,6 +343,12 @@ fn cli_check_option_usage(deletions: String, root: String) -> Result<()> {
 }
 
 fn main() {
+    tracing_subscriber::fmt()
+        .compact()
+        .without_time()
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
     let cli = Cli::parse();
 
     let result = match cli.command {
@@ -359,7 +366,7 @@ fn main() {
     };
 
     if let Err(e) = result {
-        eprintln!("{}", e);
+        tracing::error!(error = %e);
         std::process::exit(1);
     }
 }

sentry-options-cli/src/schema_evolution.rs

@@ -304,19 +304,18 @@ pub fn detect_changes(
     }
 
     if !quiet {
-        eprintln!("Schema Changes:");
         if changelog.is_empty() {
-            eprintln!("\tNo changes");
-        }
-        for change in &changelog {
-            eprintln!("\t{}", change);
+            tracing::info!("No schema changes");
+        } else {
+            for change in &changelog {
+                tracing::info!(%change, "Schema change detected");
+            }
         }
     }
 
     if !errors.is_empty() {
-        println!("Errors:");
         for error in &errors {
-            println!("\t{}", error);
+            tracing::error!(%error, "Schema validation error");
         }
         return Err(ValidationError::ValidationErrors(errors));
     }

sentry-options-cli/src/schema_retriever.rs

@@ -22,7 +22,7 @@ pub fn fetch_all_schemas(config: &RepoSchemaConfigs, out_dir: &Path, quiet: bool
     repo_names.sort();
 
     if !quiet {
-        println!("Fetching schemas...");
+        tracing::info!("Fetching schemas");
     }
 
     // Fetch all repos in parallel, collecting results
@@ -58,7 +58,7 @@ pub fn fetch_all_schemas(config: &RepoSchemaConfigs, out_dir: &Path, quiet: bool
         match result {
             Ok(()) => {
                 if !quiet {
-                    println!("  Fetched {}", repo_name);
+                    tracing::info!(repo = repo_name, "Fetched schema");
                 }
             }
             Err(e) => errors.push(e),