saluki_config/

lib.rs

//! Primitives for working with typed and untyped configuration data.
#![deny(warnings)]
#![deny(missing_docs)]

use std::sync::{Arc, RwLock};
use std::{borrow::Cow, collections::HashSet};

pub use figment::value;
use figment::{
    error::Kind,
    providers::{Env, Serialized},
    Figment, Provider,
};
use saluki_error::GenericError;
use serde::Deserialize;
use snafu::Snafu;
use tokio::sync::broadcast;
use tracing::{debug, error};

pub mod duration_string;
pub mod dynamic;
mod provider;
pub mod space_separated;

pub use self::duration_string::{parse_duration, DurationString, ParseDurationError};
pub use self::dynamic::FieldUpdateWatcher;
use self::dynamic::{settings_to_state, ConfigChangeEvent, ConfigUpdate};
use self::provider::ResolvedProvider;
pub use self::space_separated::{deserialize_opt_space_separated_or_seq, deserialize_space_separated_or_seq};

#[derive(Clone)]
struct ArcProvider(Arc<dyn Provider + Send + Sync>);

impl Provider for ArcProvider {
    fn metadata(&self) -> figment::Metadata {
        self.0.metadata()
    }

    fn data(&self) -> Result<figment::value::Map<figment::Profile, figment::value::Dict>, figment::Error> {
        self.0.data()
    }
}

enum ProviderSource {
    Static(ArcProvider),
    Dynamic(Option<ConfigUpdate>),
}

impl Clone for ProviderSource {
    fn clone(&self) -> Self {
        match self {
            Self::Static(p) => Self::Static(p.clone()),
            Self::Dynamic(_) => Self::Dynamic(None),
        }
    }
}

/// A configuration error.
#[derive(Debug, Snafu)]
#[snafu(context(suffix(false)))]
pub enum ConfigurationError {
    /// Environment variable prefix was empty.
    #[snafu(display("Environment variable prefix must not be empty."))]
    EmptyPrefix,

    /// Requested field was missing from the configuration.
    #[snafu(display("Missing field '{}' in configuration. {}", field, help_text))]
    MissingField {
        /// Help text describing how to set the missing field.
        ///
        /// This is meant to be displayed to the user, and includes environment variable-specific text if environment
        /// variables had been loaded originally.
        help_text: String,

        /// Name of the missing field.
        field: Cow<'static, str>,
    },

    /// Requested field's data type wasn't the unexpected data type.
    #[snafu(display(
        "Expected value for field '{}' to be '{}', got '{}' instead.",
        field,
        expected_ty,
        actual_ty
    ))]
    InvalidFieldType {
        /// Name of the invalid field.
        ///
        /// This is a period-separated path to the field.
        field: String,

        /// Expected data type.
        expected_ty: String,

        /// Actual data type.
        actual_ty: String,
    },

    /// Generic configuration error.
    #[snafu(transparent)]
    Generic {
        /// Error source.
        source: GenericError,
    },
}

