chore(config): dogstatsd config through the witness trait

Add the first end-to-end slice of the typed config system.
ScopedConfig<T> and DogStatsDConfig land in saluki-component-config;
a minimal SalukiConfiguration embeds DogStatsDConfig in
agent-data-plane-config; and a Translator implements the generated
witness in agent-data-plane-config-system, seeding the Saluki-only
base then driving the Datadog source over it.

Only DogStatsD-source keys have a native destination so far; the
remaining witness methods are temporary no-ops until their
destinations land. Trim the new crates' dependencies to what this
slice actually uses.

Author: webern

Cargo.lock

@@ -10,26 +10,8 @@ workspace = true
 
 [dependencies]
 agent-data-plane-config = { workspace = true }
-
-bytesize = { workspace = true }
-datadog-agent-commons = { workspace = true }
 datadog-agent-config = { workspace = true }
-datadog-protos = { workspace = true }
-figment = { workspace = true }
-futures = { workspace = true }
-prost-types = { workspace = true }
-saluki-common = { workspace = true }
 saluki-component-config = { workspace = true }
-saluki-config-tools = { workspace = true }
 saluki-context = { workspace = true }
-saluki-error = { workspace = true }
-saluki-io = { workspace = true }
-serde = { workspace = true }
 serde_json = { workspace = true }
-serde_yaml = { workspace = true }
 stringtheory = { workspace = true }
-tokio = { workspace = true, features = ["macros", "rt", "sync", "time"] }
-tracing = { workspace = true }
-
-[dev-dependencies]
-tempfile = { workspace = true }

lib/agent-data-plane-config-system/Cargo.toml

@@ -46,3 +46,7 @@
 //!                                               | tools          |  | config         |
 //!                                               +----------------+  +----------------+
 //! ```
+//!
+
+// TODO(visibility): add crate-boundary architectural guard when arch tests are wired up
+pub(crate) mod translate;

lib/agent-data-plane-config-system/src/lib.rs

