Populate metrics fields with gathered data

cjreynol · cjreynol · commit 0125d9cd0c9b · 2025-10-10T00:19:31.000Z
Also, convert the `event_type` parameters to an enum, to simplify
conversion.

Bug:449821767
diff --git a/base/cvd/cuttlefish/host/libs/metrics/BUILD.bazel b/base/cvd/cuttlefish/host/libs/metrics/BUILD.bazel
@@ -4,6 +4,16 @@ package(
     default_visibility = ["//:android_cuttlefish"],
 )
 
+cf_cc_library(
+    name = "event_type",
+    srcs = [
+        "event_type.cc",
+    ],
+    hdrs = [
+        "event_type.h",
+    ],
+)
+
 cf_cc_library(
     name = "metrics",
     srcs = [
@@ -51,10 +61,14 @@ cf_cc_library(
         "//cuttlefish/host/commands/metrics:events",
         "//cuttlefish/host/commands/metrics:send",
         "//cuttlefish/host/commands/metrics:utils",
+        "//cuttlefish/host/libs/metrics:event_type",
         "//cuttlefish/host/libs/metrics:metrics_headers",
         "//cuttlefish/host/libs/metrics:metrics_writer",
         "//cuttlefish/host/libs/metrics:session_id",
+        "//external_proto:cf_guest_cc_proto",
+        "//external_proto:cf_host_cc_proto",
         "//external_proto:cf_log_cc_proto",
+        "//external_proto:cf_metrics_event_v2_cc_proto",
         "//external_proto:clientanalytics_cc_proto",
         "//libbase",
         "@fmt",
@@ -75,6 +89,7 @@ cf_cc_library(
         "//cuttlefish/common/libs/utils:host_info",
         "//cuttlefish/common/libs/utils:random",
         "//cuttlefish/common/libs/utils:result",
+        "//cuttlefish/host/libs/metrics:event_type",
         "@fmt",
     ],
 )
diff --git a/base/cvd/cuttlefish/host/libs/metrics/event_type.cc b/base/cvd/cuttlefish/host/libs/metrics/event_type.cc
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cuttlefish/host/libs/metrics/event_type.h"
+
+#include <string>
+
+namespace cuttlefish {
+
+std::string EventTypeString(EventType event_type) {
+  switch (event_type) {
+    case EventType::DeviceInstantiation:
+      return "device_instantiation";
+    case EventType::DeviceBootStart:
+      return "device_boot_start";
+    case EventType::DeviceBootComplete:
+      return "device_boot_complete";
+    case EventType::DeviceStop:
+      return "device_stop";
+  }
+}
+
+}  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/libs/metrics/event_type.h b/base/cvd/cuttlefish/host/libs/metrics/event_type.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace cuttlefish {
+
+enum class EventType {
+  DeviceInstantiation,
+  DeviceBootStart,
+  DeviceBootComplete,
+  DeviceStop,
+};
+
+std::string EventTypeString(EventType event_type);
+
+}  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/libs/metrics/metrics_orchestration.cc b/base/cvd/cuttlefish/host/libs/metrics/metrics_orchestration.cc
@@ -31,16 +31,25 @@
 #include "cuttlefish/host/commands/metrics/events.h"
 #include "cuttlefish/host/commands/metrics/send.h"
 #include "cuttlefish/host/commands/metrics/utils.h"
+#include "cuttlefish/host/libs/metrics/event_type.h"
 #include "cuttlefish/host/libs/metrics/metrics_defs.h"
 #include "cuttlefish/host/libs/metrics/metrics_writer.h"
 #include "cuttlefish/host/libs/metrics/session_id.h"
+#include "external_proto/cf_guest.pb.h"
+#include "external_proto/cf_host.pb.h"
 #include "external_proto/cf_log.pb.h"
+#include "external_proto/cf_metrics_event_v2.pb.h"
 #include "external_proto/clientanalytics.pb.h"
 
 namespace cuttlefish {
 namespace {
 
 using logs::proto::wireless::android::cuttlefish::CuttlefishLogEvent;
+using logs::proto::wireless::android::cuttlefish::events::CuttlefishGuest;
+using logs::proto::wireless::android::cuttlefish::events::CuttlefishGuest_EventType;
+using logs::proto::wireless::android::cuttlefish::events::CuttlefishHost;
+using logs::proto::wireless::android::cuttlefish::events::CuttlefishHost_OsType;
+using logs::proto::wireless::android::cuttlefish::events::MetricsEventV2;
 using wireless_android_play_playlog::LogEvent;
 using wireless_android_play_playlog::LogRequest;
 
@@ -64,10 +73,72 @@ Result<void> SetUpMetrics(const std::string& metrics_directory) {
   return {};
 }
 
-Result<void> TransmitMetrics() {
+CuttlefishGuest_EventType ConvertEventType(EventType event_type) {
+  switch (event_type) {
+    case EventType::DeviceInstantiation:
+      return CuttlefishGuest_EventType::
+          CuttlefishGuest_EventType_CUTTLEFISH_GUEST_EVENT_TYPE_VM_INSTANTIATION;
+    case EventType::DeviceBootStart:
+      return CuttlefishGuest_EventType::
+          CuttlefishGuest_EventType_CUTTLEFISH_GUEST_EVENT_TYPE_UNSPECIFIED;
+    case EventType::DeviceBootComplete:
+      return CuttlefishGuest_EventType::
+          CuttlefishGuest_EventType_CUTTLEFISH_GUEST_EVENT_TYPE_DEVICE_BOOT_COMPLETED;
+    case EventType::DeviceStop:
+      return CuttlefishGuest_EventType::
+          CuttlefishGuest_EventType_CUTTLEFISH_GUEST_EVENT_TYPE_VM_STOP;
+  }
+}
+
+CuttlefishHost_OsType ConvertHostOs(const HostInfo& host_info) {
+  switch (host_info.os) {
+    case Os::Unknown:
+      return CuttlefishHost_OsType::
+          CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_UNSPECIFIED;
+    case Os::Linux:
+      switch (host_info.arch) {
+        case Arch::Arm:
+          return CuttlefishHost_OsType::
+              CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_LINUX_AARCH32;
+        case Arch::Arm64:
+          return CuttlefishHost_OsType::
+              CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_LINUX_AARCH64;
+        case Arch::RiscV64:
+          return CuttlefishHost_OsType::
+              CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_LINUX_RISCV64;
+        case Arch::X86:
+          return CuttlefishHost_OsType::
+              CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_LINUX_X86;
+        case Arch::X86_64:
+          return CuttlefishHost_OsType::
+              CuttlefishHost_OsType_CUTTLEFISH_HOST_OS_TYPE_LINUX_X86_64;
+      }
+  }
+}
+
+// TODO: chadreynolds - move this logic into a separate file dedicated to
+// conversion logic
+void PopulateMetricsEvent(EventType event_type,
+                          CuttlefishLogEvent& cf_log_event,
+                          const HostInfo& host_metrics,
+                          std::string_view session_id) {
+  cf_log_event.set_session_id(session_id);
+  MetricsEventV2* metrics_event = cf_log_event.mutable_metrics_event_v2();
+
+  CuttlefishGuest* guest = metrics_event->add_guest();
+  guest->set_event_type(ConvertEventType(event_type));
+  guest->set_guest_id(std::string(session_id) + "1");
+
+  CuttlefishHost* host = metrics_event->mutable_host();
+  host->set_host_os(ConvertHostOs(host_metrics));
+  host->set_host_os_version(host_metrics.release);
+}
+
+Result<void> TransmitMetrics(EventType event_type, const HostInfo& host_metrics,
+                             std::string_view session_id) {
   uint64_t now_ms = metrics::GetEpochTimeMs();
   CuttlefishLogEvent cf_log_event = metrics::BuildCfLogEvent(now_ms);
-  cf_log_event.mutable_metrics_event_v2();
+  PopulateMetricsEvent(event_type, cf_log_event, host_metrics, session_id);
   LogEvent log_event = metrics::BuildLogEvent(now_ms, cf_log_event);
   LogRequest log_request =
       metrics::BuildLogRequest(now_ms, std::move(log_event));
@@ -78,11 +149,11 @@ Result<void> TransmitMetrics() {
   return {};
 }
 
-Result<void> GatherAndWriteMetrics(std::string_view event_type,
+Result<void> GatherAndWriteMetrics(EventType event_type,
                                    const std::string& metrics_directory) {
   const std::string session_id =
       CF_EXPECT(ReadSessionIdFile(metrics_directory));
-  HostInfo host_metrics = GetHostInfo();
+  const HostInfo host_metrics = GetHostInfo();
   // TODO: chadreynolds - gather the rest of the data (guest/flag information)
   // TODO: chadreynolds - convert data to the proto representation
   CF_EXPECT(WriteMetricsEvent(event_type, metrics_directory, session_id,
@@ -91,13 +162,12 @@ Result<void> GatherAndWriteMetrics(std::string_view event_type,
     LOG(INFO) << "This will automatically send diagnostic information to "
                  "Google, such as crash reports and usage data from the host "
                  "machine managing the Android Virtual Device.";
-    CF_EXPECT(TransmitMetrics());
+    CF_EXPECT(TransmitMetrics(event_type, host_metrics, session_id));
   }
   return {};
 }
 
-void RunMetrics(const std::string& metrics_directory,
-                std::string_view event_type) {
+void RunMetrics(const std::string& metrics_directory, EventType event_type) {
   if (!FileExists(metrics_directory)) {
     LOG(INFO) << "Metrics directory does not exist, perhaps metrics were not "
                  "initialized.";
@@ -107,7 +177,7 @@ void RunMetrics(const std::string& metrics_directory,
       GatherAndWriteMetrics(event_type, metrics_directory);
   if (!event_result.ok()) {
     LOG(INFO) << fmt::format("Failed to gather metrics for {}.  Error: {}",
-                             event_type, event_result.error());
+                             EventTypeString(event_type), event_result.error());
   }
 }
 
@@ -123,25 +193,25 @@ void GatherVmInstantiationMetrics(const LocalInstanceGroup& instance_group) {
                               metrics_setup_result.error());
     return;
   }
-  RunMetrics(metrics_directory, "device instantiation");
+  RunMetrics(metrics_directory, EventType::DeviceInstantiation);
 }
 
 void GatherVmStartMetrics(const LocalInstanceGroup& instance_group) {
   const std::string metrics_directory =
       GetMetricsDirectoryFilepath(instance_group);
-  RunMetrics(metrics_directory, "device start");
+  RunMetrics(metrics_directory, EventType::DeviceBootStart);
 }
 
 void GatherVmBootCompleteMetrics(const LocalInstanceGroup& instance_group) {
   const std::string metrics_directory =
       GetMetricsDirectoryFilepath(instance_group);
-  RunMetrics(metrics_directory, "device boot complete");
+  RunMetrics(metrics_directory, EventType::DeviceBootComplete);
 }
 
 void GatherVmStopMetrics(const LocalInstanceGroup& instance_group) {
   const std::string metrics_directory =
       GetMetricsDirectoryFilepath(instance_group);
-  RunMetrics(metrics_directory, "device stop");
+  RunMetrics(metrics_directory, EventType::DeviceStop);
 }
 
 }  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/libs/metrics/metrics_writer.cc b/base/cvd/cuttlefish/host/libs/metrics/metrics_writer.cc
@@ -26,6 +26,7 @@
 #include "cuttlefish/common/libs/utils/host_info.h"
 #include "cuttlefish/common/libs/utils/random.h"
 #include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/metrics/event_type.h"
 
 namespace cuttlefish {
 namespace {
@@ -37,12 +38,12 @@ std::string GenerateFilenameSuffix() {
 
 }  // namespace
 
-Result<void> WriteMetricsEvent(std::string_view event_type,
+Result<void> WriteMetricsEvent(EventType event_type,
                                const std::string& metrics_directory,
                                std::string_view session_id,
                                const HostInfo& host_metrics) {
   const std::string event_filepath =
-      fmt::format("{}/{}_{}_{}", metrics_directory, event_type,
+      fmt::format("{}/{}_{}_{}", metrics_directory, EventTypeString(event_type),
                   std::chrono::system_clock::now(), GenerateFilenameSuffix());
   // TODO: chadreynolds - convert (what will be a proto) to text
   CF_EXPECT(WriteNewFile(
diff --git a/base/cvd/cuttlefish/host/libs/metrics/metrics_writer.h b/base/cvd/cuttlefish/host/libs/metrics/metrics_writer.h
@@ -21,11 +21,11 @@
 
 #include "cuttlefish/common/libs/utils/host_info.h"
 #include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/metrics/event_type.h"
 
 namespace cuttlefish {
 
-// TODO: chadreynolds - add support for more fields than HostInfo
-Result<void> WriteMetricsEvent(std::string_view event_type,
+Result<void> WriteMetricsEvent(EventType event_type,
                                const std::string& metrics_directory,
                                std::string_view session_id,
                                const HostInfo& host_metrics);