impl From<figment::Error> for ConfigurationError {
    fn from(e: figment::Error) -> Self {
        match e.kind {
            Kind::InvalidType(actual_ty, expected_ty) => Self::InvalidFieldType {
                field: e.path.join("."),
                expected_ty,
                actual_ty: actual_ty.to_string(),
            },
            _ => Self::Generic { source: e.into() },
        }
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
enum LookupSource {
    /// The configuration key is looked up in a form suitable for environment variables.
    Environment { prefix: String },
}

impl LookupSource {
    fn transform_key(&self, key: &str) -> String {
        match self {
            // The prefix should already be uppercased, with a trailing underscore, which is needed when we actually
            // configure the provider used for reading from the environment... so we don't need to re-do that here.
            LookupSource::Environment { prefix } => format!("{}{}", prefix, key.replace('.', "_").to_uppercase()),
        }
    }
}

/// A configuration loader that can pull from various sources.
///
/// This loader provides a wrapper around a lower-level library, `figment`, to expose a simpler and focused API for both
/// loading configuration data from various sources, as well as querying it.
///
/// A variety of configuration sources can be configured (see below), with an implicit priority based on the order in
/// which sources are added: sources added later take precedence over sources prior. Additionally, either a typed value
/// can be extracted from the configuration ([`into_typed`][Self::into_typed]), or the raw configuration data can be
/// accessed via a generic API ([`into_generic`][Self::into_generic]).
///
/// # Supported sources
///
/// - YAML file
/// - JSON file
/// - environment variables (must be prefixed; see [`from_environment`][Self::from_environment])
#[derive(Clone, Default)]
pub struct ConfigurationLoader {
    lookup_sources: HashSet<LookupSource>,
    provider_sources: Vec<ProviderSource>,
}

impl ConfigurationLoader {
    /// Appends one or more providers to the configuration chain.
    ///
    /// Sources are merged in the order they're added: later sources take precedence over earlier ones. Call
    /// this method after any file-loading methods and before [`from_environment`][Self::from_environment] to
    /// place the added providers at the correct intermediate precedence level:
    ///
    /// ```text
    /// file providers  <  add_providers(...)  <  from_environment(...)
    /// ```
    pub fn add_providers<P, I>(mut self, providers: I) -> Self
    where
        P: Provider + Send + Sync + 'static,
        I: IntoIterator<Item = P>,
    {
        for p in providers {
            self.provider_sources
                .push(ProviderSource::Static(ArcProvider(Arc::new(p))));
        }
        self
    }

    /// Loads the given YAML configuration file.
    ///
    /// # Errors
    ///
    /// If the file couldn't be read, or if the file isn't valid YAML, an error will be returned.
    pub fn from_yaml<P>(mut self, path: P) -> Result<Self, ConfigurationError>
    where
        P: AsRef<std::path::Path>,
    {
        let resolved_provider = ResolvedProvider::from_yaml(&path)?;
        self.provider_sources
            .push(ProviderSource::Static(ArcProvider(Arc::new(resolved_provider))));
        Ok(self)
    }

    /// Attempts to load the given YAML configuration file, ignoring any errors.
    ///
    /// Errors include the file not existing, not being readable/accessible, and not being valid YAML.
    pub fn try_from_yaml<P>(mut self, path: P) -> Self
    where
        P: AsRef<std::path::Path>,
    {
        match ResolvedProvider::from_yaml(&path) {
            Ok(resolved_provider) => {
                self.provider_sources
                    .push(ProviderSource::Static(ArcProvider(Arc::new(resolved_provider))));
            }
            Err(e) => {
                println!(
                    "Unable to read YAML configuration file '{}': {}. Ignoring.",
                    path.as_ref().to_string_lossy(),
                    e
                );
            }
        }
        self
    }

    /// Loads the given JSON configuration file.
    ///
    /// # Errors
    ///
    /// If the file couldn't be read, or if the file isn't valid JSON, an error will be returned.
    pub fn from_json<P>(mut self, path: P) -> Result<Self, ConfigurationError>
    where
        P: AsRef<std::path::Path>,
    {
        let resolved_provider = ResolvedProvider::from_json(&path)?;
        self.provider_sources
            .push(ProviderSource::Static(ArcProvider(Arc::new(resolved_provider))));
        Ok(self)
    }

    /// Attempts to load the given JSON configuration file, ignoring any errors.
    ///
    /// Errors include the file not existing, not being readable/accessible, and not being valid JSON.
    pub fn try_from_json<P>(mut self, path: P) -> Self
    where
        P: AsRef<std::path::Path>,
    {
        match ResolvedProvider::from_json(&path) {
            Ok(resolved_provider) => {
                self.provider_sources
                    .push(ProviderSource::Static(ArcProvider(Arc::new(resolved_provider))));
            }
            Err(e) => {
                println!(
                    "Unable to read JSON configuration file '{}': {}. Ignoring.",
                    path.as_ref().to_string_lossy(),
                    e
                );
            }
        }
        self
    }

    /// Loads configuration from environment variables.
    ///
    /// The prefix given will have an underscore appended to it if it doesn't already end with one. For
    /// example, with a prefix of `app`, any environment variable starting with `app_` would be matched. The
    /// prefix is case-insensitive.
    ///
    /// Sources are merged in the order they're added, with later sources taking precedence over earlier ones.
    /// Sources added after this call will have higher precedence than environment variables.
    ///
    /// # Errors
    ///
    /// If the prefix is empty, an error will be returned.
    pub fn from_environment(mut self, prefix: &'static str) -> Result<Self, ConfigurationError> {
        if prefix.is_empty() {
            return Err(ConfigurationError::EmptyPrefix);
        }

        let prefix = if prefix.ends_with('_') {
            prefix.to_string()
        } else {
            format!("{}_", prefix)
        };

        // Convert to use Serialized::defaults since, Env isn't Send + Sync
        let env = Env::prefixed(&prefix).split("__");
        let values = env.data().unwrap();
        if let Some(default_dict) = values.get(&figment::Profile::Default) {
            self.provider_sources
                .push(ProviderSource::Static(ArcProvider(Arc::new(Serialized::defaults(
                    default_dict.clone(),
                )))));
            self.lookup_sources.insert(LookupSource::Environment { prefix });
        }
        Ok(self)
    }

    /// Enables dynamic configuration, starting from the given initial update.
    ///
    /// The dynamic configuration layers over the providers added before this call, and under the providers added after
    /// it. [`into_generic`][Self::into_generic] applies `initial` to it, and returns the [`ConfigUpdater`] that applies
    /// each later update.
    pub fn with_dynamic_configuration(mut self, initial: ConfigUpdate) -> Self {
        self.provider_sources.push(ProviderSource::Dynamic(Some(initial)));
        self
    }

    /// Consumes the configuration loader, deserializing it as `T`.
    ///
    /// ## Errors
    ///
    /// If the configuration couldn't be deserialized into `T`, an error will be returned.
    pub fn into_typed<'a, T>(self) -> Result<T, ConfigurationError>
    where
        T: Deserialize<'a>,
    {
        let figment = build_figment_from_sources(&self.provider_sources);
        figment.extract().map_err(Into::into)
    }

    /// Consumes the configuration loader and wraps it in a generic wrapper.
    ///
    /// If dynamic configuration is enabled, the returned configuration already contains the initial update, and this
    /// also returns the [`ConfigUpdater`] that applies each later update.
    ///
    /// ## Errors
    ///
    /// If dynamic configuration is enabled and the initial configuration can't be extracted from its providers, an
    /// error will be returned.
    pub async fn into_generic(mut self) -> Result<(GenericConfiguration, Option<ConfigUpdater>), ConfigurationError> {
        let has_dynamic_provider = self
            .provider_sources
            .iter()
            .any(|s| matches!(s, ProviderSource::Dynamic(_)));

        if has_dynamic_provider {
            let mut initial_opt = None;
            for source in self.provider_sources.iter_mut() {
                if let ProviderSource::Dynamic(ref mut initial) = source {
                    initial_opt = initial.take();
                    break;
                }
            }
            let initial = initial_opt.expect("Dynamic initial update should exist but was not found");

            // Build the configuration from the initial update, so that no caller can read the configuration before it
            // contains that update.
            let mut dynamic_state = serde_json::Value::Null;
            apply_to_dynamic_state(&mut dynamic_state, initial);
            let figment = build_figment_with_dynamic_state(&self.provider_sources, &dynamic_state);
            let current_config = figment.extract()?;

            let (event_sender, _) = broadcast::channel(100);

            let generic_config = GenericConfiguration {
                inner: Arc::new(Inner {
                    figment: RwLock::new(figment),
                    lookup_sources: self.lookup_sources,
                    event_sender: Some(event_sender.clone()),
                }),
            };

            let updater = ConfigUpdater {
                inner: generic_config.inner.clone(),
                provider_sources: self.provider_sources,
                sender: event_sender,
                dynamic_state,
                current_config,
            };

            Ok((generic_config, Some(updater)))
        } else {
            // Otherwise, just build the static configuration.
            let figment = build_figment_from_sources(&self.provider_sources);

            let generic_config = GenericConfiguration {
                inner: Arc::new(Inner {
                    figment: RwLock::new(figment),
                    lookup_sources: self.lookup_sources,
                    event_sender: None,
                }),
            };

            Ok((generic_config, None))
        }
    }

    /// Configures a [`GenericConfiguration`] that's suitable for tests.
    ///
    /// This configures the loader with the following defaults:
    ///
    /// - configuration from a JSON file
    /// - configuration from environment variables
    ///
    /// If `initial_snapshot` is set, dynamic configuration is enabled: the returned configuration already contains that
    /// snapshot, and a dynamic configuration sender is returned for each later update. This function also spawns a task
    /// on the current runtime that applies each update the sender sends.
    ///
    /// This is generally only useful for testing purposes, and is exposed publicly in order to be used in cross-crate
    /// testing scenarios.
    #[cfg(any(test, feature = "test-util"))]
    pub async fn for_tests(
        file_values: Option<serde_json::Value>, env_vars: Option<&[(String, String)]>,
        initial_snapshot: Option<ConfigUpdate>,
    ) -> (GenericConfiguration, Option<tokio::sync::mpsc::Sender<ConfigUpdate>>) {
        Self::for_tests_with_provider_factory(file_values, env_vars, initial_snapshot, |_| {
            Serialized::defaults(serde_json::json!({}))
        })
        .await
    }

    /// Like [`for_tests`][Self::for_tests], but calls `provider_factory` to build an additional
    /// provider inserted between the file provider and the environment provider.
    ///
    /// The factory receives an owned copy of the explicitly configured test environment variables. Providers can use
    /// this input instead of reading unrelated variables from the ambient process environment. The factory is called
    /// after the test environment variables have been set for providers that still require process environment access.
    ///
    /// This is generally only useful for testing purposes, and is exposed publicly in order to be used in cross-crate testing scenarios.
    #[cfg(any(test, feature = "test-util"))]
    pub async fn for_tests_with_provider_factory<P, F>(
        file_values: Option<serde_json::Value>, env_vars: Option<&[(String, String)]>,
        initial_snapshot: Option<ConfigUpdate>, provider_factory: F,
    ) -> (GenericConfiguration, Option<tokio::sync::mpsc::Sender<ConfigUpdate>>)
    where
        P: Provider + Send + Sync + 'static,
        F: FnOnce(Vec<(String, String)>) -> P,
    {
        let json_file = tempfile::NamedTempFile::new().expect("should not fail to create temp file.");
        let path = &json_file.path();
        let json_to_write = file_values.unwrap_or(serde_json::json!({}));
        serde_json::to_writer(&json_file, &json_to_write).expect("should not fail to write to temp file.");

        let mut loader = ConfigurationLoader::default().try_from_json(path);
        if let Some(initial_snapshot) = initial_snapshot {
            loader = loader.with_dynamic_configuration(initial_snapshot);
        }

        // All tests that mutate process-wide environment variables while loading configuration serialize against a
        // single shared lock (see `test_env_lock`), so that tests in other modules and crates can't race with the
        // env-var manipulation below.
        let guard = test_env_lock();

        if let Some(pairs) = env_vars.as_ref() {
            for (k, v) in pairs.iter() {
                // Set under both the raw name and the TEST_ prefix:
                //   - Raw name: available to any env-reading providers built by `provider_factory`
                //   - TEST_ prefix: read by from_environment("TEST") (simulates DD_ prefix)
                std::env::set_var(k, v);
                std::env::set_var(format!("TEST_{}", k), v);
            }
        }

        // Build and insert the extra provider while env vars are set so it can snapshot them.
        let provider_env_vars = env_vars.unwrap_or_default().to_vec();
        let loader = loader.add_providers([provider_factory(provider_env_vars)]);

        // Add environment provider last so it has the highest precedence.
        let loader = loader
            .from_environment("TEST")
            .expect("should not fail to add environment provider");

        // Clean up test-provided env vars now that all providers have been built.
        if let Some(pairs) = env_vars.as_ref() {
            for (k, _) in pairs.iter() {
                std::env::remove_var(k);
                std::env::remove_var(format!("TEST_{}", k));
            }
        }

        drop(guard);

        let (cfg, updater) = loader
            .into_generic()
            .await
            .expect("should not fail to build generic configuration");
        let maybe_sender = updater.map(|mut updater| {
            let (sender, mut receiver) = tokio::sync::mpsc::channel(1);
            tokio::spawn(async move {
                while let Some(update) = receiver.recv().await {
                    updater
                        .apply(update)
                        .expect("should not fail to apply dynamic configuration update");
                }
            });
            sender
        });

        (cfg, maybe_sender)
    }
}

/// Acquires the process-global lock that serializes tests which mutate environment variables while loading
/// configuration, returning the held guard.
///
/// [`ConfigurationLoader::for_tests`] and [`ConfigurationLoader::for_tests_with_provider_factory`] set and unset
/// process-wide environment variables to simulate `DD_`-prefixed configuration. Because the process environment is
/// global mutable state, any test in any crate that reads or writes environment variables relevant to configuration
/// loading MUST hold this lock for the duration of that access, so that all such tests serialize against each other
/// rather than racing.
///
/// This is exposed publicly so that tests in downstream crates can serialize against the same single lock that the
/// loader itself uses, instead of each hand-rolling an independent (and therefore non-serializing) mutex.
///
/// Lock poisoning is intentionally ignored: the mutex guards no data (its guarded type is `()`), so a panic in
/// another test while the lock was held leaves nothing in an inconsistent state. Propagating poisoning would only
/// cascade an unrelated test failure into every later env-mutating test.
#[cfg(any(test, feature = "test-util"))]
pub fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {
    static ENV_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());
    ENV_MUTEX.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}

/// Builds a [`GenericConfiguration`] from an in-memory JSON body, for use in tests.
///
/// This is a thin convenience wrapper around [`ConfigurationLoader::for_tests`] for the common case of a test that
/// only needs file-based configuration values, with no environment variables and no dynamic configuration. The
/// dynamic-configuration sender that `for_tests` can optionally return is unused in that case and is discarded here.
///
/// Callers that need a typed configuration should build it from the returned [`GenericConfiguration`] (for example,
/// via a `SomeConfiguration::from_configuration` constructor or [`GenericConfiguration::as_typed`]).
///
/// This is exposed publicly so that tests in downstream crates can share a single loader helper instead of
/// re-implementing it per file.
#[cfg(any(test, feature = "test-util"))]
pub async fn config_from(file_values: serde_json::Value) -> GenericConfiguration {
    let (config, _) = ConfigurationLoader::for_tests(Some(file_values), None, None).await;
    config
}

fn build_figment_from_sources(sources: &[ProviderSource]) -> Figment {
    sources.iter().fold(Figment::new(), |figment, source| match source {
        ProviderSource::Static(p) => figment.admerge(p.clone()),
        // No-op. The merging is handled by the updater task.
        ProviderSource::Dynamic(_) => figment,
    })
}

/// Inserts or updates a value for a key.
///
/// Intermediate objects are created if they don't exist.
pub fn upsert(root: &mut serde_json::Value, key: &str, value: serde_json::Value) {
    if !root.is_object() {
        *root = serde_json::Value::Object(serde_json::Map::new());
    }

    let mut current = root;
    // Create a new node for each segment if the key is dotted.
    let mut segments = key.split('.').peekable();

    while let Some(seg) = segments.next() {
        let is_leaf = segments.peek().is_none();

        // Ensure current is an object before operating
        if !current.is_object() {
            *current = serde_json::Value::Object(serde_json::Map::new());
        }
        let node = current.as_object_mut().expect("current node should be an object");

        if is_leaf {
            node.insert(seg.to_string(), value);
            break;
        } else {
            // Ensure child exists and is an object
            let should_create_node = match node.get(seg) {
                Some(v) => !v.is_object(),
                None => true,
            };
            // Check if we need to create an intermediate node if it doesn't exist.
            if should_create_node {
                node.insert(seg.to_string(), serde_json::Value::Object(serde_json::Map::new()));
            }

            // Advance the current node to the next level.
            current = node.get_mut(seg).expect("should not fail to get nested object");
        }
    }
}

/// Applies dynamic configuration updates to a [`GenericConfiguration`].
///
/// [`ConfigurationLoader::into_generic`] returns this when dynamic configuration is enabled, after it has applied the
/// initial update. The caller decides where later updates come from and when to apply them, by calling
/// [`apply`][Self::apply] for each one.
pub struct ConfigUpdater {
    inner: Arc<Inner>,
    provider_sources: Vec<ProviderSource>,
    sender: broadcast::Sender<ConfigChangeEvent>,
    dynamic_state: serde_json::Value,
    current_config: figment::value::Value,
}

impl ConfigUpdater {
    /// Applies an update to the dynamic configuration.
    ///
    /// A snapshot replaces the whole dynamic configuration, and a partial update sets one key. When this returns, the
    /// configuration contains the update, and a change event has been sent for each key whose value changed.
    ///
    /// ## Errors
    ///
    /// If the updated configuration can't be extracted from its providers, an error will be returned, and the
    /// configuration keeps its previous values. The update is still recorded, so each later update applies on top of
    /// it.
    pub fn apply(&mut self, update: ConfigUpdate) -> Result<(), ConfigurationError> {
        apply_to_dynamic_state(&mut self.dynamic_state, update);

        // Rebuild the figment object on every update, respecting the original provider order.
        let new_figment = build_figment_with_dynamic_state(&self.provider_sources, &self.dynamic_state);
        let new_config: figment::value::Value = new_figment.extract()?;

        if self.current_config != new_config {
            let changes = dynamic::diff_config(&self.current_config, &new_config);

            {
                let mut figment_guard = self.inner.figment.write().unwrap_or_else(|e| {
                    error!("Failed to acquire write lock for dynamic configuration: {}", e);
                    e.into_inner()
                });
                *figment_guard = new_figment;
            }

            for change in changes {
                // Send the change event to any receivers of the dynamic handler.
                // If there are no receivers, `send` will fail. This is expected and fine,
                // so we can ignore the error to avoid log spam.
                let _ = self.sender.send(change);
            }

            // Update our "current" state for the next update.
            self.current_config = new_config;
        }

        Ok(())
    }
}

/// Applies one update to the dynamic state: a snapshot replaces it, and a partial update sets one (possibly dotted) key.
fn apply_to_dynamic_state(dynamic_state: &mut serde_json::Value, update: ConfigUpdate) {
    // The by-key view is an effective-value view: it holds what each key resolves to, so it drops the
    // provenance carried by each setting.
    match update {
        ConfigUpdate::Snapshot(settings) => {
            debug!("Received configuration snapshot update.");
            *dynamic_state = settings_to_state(&settings);
        }
        ConfigUpdate::Partial(setting) => {
            debug!(key = %setting.key, "Received partial configuration update.");
            if dynamic_state.is_null() {
                *dynamic_state = serde_json::Value::Object(serde_json::Map::new());
            }
            if dynamic_state.is_object() {
                upsert(dynamic_state, &setting.key, setting.value);
            } else {
                error!("Received partial update but current dynamic state is not an object. This should not happen.");
            }
        }
    }
}

/// Builds the figment from every provider source, in order, with `dynamic_state` in place of the dynamic provider.
fn build_figment_with_dynamic_state(sources: &[ProviderSource], dynamic_state: &serde_json::Value) -> Figment {
    sources.iter().fold(Figment::new(), |figment, source| match source {
        ProviderSource::Static(p) => figment.admerge(p.clone()),
        ProviderSource::Dynamic(_) => figment.admerge(Serialized::defaults(dynamic_state.clone())),
    })
}

#[derive(Debug)]
struct Inner {
    figment: RwLock<Figment>,
    lookup_sources: HashSet<LookupSource>,
    event_sender: Option<broadcast::Sender<ConfigChangeEvent>>,
}

/// A generic configuration object.
///
/// This represents the merged configuration derived from [`ConfigurationLoader`] in its raw form. Values can be
/// queried by key, and can be extracted either as typed values or in their raw form.
///
/// Keys must be in the form of `a.b.c`, where periods (`.`) as used to indicate a nested value.
///
/// Using an example JSON configuration:
///
/// ```json
/// {
///   "a": {
///     "b": {
///       "c": "value"
///     }
///   }
/// }
/// ```
///
/// Querying for the value of `a.b.c` would return `"value"`, and querying for `a.b` would return the nested object `{
/// "c": "value" }`.
#[derive(Clone, Debug)]
pub struct GenericConfiguration {
    inner: Arc<Inner>,
}

impl GenericConfiguration {
    fn get<'a, T>(&self, key: &str) -> Result<T, ConfigurationError>
    where
        T: Deserialize<'a>,
    {
        let figment_guard = self.inner.figment.read().unwrap();
        match figment_guard.extract_inner(key) {
            Ok(value) => Ok(value),
            Err(e) => {
                if matches!(e.kind, figment::error::Kind::MissingField(_)) {
                    // We might have been given a key that uses nested notation -- `foo.bar` -- but is only present in the
                    // environment variables. We specifically don't want to use a different separator in environment
                    // variables to map to nested key separators, so we simply try again here but with all nested key
                    // separators (`.`) replaced with `_`, to match environment variables.
                    let fallback_key = key.replace('.', "_");
                    figment_guard
                        .extract_inner(&fallback_key)
                        .map_err(|fallback_e| from_figment_error(&self.inner.lookup_sources, fallback_e))
                } else {
                    Err(e.into())
                }
            }
        }
    }

