fix(telemetry): include dependencies and integrations in app-extended-heartbeat

Per the instrumentation-telemetry-api-docs schema, app-extended-heartbeat
must carry the full state — configuration, dependencies, and integrations —
so the agent can reconstruct application records on data loss. dd-trace-go
and dd-trace-dotnet both ship the full triple. The Rust worker, however,
defines AppStarted as a configuration-only struct and reuses it for
app-extended-heartbeat, so dependencies and integrations are not included
in the heartbeat payload.

The ExtendedHeartbeat handler does call unflush_stored() on all three
collectors, evidently with the intent of re-emitting the full state.
Because the heartbeat payload omits the re-queued dependencies and
integrations and app_started_sent_success only pops configurations from
unflushed, the re-queued items remain in unflushed and are sent on the
next FlushData as a duplicate app-integrations-change /
app-dependencies-loaded.

Updating the shared AppStarted struct, build_app_started, and
app_started_sent_success addresses both Lifecycle(Start) and
Lifecycle(ExtendedHeartbeat) call sites.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cataphract

libdd-telemetry/src/data/payloads.rs

@@ -48,6 +48,8 @@ pub enum ConfigurationOrigin {
 #[derive(Serialize, Debug)]
 pub struct AppStarted {
     pub configuration: Vec<Configuration>,
+    pub dependencies: Vec<Dependency>,
+    pub integrations: Vec<Integration>,
 }
 
 #[derive(Serialize, Debug)]

libdd-telemetry/src/worker/mod.rs

@@ -673,13 +673,21 @@ impl TelemetryWorker {
     fn build_app_started(&mut self) -> data::AppStarted {
         data::AppStarted {
             configuration: self.data.configurations.unflushed().cloned().collect(),
+            dependencies: self.data.dependencies.unflushed().cloned().collect(),
+            integrations: self.data.integrations.unflushed().cloned().collect(),
         }
     }
 
     fn app_started_sent_success(&mut self, p: &data::AppStarted) {
         self.data
             .configurations
             .removed_flushed(p.configuration.len());
+        self.data
+            .dependencies
+            .removed_flushed(p.dependencies.len());
+        self.data
+            .integrations
+            .removed_flushed(p.integrations.len());
     }
 
     fn payload_sent_success(&mut self, payload: &data::Payload) {