Merge remote-tracking branch 'origin/main' into ci/update-agent-version-7.80.2

# Conflicts:
#	.datadog-agent-version
#	.gitlab-ci.yml
#	docker/Dockerfile.datadog-agent

Author: jszwedko

.github/workflows/slapr.yml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   run_slapr:
-    if: github.event.pull_request.base.ref == 'main' && github.event.pull_request.head.repo.full_name == github.repository
+    if: github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-latest
     permissions:
       id-token: write

.gitignore

@@ -6,6 +6,7 @@ test/build/
 test/ddprof
 test/lading
 test/one-off/__pycache__
+test/antithesis/scratchbook/
 dhat-heap.json
 .DS_Store
 dist/

.vale/styles/config/vocabularies/technical/accept.txt

@@ -235,6 +235,7 @@ launchd
 Wireshark
 testsupport
 callee
+Bazel
 trivy
 Erlang
 OTP

Cargo.lock

@@ -38,7 +38,7 @@ endif
 export ADP_STANDALONE_IPC_CERT_FILE := /tmp/adp-ipc-cert.pem
 
 # macOS integration-test settings.
-MACOS_TEST_AGENT_VERSION ?= 7.78.0
+MACOS_TEST_AGENT_VERSION ?= 7.80.1
 MACOS_TEST_AGENT_DMG_DIR ?= /tmp/saluki-dda-dmg-cache
 MACOS_TEST_AGENT_DMG_URL ?= https://s3.amazonaws.com/dd-agent/datadog-agent-$(MACOS_TEST_AGENT_VERSION)-1.$(shell uname -m).dmg
 MACOS_TEST_AGENT_INSTALL_DIR ?= /tmp/saluki-dda/datadog-agent
@@ -75,7 +75,7 @@ export WINDOWS_CROSS_LLVM_BIN ?= /opt/homebrew/opt/llvm/bin
 export WINDOWS_CROSS_CARGO_ARGS ?= --package agent-data-plane
 
 # Version of source repositories (Git tag) for vendored Protocol Buffers definitions.
-export PROTOBUF_SRC_REPO_DD_AGENT ?= 7.73.x
+export PROTOBUF_SRC_REPO_DD_AGENT ?= 7.80.x
 export PROTOBUF_SRC_REPO_AGENT_PAYLOAD ?= v5.0.164
 export PROTOBUF_SRC_REPO_CONTAINERD ?= v2.2.0
 export PROTOBUF_SRC_REPO_SKETCHES_GO ?= v1.4.7

Makefile

