Enabled

Author: ardatan

Cargo.lock

@@ -61,3 +61,4 @@ retry-policies = "0.4.0"
 reqwest-retry = "0.7.0"
 reqwest-middleware = "0.4.2"
 vrl = { version = "0.27.0", features = ["compiler", "parser", "value", "diagnostic", "stdlib", "core"] }
+regex-automata = "0.4.10"

Cargo.toml

@@ -46,11 +46,11 @@ reqwest-retry = { workspace = true }
 reqwest-middleware = { workspace = true }
 vrl = { workspace = true }
 serde_json = { workspace = true }
+regex-automata = { workspace = true }
 
 mimalloc = { version = "0.1.48", features = ["v3"] }
 moka = { version = "0.12.10", features = ["future"] }
 ulid = "1.2.1"
 tokio-util = "0.7.16"
 cookie = "0.18.1"
-regex-automata = "0.4.10"
 arc-swap = "1.7.1"

bin/router/Cargo.toml

@@ -42,7 +42,7 @@ pub fn collect_usage_report(
     execution_result: &PlanExecutionOutput,
 ) {
     let mut rng = rand::rng();
-    let sampled = rng.random::<f64>() < usage_config.sample_rate;
+    let sampled = rng.random::<f64>() < usage_config.sample_rate.as_f64();
     if !sampled {
         return;
     }

bin/router/src/pipeline/usage_reporting.rs

@@ -30,9 +30,9 @@ xxhash-rust = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
 dashmap = { workspace = true }
 vrl = { workspace = true }
+regex-automata = { workspace = true }
 
 ahash = "0.8.12"
-regex-automata = "0.4.10"
 strum = { version = "0.27.2", features = ["derive"] }
 ntex-http = "0.1.15"
 ordered-float = "4.2.0"

lib/executor/Cargo.toml

@@ -23,6 +23,7 @@ http = { workspace = true }
 jsonwebtoken = { workspace = true }
 retry-policies = { workspace = true}
 tracing = { workspace = true }
+regex-automata = { workspace = true }
 
 schemars = "1.0.4"
 humantime-serde = "1.1.1"

lib/router-config/Cargo.toml

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{fmt::Display, time::Duration};
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -11,16 +11,19 @@ pub struct UsageReportingConfig {
     /// Your [Registry Access Token](https://the-guild.dev/graphql/hive/docs/management/targets#registry-access-tokens) with write permission.
     pub access_token: String,
     /// A target ID, this can either be a slug following the format “$organizationSlug/$projectSlug/$targetSlug” (e.g “the-guild/graphql-hive/staging”) or an UUID (e.g. “a0f4c605-6541-4350-8cfe-b31f21a4bf80”). To be used when the token is configured with an organization access token.
+    #[serde(deserialize_with = "deserialize_target_id")]
     pub target_id: Option<String>,
     /// For self-hosting, you can override `/usage` endpoint (defaults to `https://app.graphql-hive.com/usage`).
     #[serde(default = "default_endpoint")]
     pub endpoint: String,
     /// Sample rate to determine sampling.
-    /// 0.0 = 0% chance of being sent
-    /// 1.0 = 100% chance of being sent
-    /// Default: 1.0
+    /// 0% = never being sent
+    /// 50% = half of the requests being sent
+    /// 100% = always being sent
+    /// Default: 100%
     #[serde(default = "default_sample_rate")]
-    pub sample_rate: f64,
+    #[schemars(with = "String")]
+    pub sample_rate: Percentage,
     /// A list of operations (by name) to be ignored by Hive.
     /// Example: ["IntrospectionQuery", "MeQuery"]
     #[serde(default)]
@@ -94,8 +97,8 @@ fn default_endpoint() -> String {
     "https://app.graphql-hive.com/usage".to_string()
 }
 
-fn default_sample_rate() -> f64 {
-    1.0
+fn default_sample_rate() -> Percentage {
+    Percentage::from_f64(1.0).unwrap()
 }
 
 fn default_client_name_header() -> String {
@@ -125,3 +128,113 @@ fn default_connect_timeout() -> Duration {
 fn default_flush_interval() -> Duration {
     Duration::from_secs(5)
 }
+
+// Target ID regexp for validation: slug format
+const TARGET_ID_SLUG_REGEX: &str = r"^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_]+$";
+// Target ID regexp for validation: UUID format
+const TARGET_ID_UUID_REGEX: &str =
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+
+fn deserialize_target_id<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let opt = Option::<String>::deserialize(deserializer)?;
+    if let Some(ref s) = opt {
+        let trimmed_s = s.trim();
+        if trimmed_s.is_empty() {
+            Ok(None)
+        } else {
+            let slug_regex =
+                regex_automata::meta::Regex::new(TARGET_ID_SLUG_REGEX).map_err(|err| {
+                    serde::de::Error::custom(format!(
+                        "Failed to compile target_id slug regex: {}",
+                        err
+                    ))
+                })?;
+            if slug_regex.is_match(trimmed_s) {
+                return Ok(Some(trimmed_s.to_string()));
+            }
+            let uuid_regex =
+                regex_automata::meta::Regex::new(TARGET_ID_UUID_REGEX).map_err(|err| {
+                    serde::de::Error::custom(format!(
+                        "Failed to compile target_id UUID regex: {}",
+                        err
+                    ))
+                })?;
+            if uuid_regex.is_match(trimmed_s) {
+                return Ok(Some(trimmed_s.to_string()));
+            }
+            Err(serde::de::Error::custom(format!(
+                "Invalid target_id format: '{}'. It must be either in slug format '$organizationSlug/$projectSlug/$targetSlug' or UUID format 'a0f4c605-6541-4350-8cfe-b31f21a4bf80'",
+                trimmed_s
+            )))
+        }
+    } else {
+        Ok(None)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Percentage {
+    value: f64,
+}
+
+impl Percentage {
+    pub fn from_str(s: &str) -> Result<Self, String> {
+        let s_trimmed = s.trim();
+        if let Some(number_part) = s_trimmed.strip_suffix('%') {
+            let value: f64 = number_part.parse().map_err(|err| {
+                format!(
+                    "Failed to parse percentage value '{}': {}",
+                    number_part, err
+                )
+            })?;
+            Ok(Percentage::from_f64(value / 100.0)?)
+        } else {
+            Err(format!(
+                "Percentage value must end with '%', got: '{}'",
+                s_trimmed
+            ))
+        }
+    }
+    pub fn from_f64(value: f64) -> Result<Self, String> {
+        if !(0.0..=1.0).contains(&value) {
+            return Err(format!(
+                "Percentage value must be between 0 and 1, got: {}",
+                value
+            ));
+        }
+        Ok(Percentage { value })
+    }
+    pub fn as_f64(&self) -> f64 {
+        self.value
+    }
+}
+
+impl Display for Percentage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}%", self.value * 100.0)
+    }
+}   
+
+// Deserializer from `n%` string to `Percentage` struct
+impl<'de> Deserialize<'de> for Percentage {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Percentage::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+// Serializer from `Percentage` struct to `n%` string
+impl Serialize for Percentage {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}