Struct RemoteAgent 

pub struct RemoteAgent<R, S = Unstarted>
where
    R: RemoteAgentSpecification,
    S: Stage,
{ /* private fields */ }

The remote agent startup sequence.

R is the binary’s RemoteAgentSpecification, and S is the current stage, which determines the methods available.

Implementations

impl<R> RemoteAgent<R, Unstarted>

where R: RemoteAgentSpecification,

pub fn new(local: R::LocalConfiguration, translator: LoggingTranslator) -> Self

Creates a new RemoteAgent from its local configuration.

translator translates the authoritative logging settings once they’re known.

pub fn with_start_time(self, start_time: Instant) -> Self

Sets the time the process started, which is used to report how long the topology took to become healthy.

Defaults to the time the RemoteAgent was created.

pub async fn start( self, bootstrap_guard: &mut BootstrapGuard, bootstrap_supervisor: Supervisor, ) -> Result<RemoteAgent<R, Started>, GenericError>

Selects the configuration authority and reloads logging to match it.

In connected mode, this registers with the Datadog Agent and waits for its initial configuration. In standalone mode, the local configuration becomes authoritative.

bootstrap_supervisor is the supervisor returned by the process bootstrap, which runs as the first child of the root supervisor.

Errors

If registration fails, or the configuration can’t be loaded, an error is returned.

impl<R> RemoteAgent<R, Started>

where R: RemoteAgentSpecification,

pub fn config(&self) -> &R::AuthoritativeConfiguration

Returns the authoritative configuration.

pub fn is_standalone(&self) -> bool

Returns true if the remote agent runs without the Datadog Agent.

pub async fn initialize( self, ) -> Result<RemoteAgent<R, Initialized>, GenericError>

Creates the registries and the environment provider.

In connected mode, the environment provider connects to the Datadog Agent for the hostname, autodiscovery, and workload metadata. In standalone mode, it reports the configured hostname, and nothing else.

Errors

If the environment provider can’t be created, an error is returned.

impl<R> RemoteAgent<R, Initialized>

where R: RemoteAgentSpecification,

pub fn config(&self) -> &R::AuthoritativeConfiguration

Returns the authoritative configuration.

pub fn is_standalone(&self) -> bool

Returns true if the remote agent runs without the Datadog Agent.

pub fn env_provider(&self) -> &RemoteAgentEnvironmentProvider

Returns the environment provider.

pub fn component_registry(&self) -> &ComponentRegistry

Returns the component registry, which the topology registers its components and memory bounds with.

pub fn health_registry(&self) -> &HealthRegistry

Returns the health registry.

pub fn client_configuration(&self) -> Option<&RemoteAgentClientConfiguration>

Returns the configuration for connecting to the Datadog Agent, or None in standalone mode.

pub async fn remote_config_client( &mut self, ) -> Result<Option<RemoteConfigurationClient>, GenericError>

Returns the Remote Configuration client, connecting to the Datadog Agent on the first call.

The polling worker runs under the internal supervisor once the remote agent runs, so subscriptions made before then are all included in its first poll. Binaries should only call this when they have products to subscribe to, since connecting starts the worker polling.

Returns None in standalone mode, or if Remote Configuration is turned off.

Errors

If the client can’t connect to the Datadog Agent, an error is returned.

pub fn create_remote_agent_supervisor( &self, status_sections: Vec<Arc<dyn StatusSectionProvider>>, telemetry_rules: Vec<RemapperRule>, ) -> Result<Supervisor, GenericError>

Creates the supervisor for the parts of the control plane that only the facade can build.

The supervisor is named remote-agent, and must be added to the binary’s control plane supervisor. It serves the supervision tree on the privileged API endpoint and, in connected mode, runs the remote agent workers from RemoteAgentBootstrap: it serves the status, flare, and telemetry services, and reports diagnostic events to the Datadog Agent.

status_sections and telemetry_rules are passed to RemoteAgentBootstrap::create_services_worker.

Errors

If the supervisor can’t be created, an error is returned.

pub async fn run( self, blueprint: TopologyBlueprint, control_plane: Supervisor, ) -> Result<(), GenericError>

Runs the remote agent until the process receives a shutdown signal.

See run_until for the parameters.

Errors

If the remote agent can’t be assembled, or the supervision tree fails, an error is returned.

pub async fn run_until<F>( self, blueprint: TopologyBlueprint, control_plane: Supervisor, shutdown: F, ) -> Result<(), GenericError>

where F: Future<Output = ()> + Send + 'static,

Runs the remote agent until shutdown resolves.

This creates the internal supervisor around control_plane, validates the memory bounds, and then runs the supervision tree with blueprint as the topology.

control_plane is the binary’s control plane supervisor, which must include the supervisor from create_remote_agent_supervisor. The memory bounds cover every component registered with the component registry, so blueprint must be fully built.

A shutdown in which some components had to be stopped forcefully, after exceeding their shutdown timeout, is logged as a warning rather than returned as an error, since the process did stop.

Errors

If the internal supervisor can’t be created, the memory bounds can’t be validated, or the supervision tree fails, an error is returned.