enhancement(api top): show "disabled" in Memory Used when allocation tracing is off (#25138)

* enhancement(vector top): show "disabled" in Memory Used when allocation tracing is off

Add GetAllocationTracingStatus gRPC endpoint that reports whether
the connected Vector instance has --allocation-tracing active.
vector-top queries this on startup and shows "disabled" in the
Memory Used column when tracing is off, instead of misleading zeros.

Changes:
- proto: add GetAllocationTracingStatus RPC and messages
- service.rs: implement the endpoint using is_allocation_tracing_enabled()
- client.rs: add get_allocation_tracing_status() method
- metrics.rs: query the endpoint on startup, store result in State
- state.rs: add allocation_tracing_active field to State
- dashboard.rs: show "disabled" when allocation_tracing_active is false

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

* chore: add changelog fragment for Memory Used disabled label

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

* add authors

* fix(api): guard allocation tracing RPC behind cfg feature flag

The `get_allocation_tracing_status` RPC handler unconditionally called
`is_allocation_tracing_enabled()`, which only exists behind the
`allocation-tracing` feature gate. This broke builds on feature sets
that lack it (e.g. `default-msvc`). Add cfg guards so the handler
returns `false` when the feature is absent.

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

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: pront

changelog.d/vector_top_disabled_memory_used.enhancement.md

@@ -0,0 +1,3 @@
+`vector top` terminal UI now shows `disabled` in the Memory Used column when the connected Vector instance was not started with `--allocation-tracing`, instead of displaying misleading zeros. A new `GetAllocationTracingStatus` gRPC endpoint is queried on connect to determine the status.
+
+authors: pront

lib/vector-api-client/src/client.rs

@@ -5,6 +5,7 @@ use tonic::transport::{Channel, Endpoint};
 use crate::{
     error::{Error, Result},
     proto::{
+        GetAllocationTracingStatusRequest, GetAllocationTracingStatusResponse,
         GetComponentsRequest, GetComponentsResponse, GetMetaRequest, GetMetaResponse,
         HealthRequest, HealthResponse, MetricName, StreamComponentAllocatedBytesRequest,
         StreamComponentAllocatedBytesResponse, StreamComponentMetricsRequest,
@@ -77,6 +78,17 @@ impl Client {
         Ok(response.into_inner())
     }
 
+    /// Check whether allocation tracing is active on the connected Vector instance
+    pub async fn get_allocation_tracing_status(
+        &mut self,
+    ) -> Result<GetAllocationTracingStatusResponse> {
+        let client = self.ensure_connected()?;
+        let response = client
+            .get_allocation_tracing_status(GetAllocationTracingStatusRequest {})
+            .await?;
+        Ok(response.into_inner())
+    }
+
     // ========== Streaming RPCs ==========
 
     /// Stream periodic heartbeat timestamps

lib/vector-top/src/dashboard.rs

@@ -349,7 +349,11 @@ impl<'a> Widgets<'a> {
                     self.human_metrics,
                 ),
                 #[cfg(feature = "allocation-tracing")]
-                r.allocated_bytes.human_format_bytes(),
+                if state.allocation_tracing_active {
+                    r.allocated_bytes.human_format_bytes()
+                } else {
+                    "disabled".to_string()
+                },
                 if self.human_metrics {
                     r.errors.human_format()
                 } else {

lib/vector-top/src/metrics.rs

@@ -569,5 +569,21 @@ pub async fn init_components(
         })
         .collect::<BTreeMap<_, _>>();
 
-    Ok(state::State::new(rows))
+    let mut state = state::State::new(rows);
+
+    #[cfg(feature = "allocation-tracing")]
+    {
+        // Allocation tracing is a compile-time + startup-time setting on the
+        // server, so querying once per connection is sufficient. On error
+        // (e.g. older server without this RPC) we default to false, matching
+        // pre-existing behavior. This is re-evaluated on every reconnect via
+        // the retry loop in `subscription()`.
+        state.allocation_tracing_active = client
+            .get_allocation_tracing_status()
+            .await
+            .map(|r| r.enabled)
+            .unwrap_or(false);
+    }
+
+    Ok(state)
 }

lib/vector-top/src/state.rs

@@ -122,6 +122,10 @@ pub struct State {
     pub sort_state: SortState,
     pub filter_state: FilterState,
     pub ui: UiState,
+    /// Set to `true` once we receive the first `AllocatedBytes` event,
+    /// indicating the connected Vector instance has allocation tracing active.
+    #[cfg(feature = "allocation-tracing")]
+    pub allocation_tracing_active: bool,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -343,6 +347,8 @@ impl State {
             ui: UiState::default(),
             sort_state: SortState::default(),
             filter_state: FilterState::default(),
+            #[cfg(feature = "allocation-tracing")]
+            allocation_tracing_active: false,
         }
     }
 

proto/vector/observability.proto

@@ -17,6 +17,9 @@ service ObservabilityService {
   // Get information about configured components (sources, transforms, sinks)
   rpc GetComponents(GetComponentsRequest) returns (GetComponentsResponse);
 
+  // Check whether allocation tracing is active on this instance
+  rpc GetAllocationTracingStatus(GetAllocationTracingStatusRequest) returns (GetAllocationTracingStatusResponse);
+
   // ========== Real-time Metric Streams ==========
   // All streaming RPCs send periodic updates at the specified interval
 
@@ -54,6 +57,12 @@ message GetMetaResponse {
   string hostname = 2;
 }
 
+message GetAllocationTracingStatusRequest {}
+
+message GetAllocationTracingStatusResponse {
+  bool enabled = 1;
+}
+
 // ========== Component Messages ==========
 
 message GetComponentsRequest {

src/api/grpc/service.rs

@@ -436,6 +436,19 @@ impl observability::Service for ObservabilityService {
         Ok(Response::new(GetMetaResponse { version, hostname }))
     }
 
+    async fn get_allocation_tracing_status(
+        &self,
+        _request: Request<GetAllocationTracingStatusRequest>,
+    ) -> Result<Response<GetAllocationTracingStatusResponse>, Status> {
+        #[cfg(feature = "allocation-tracing")]
+        let enabled = crate::internal_telemetry::allocations::is_allocation_tracing_enabled();
+        #[cfg(not(feature = "allocation-tracing"))]
+        let enabled = false;
+        Ok(Response::new(GetAllocationTracingStatusResponse {
+            enabled,
+        }))
+    }
+
     async fn get_components(
         &self,
         request: Request<GetComponentsRequest>,