    /// Gets a configuration value by key.
    ///
    /// The key must be in the form of `a.b.c`, where periods (`.`) are used to indicate a nested lookup.
    ///
    /// ## Errors
    ///
    /// If the key doesn't exist in the configuration, or if the value couldn't be deserialized into `T`, an error
    /// variant will be returned.
    pub fn get_typed<'a, T>(&self, key: &str) -> Result<T, ConfigurationError>
    where
        T: Deserialize<'a>,
    {
        self.get(key)
    }

    /// Gets a configuration value by key, or the default value if a key doesn't exist or couldn't be deserialized.
    ///
    /// The `Default` implementation of `T` will be used both if the key couldn't be found, as well as for any error
    /// during deserialization. This effectively swallows any errors and should generally be used sparingly.
    ///
    /// The key must be in the form of `a.b.c`, where periods (`.`) are used to indicate a nested lookup.
    pub fn get_typed_or_default<'a, T>(&self, key: &str) -> T
    where
        T: Default + Deserialize<'a>,
    {
        self.get(key).unwrap_or_default()
    }

    /// Gets a configuration value by key, if it exists.
    ///
    /// If the key exists in the configuration, and can be deserialized, `Ok(Some(value))` is returned. Otherwise,
    /// `Ok(None)` will be returned.
    ///
    /// The key must be in the form of `a.b.c`, where periods (`.`) are used to indicate a nested lookup.
    ///
    /// ## Errors
    ///
    /// If the value couldn't be deserialized into `T`, an error will be returned.
    pub fn try_get_typed<'a, T>(&self, key: &str) -> Result<Option<T>, ConfigurationError>
    where
        T: Deserialize<'a>,
    {
        match self.get(key) {
            Ok(value) => Ok(Some(value)),
            Err(ConfigurationError::MissingField { .. }) => Ok(None),
            Err(e) => Err(e),
        }
    }

