feat: add build info for flow heartbeat task (#4228)

* chore: refactor load region stats

* feat: add build info for flow heartbeat

src/flow/Cargo.toml

@@ -26,6 +26,7 @@ common-recordbatch.workspace = true
 common-runtime.workspace = true
 common-telemetry.workspace = true
 common-time.workspace = true
+common-version.workspace = true
 datafusion.workspace = true
 datafusion-common.workspace = true
 datafusion-expr.workspace = true

src/flow/src/heartbeat.rs

@@ -24,6 +24,7 @@ use common_meta::heartbeat::handler::{
 use common_meta::heartbeat::mailbox::{HeartbeatMailbox, MailboxRef, OutgoingMessage};
 use common_meta::heartbeat::utils::outgoing_message_to_mailbox_message;
 use common_telemetry::{debug, error, info};
+use greptime_proto::v1::meta::NodeInfo;
 use meta_client::client::{HeartbeatSender, HeartbeatStream, MetaClient};
 use servers::addrs;
 use servers::heartbeat_options::HeartbeatOptions;
@@ -43,6 +44,7 @@ pub struct HeartbeatTask {
     report_interval: Duration,
     retry_interval: Duration,
     resp_handler_executor: HeartbeatResponseHandlerExecutorRef,
+    start_time_ms: u64,
 }
 
 impl HeartbeatTask {
@@ -59,6 +61,7 @@ impl HeartbeatTask {
             report_interval: heartbeat_opts.interval,
             retry_interval: heartbeat_opts.retry_interval,
             resp_handler_executor,
+            start_time_ms: common_time::util::current_time_millis() as u64,
         }
     }
 
@@ -84,23 +87,34 @@ impl HeartbeatTask {
     }
 
     fn create_heartbeat_request(
-        message: OutgoingMessage,
-        self_peer: &Option<Peer>,
+        message: Option<OutgoingMessage>,
+        peer: Option<Peer>,
+        start_time_ms: u64,
     ) -> Option<HeartbeatRequest> {
-        match outgoing_message_to_mailbox_message(message) {
-            Ok(message) => {
-                let req = HeartbeatRequest {
-                    mailbox_message: Some(message),
-                    peer: self_peer.clone(),
-                    ..Default::default()
-                };
-                Some(req)
-            }
-            Err(e) => {
+        let mailbox_message = match message.map(outgoing_message_to_mailbox_message) {
+            Some(Ok(message)) => Some(message),
+            Some(Err(e)) => {
                 error!(e; "Failed to encode mailbox messages");
-                None
+                return None;
             }
-        }
+            None => None,
+        };
+
+        Some(HeartbeatRequest {
+            mailbox_message,
+            peer,
+            info: Self::build_node_info(start_time_ms),
+            ..Default::default()
+        })
+    }
+
+    fn build_node_info(start_time_ms: u64) -> Option<NodeInfo> {
+        let build_info = common_version::build_info();
+        Some(NodeInfo {
+            version: build_info.version.to_string(),
+            git_commit: build_info.commit_short.to_string(),
+            start_time_ms,
+        })
     }
 
     fn start_heartbeat_report(
@@ -109,6 +123,7 @@ impl HeartbeatTask {
         mut outgoing_rx: mpsc::Receiver<OutgoingMessage>,
     ) {
         let report_interval = self.report_interval;
+        let start_time_ms = self.start_time_ms;
         let self_peer = Some(Peer {
             id: self.node_id,
             addr: self.peer_addr.clone(),
@@ -124,18 +139,14 @@ impl HeartbeatTask {
                 let req = tokio::select! {
                     message = outgoing_rx.recv() => {
                         if let Some(message) = message {
-                            Self::create_heartbeat_request(message, &self_peer)
+                            Self::create_heartbeat_request(Some(message), self_peer.clone(), start_time_ms)
                         } else {
                             // Receives None that means Sender was dropped, we need to break the current loop
                             break
                         }
                     }
                     _ = interval.tick() => {
-                        let req = HeartbeatRequest {
-                            peer: self_peer.clone(),
-                            ..Default::default()
-                        };
-                        Some(req)
+                        Self::create_heartbeat_request(None, self_peer.clone(), start_time_ms)
                     }
                 };