fix(config): coerce scalar config leaves the way the Agent does

The Agent never reads a setting as the type its YAML holds: GetBool,
GetInt, GetFloat64, and GetString each cast the stored value through
spf13/cast. Permissiveness is therefore a property of a leaf's declared
type, not of the key, so `dogstatsd_port: "8125"` and a string-typed
leaf written as a YAML boolean are configurations the Agent accepts.

The generated Datadog source model took each leaf's JSON type
literally, so those spellings failed deserialization. That aborts the
strict startup gate, and at runtime it rejects the whole Agent snapshot,
holding every other key at its last-known-good value.

Port cast.To{Bool,Int64,Float64,String}E into cast_de and have codegen
attach one by leaf type, keeping the schema's type as the field type.
env_decode now shares those parsers, so one accept-set serves the file,
the environment, and the Agent stream. A value the cast cannot convert
stays a hard error rather than the Agent's silent zero value.

Every generated field is classified, and an unrecognized type fails the
build, so a schema change cannot quietly ship a leaf that rejects input
the Agent accepts. This subsumes the overlay's `input_shape` metadata,
whose one shape (a byte size written as an integer) is what a string
leaf now accepts by type, so it and string_de are removed.

Author: webern

.claude/skills/config-system/SKILL.md

@@ -123,6 +123,19 @@ Reserve `#[serde(flatten)]` for a struct that genuinely groups several *top-leve
 example, the forwarder's `forwarder_*` retry settings). Name a Rust field after its canonical
 section rather than renaming it onto one.
 
+## Scalar leaf coercion
+
+The Agent reads every setting by casting whatever is stored to the accessor's type (`GetBool`,
+`GetInt`, `GetString`, ...), so a leaf's permissiveness follows from its declared type, not from the
+key: `dogstatsd_port: "8125"`, or a `string`-typed leaf written as a YAML boolean, are configurations
+the Agent accepts. `datadog-agent/config/src/cast_de.rs` ports those casts, codegen attaches one to
+every scalar leaf by type (`permissivize`), and `env_decode` shares the same parsers, so every source
+accepts the same spellings. A value the cast cannot convert is a hard error rather than the Agent's
+silent zero value.
+
+Do not hand-write a per-key tolerant deserializer for a schema-typed scalar; give the coercion to the
+type instead. A generated field whose type has no classification fails the build.
+
 ## Saluki-only values
 
 Values absent from the Datadog schema reach `SalukiConfiguration` through the `SalukiOnly` source

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

@@ -546,6 +546,26 @@ mod tests {
         assert_eq!(system.config().domains.dogstatsd.debug_log.log_file_max_size, 10485760);
     }
 
+    #[tokio::test]
+    async fn standalone_loads_scalars_written_in_any_form_the_agent_casts() {
+        // The Agent reads a setting by casting whatever its configuration holds to the accessor's
+        // type, so a boolean written where the schema declares a string, or a quoted integer, is a
+        // configuration it accepts. Each must reach the typed model instead of aborting the strict
+        // startup gate.
+        let system = standalone_system(
+            Some(json!({
+                "use_v3_api": { "series": { "enabled": true } },
+                "dogstatsd_port": "8126",
+            })),
+            None,
+        )
+        .await
+        .expect("scalars in Agent-castable forms boot");
+
+        assert_eq!(system.config().shared.metrics_encoding.v3_series_mode.mode, "true");
+        assert_eq!(system.config().domains.dogstatsd.listeners.port, 8126);
+    }
+
     #[tokio::test]
     async fn translation_invalid_update_is_rejected_keeping_last_known_good() {
         let (system, agent_tx) =

lib/datadog-agent/config-overlay-model/src/lib.rs

@@ -59,9 +59,6 @@ pub struct FullSupport {
     /// GitHub issue tracking number.
     #[serde(default)]
     pub issue: Option<String>,
-    /// Accepted input shape when it is wider than the schema's declared type (see [`InputShape`]).
-    #[serde(default)]
-    pub input_shape: Option<InputShape>,
     /// Fields to support the `config_registry` and configuration smoke tests.
     pub test_support: TestSupport,
 }
@@ -82,9 +79,6 @@ pub struct PartialSupport {
     /// GitHub issue tracking number.
     #[serde(default)]
     pub issue: Option<String>,
-    /// Accepted input shape when it is wider than the schema's declared type (see [`InputShape`]).
-    #[serde(default)]
-    pub input_shape: Option<InputShape>,
     /// Fields to support the `config_registry` and configuration smoke tests.
     pub test_support: TestSupport,
 }
@@ -241,19 +235,6 @@ pub enum ValueType {
     StringList,
 }
 
-/// A widened input shape a schema `string` leaf accepts beyond a bare string.
-///
-/// The vendored schema types some settings as `string` but documents an equivalent numeric form
-/// (for example a byte size given as `10485760` instead of `"10MB"`). The schema cannot express that
-/// union, so the overlay names it and codegen attaches a tolerant deserializer to the generated
-/// field.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum InputShape {
-    /// Accept a string unchanged, or a non-negative integer normalized to its decimal string.
-    StringOrInteger,
-}
-
 /// File paths to the two YAML files required as input by this library.
 ///
 /// Defaults to the canonical location of the required schema files in this library.