    /// Attempts to deserialize the entire configuration as `T`.
    ///
    /// ## Errors
    ///
    /// If the value couldn't be deserialized into `T`, an error will be returned.
    pub fn as_typed<'a, T>(&self) -> Result<T, ConfigurationError>
    where
        T: Deserialize<'a>,
    {
        self.inner
            .figment
            .read()
            .unwrap()
            .extract()
            .map_err(|e| from_figment_error(&self.inner.lookup_sources, e))
    }

    /// Subscribes for updates to the configuration.
    pub fn subscribe_for_updates(&self) -> Option<broadcast::Receiver<dynamic::ConfigChangeEvent>> {
        self.inner.event_sender.as_ref().map(|s| s.subscribe())
    }

    /// Extracts the entire configuration as a flat list of dot-separated key paths and their values.
    ///
    /// Nested JSON objects are descended into, joining keys with dots. Arrays, strings, numbers,
    /// bools, and nulls are leaf values and are never descended into. The returned values are
    /// never `Value::Object`.
    ///
    /// ## Errors
    ///
    /// If the configuration couldn't be serialized to JSON, an error will be returned.
    pub fn flattened_keys(&self) -> Result<Vec<(String, serde_json::Value)>, ConfigurationError> {
        let root: serde_json::Value = self.as_typed()?;
        let mut out = Vec::new();
        flatten_value(&root, &mut String::new(), &mut out);
        Ok(out)
    }