@@ -0,0 +1,152 @@
+//! Translation layer from Datadog config to ADP-native config.
+//!
+//! This module owns the [`Translator`] -- the [`DatadogConfigConsumer`] implementation that writes
+//! witnessed Datadog values directly into the ADP-native structs embedded in a
+//! [`SalukiConfiguration`].
+//!
+//! 1. The Saluki-schema-only seed (`saluki_only.seed()`) produces the base `SalukiConfiguration`
+//!    with defaults plus Saluki-only fields that cannot arrive from the Datadog agent.
+//! 2. The Datadog witness `drive` overlays its config fields via the `consume_<key>` methods.
+//!
+//! [`DatadogConfigConsumer`]: datadog_agent_config::DatadogConfigConsumer
+//! [`SalukiConfiguration`]: agent_data_plane_config::SalukiConfiguration
+
+mod datadog;
+
+use agent_data_plane_config::{SalukiConfiguration, SalukiOnlyConfiguration};
+use datadog_agent_config::{drive, DatadogConfiguration, TranslateError};
+
+/// The witness consumer that accumulates a [`SalukiConfiguration`] from a Datadog source parse.
+///
+/// The accumulator composes the output type [`SalukiConfiguration`], along with accumulated
+/// translation errors.
+#[allow(dead_code)]
+pub(crate) struct Translator {
+    /// The in-progress native model. Seeded from the Saluki-only base, then overlaid by the drive.
+    pub(crate) saluki: SalukiConfiguration,
+
+    /// Accumulated semantic translation errors. The first is surfaced by `drive`.
+    errors: Vec<TranslateError>,
+}
+
+impl Translator {
+    /// Creates a translator over a seeded base.
+    ///
+    /// `base` is the lowest-precedence starting point (typically `saluki_only.seed()`). The Datadog
+    /// drive overlays its schema fields on top, so the base only usefully carries disjoint
+    /// Saluki-schema-only fields.
+    #[allow(dead_code)]
+    pub(crate) fn new(base: SalukiConfiguration) -> Self {
+        Self {
+            saluki: base,
+            errors: Vec::new(),
+        }
+    }
+
+    /// Returns the finished native model.
+    #[allow(dead_code)]
+    pub(crate) fn finish(self) -> SalukiConfiguration {
+        self.saluki
+    }
+
+    /// Records a semantic translation error. The first recorded error is surfaced by `drive`.
+    #[allow(dead_code)]
+    pub(crate) fn record_error(&mut self, e: TranslateError) {
+        self.errors.push(e);
+    }
+}
+
+/// Translates a Datadog source parse plus the Saluki-only seed into the ADP-native model.
+///
+/// This is the single reusable translation path used by both startup and each dynamic update:
+/// seed a [`Translator`] from `saluki_only`, drive the Datadog witness over it, and finish.
+///
+/// # Errors
+///
+/// Returns the first [`TranslateError`] recorded while consuming a witnessed value (for example, a
+/// value that cannot be parsed into its native destination). Callers decide policy: startup bails;
+/// a dynamic update is rejected and the last-good config retained.
+#[allow(dead_code)]
+pub(crate) fn translate(
+    saluki_only: &SalukiOnlyConfiguration, datadog: &DatadogConfiguration,
+) -> Result<SalukiConfiguration, TranslateError> {
+    let mut t = Translator::new(saluki_only.seed());
+    drive(datadog, &mut t)?;
+    Ok(t.finish())
+}
+
+#[cfg(test)]
+mod tests {
+    use saluki_component_config::dogstatsd::SourceConfig;
+
+    use super::*;
+
+    // Datadog Agent defaults clobber Saluki native defaults by design. Translation is
+    // clobber-not-merge: a Datadog-schema field's default overwrites the native default even when
+    // the two differ.
+    // TODO: we need a mechanism for default alignment #1802
+    #[test]
+    fn seed_then_drive_default_succeeds_and_clobbers() {
+        let saluki_only = SalukiOnlyConfiguration::default();
+        let datadog = DatadogConfiguration::default();
+        let config = translate(&saluki_only, &datadog).expect("default translation succeeds");
+        // The drive ran: the Datadog default port (8125) flows into the native source.
+        assert_eq!(config.components.dogstatsd.source.port, 8125);
+        // Clobber, not merge: the Datadog default for `dogstatsd_capture_depth` is 0, and it
+        // overwrites the native default of 1024 (the component later raises sub-1024 values).
+        assert_eq!(config.components.dogstatsd.source.capture_depth, 0);
+    }
+
+    #[test]
+    fn seed_and_drive_write_disjoint_dogstatsd_fields() {
+        // Saluki-only seeds `allow_context_heap_allocs` (a Saluki-schema-only field); the Datadog
+        // drive overlays `dogstatsd_port` (a Datadog-schema field). Both survive into one struct.
+        let mut saluki_only = SalukiOnlyConfiguration::default();
+        saluki_only.dogstatsd.allow_context_heap_allocs = Some(false);
+
+        let datadog = DatadogConfiguration {
+            dogstatsd_port: 7000,
+            ..Default::default()
+        };
+
+        let config = translate(&saluki_only, &datadog).expect("translation succeeds");
+        assert!(
+            !config.components.dogstatsd.source.allow_context_heap_allocations,
+            "seeded Saluki-only field survives"
+        );
+        assert_eq!(
+            config.components.dogstatsd.source.port, 7000,
+            "Datadog drive overlays its field"
+        );
+    }
+
+    #[test]
+    fn drive_overlays_dogstatsd_source() {
+        let saluki_only = SalukiOnlyConfiguration::default();
+        let datadog = DatadogConfiguration {
+            dogstatsd_buffer_size: 4096,
+            dogstatsd_non_local_traffic: true,
+            dogstatsd_tag_cardinality: "high".to_string(),
+            ..Default::default()
+        };
+
+        let config = translate(&saluki_only, &datadog).expect("translation succeeds");
+        let source: &SourceConfig = &config.components.dogstatsd.source;
+        assert_eq!(source.buffer_size, 4096);
+        assert!(source.non_local_traffic);
+        assert_eq!(
+            source.origin_enrichment.tag_cardinality,
+            saluki_context::origin::OriginTagCardinality::High
+        );
+    }
+
+    #[test]
+    fn malformed_value_surfaces_as_error() {
+        let saluki_only = SalukiOnlyConfiguration::default();
+        let datadog = DatadogConfiguration {
+            dogstatsd_tag_cardinality: "bogus".to_string(),
+            ..Default::default()
+        };
+        assert!(translate(&saluki_only, &datadog).is_err());
+    }
+}

lib/agent-data-plane-config-system/src/translate/datadog/mod.rs

@@ -11,7 +11,6 @@ workspace = true
 [dependencies]
 bytesize = { workspace = true }
 saluki-component-config = { workspace = true }
-saluki-io = { workspace = true }
 serde = { workspace = true }
 
 [dev-dependencies]

lib/agent-data-plane-config-system/src/translate/mod.rs

@@ -0,0 +1,13 @@
+//! [`ControlConfiguration`]: pipeline gates, topology-shaping, and data plane decisions.
+//!
+//! Control config is read by the config system and the data plane, not by components.
+
+/// Pipeline gates and topology-shaping decisions for ADP.
+///
+/// Read first, before [`ComponentConfiguration`](crate::ComponentConfiguration): it decides which
+/// pipelines and topology to build. Consumed by the orchestration layer only.
+#[derive(Clone, Debug, Default, PartialEq, serde::Serialize)]
+pub struct ControlConfiguration {
+    /// Whether the data plane runs at all.
+    pub enabled: bool,
+}

lib/agent-data-plane-config/Cargo.toml