@@ -43,22 +43,28 @@ impl HostTagsConfiguration {
 #[async_trait]
 impl SynchronousTransformBuilder for HostTagsConfiguration {
     async fn build(&self, _context: ComponentContext) -> Result<Box<dyn SynchronousTransform + Send>, GenericError> {
-        // Make an initial request of the host tags from the Datadog Agent.
-        //
-        // We only pay attention to the "system" tags, as the "google_cloud_platform" tags are not relevant here.
-        let host_tags_reply = self.client.get_host_tags().await?.into_inner();
-        let host_tags = host_tags_reply
-            .system
-            .into_iter()
-            .map(|s| Arc::from(s.as_str()))
-            .map(MetaString::from)
-            .map(Tag::from)
-            .collect::<SharedTagSet>();
+        // Only fetch host tags when enrichment is enabled (`expected_tags_duration > 0`), matching the Core
+        // Agent; at the default of 0 the tags are discarded immediately. Fetching always would block `build()`
+        // on the Core Agent's slow `GetHostTags` RPC, delaying DogStatsD draining and starving origin detection.
+        let host_tags = if self.expected_tags_duration > Duration::ZERO {
+            // We only pay attention to the "system" tags, as the "google_cloud_platform" tags are not relevant here.
+            let host_tags_reply = self.client.get_host_tags().await?.into_inner();
+            let host_tags = host_tags_reply
+                .system
+                .into_iter()
+                .map(|s| Arc::from(s.as_str()))
+                .map(MetaString::from)
+                .map(Tag::from)
+                .collect::<SharedTagSet>();
+            Some(host_tags)
+        } else {
+            None
+        };
 
         Ok(Box::new(HostTagsEnrichment {
             start: Instant::now(),
             expected_tags_duration: self.expected_tags_duration,
-            host_tags: Some(host_tags),
+            host_tags,
         }))
     }
 }

bin/agent-data-plane/src/components/host_tags/mod.rs

@@ -5,6 +5,7 @@
 
 #![deny(warnings)]
 #![deny(missing_docs)]
+use std::path::Path;
 use std::time::Instant;
 
 // Pull in the Antithesis coverage-instrumentation runtime shim only when
@@ -45,10 +46,8 @@ static ALLOC: resource_accounting::TrackingAllocator<std::alloc::System> =
 async fn main() -> Result<(), GenericError> {
     let started = Instant::now();
 
-    // Initialize the Antithesis SDK as early as possible so assertions and lifecycle hooks register
-    // their catalog before any are evaluated. No-op outside Antithesis and absent in production builds.
     #[cfg(feature = "antithesis")]
-    antithesis_sdk::antithesis_init();
+    initialize_antithesis();
 
     let cli: Cli = argh::from_env();
 
@@ -61,14 +60,7 @@ async fn main() -> Result<(), GenericError> {
     // Load our "bootstrap" configuration -- static configuration on disk or from environment variables -- so we can
     // initialize basic subsystems before executing the given subcommand.
     let bootstrap_config_path = cli.config_file.unwrap_or_else(PlatformSettings::get_config_file_path);
-    let bootstrap_config = ConfigurationLoader::default()
-        .with_key_aliases(KEY_ALIASES)
-        .from_yaml(&bootstrap_config_path)
-        .error_context("Failed to load Datadog Agent configuration file during bootstrap.")?
-        .add_providers([DatadogRemapper::new()])
-        .from_environment(PlatformSettings::get_env_var_prefix())
-        .error_context("Environment variable prefix should not be empty.")?
-        .bootstrap_generic();
+    let bootstrap_config = load_bootstrap_config(&bootstrap_config_path)?.bootstrap_generic();
 
     // Translate the bootstrap configuration into ADP's logging configuration, applying ADP-specific rules
     // (per-subagent log file key, never sharing a file with the Core Agent).
@@ -122,6 +114,52 @@ async fn main() -> Result<(), GenericError> {
     Ok(())
 }
 
+/// Initializes the Antithesis SDK and installs a panic-reporting hook. Set
+/// ideally before any panics are possible.
+#[cfg(feature = "antithesis")]
+fn initialize_antithesis() {
+    antithesis_sdk::antithesis_init();
+
+    let default_hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |info| {
+        let location = info.location().map_or_else(String::new, |l| l.to_string());
+        let payload = info.payload();
+        let message = payload
+            .downcast_ref::<&str>()
+            .map(|s| (*s).to_string())
+            .or_else(|| payload.downcast_ref::<String>().cloned())
+            .unwrap_or_else(|| "<non-string panic payload>".to_string());
+        antithesis_sdk::assert_unreachable!(
+            "agent-data-plane panicked",
+            &serde_json::json!({ "message": message, "location": location })
+        );
+        default_hook(info);
+    }));
+}
+
+/// Loads bootstrap configuration from the on-disk file and environment
+/// variables.
+fn load_bootstrap_config(bootstrap_config_path: &Path) -> Result<ConfigurationLoader, GenericError> {
+    let loaded = ConfigurationLoader::default()
+        .with_key_aliases(KEY_ALIASES)
+        .from_yaml(bootstrap_config_path)
+        .error_context("Failed to load Datadog Agent configuration file during bootstrap.")
+        .and_then(|loader| {
+            loader
+                .add_providers([DatadogRemapper::new()])
+                .from_environment(PlatformSettings::get_env_var_prefix())
+                .error_context("Environment variable prefix should not be empty.")
+        });
+    // A graceful config rejection exits 1 rather than crashing; classify that against a clean boot.
+    #[cfg(feature = "antithesis")]
+    antithesis_sdk::assert_always_or_unreachable!(
+        loaded.is_ok(),
+        "agent-data-plane boots under sampled config",
+        &serde_json::json!({ "phase": "config_load", "error": loaded.as_ref().err().map(|e| format!("{e:?}")) })
+    );
+    loaded
+}
+
 fn parse_metrics_level(config: &GenericConfiguration) -> Result<Level, GenericError> {
     let raw = config
         .try_get_typed::<String>("metrics_level")
@@ -157,6 +195,13 @@ async fn run_inner(
                     }
                     Err(e) => {
                         error!("{:?}", e);
+                        // Same boot property as the config-load gate, distinguished by `phase` in the details.
+                        #[cfg(feature = "antithesis")]
+                        antithesis_sdk::assert_always_or_unreachable!(
+                            false,
+                            "agent-data-plane boots under sampled config",
+                            &serde_json::json!({ "phase": "run_setup", "error": format!("{e:?}") })
+                        );
                         Some(1)
                     }
                 };