Implement app-extended-heartbeat telemetry event

Add support for app-extended-heartbeat telemetry event that sends
configuration, dependencies, and integrations data at a configurable
interval (default: 24 hours). This event serves as a failsafe for
reconstructing application records in case of data failures.

Changes:
- Add DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL environment variable
- Add extended_heartbeat_interval configuration to Configuration and
  FinalizedConfiguration structs
- Implement app_extended_heartbeat_payload() method that generates
  payload with configuration, dependencies, and integrations arrays
- Schedule recurring extended heartbeat task alongside regular heartbeat
- Add comprehensive test coverage for extended heartbeat functionality
- Fix existing test bug: check heartbeat_interval instead of metrics_interval

The payload excludes 'products' and 'install_signature' fields as per
the API specification, focusing only on configuration, dependencies,
and integrations data.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: khanayan123

include/datadog/environment.h

@@ -51,6 +51,7 @@ namespace environment {
   MACRO(DD_VERSION)                                            \
   MACRO(DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED)           \
   MACRO(DD_TELEMETRY_HEARTBEAT_INTERVAL)                       \
+  MACRO(DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL)              \
   MACRO(DD_TELEMETRY_METRICS_ENABLED)                          \
   MACRO(DD_TELEMETRY_METRICS_INTERVAL_SECONDS)                 \
   MACRO(DD_TELEMETRY_DEBUG)                                    \

include/datadog/telemetry/configuration.h

@@ -29,6 +29,9 @@ struct Configuration {
   // Interval at which the heartbeat payload will be sent.
   // Can be overriden by `DD_TELEMETRY_HEARTBEAT_INTERVAL` environment variable.
   tracing::Optional<double> heartbeat_interval_seconds;
+  // Interval at which the extended heartbeat payload will be sent.
+  // Can be overriden by `DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL` environment variable.
+  tracing::Optional<double> extended_heartbeat_interval_seconds;
   // `integration_name` is the name of the product integrating this library.
   // Example: "nginx", "envoy" or "istio".
   tracing::Optional<std::string> integration_name;
@@ -52,6 +55,7 @@ struct FinalizedConfiguration {
   bool report_logs;
   std::chrono::steady_clock::duration metrics_interval;
   std::chrono::steady_clock::duration heartbeat_interval;
+  std::chrono::steady_clock::duration extended_heartbeat_interval;
   std::string integration_name;
   std::string integration_version;
   std::vector<Product> products;

src/datadog/telemetry/configuration.cpp

@@ -48,6 +48,16 @@ tracing::Expected<Configuration> load_telemetry_env_config() {
     env_cfg.heartbeat_interval_seconds = *maybe_value;
   }
 
+  if (auto extended_heartbeat_interval_seconds =
+          lookup(environment::DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL)) {
+    auto maybe_value = parse_double(*extended_heartbeat_interval_seconds);
+    if (auto error = maybe_value.if_error()) {
+      return *error;
+    }
+
+    env_cfg.extended_heartbeat_interval_seconds = *maybe_value;
+  }
+
   return env_cfg;
 }
 
@@ -112,6 +122,19 @@ tracing::Expected<FinalizedConfiguration> finalize_config(
       std::chrono::duration_cast<std::chrono::milliseconds>(
           std::chrono::duration<double>(heartbeat_interval.second));
 
+  // extended_heartbeat_interval_seconds
+  auto extended_heartbeat_interval =
+      pick(env_config->extended_heartbeat_interval_seconds,
+           user_config.extended_heartbeat_interval_seconds, 86400);
+  if (extended_heartbeat_interval.second <= 0.) {
+    return Error{Error::Code::OUT_OF_RANGE_INTEGER,
+                 "Telemetry extended heartbeat polling interval must be a "
+                 "positive value"};
+  }
+  result.extended_heartbeat_interval =
+      std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::duration<double>(extended_heartbeat_interval.second));
+
   // integration_name
   std::tie(origin, result.integration_name) =
       pick(env_config->integration_name, user_config.integration_name,

src/datadog/telemetry/telemetry_impl.cpp

@@ -223,6 +223,12 @@ void Telemetry::schedule_tasks() {
       config_.heartbeat_interval,
       [this]() { send_payload("app-heartbeat", heartbeat_and_telemetry()); }));
 
+  tasks_.emplace_back(scheduler_->schedule_recurring_event(
+      config_.extended_heartbeat_interval, [this]() {
+        send_payload("app-extended-heartbeat",
+                     app_extended_heartbeat_payload());
+      }));
+
   if (config_.report_metrics) {
     tasks_.emplace_back(scheduler_->schedule_recurring_event(
         config_.metrics_interval, [this]() mutable { capture_metrics(); }));
@@ -678,6 +684,40 @@ std::string Telemetry::app_started_payload() {
   return batch.dump();
 }
 
+std::string Telemetry::app_extended_heartbeat_payload() {
+  auto configuration_json = nlohmann::json::array();
+
+  for (const auto& product : config_.products) {
+    auto& configurations = product.configurations;
+    for (const auto& [_, config_metadatas] : configurations) {
+      for (const auto& config_metadata : config_metadatas) {
+        configuration_json.emplace_back(
+            generate_configuration_field(config_metadata));
+      }
+    }
+  }
+
+  auto dependencies_json = nlohmann::json::array();
+
+  auto integrations_json = nlohmann::json::array();
+  if (!config_.integration_name.empty()) {
+    integrations_json.emplace_back(nlohmann::json{
+        {"name", config_.integration_name},
+        {"version", config_.integration_version},
+        {"enabled", true},
+    });
+  }
+
+  auto telemetry_body = generate_telemetry_body("app-extended-heartbeat");
+  telemetry_body["payload"] = nlohmann::json{
+      {"configuration", configuration_json},
+      {"dependencies", dependencies_json},
+      {"integrations", integrations_json},
+  };
+
+  return telemetry_body.dump();
+}
+
 nlohmann::json Telemetry::generate_telemetry_body(std::string request_type) {
   std::time_t tracer_time = std::chrono::duration_cast<std::chrono::seconds>(
                                 clock_().wall.time_since_epoch())

src/datadog/telemetry/telemetry_impl.h

@@ -152,6 +152,10 @@ class Telemetry final {
   // Constructs a messsage-batch containing `app-heartbeat`, and if metrics
   // have been modified, a `generate-metrics` message.
   std::string heartbeat_and_telemetry();
+  // Constructs an `app-extended-heartbeat` message containing configuration,
+  // dependencies, and integrations (reuses app-started payload logic but
+  // excludes products and install_signature).
+  std::string app_extended_heartbeat_payload();
   // Constructs a message-batch containing `app-closing`, and if metrics have
   // been modified, a `generate-metrics` message.
   std::string app_closing_payload();

test/telemetry/test_telemetry.cpp

@@ -45,8 +45,10 @@ std::optional<nlohmann::json> find_payload(const nlohmann::json& messages,
 struct FakeEventScheduler : public EventScheduler {
   size_t count_tasks = 0;
   std::function<void()> heartbeat_callback = nullptr;
+  std::function<void()> extended_heartbeat_callback = nullptr;
   std::function<void()> metrics_callback = nullptr;
   Optional<std::chrono::steady_clock::duration> heartbeat_interval;
+  Optional<std::chrono::steady_clock::duration> extended_heartbeat_interval;
   Optional<std::chrono::steady_clock::duration> metrics_interval;
   bool cancelled = false;
 
@@ -57,6 +59,9 @@ struct FakeEventScheduler : public EventScheduler {
       heartbeat_callback = callback;
       heartbeat_interval = interval;
     } else if (count_tasks == 1) {
+      extended_heartbeat_callback = callback;
+      extended_heartbeat_interval = interval;
+    } else if (count_tasks == 2) {
       metrics_callback = callback;
       metrics_interval = interval;
     }
@@ -69,6 +74,11 @@ struct FakeEventScheduler : public EventScheduler {
     heartbeat_callback();
   }
 
+  void trigger_extended_heartbeat() {
+    assert(extended_heartbeat_callback != nullptr);
+    extended_heartbeat_callback();
+  }
+
   void trigger_metrics_capture() {
     assert(metrics_callback != nullptr);
     metrics_callback();
@@ -391,6 +401,54 @@ TELEMETRY_IMPLEMENTATION_TEST("Tracer telemetry API") {
     REQUIRE(find_payload(message_batch["payload"], "app-heartbeat"));
   }
 
+  SECTION("generates an extended heartbeat message") {
+    client->clear();
+
+    Configuration cfg;
+    cfg.extended_heartbeat_interval_seconds = 1;
+    Product product;
+    product.name = Product::Name::tracing;
+    product.enabled = true;
+    product.version = tracer_version;
+    product.configurations =
+        std::unordered_map<ConfigName, std::vector<ConfigMetadata>>{
+            {ConfigName::SERVICE_NAME,
+             {ConfigMetadata(ConfigName::SERVICE_NAME, "test-service",
+                             ConfigMetadata::Origin::CODE)}},
+        };
+    cfg.products.emplace_back(std::move(product));
+
+    auto final_cfg = finalize_config(cfg);
+    REQUIRE(final_cfg);
+
+    Telemetry telemetry_extended{*final_cfg, tracer_signature, logger, client,
+                                  scheduler, *url, clock};
+
+    client->clear();
+    auto extended_heartbeat_message =
+        telemetry_extended.app_extended_heartbeat_payload();
+    auto extended_heartbeat =
+        nlohmann::json::parse(extended_heartbeat_message);
+
+    REQUIRE(is_valid_telemetry_payload(extended_heartbeat) == true);
+    REQUIRE(extended_heartbeat["request_type"] == "app-extended-heartbeat");
+    REQUIRE(extended_heartbeat["payload"].contains("configuration"));
+    REQUIRE(extended_heartbeat["payload"].contains("dependencies"));
+    REQUIRE(extended_heartbeat["payload"].contains("integrations"));
+
+    REQUIRE(extended_heartbeat["payload"]["configuration"].is_array());
+    REQUIRE(extended_heartbeat["payload"]["dependencies"].is_array());
+    REQUIRE(extended_heartbeat["payload"]["integrations"].is_array());
+
+    CHECK(!extended_heartbeat["payload"].contains("products"));
+    CHECK(!extended_heartbeat["payload"].contains("install_signature"));
+
+    auto cfg_payload = extended_heartbeat["payload"]["configuration"];
+    REQUIRE(cfg_payload.size() == 1);
+    CHECK(cfg_payload[0]["name"] == "service");
+    CHECK(cfg_payload[0]["value"] == "test-service");
+  }
+
   SECTION("metrics reporting") {
     SECTION("counters are correctly serialized in generate-metrics payload") {
       client->clear();
@@ -903,7 +961,10 @@ TELEMETRY_IMPLEMENTATION_TEST("Tracer telemetry configuration") {
     CHECK(scheduler->metrics_interval == 500ms);
 
     CHECK(scheduler->heartbeat_callback != nullptr);
-    CHECK(scheduler->metrics_interval != 30s);
+    CHECK(scheduler->heartbeat_interval == 30s);
+
+    CHECK(scheduler->extended_heartbeat_callback != nullptr);
+    CHECK(scheduler->extended_heartbeat_interval == 86400s);
   }
 
   SECTION("disabling logs reporting do not collect logs") {