@@ -0,0 +1,8 @@
+//! DogStatsD-domain component configuration group.
+
+/// DogStatsD-domain component configuration: source, mapper, aggregate, debug-log, and filter.
+#[derive(Clone, Debug, Default, PartialEq, serde::Serialize)]
+pub struct Config {
+    /// DogStatsD source configuration (listeners, parser/decoding options).
+    pub source: saluki_component_config::dogstatsd::SourceConfig,
+}

lib/agent-data-plane-config/src/control.rs

@@ -1,15 +1,31 @@
 //! # Configuration model for Saluki components and ADP.
 //!
-//! `SalukiConfiguration` is the type which configures ADP.
+//! [`SalukiConfiguration`] is the ADP-native runtime configuration model: the typed output of
+//! configuration translation, and the single model that all ADP runtime code consumes. It
+//! adds control-level configuration ([`ControlConfiguration`]) to the component groups, which embed
+//! the leaf structs from `saluki-component-config` directly.
 //!
-//! ## Responsibilities
+//! [`SalukiOnlyConfiguration`] is the Saluki-schema-only source input. Its [`seed`] produces
+//! a base `SalukiConfiguration` (defaults plus Saluki-only values) that the Datadog `drive` later
+//! overlays its disjoint schema fields onto.
 //!
-//! Model all runtime configuration used by ADP in a single, hierarchical type by adding
-//! control-level configuration to what is modeled in `saluki-component-config`.
+//! ## Workspace dependency boundaries
 //!
-//! ## Workspace Dependency Boundaries
+//! Depends on `saluki-component-config` (embeds its leaf structs). Must not depend on the Datadog
+//! source model (`datadog-agent-config`), the raw config map (`saluki-config-tools`), the config
+//! system (`agent-data-plane-config-system`), or component implementations (`saluki-components`). It
+//! is separate from `saluki-component-config` so components see only their own slice, and separate
+//! from the config-system so the model provably cannot import source mechanics.
 //!
-//! This depends only on `saluki-component-config` and `saluki-io`; it must not depend on the
-//! Datadog model or a raw config map. It is separate from `saluki-component-config` so components
-//! see only their own slice, and separate from the config-system so the model provably cannot
-//! import source mechanics: it does not depend on them.
+//! [`seed`]: SalukiOnlyConfiguration::seed
+
+#![deny(missing_docs)]
+
+pub mod control;
+pub mod dogstatsd;
+pub mod model;
+pub mod saluki_only;
+
+pub use self::control::ControlConfiguration;
+pub use self::model::{ComponentConfiguration, SalukiConfiguration};
+pub use self::saluki_only::SalukiOnlyConfiguration;

lib/agent-data-plane-config/src/dogstatsd.rs

@@ -0,0 +1,44 @@
+//! The ADP-native runtime configuration model: [`SalukiConfiguration`] and its component groups.
+//!
+//! [`SalukiConfiguration`] is the single output of configuration translation. It has two top-level
+//! groups: [`ControlConfiguration`] (pipeline gates and topology shaping and
+//! [`ComponentConfiguration`] (the per-domain component groups, each read by its owning component).
+//!
+//! Every group wrapper embeds the `saluki-component-config` leaf structs directly. The translator
+//! writes witnessed values into these embedded leaf structs.
+//!
+
+// TODO: Only the DogStatsD source is modeled; component groups land with rapid strangler-fig PRs.
+
+use crate::control::ControlConfiguration;
+use crate::dogstatsd;
+
+/// The complete ADP-native runtime configuration after translation.
+///
+/// First, configuration not appearing the Datadog config model, [`SalukiOnlyConfiguration`], is
+/// used as a seed (since it cannot come from Datadog config). This is done with
+/// [`SalukiOnlyConfiguration::seed`](crate::SalukiOnlyConfiguration::seed).
+///
+/// Then that seeded configuration is mutated by everything found in `DatadogConfiguration` by
+/// driving it through the witness trait.
+#[derive(Clone, Debug, Default, PartialEq, serde::Serialize)]
+pub struct SalukiConfiguration {
+    /// Pipeline gates, topology-shaping decisions and data plane configuration. Consumed by the
+    /// orchestration layers (config-system and the topology builder).
+    pub control: ControlConfiguration,
+
+    /// Per-domain component configuration groups. Each component receives its own slice from here.
+    pub components: ComponentConfiguration,
+}
+
+/// The per-domain component configuration groups.
+///
+/// Each field is a group wrapper that embeds the `saluki-component-config` leaf structs for one
+/// ownership domain. A component is handed only its own leaf slice (for example,
+/// `&components.dogstatsd.source`), never the whole `ComponentConfiguration` or
+/// [`SalukiConfiguration`].
+#[derive(Clone, Debug, Default, PartialEq, serde::Serialize)]
+pub struct ComponentConfiguration {
+    /// DogStatsD source, mapper, aggregate, debug-log, and filter configuration.
+    pub dogstatsd: dogstatsd::Config,
+}