refactor(remote-config)!: replace ParserRegistry with consumer-owned product enum

Removes the dynamic-dispatch RemoteConfigParsedData trait + ParserRegistry +
Box<dyn>+downcast pattern in favour of a consumer-owned, statically-typed
product enum (option C).

- datadog-remote-config: drop RemoteConfigParsedData, ProductParser,
  ParserRegistry, IgnoredProduct, default_registry, RegistryParser; replace
  with a generic RemoteConfigValue<T> and a BuiltinProducts enum (+
  BuiltinProductsParser ZST) covering AgentConfig/AgentTask/ApmTracing.
- datadog-live-debugger: replace live_debugger_parser() with an inherent
  LiveDebuggingData::parse(&[u8]) method; drop the trait impl.
- datadog-ffe: drop the empty remote_config module entirely; consumers call
  UniversalFlagConfig::from_json directly.
- datadog-sidecar: define SidecarProducts enum + SidecarParser ZST covering
  the four products the sidecar actually consumes plus Other; drop the
  Arc<ParserRegistry> from RemoteConfigManager and drive read_config via a
  typed match on RemoteConfigProduct.
- libdd-tracer-flare: reuse BuiltinProducts; replace the
  TryFrom<&dyn RemoteConfigParsedData> impl with a TryFrom<&BuiltinProducts>
  match; drop downcast_ref calls in the listener loop.
- examples/remote_config_fetch.rs: switch to BuiltinProducts.

No new dependencies. Zero Box<dyn ...> remote-config types and zero
downcast_ref calls in consumer code. cargo check --workspace is clean.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: iunanua

datadog-ffe/src/lib.rs

@@ -3,7 +3,6 @@
 
 mod flag_type;
 
-pub mod remote_config;
 pub mod rules_based;
 
 pub use flag_type::{ExpectedFlagType, FlagType};

datadog-ffe/src/remote_config.rs

@@ -2,23 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::probe_defs::LiveDebuggingData;
-use datadog_remote_config::{ProductParser, RemoteConfigParsedData, RemoteConfigProduct};
-use std::any::Any;
 