lib/datadog-agent/config/build/datadog_config_gen.rs

@@ -20,11 +20,15 @@
 //! Vec<String>>` may carry each map value as either one scalar string or a sequence. Handling those
 //! shapes at the deserialization boundary keeps downstream types consistent; see `stringlistize`
 //! and `crate::list_de`.
+//!
+//! Scalar leaves get the Agent's own type coercion for the same reason: the Agent reads every
+//! setting through a cast against its declared type, so each leaf must accept the spellings that
+//! cast accepts. See `permissivize` and `crate::cast_de`.
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::path::Path;
 
 use datadog_agent_config_overlay_model::schema_gen::{FieldInfo, FieldType};
-use datadog_agent_config_overlay_model::{load_resolved_schema, InputShape, KnownEntry, SchemaOverlay};
+use datadog_agent_config_overlay_model::{load_resolved_schema, KnownEntry, SchemaOverlay};
 use indexmap::IndexMap;
 use serde_json::{Map, Value};
 use syn::visit_mut::{self, VisitMut};
@@ -75,8 +79,7 @@ pub fn generate(
     let pruned_schema = Value::Object(root);
 
     let aliases = field_aliases(overlay);
-    let input_shapes = field_input_shapes(overlay);
-    let body = render(pruned_schema, &aliases, &durations, &input_shapes);
+    let body = render(pruned_schema, &aliases, &durations);
 
     let mut out = String::new();
     out.push_str("// @generated by build.rs from core_schema.yaml + schema_overlay.yaml — DO NOT EDIT\n");
@@ -111,22 +114,6 @@ fn field_aliases(overlay: &SchemaOverlay) -> HashMap<String, Vec<String>> {
     map
 }
 
-/// Collect `dotted key -> InputShape` for every supported entry that declares `input_shape`.
-fn field_input_shapes(overlay: &SchemaOverlay) -> BTreeMap<String, InputShape> {
-    let mut map = BTreeMap::new();
-    for (key, entry) in &overlay.inventory {
-        let shape = match entry {
-            KnownEntry::Full(f) => f.input_shape,
-            KnownEntry::Partial(p) => p.input_shape,
-            _ => None,
-        };
-        if let Some(shape) = shape {
-            map.insert(key.clone(), shape);
-        }
-    }
-    map
-}
-
 /// Collect the dotted paths of every `support: full` / `support: partial` overlay entry.
 fn supported_keys(overlay: &SchemaOverlay) -> HashSet<String> {
     overlay
@@ -223,10 +210,7 @@ fn duration_default_nanos(info: Option<&FieldInfo>, path: &str) -> u64 {
 }
 
 /// Run typify over the pruned schema and pretty-print the generated module body.
-fn render(
-    pruned_schema: Value, aliases: &HashMap<String, Vec<String>>, durations: &BTreeMap<String, u64>,
-    input_shapes: &BTreeMap<String, InputShape>,
-) -> String {
+fn render(pruned_schema: Value, aliases: &HashMap<String, Vec<String>>, durations: &BTreeMap<String, u64>) -> String {
     let root_schema: schemars::schema::RootSchema =
         serde_json::from_value(pruned_schema).expect("pruned schema is not a valid JSON Schema document");
 
@@ -258,7 +242,7 @@ fn render(
     stringlistize(&mut file);
     strip_section_prefixes(&mut file);
     durationize(&mut file, durations);
-    inject_input_shapes(&mut file, input_shapes);
+    permissivize(&mut file);
 
     let rendered = blank_lines_between_fields(&prettyplease::unparse(&file));
     let rendered = blank_lines_between_items(&rendered);
@@ -566,18 +550,20 @@ fn option_section_inner(ty: &syn::Type) -> Option<syn::Type> {
     }
 }
 
-/// Attach the string-or-integer tolerant deserializer to every leaf whose overlay entry declares
-/// `input_shape: string_or_integer`.
+/// Give every scalar leaf the coercion the Agent applies when it reads that leaf's declared type.
 ///
-/// The target leaf is located by its full dotted path, navigating section structs from the root, so
-/// two like-named leaves in different sections never collide (unlike a bare field-name match). The
-/// leaf must be a plain `String` field; anything else is an overlay/schema mismatch and fails the
-/// build. Runs after `strip_section_prefixes`, so section structs already carry their bare names.
-fn inject_input_shapes(file: &mut syn::File, input_shapes: &BTreeMap<String, InputShape>) {
-    if input_shapes.is_empty() {
-        return;
-    }
-
+/// The Agent casts a stored value to the accessor's type, so a leaf's permissiveness follows from its
+/// schema type alone and needs no per-key metadata: `crate::cast_de` holds one coercion per type and
+/// this attaches it by the leaf's generated Rust type, which typify derived from that schema type.
+///
+/// Every field is classified, and an unrecognized shape fails the build. A schema change that
+/// introduces a new leaf type must then decide how that type coerces instead of silently shipping a
+/// leaf that rejects input the Agent accepts. Runs after `durationize` and `stringlistize`, whose
+/// leaves carry their own shape-tolerant readers.
+// TODO: a leaf the Agent reads through an accessor of a different type than the schema declares
+// cannot be resolved from the schema type alone, and would need per-key overlay metadata. Add it back
+// if such a leaf turns up.
+fn permissivize(file: &mut syn::File) {
     let struct_names: HashSet<String> = file
         .items
         .iter()
@@ -587,26 +573,114 @@ fn inject_input_shapes(file: &mut syn::File, input_shapes: &BTreeMap<String, Inp
         })
         .collect();
 
-    for (dotted, shape) in input_shapes {
-        let (owner_struct, leaf_field) = resolve_owner_and_leaf(file, &struct_names, dotted);
-        let field = find_field_mut(file, &owner_struct, &leaf_field).unwrap_or_else(|| {
-            panic!("input_shape key `{dotted}` resolves to unknown field `{owner_struct}.{leaf_field}`")
-        });
-        match shape {
-            InputShape::StringOrInteger => {
-                assert!(
-                    is_plain_string(&field.ty),
-                    "input_shape `string_or_integer` on `{dotted}`, but its generated field is not a plain \
-                     `String`; this metadata only applies to schema-string leaves"
-                );
-                field.attrs.push(parse_quote!(
-                    #[serde(deserialize_with = "crate::string_de::deserialize_string_or_integer")]
-                ));
-            }
+    for item in &mut file.items {
+        let Item::Struct(s) = item else { continue };
+        let syn::Fields::Named(fields) = &mut s.fields else {
+            continue;
+        };
+        for field in &mut fields.named {
+            let name = field.ident.as_ref().expect("a named field has an identifier");
+            let deserializer = match leaf_kind(&field.ty, &struct_names) {
+                LeafKind::Bool => "crate::cast_de::deserialize_bool",
+                LeafKind::Integer => "crate::cast_de::deserialize_i64",
+                LeafKind::Number => "crate::cast_de::deserialize_f64",
+                LeafKind::Text => "crate::cast_de::deserialize_string",
+                LeafKind::OptionalText => "crate::cast_de::deserialize_optional_string",
+                LeafKind::Exempt => continue,
+                LeafKind::Unknown => panic!(
+                    "field `{}.{name}` has no declared coercion; classify its type in `leaf_kind` and \
+                     give that type a coercion in `crate::cast_de`",
+                    s.ident
+                ),
+            };
+            field
+                .attrs
+                .push(parse_quote!(#[serde(deserialize_with = #deserializer)]));
         }
     }
 }
 
+/// How one generated field accepts input.
+enum LeafKind {
+    Bool,
+    Integer,
+    Number,
+    Text,
+    OptionalText,
+    /// A nested section, or a leaf whose shape another pass or its own consumer handles.
+    Exempt,
+    Unknown,
+}
+
+/// Classify a generated field by the type typify derived from its schema type.
+fn leaf_kind(ty: &syn::Type, struct_names: &HashSet<String>) -> LeafKind {
+    if section_struct_name(ty, struct_names).is_some() {
+        return LeafKind::Exempt;
+    }
+    if is_plain_string(ty) {
+        return LeafKind::Text;
+    }
+    if option_inner(ty).is_some_and(is_plain_string) {
+        return LeafKind::OptionalText;
+    }
+    if is_vec_string(ty) || is_string_map_vec_string(ty) || is_json_container(ty) || is_duration(ty) {
+        return LeafKind::Exempt;
+    }
+    match plain_ident(ty) {
+        Some(ident) if ident == "bool" => LeafKind::Bool,
+        Some(ident) if ident == "i64" => LeafKind::Integer,
+        Some(ident) if ident == "f64" => LeafKind::Number,
+        _ => LeafKind::Unknown,
+    }
+}
+
+/// The final path segment of a type carrying no generic arguments (`bool`, `i64`, `String`, ...).
+fn plain_ident(ty: &syn::Type) -> Option<&syn::Ident> {
+    let syn::Type::Path(tp) = ty else { return None };
+    let seg = tp.path.segments.last()?;
+    matches!(seg.arguments, syn::PathArguments::None).then_some(&seg.ident)
+}
+
+/// If `ty` is `Option<T>`, return `T`.
+fn option_inner(ty: &syn::Type) -> Option<&syn::Type> {
+    let syn::Type::Path(tp) = ty else { return None };
+    let last = tp.path.segments.last()?;
+    if last.ident != "Option" {
+        return None;
+    }
+    let syn::PathArguments::AngleBracketed(args) = &last.arguments else {
+        return None;
+    };
+    match args.args.first()? {
+        syn::GenericArgument::Type(inner) => Some(inner),
+        _ => None,
+    }
+}
+
+/// Returns whether `ty` is a raw JSON container, the shape an object-typed or heterogeneous-array
+/// leaf keeps so its own consumer can interpret it.
+fn is_json_container(ty: &syn::Type) -> bool {
+    let syn::Type::Path(tp) = ty else { return false };
+    if tp.path.segments.iter().any(|seg| seg.ident == "serde_json") {
+        return true;
+    }
+    let Some(last) = tp.path.segments.last() else {
+        return false;
+    };
+    if last.ident != "Vec" {
+        return false;
+    }
+    let syn::PathArguments::AngleBracketed(args) = &last.arguments else {
+        return false;
+    };
+    matches!(args.args.first(), Some(syn::GenericArgument::Type(inner)) if is_json_container(inner))
+}
+
+/// Returns whether `ty` is the `std::time::Duration` that `durationize` installs.
+fn is_duration(ty: &syn::Type) -> bool {
+    plain_ident(ty).is_some_and(|ident| ident == "Duration")
+}
+
 /// Resolve a dotted key to the `(owner struct name, leaf field name)` in the generated tree.
 ///
 /// Every non-final segment is a non-optional nested section struct (its type names one of the
@@ -620,9 +694,9 @@ fn resolve_owner_and_leaf(file: &syn::File, struct_names: &HashSet<String>, dott
             return (current, (*segment).to_string());
         }
         let field = find_field(file, &current, segment)
-            .unwrap_or_else(|| panic!("input_shape key `{dotted}`: field `{segment}` not found on struct `{current}`"));
+            .unwrap_or_else(|| panic!("key `{dotted}`: field `{segment}` not found on struct `{current}`"));
         current = section_struct_name(&field.ty, struct_names)
-            .unwrap_or_else(|| panic!("input_shape key `{dotted}`: segment `{segment}` is not a nested section"));
+            .unwrap_or_else(|| panic!("key `{dotted}`: segment `{segment}` is not a nested section"));
     }
 
     unreachable!("a dotted key always has a final segment");

lib/datadog-agent/config/schema/schema_overlay.yaml

@@ -883,7 +883,6 @@ inventory:
     support: full
     pipelines: [dogstatsd]
     description: "DSD log file max size"
-    input_shape: string_or_integer
     test_support:
       used_by: [DogStatsDDebugLogConfiguration]
       test_json: '"42MB"'
@@ -1741,7 +1740,6 @@ inventory:
     support: full
     pipelines: [cross_cutting]
     description: "Max log file size before rolling"
-    input_shape: string_or_integer
     test_support:
       used_by: [NO_SMOKE]