Struct ControlConfiguration 

pub struct ControlConfiguration {

    pub enabled: bool,
    pub dogstatsd: bool,
    pub checks: bool,
    pub otlp: bool,
    pub standalone_mode: bool,
    pub remote_agent_enabled: bool,
    pub use_new_config_stream_endpoint: bool,
    pub api_listen_address: String,
    pub secure_api_listen_address: String,
    pub logging: Logging,
    pub ipc: ControlIpc,
    pub aggregator_stop_timeout: Duration,
    pub stop_timeout: Option<Duration>,
    pub memory_limit: Option<u64>,
    pub memory_slop_factor: f64,
    pub enable_global_limiter: bool,
    pub memory_mode: MemoryMode,
}

Topology gates and orchestration decisions. Most are static; logging.level is live.

The derived Default is all zeroes, empty, and false, and serves only as the starting point for translation. The effective default of each field is the one translation resolves, noted per field below.

Fields

enabled: bool

Master switch for the whole data plane; when false, no pipelines are built.

dogstatsd: bool

Whether the DogStatsD metrics pipeline is built.

checks: bool

Whether the checks metrics pipeline is built. (not in Datadog Agent config schema)

otlp: bool

Whether the OTLP pipeline is built.

standalone_mode: bool

Whether standalone mode is active, running without a core Agent. (not in Datadog Agent config schema)

remote_agent_enabled: bool

Whether the process registers itself with the core Agent as a remote agent.

use_new_config_stream_endpoint: bool

Whether to subscribe to core Agent configuration updates over the newer config-stream endpoint.

api_listen_address: String

Address the unsecured control API listens on.

secure_api_listen_address: String

Address the mutually authenticated control API listens on. Every HTTP and gRPC client must present the exact configured Agent IPC certificate during the TLS handshake.

logging: Logging

Logging configuration, read before runtime authority exists.

ipc: ControlIpc

Bootstrap IPC and remote-agent connection parameters.

aggregator_stop_timeout: Duration

Grace period the aggregator is given to flush before shutdown.

stop_timeout: Option<Duration>

Override for the topology shutdown grace period.

Defaults to None. When absent, the topology timeout is the sum of aggregator_stop_timeout and forwarder_stop_timeout.

memory_limit: Option<u64>

Process memory ceiling, in bytes, that bounds validation and the global limiter work against.

Defaults to None. When absent, ADP reads the ceiling from the process cgroup, but only when DOCKER_DD_AGENT is set to a non-empty value. When neither source supplies a value, bounds validation is skipped and the global limiter never exerts backpressure, whatever memory_mode and enable_global_limiter say.

Some(0) is a ceiling of zero bytes rather than “no ceiling”: every component bound then exceeds it, which is fatal under MemoryMode::Strict. A ceiling above 2^53 bytes is rejected during startup.

Set this to the memory the process is allowed to use, and leave it unset only where cgroup detection supplies that number.

memory_slop_factor: f64

Fraction of memory_limit held back as headroom for memory the component bounds do not account for.

Defaults to DEFAULT_MEMORY_SLOP_FACTOR (0.25), which validates bounds against 75% of memory_limit. Valid values run from 0.0 up to but excluding 1.0, where 0.0 holds nothing back. A value outside that range, including NaN, fails startup once a memory ceiling resolves, and goes unused when none does.

Raise this for a workload whose real usage overshoots its validated bounds; lower it to hand more of a tight ceiling to the components that do account for their usage.

enable_global_limiter: bool

Whether the global memory limiter exerts backpressure as usage approaches the effective ceiling.

Defaults to DEFAULT_ENABLE_GLOBAL_LIMITER (true). When false, the limiter is a no-op: it throttles nothing, and only the components’ own bounds hold memory usage down. Either way it does nothing unless a memory ceiling resolves and memory_mode is MemoryMode::Permissive or MemoryMode::Strict, because no other case installs a limiter.

Turn this off to attribute a throughput drop to memory backpressure, accepting that the process can then run past memory_limit.

memory_mode: MemoryMode

How the component memory bounds are reconciled with the effective memory ceiling during startup.

Defaults to MemoryMode::Disabled. Validation runs only when a memory ceiling resolves; without one, Permissive and Strict log that validation was skipped and startup continues.

Run Permissive first to learn whether a ceiling fits the topology, then move to Strict where the platform kills a process that exceeds its ceiling and refusing to start is the better failure.

Implementations

impl ControlConfiguration

pub fn requires_datadog_forwarder(&self) -> bool

Derived decision the topology builder reads. The outbound Datadog forwarder is needed only if some pipeline that emits to Datadog is enabled.

Trait Implementations

impl Clone for ControlConfiguration

fn clone(&self) -> ControlConfiguration

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ControlConfiguration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ControlConfiguration

fn default() -> ControlConfiguration

Returns the “default value” for a type.

impl PartialEq for ControlConfiguration

fn eq(&self, other: &ControlConfiguration) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ControlConfiguration

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ControlConfiguration