-impl RemoteConfigParsedData for LiveDebuggingData {
-    fn as_any(&self) -> &dyn Any {
-        self
+impl LiveDebuggingData {
+    pub fn parse(data: &[u8]) -> anyhow::Result<Self> {
+        crate::parse_json::parse(&String::from_utf8_lossy(data))
     }
-
-    fn product(&self) -> RemoteConfigProduct {
-        RemoteConfigProduct::LiveDebugger
-    }
-}
-
-pub fn live_debugger_parser() -> ProductParser {
-    Box::new(|data: &[u8]| {
-        let s = String::from_utf8_lossy(data);
-        let parsed = crate::parse_json::parse(&s)?;
-        Ok(Box::new(parsed) as Box<dyn RemoteConfigParsedData>)
-    })
 }

datadog-live-debugger/src/remote_config.rs

@@ -1,12 +1,11 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-use datadog_remote_config::config::dynamic::DynamicConfigFile;
 use datadog_remote_config::fetch::{ConfigInvariants, ConfigOptions, SingleChangesFetcher};
 use datadog_remote_config::file_change_tracker::{Change, FilePath};
 use datadog_remote_config::file_storage::ParsedFileStorage;
 use datadog_remote_config::RemoteConfigProduct::ApmTracing;
-use datadog_remote_config::{RemoteConfigParsedData, Target};
+use datadog_remote_config::{BuiltinProducts, Target};
 use libdd_common::tag::Tag;
 use libdd_common::Endpoint;
 use std::time::Duration;
@@ -87,13 +86,11 @@ async fn main() {
     }
 }
 
-fn print_file_contents(contents: &anyhow::Result<Box<dyn RemoteConfigParsedData>>) {
+fn print_file_contents(contents: &anyhow::Result<BuiltinProducts>) {
+    // Note: these contents may be large. Do not actually print it fully in a non-dev env.
     match contents {
-        Ok(data) => {
-            println!("Product: {:?}", data.product());
-            if let Some(cfg) = data.as_any().downcast_ref::<DynamicConfigFile>() {
-                println!("DynamicConfig action: {}", cfg.action);
-            }
+        Ok(products) => {
+            println!("Products contents: {products:?}");
         }
         Err(e) => {
             println!("Failed parsing file: {e:?}");

datadog-remote-config/examples/remote_config_fetch.rs

@@ -3,7 +3,6 @@
 
 use crate::fetch::FileStorage;
 use crate::file_change_tracker::{FilePath, UpdatedFiles};
-use crate::parse::{default_registry, ParserRegistry, RemoteConfigParsedData};
 use crate::RemoteConfigPath;
 use libdd_common::MutexExt;
 use std::ops::Deref;
@@ -31,7 +30,8 @@ impl<P: ParseFile> RawFileStorage<P> {
     }
 }
 
-/// Instance-based file parser. Implementations may carry state (e.g. an [`Arc<ParserRegistry>`]).
+/// Instance-based file parser. Implementations may carry state (e.g. configuration to drive a
+/// product-specific parsing decision).
 pub trait ParseFile: Clone + Send + Sync {
     /// The type of the parsed/stored content.
     type Parsed: Send;
@@ -134,32 +134,5 @@ impl ParseFile for RawBytesParser {
 /// Stores the remote config file contents in raw (unparsed) form.
 pub type SimpleFileStorage = RawFileStorage<RawBytesParser>;
 
-// ── RegistryParser ────────────────────────────────────────────────────────────
-
-/// A [`ParseFile`] implementation that dispatches to a [`ParserRegistry`].
-#[derive(Clone)]
-pub struct RegistryParser(pub Arc<ParserRegistry>);
-
-impl ParseFile for RegistryParser {
-    type Parsed = anyhow::Result<Box<dyn RemoteConfigParsedData>>;
-
-    fn parse(&self, path: &RemoteConfigPath, contents: Vec<u8>) -> Self::Parsed {
-        self.0.parse(path.product, &contents)
-    }
-}
-
-/// Stores the remote config file contents in parsed form using a [`ParserRegistry`].
-pub type ParsedFileStorage = RawFileStorage<RegistryParser>;
-
-impl ParsedFileStorage {
-    /// Create a storage backed by the given registry.
-    pub fn with_registry(registry: Arc<ParserRegistry>) -> Self {
-        RawFileStorage::new(RegistryParser(registry))
-    }
-}
-
-impl Default for ParsedFileStorage {
-    fn default() -> Self {
-        Self::with_registry(Arc::new(default_registry()))
-    }
-}
+/// Stores remote config file contents parsed as [`crate::BuiltinProducts`].
+pub type ParsedFileStorage = RawFileStorage<crate::parse::BuiltinProductsParser>;

datadog-remote-config/src/file_storage.rs

@@ -1,169 +1,105 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(feature = "client")]
+use crate::file_storage::ParseFile;
 use crate::{
     config::{
         self, agent_config::AgentConfigFile, agent_task::AgentTaskFile, dynamic::DynamicConfigFile,
     },
     RemoteConfigPath, RemoteConfigProduct, RemoteConfigSource,
 };
-use std::any::Any;
-use std::collections::HashMap;
 
-/// Opaque parsed payload for a remote config product. Product crates implement this on their own
-/// types and export a [`ProductParser`] factory; the RC crate stores and distributes the results
-/// without knowing their concrete type.
-pub trait RemoteConfigParsedData: Send + Sync + 'static {
-    fn as_any(&self) -> &dyn Any;
-    fn product(&self) -> RemoteConfigProduct;
-}
-
-/// A product-specific parser: converts raw bytes into a parsed payload.
-pub type ProductParser =
-    Box<dyn Fn(&[u8]) -> anyhow::Result<Box<dyn RemoteConfigParsedData>> + Send + Sync>;
-
-/// Maps [`RemoteConfigProduct`] variants to their parser functions.
+/// Parsed payload for the products owned by `datadog-remote-config`.
 ///
-/// Consumers build a registry (optionally starting from [`default_registry`]) and inject it into
-/// the file storage or fetcher. Products with no registered parser return [`IgnoredProduct`]
-/// so callers can track the config without processing its contents.
-pub struct ParserRegistry {
-    parsers: HashMap<RemoteConfigProduct, ProductParser>,
+/// Consumers that only care about these products can use this enum directly via
+/// [`BuiltinProductsParser`]. Consumers that need additional products should define their own
+/// enum and [`ParseFile`] implementation.
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum BuiltinProducts {
+    AgentConfig(AgentConfigFile),
+    AgentTask(AgentTaskFile),
+    ApmTracing(DynamicConfigFile),
+    Other(RemoteConfigProduct),
 }
 
-impl ParserRegistry {
-    pub fn new() -> Self {
-        ParserRegistry {
-            parsers: HashMap::new(),
+impl BuiltinProducts {
+    pub fn product(&self) -> RemoteConfigProduct {
+        match self {
+            BuiltinProducts::AgentConfig(_) => RemoteConfigProduct::AgentConfig,
+            BuiltinProducts::AgentTask(_) => RemoteConfigProduct::AgentTask,
+            BuiltinProducts::ApmTracing(_) => RemoteConfigProduct::ApmTracing,
+            BuiltinProducts::Other(p) => *p,
         }
     }
 
-    /// Register a parser for a product. Replaces any existing parser for that product.
-    pub fn register(&mut self, product: RemoteConfigProduct, parser: ProductParser) {
-        self.parsers.insert(product, parser);
-    }
-
-    /// Parse `data` for `product`. Returns [`IgnoredProduct`] (not an error) when no parser is
-    /// registered, so callers can still track the config in their bookkeeping structures.
-    pub fn parse(
-        &self,
-        product: RemoteConfigProduct,
-        data: &[u8],
-    ) -> anyhow::Result<Box<dyn RemoteConfigParsedData>> {
-        match self.parsers.get(&product) {
-            Some(parser) => parser(data),
-            None => Ok(Box::new(IgnoredProduct(product))),
-        }
-    }
-}
-
-impl Default for ParserRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-// ── Implementations for RC-internal product types ────────────────────────────
-
-/// Sentinel returned by [`ParserRegistry::parse`] when no parser is registered for a product.
-/// Consumers that want to handle only specific products can downcast and ignore this type.
-pub struct IgnoredProduct(pub RemoteConfigProduct);
-
-impl RemoteConfigParsedData for IgnoredProduct {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    fn product(&self) -> RemoteConfigProduct {
-        self.0
+    pub fn try_parse(product: RemoteConfigProduct, data: &[u8]) -> anyhow::Result<BuiltinProducts> {
+        Ok(match product {
+            RemoteConfigProduct::AgentConfig => {
+                BuiltinProducts::AgentConfig(config::agent_config::parse_json(data)?)
+            }
+            RemoteConfigProduct::AgentTask => {
+                BuiltinProducts::AgentTask(config::agent_task::parse_json(data)?)
+            }
+            RemoteConfigProduct::ApmTracing => {
+                BuiltinProducts::ApmTracing(config::dynamic::parse_json(data)?)
+            }
+            other => BuiltinProducts::Other(other),
+        })
     }
 }
 
-impl RemoteConfigParsedData for DynamicConfigFile {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    fn product(&self) -> RemoteConfigProduct {
-        RemoteConfigProduct::ApmTracing
-    }
-}
+/// [`ParseFile`] implementation for [`BuiltinProducts`]. Use this with [`RawFileStorage`] when
+/// no extra products beyond the RC-internal set need parsing.
+///
+/// [`RawFileStorage`]: crate::file_storage::RawFileStorage
+#[cfg(feature = "client")]
+#[derive(Clone, Default)]
+pub struct BuiltinProductsParser;
 
-impl RemoteConfigParsedData for AgentConfigFile {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    fn product(&self) -> RemoteConfigProduct {
-        RemoteConfigProduct::AgentConfig
-    }
-}
+#[cfg(feature = "client")]
+impl ParseFile for BuiltinProductsParser {
+    type Parsed = anyhow::Result<BuiltinProducts>;
 
-impl RemoteConfigParsedData for AgentTaskFile {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    fn product(&self) -> RemoteConfigProduct {
-        RemoteConfigProduct::AgentTask
+    fn parse(&self, path: &RemoteConfigPath, contents: Vec<u8>) -> Self::Parsed {
+        BuiltinProducts::try_parse(path.product, &contents)
     }
 }
 
-/// Returns a registry pre-loaded with parsers for the RC-internal products:
-/// [`RemoteConfigProduct::AgentConfig`], [`RemoteConfigProduct::AgentTask`], and
-/// [`RemoteConfigProduct::ApmTracing`].
+/// A parsed remote config file along with metadata extracted from its path.
 ///
-/// Consumers that need additional product parsers (live-debugger, FFE, …) should call
-/// [`ParserRegistry::register`] on the returned registry before use.
-pub fn default_registry() -> ParserRegistry {
-    let mut registry = ParserRegistry::new();
-    registry.register(
-        RemoteConfigProduct::AgentConfig,
-        Box::new(|data: &[u8]| {
-            let parsed = config::agent_config::parse_json(data)?;
-            Ok(Box::new(parsed) as Box<dyn RemoteConfigParsedData>)
-        }),
-    );
-    registry.register(
-        RemoteConfigProduct::AgentTask,
-        Box::new(|data: &[u8]| {
-            let parsed = config::agent_task::parse_json(data)?;
-            Ok(Box::new(parsed) as Box<dyn RemoteConfigParsedData>)
-        }),
-    );
-    registry.register(
-        RemoteConfigProduct::ApmTracing,
-        Box::new(|data: &[u8]| {
-            let parsed = config::dynamic::parse_json(data)?;
-            Ok(Box::new(parsed) as Box<dyn RemoteConfigParsedData>)
-        }),
-    );
-    registry
-}
-
-// ── RemoteConfigValue ─────────────────────────────────────────────────────────
-
-pub struct RemoteConfigValue {
+/// `T` is the consumer-defined parsed-payload enum; for the built-in set, use
+/// [`BuiltinProducts`].
+pub struct RemoteConfigValue<T> {
     pub source: RemoteConfigSource,
-    pub data: Box<dyn RemoteConfigParsedData>,
+    pub data: T,
     pub config_id: String,
     pub name: String,
 }
 
-impl std::fmt::Debug for RemoteConfigValue {
+impl<T: std::fmt::Debug> std::fmt::Debug for RemoteConfigValue<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("RemoteConfigValue")
             .field("source", &self.source)
-            .field("product", &self.data.product())
+            .field("data", &self.data)
             .field("config_id", &self.config_id)
             .field("name", &self.name)
             .finish()
     }
 }
 
-impl RemoteConfigValue {
-    pub fn try_parse(path: &str, data: &[u8], registry: &ParserRegistry) -> anyhow::Result<Self> {
+impl<T> RemoteConfigValue<T> {
+    pub fn try_parse(
+        path: &str,
+        data: &[u8],
+        parse: impl FnOnce(RemoteConfigProduct, &[u8]) -> anyhow::Result<T>,
+    ) -> anyhow::Result<Self> {
         let path = RemoteConfigPath::try_parse(path)?;
-        let data = registry.parse(path.product, data)?;
+        let parsed = parse(path.product, data)?;
         Ok(RemoteConfigValue {
             source: path.source,
-            data,
+            data: parsed,
             config_id: path.config_id.to_string(),
             name: path.name.to_string(),
         })