    /// Creates a watcher that yields only when the given key changes.
    ///
    /// If dynamic configuration is disabled, the returned watcher's `changed()`
    /// will wait indefinitely.
    pub fn watch_for_updates(&self, key: &str) -> FieldUpdateWatcher {
        FieldUpdateWatcher {
            key: key.to_string(),
            rx: self.subscribe_for_updates(),
        }
    }
}

/// Recursively descend into the tree building a dot-separated path until hitting a non-Object leaf node.
fn flatten_value(value: &serde_json::Value, prefix: &mut String, out: &mut Vec<(String, serde_json::Value)>) {
    if let serde_json::Value::Object(map) = value {
        for (key, child) in map {
            let prev_len = prefix.len();
            if !prefix.is_empty() {
                prefix.push('.');
            }
            prefix.push_str(key);
            flatten_value(child, prefix, out);
            prefix.truncate(prev_len);
        }
    } else {
        out.push((prefix.clone(), value.clone()));
    }
}

fn from_figment_error(lookup_sources: &HashSet<LookupSource>, e: figment::Error) -> ConfigurationError {
    match e.kind {
        Kind::MissingField(field) => {
            let mut valid_keys = lookup_sources
                .iter()
                .map(|source| source.transform_key(&field))
                .collect::<Vec<_>>();

            // Always specify the original key as a valid key to try.
            valid_keys.insert(0, field.to_string());

            let help_text = format!("Try setting `{}`.", valid_keys.join("` or `"));

            ConfigurationError::MissingField { help_text, field }
        }
        Kind::InvalidType(actual_ty, expected_ty) => ConfigurationError::InvalidFieldType {
            field: e.path.join("."),
            expected_ty,
            actual_ty: actual_ty.to_string(),
        },
        _ => ConfigurationError::Generic { source: e.into() },
    }
}

#[cfg(test)]
mod tests {
    use super::dynamic::ConfigSetting;
    use super::*;

