chore(sampling): move the libdd-sampling crate from dd-trace-rs

Author: bantonsson

.github/CODEOWNERS

@@ -49,6 +49,7 @@ libdd-library-config*/               @DataDog/apm-sdk-capabilities-rust
 libdd-log*/                          @DataDog/apm-common-components-core
 libdd-otel-thread-ctx/               @DataDog/apm-common-components-core
 libdd-profiling*/                    @DataDog/libdatadog-profiling
+libdd-sampling/                      @DataDog/apm-common-components-core
 libdd-shared-runtime*/               @DataDog/apm-common-components-core
 libdd-telemetry*/                    @DataDog/apm-common-components-core
 libdd-tinybytes                      @DataDog/apm-common-components-core

libdd-sampling/Cargo.toml

@@ -0,0 +1,23 @@
+# Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "libdd-sampling"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+readme.workspace = true
+description = "Core sampling logic for Datadog tracing"
+authors.workspace = true
+
+[dependencies]
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+hashbrown = { workspace = true }
+foldhash = { workspace = true }
+lru = "0.16.3"
+
+[dev-dependencies]
+criterion = "0.5"

libdd-sampling/src/agent_service_sampler.rs

@@ -0,0 +1,51 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use std::{
+    collections::HashMap,
+    sync::{Arc, RwLock},
+};
+
+use crate::rate_sampler::RateSampler;
+
+#[derive(Debug, serde::Deserialize)]
+pub struct AgentRates<'a> {
+    #[serde(borrow)]
+    pub rate_by_service: Option<HashMap<&'a str, f64>>,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ServicesSampler {
+    inner: Arc<RwLock<HashMap<String, RateSampler>>>,
+}
+
+impl ServicesSampler {
+    pub fn get(&self, service: &str) -> Option<RateSampler> {
+        self.inner.read().unwrap().get(service).cloned()
+    }
+
+    pub fn update_rates<I: IntoIterator<Item = (String, f64)>>(&self, rates: I) {
+        let new_rates: HashMap<_, _> = rates
+            .into_iter()
+            .map(|(s, r)| (s, RateSampler::new(r)))
+            .collect();
+        *self.inner.write().unwrap() = new_rates;
+    }
+
+    // used for testing purposes
+
+    #[allow(dead_code)]
+    pub(crate) fn is_empty(&self) -> bool {
+        self.inner.read().unwrap().is_empty()
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn len(&self) -> usize {
+        self.inner.read().unwrap().len()
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn contains_key(&self, service: &str) -> bool {
+        self.inner.read().unwrap().contains_key(service)
+    }
+}

libdd-sampling/src/constants.rs

@@ -0,0 +1,48 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Shared constants for the datadog_opentelemetry::sampling crate
+
+/// Sampling rate limits
+pub mod rate {
+    /// Maximum sampling rate
+    pub const MAX_SAMPLE_RATE: f64 = 1.0;
+    /// Minimum sampling rate
+    pub const MIN_SAMPLE_RATE: f64 = 0.0;
+}
+
+/// Pattern matching constants
+pub mod pattern {
+    /// Marker to represent "no rule" for a field (empty string)
+    pub const NO_RULE: &str = "";
+}
+
+/// Numeric constants used in sampling algorithms
+pub mod numeric {
+    /// Knuth's multiplicative hash factor for deterministic sampling
+    pub const KNUTH_FACTOR: u64 = 1_111_111_111_111_111_111;
+    /// Maximum 64-bit unsigned integer value
+    pub const MAX_UINT_64BITS: u64 = u64::MAX;
+}
+
+#[allow(unused)]
+/// Attribute keys used in tracing
+pub mod attr {
+    /// Service name attribute key
+    pub const SERVICE_TAG: &str = "service.name";
+    /// Environment attribute key
+    pub const ENV_TAG: &str = "env";
+    /// Resource name attribute key
+    pub const RESOURCE_TAG: &str = "resource.name";
+}
+
+#[allow(unused)]
+/// Rule provenance categories
+pub mod provenance {
+    /// Customer-defined rules
+    pub const CUSTOMER: &str = "customer";
+    /// Dynamically loaded rules
+    pub const DYNAMIC: &str = "dynamic";
+    /// Default built-in rules
+    pub const DEFAULT: &str = "default";
+}