Include instance_id from the instance database

Preferring the user or `cvd` identifiers rather than generating
sequential numbers.

Bug: 450049144

Author: cjreynol

base/cvd/cuttlefish/host/libs/metrics/guest_metrics.cc

@@ -31,25 +31,23 @@ constexpr char kAvbtool[] = "avbtool";
 
 }  // namespace
 
-Result<std::vector<GuestInfo>> GetGuestInfo(const GuestPaths& guest_paths) {
-  std::vector<GuestInfo> result;
-  result.reserve(guest_paths.artifacts.size());
-  int i = 1;
+Result<std::vector<GuestMetrics>> GetGuestMetrics(const Guests& guests) {
+  std::vector<GuestMetrics> result;
+  result.reserve(guests.guest_infos.size());
 
-  for (const std::string& artifact_path : guest_paths.artifacts) {
+  for (const GuestInfo& guest : guests.guest_infos) {
     const std::string boot_image_path =
-        fmt::format("{}/boot.img", artifact_path);
+        fmt::format("{}/boot.img", guest.product_out);
     const std::string avbtool_path =
-        fmt::format("{}/bin/{}", guest_paths.host_artifacts, kAvbtool);
-    result.emplace_back(GuestInfo{
-        .instance_number = i,
+        fmt::format("{}/bin/{}", guests.host_artifacts, kAvbtool);
+    result.emplace_back(GuestMetrics{
+        .instance_id = guest.instance_id,
         .os_version = CF_EXPECTF(
             ReadAndroidVersionFromBootImage(boot_image_path, avbtool_path),
             "Failed to read guest os version from \"{}\" using `{}` at "
             "\"{}\".",
             boot_image_path, kAvbtool, avbtool_path),
     });
-    i++;
   }
   return result;
 }

base/cvd/cuttlefish/host/libs/metrics/guest_metrics.h

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -24,16 +25,21 @@
 
 namespace cuttlefish {
 
-struct GuestPaths {
+struct GuestInfo {
+  uint32_t instance_id;
+  std::string product_out;
+};
+
+struct Guests {
   std::string host_artifacts;
-  std::vector<std::string> artifacts;
+  std::vector<GuestInfo> guest_infos;
 };
 
-struct GuestInfo {
-  int instance_number;
+struct GuestMetrics {
+  uint32_t instance_id;
   std::string os_version;
 };
 
-Result<std::vector<GuestInfo>> GetGuestInfo(const GuestPaths& guest_paths);
+Result<std::vector<GuestMetrics>> GetGuestMetrics(const Guests& guests);
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.cc

@@ -104,11 +104,11 @@ CuttlefishLogEvent BuildCuttlefishLogEvent(const MetricsData& metrics_data) {
 
   MetricsEventV2& metrics_event = *cf_log_event.mutable_metrics_event_v2();
 
-  for (const GuestInfo& guest_info : metrics_data.guest_metrics) {
+  for (const GuestMetrics& guest_info : metrics_data.guest_metrics) {
     CuttlefishGuest& guest = *metrics_event.add_guest();
     guest.set_event_type(ConvertEventType(metrics_data.event_type));
-    guest.set_guest_id(fmt::format("{}-{}", metrics_data.session_id,
-                                   guest_info.instance_number));
+    guest.set_guest_id(
+        fmt::format("{}-{}", metrics_data.session_id, guest_info.instance_id));
     guest.set_guest_os_version(guest_info.os_version);
   }
 

base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.h

@@ -33,7 +33,7 @@ struct MetricsData {
   std::string cf_common_version;
   std::chrono::milliseconds now;
   HostInfo host_metrics;
-  std::vector<GuestInfo> guest_metrics;
+  std::vector<GuestMetrics> guest_metrics;
 };
 
 wireless_android_play_playlog::LogRequest ConstructLogRequest(

base/cvd/cuttlefish/host/libs/metrics/metrics_orchestration.cc

@@ -31,6 +31,7 @@
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/common/libs/utils/tee_logging.h"
 #include "cuttlefish/host/commands/cvd/instances/instance_group_record.h"
+#include "cuttlefish/host/commands/cvd/instances/instance_record.h"
 #include "cuttlefish/host/commands/cvd/metrics/is_enabled.h"
 #include "cuttlefish/host/commands/cvd/version/version.h"
 #include "cuttlefish/host/libs/metrics/event_type.h"
@@ -58,37 +59,44 @@ constexpr char kReadmeText[] =
 
 struct MetricsPaths {
   std::string metrics_directory;
-  GuestPaths guest_paths;
+  Guests guests;
 };
 
 std::chrono::milliseconds GetEpochTime() {
   auto now = std::chrono::system_clock::now().time_since_epoch();
   return std::chrono::duration_cast<std::chrono::milliseconds>(now);
 }
 
-// use as many ProductOut values are available, then pad with the first value up
-// to the number of instances
-std::vector<std::string> GetProductOutPaths(
-    const std::string& group_product_out, const int instance_count) {
-  std::vector<std::string> result =
+std::vector<GuestInfo> GetGuestInfos(
+    const std::string& group_product_out,
+    const std::vector<LocalInstance>& instances) {
+  std::vector<GuestInfo> result;
+
+  // Split always returns at least one element
+  std::vector<std::string> product_out_paths =
       android::base::Split(group_product_out, ",");
-  if (!result.empty() && result.size() < instance_count) {
-    for (int i = result.size(); i < instance_count; i++) {
-      result.emplace_back(result.front());
+  for (int i = 0; i < instances.size(); i++) {
+    auto guest = GuestInfo{
+        .instance_id = instances[i].id(),
+    };
+    if (product_out_paths.size() > i) {
+      guest.product_out = product_out_paths[i];
+    } else {  // pad with the first value
+      guest.product_out = product_out_paths.front();
     }
+    result.emplace_back(guest);
   }
   return result;
 }
 
 MetricsPaths GetMetricsPaths(const LocalInstanceGroup& instance_group) {
   return MetricsPaths{
       .metrics_directory = instance_group.MetricsDir(),
-      .guest_paths =
-          GuestPaths{
+      .guests =
+          Guests{
               .host_artifacts = instance_group.HostArtifactsPath(),
-              .artifacts =
-                  GetProductOutPaths(instance_group.ProductOutPath(),
-                                     instance_group.Instances().size()),
+              .guest_infos = GetGuestInfos(instance_group.ProductOutPath(),
+                                           instance_group.Instances()),
           },
   };
 }
@@ -110,7 +118,7 @@ Result<MetricsData> GatherMetrics(const MetricsPaths& metrics_paths,
       .cf_common_version = GetVersionIds().ToString(),
       .now = GetEpochTime(),
       .host_metrics = GetHostInfo(),
-      .guest_metrics = CF_EXPECT(GetGuestInfo(metrics_paths.guest_paths)),
+      .guest_metrics = CF_EXPECT(GetGuestMetrics(metrics_paths.guests)),
   };
 }