    #[tokio::test]
    async fn static_configuration() {
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "foo": "bar",
                "baz": 5,
                "foobar": { "a": false, "b": "c" }
            })),
            Some(&[("ENV_VAR".to_string(), "from_env".to_string())]),
            None,
        )
        .await;

        assert_eq!(cfg.get_typed::<String>("foo").unwrap(), "bar");
        assert_eq!(cfg.get_typed::<i32>("baz").unwrap(), 5);
        assert!(!cfg.get_typed::<bool>("foobar.a").unwrap());
        assert_eq!(cfg.get_typed::<String>("env_var").unwrap(), "from_env");
        assert!(matches!(
            cfg.get::<String>("nonexistentKey"),
            Err(ConfigurationError::MissingField { .. })
        ));
    }

    #[tokio::test]
    async fn dynamic_configuration() {
        let (cfg, sender) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "foo": "bar",
                "baz": 5,
                "foobar": { "a": false, "b": "c" }
            })),
            Some(&[("ENV_VAR".to_string(), "from_env".to_string())]),
            Some(ConfigUpdate::snapshot([ConfigSetting::explicit(
                "new",
                serde_json::json!("from_snapshot"),
            )])),
        )
        .await;
        let sender = sender.expect("sender should exist");

        // Test that existing values still exist.
        assert_eq!(cfg.get_typed::<String>("foo").unwrap(), "bar");

        // Test that new values from the snapshot exist.
        assert_eq!(cfg.get_typed::<String>("new").unwrap(), "from_snapshot");

        let mut rx = cfg.subscribe_for_updates().expect("dynamic updates should be enabled");

        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "new_key",
                "from dynamic update".to_string().into(),
            )))
            .await
            .unwrap();

        tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                match rx.recv().await {
                    Ok(ev) if ev.key == "new_key" => break ev,
                    Err(e) => panic!("updates channel closed: {e}"),
                    Ok(_) => continue,
                }
            }
        })
        .await
        .expect("timed out waiting for new_key update");

        assert_eq!(cfg.get_typed::<String>("new_key").unwrap(), "from dynamic update");

        // Test that an update with a nested key is applied.
        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "foobar.a",
                serde_json::json!(true),
            )))
            .await
            .unwrap();

        tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                match rx.recv().await {
                    Ok(ev) if ev.key == "foobar.a" => break ev,
                    Err(e) => panic!("updates channel closed: {e}"),
                    Ok(_) => continue,
                }
            }
        })
        .await
        .expect("timed out waiting for foobar.a update");

        assert!(cfg.get_typed::<bool>("foobar.a").unwrap());
        assert_eq!(cfg.get_typed::<String>("foobar.b").unwrap(), "c");
    }

    #[test]
    fn update_events_are_sent_after_the_figment_map_is_updated() {
        fn recv_with_timeout(
            rx: &mut tokio::sync::broadcast::Receiver<ConfigChangeEvent>, timeout: std::time::Duration,
        ) -> Option<ConfigChangeEvent> {
            let deadline = std::time::Instant::now() + timeout;
            loop {
                match rx.try_recv() {
                    Ok(event) => return Some(event),
                    Err(tokio::sync::broadcast::error::TryRecvError::Empty) if std::time::Instant::now() < deadline => {
                        std::thread::sleep(std::time::Duration::from_millis(1));
                    }
                    Err(tokio::sync::broadcast::error::TryRecvError::Empty) => return None,
                    Err(e) => panic!("updates channel failed: {e}"),
                }
            }
        }

        let runtime = tokio::runtime::Builder::new_current_thread().build().unwrap();
        let (cfg, sender) = runtime.block_on(async {
            let (cfg, sender) = ConfigurationLoader::for_tests(
                None,
                None,
                Some(ConfigUpdate::snapshot([ConfigSetting::explicit(
                    "observed",
                    serde_json::json!("old"),
                )])),
            )
            .await;
            (cfg, sender.expect("sender should exist"))
        });

        let (stop_tx, stop_rx) = tokio::sync::oneshot::channel();
        let (started_tx, started_rx) = std::sync::mpsc::channel();
        let runtime_thread = std::thread::spawn(move || {
            runtime.block_on(async {
                started_tx.send(()).unwrap();
                let _ = stop_rx.await;
            });
        });
        started_rx.recv().unwrap();

        let mut rx = cfg.subscribe_for_updates().expect("dynamic updates should be enabled");
        let figment_guard = cfg.inner.figment.read().unwrap();

        sender
            .blocking_send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "observed",
                serde_json::json!("new"),
            )))
            .unwrap();

        let early_event = recv_with_timeout(&mut rx, std::time::Duration::from_millis(100));
        assert!(
            early_event.is_none(),
            "update event arrived before the figment map changed"
        );

        drop(figment_guard);

        let event = recv_with_timeout(&mut rx, std::time::Duration::from_secs(2))
            .expect("timed out waiting for observed update");
        assert_eq!(event.key, "observed");
        assert_eq!(cfg.get_typed::<String>("observed").unwrap(), "new");

        let _ = stop_tx.send(());
        runtime_thread.join().unwrap();
    }

    #[tokio::test]
    async fn environment_precedence_over_dynamic() {
        let (cfg, sender) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "foo": "bar",
                "baz": 5,
                "foobar": { "a": false, "b": "c" }
            })),
            Some(&[("ENV_VAR".to_string(), "from_env".to_string())]),
            Some(ConfigUpdate::snapshot([ConfigSetting::explicit(
                "env_var",
                serde_json::json!("from_snapshot_env_var"),
            )])),
        )
        .await;
        let sender = sender.expect("sender should exist");

        // Env provider has highest precedence so the snapshot should not override it.
        assert_eq!(cfg.get_typed::<String>("env_var").unwrap(), "from_env");

        let mut rx = cfg.subscribe_for_updates().expect("dynamic updates should be enabled");

        // Send a partial update that attempts to override the env-backed key.
        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "env_var",
                serde_json::json!("from_partial"),
            )))
            .await
            .unwrap();

        // Also attempt to override the nested env-backed key via dynamic.
        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "foobar.a",
                serde_json::json!(false),
            )))
            .await
            .unwrap();

        // Send a dummy partial update to ensure the updater has processed prior partials.
        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "dummy",
                serde_json::json!(1),
            )))
            .await
            .unwrap();

        tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                match rx.recv().await {
                    Ok(ev) if ev.key == "dummy" => break,
                    Err(e) => panic!("updates channel closed: {e}"),
                    Ok(_) => continue,
                }
            }
        })
        .await
        .expect("timed out waiting for sync marker");

        assert_eq!(cfg.get_typed::<String>("env_var").unwrap(), "from_env");
    }

    #[tokio::test]
    async fn dynamic_configuration_add_new_nested_key() {
        let (cfg, sender) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "foo": "bar",
                "baz": 5,
                "foobar": { "a": false, "b": "c" }
            })),
            None,
            Some(ConfigUpdate::snapshot([])),
        )
        .await;
        let sender = sender.expect("sender should exist");

        let mut rx = cfg.subscribe_for_updates().expect("dynamic updates should be enabled");

        sender
            .send(ConfigUpdate::Partial(ConfigSetting::explicit(
                "new_parent.new_child",
                serde_json::json!(42),
            )))
            .await
            .unwrap();

        // new_parent object did not exist before, so the diff will emit the object "new_parent"
        tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                match rx.recv().await {
                    Ok(ev) if ev.key == "new_parent" => break ev,
                    Err(e) => panic!("updates channel closed: {e}"),
                    Ok(_) => continue,
                }
            }
        })
        .await
        .expect("timed out waiting for new_parent.new_child update");

        assert_eq!(cfg.get_typed::<i32>("new_parent.new_child").unwrap(), 42);
    }

    #[tokio::test]
    async fn underscore_fallback_on_get() {
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({})),
            Some(&[("RANDOM_KEY".to_string(), "from_env_only".to_string())]),
            None,
        )
        .await;

        assert_eq!(cfg.get_typed::<String>("random.key").unwrap(), "from_env_only");
    }

    #[tokio::test]
    async fn underscore_fallback_on_get_multi_segment_key() {
        // A single-underscore Agent-style env var (e.g. `DD_DATA_PLANE_API_LISTEN_ADDRESS`, which
        // `for_tests` simulates with the `TEST_` prefix) produces a flat figment key. A deeply
        // nested `get`/`try_get_typed` query must still resolve it via the dot-to-underscore
        // fallback, so callers don't need double-underscore env vars for these keys.
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({})),
            Some(&[(
                "DATA_PLANE_API_LISTEN_ADDRESS".to_string(),
                "tcp://0.0.0.0:55100".to_string(),
            )]),
            None,
        )
        .await;

        assert_eq!(
            cfg.try_get_typed::<String>("data_plane.api_listen_address").unwrap(),
            Some("tcp://0.0.0.0:55100".to_string()),
        );
    }

    #[tokio::test]
    async fn static_configuration_has_no_updates() {
        let (cfg, maybe_sender) = ConfigurationLoader::for_tests(Some(serde_json::json!({})), None, None).await;
        assert!(maybe_sender.is_none());
        assert!(cfg.subscribe_for_updates().is_none());
    }

    #[tokio::test]
    async fn updater_applies_each_update_before_returning() {
        let (cfg, updater) = ConfigurationLoader::default()
            .with_dynamic_configuration(ConfigUpdate::snapshot([ConfigSetting::explicit(
                "key",
                serde_json::json!("from_snapshot"),
            )]))
            .into_generic()
            .await
            .expect("should not fail to build generic configuration");
        let mut updater = updater.expect("dynamic configuration should return an updater");
        assert_eq!(cfg.get_typed::<String>("key").unwrap(), "from_snapshot");

        let mut rx = cfg.subscribe_for_updates().expect("dynamic updates should be enabled");
        updater
            .apply(ConfigUpdate::Partial(ConfigSetting::explicit(
                "key",
                serde_json::json!("from_update"),
            )))
            .expect("should not fail to apply the update");

        // Nothing runs in the background: the update and its change event are both visible as soon as `apply` returns.
        assert_eq!(cfg.get_typed::<String>("key").unwrap(), "from_update");
        let event = rx.try_recv().expect("the change event should already be sent");
        assert_eq!(event.key, "key");
    }

    #[tokio::test]
    async fn flattened_keys_flat_and_nested() {
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "top": "value",
                "nested": { "a": 1, "b": { "c": true } }
            })),
            None,
            None,
        )
        .await;

        let pairs = cfg.flattened_keys().unwrap();
        let map: std::collections::HashMap<&str, &serde_json::Value> =
            pairs.iter().map(|(k, v)| (k.as_str(), v)).collect();

        assert_eq!(map.get("top"), Some(&&serde_json::json!("value")));
        assert_eq!(map.get("nested.a"), Some(&&serde_json::json!(1)));
        assert_eq!(map.get("nested.b.c"), Some(&&serde_json::json!(true)));
        assert!(!map.contains_key("nested"));
        assert!(!map.contains_key("nested.b"));
    }

    #[tokio::test]
    async fn flattened_keys_arrays_are_leaves() {
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "tags": ["a", "b"],
                "matrix": [[1, 2], [3, 4]]
            })),
            None,
            None,
        )
        .await;

        let pairs = cfg.flattened_keys().unwrap();
        let map: std::collections::HashMap<&str, &serde_json::Value> =
            pairs.iter().map(|(k, v)| (k.as_str(), v)).collect();

        assert_eq!(map.get("tags"), Some(&&serde_json::json!(["a", "b"])));
        assert_eq!(map.get("matrix"), Some(&&serde_json::json!([[1, 2], [3, 4]])));
    }

    #[tokio::test]
    async fn flattened_keys_null_values_absent() {
        let (cfg, _) = ConfigurationLoader::for_tests(
            Some(serde_json::json!({
                "present": "yes",
                "absent": null
            })),
            None,
            None,
        )
        .await;

        let pairs = cfg.flattened_keys().unwrap();
        let map: std::collections::HashMap<&str, &serde_json::Value> =
            pairs.iter().map(|(k, v)| (k.as_str(), v)).collect();

        assert_eq!(map.get("present"), Some(&&serde_json::json!("yes")));
        // Figment drops null values during deserialization, so they are absent from the output.
        assert!(!map.contains_key("absent"));
    }

    #[tokio::test]
    async fn from_yaml_loads_configuration_file() {
        use std::io::Write as _;

        let mut file = tempfile::NamedTempFile::new().expect("should create temp file");
        file.write_all(b"top: value\nnested:\n  inner: 7\n")
            .expect("should write temp file");
        file.flush().expect("should flush temp file");

        let (cfg, _) = ConfigurationLoader::default()
            .from_yaml(file.path())
            .expect("YAML file should load")
            .into_generic()
            .await
            .expect("should build generic configuration");

        assert_eq!(cfg.get_typed::<String>("top").unwrap(), "value");
        assert_eq!(cfg.get_typed::<i64>("nested.inner").unwrap(), 7);
    }

    #[tokio::test]
    async fn try_from_yaml_ignores_unreadable_file() {
        // `try_from_yaml` swallows load errors (here, a nonexistent path), yielding a config with no values rather
        // than failing to build.
        let (cfg, _) = ConfigurationLoader::default()
            .try_from_yaml("/nonexistent/definitely/not/here.yaml")
            .into_generic()
            .await
            .expect("should build generic configuration even when the file is missing");

        assert!(matches!(
            cfg.get::<String>("anything"),
            Err(ConfigurationError::MissingField { .. })
        ));
    }

    #[tokio::test]
    async fn from_json_returns_error_for_invalid_file() {
        use std::io::Write as _;

        let mut file = tempfile::NamedTempFile::new().expect("should create temp file");
        file.write_all(b"{ not valid json ").expect("should write temp file");
        file.flush().expect("should flush temp file");

        let result = ConfigurationLoader::default().from_json(file.path());
        assert!(result.is_err(), "invalid JSON should fail to load at the loader level");
    }
}