Introduce Diagnostics TelemetryLog

The Diagnostics TelemetryLog class is used to cache the most recent info
fetched by SystemDataProvider.

Bug: 1128204
Change-Id: I9ea328921be4316a2d57920d3aa8d0e4291f14d2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626077Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Commit-Queue: Bailey Berro <baileyberro@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843635}

chromeos/components/diagnostics_ui/backend/BUILD.gn

@@ -22,6 +22,8 @@ static_library("backend") {
     "system_data_provider.h",
     "system_routine_controller.cc",
     "system_routine_controller.h",
+    "telemetry_log.cc",
+    "telemetry_log.h",
   ]
 
   deps = [
@@ -46,6 +48,7 @@ source_set("unit_tests") {
     "routine_log_unittest.cc",
     "system_data_provider_unittest.cc",
     "system_routine_controller_unittest.cc",
+    "telemetry_log_unittest.cc",
   ]
 
   deps = [

chromeos/components/diagnostics_ui/backend/telemetry_log.cc

+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chromeos/components/diagnostics_ui/backend/telemetry_log.h"
+
+#include <sstream>
+#include <utility>
+
+namespace chromeos {
+namespace diagnostics {
+namespace {
+
+const char kNewline[] = "\n";
+
+// SystemInfo constants:
+const char kSystemInfoSectionName[] = "--- System Info ---";
+const char kSystemInfoBoardNameTitle[] = "Board Name: ";
+const char kSystemInfoMarketingNameTitle[] = "Marketing Name: ";
+const char kSystemInfoCpuModelNameTitle[] = "CpuModel Name: ";
+const char kSystemInfoTotalMemoryTitle[] = "Total Memory (kib): ";
+const char kSystemInfoCpuThreadCountTitle[] = "Thread Count:  ";
+const char kSystemInfoCpuMaxClockSpeedTitle[] = "Cpu Max Clock Speed (kHz):  ";
+const char kSystemInfoMilestoneVersionTitle[] = "Milestone Version: ";
+const char kSystemInfoHasBatteryTitle[] = "Has Battery: ";
+
+// BatteryChargeStatus constants:
+const char kBatteryChargeStatusSectionName[] = "--- Battery Charge Status ---";
+const char kBatteryChargeStatusBatteryStateTitle[] = "Battery State: ";
+const char kBatteryChargeStatusPowerSourceTitle[] = "Power Source: ";
+const char kBatteryChargeStatusPowerTimeTitle[] = "Power Time: ";
+const char kBatteryChargeStatusCurrentNowTitle[] = "Current Now (mA): ";
+const char kBatteryChargeStatusChargeNowTitle[] = "Chage Now (mAh): ";
+
+// BatteryHealth constants:
+const char kBatteryHealthSectionName[] = "--- Battery Health ---";
+const char kBatteryHealthChargeFullNowTitle[] = "Charge Full Now (mAh): ";
+const char kBatteryHealthChargeFullDesignTitle[] = "Charge Full Design (mAh): ";
+const char kBatteryHealthCycleCountTitle[] = "Cycle Count: ";
+const char kBatteryHealthWearPercentageTitle[] = "Wear Percentage: ";
+
+// MemoryUsage constants:
+const char kMemoryUsageSectionName[] = "--- Memory Usage ---";
+const char kMemoryUsageTotalMemoryTitle[] = "Total Memory (kib): ";
+const char kMemoryUsageAvailableMemoryTitle[] = "Available Memory (kib): ";
+const char kMemoryUsageFreeMemoryTitle[] = "Free Memory (kib): ";
+
+// CpuUsage constants:
+const char kCpuUsageSectionName[] = "--- Cpu Usage ---";
+const char kCpuUsageUserTitle[] = "Usage User: ";
+const char kCpuUsageSystemTitle[] = "Usage System: ";
+const char kCpuUsageFreeTitle[] = "Usage Free: ";
+const char kCpuUsageAvgTempTitle[] = "Avg Temp (C): ";
+const char kCpuUsageScalingFrequencyTitle[] =
+    "Current scaled frequency (kHz): ";
+
+}  // namespace
+
+TelemetryLog::TelemetryLog() = default;
+TelemetryLog::~TelemetryLog() = default;
+
+void TelemetryLog::UpdateSystemInfo(mojom::SystemInfoPtr latest_system_info) {
+  latest_system_info_ = std::move(latest_system_info);
+}
+
+void TelemetryLog::UpdateBatteryChargeStatus(
+    mojom::BatteryChargeStatusPtr latest_battery_charge_status) {
+  latest_battery_charge_status_ = std::move(latest_battery_charge_status);
+}
+
+void TelemetryLog::UpdateBatteryHealth(
+    mojom::BatteryHealthPtr latest_battery_health) {
+  latest_battery_health_ = std::move(latest_battery_health);
+}
+
+void TelemetryLog::UpdateMemoryUsage(
+    mojom::MemoryUsagePtr latest_memory_usage) {
+  latest_memory_usage_ = std::move(latest_memory_usage);
+}
+
+void TelemetryLog::UpdateCpuUsage(mojom::CpuUsagePtr latest_cpu_usage) {
+  latest_cpu_usage_ = std::move(latest_cpu_usage);
+}
+
+std::string TelemetryLog::GetTelemetryLog() const {
+  std::stringstream output;
+  if (latest_system_info_) {
+    output << kSystemInfoSectionName << kNewline << kSystemInfoBoardNameTitle
+           << latest_system_info_->board_name << kNewline
+           << kSystemInfoMarketingNameTitle
+           << latest_system_info_->marketing_name << kNewline
+           << kSystemInfoCpuModelNameTitle
+           << latest_system_info_->cpu_model_name << kNewline
+           << kSystemInfoTotalMemoryTitle
+           << latest_system_info_->total_memory_kib << kNewline
+           << kSystemInfoCpuThreadCountTitle
+           << latest_system_info_->cpu_threads_count << kNewline
+           << kSystemInfoCpuMaxClockSpeedTitle
+           << latest_system_info_->cpu_max_clock_speed_khz << kNewline
+           << kSystemInfoMilestoneVersionTitle
+           << latest_system_info_->version_info->milestone_version << kNewline
+           << kSystemInfoHasBatteryTitle
+           << latest_system_info_->device_capabilities->has_battery << kNewline
+           << kNewline;
+  }
+  if (latest_battery_charge_status_) {
+    output << kBatteryChargeStatusSectionName << kNewline
+           << kBatteryChargeStatusBatteryStateTitle
+           << latest_battery_charge_status_->battery_state << kNewline
+           << kBatteryChargeStatusPowerSourceTitle
+           << latest_battery_charge_status_->power_adapter_status << kNewline
+           << kBatteryChargeStatusPowerTimeTitle
+           << latest_battery_charge_status_->power_time << kNewline
+           << kBatteryChargeStatusCurrentNowTitle
+           << latest_battery_charge_status_->current_now_milliamps << kNewline
+           << kBatteryChargeStatusChargeNowTitle
+           << latest_battery_charge_status_->charge_now_milliamp_hours
+           << kNewline << kNewline;
+  }
+  if (latest_battery_health_) {
+    output << kBatteryHealthSectionName << kNewline
+           << kBatteryHealthChargeFullNowTitle
+           << latest_battery_health_->charge_full_now_milliamp_hours << kNewline
+           << kBatteryHealthChargeFullDesignTitle
+           << latest_battery_health_->charge_full_design_milliamp_hours
+           << kNewline << kBatteryHealthCycleCountTitle
+           << latest_battery_health_->cycle_count << kNewline
+           << kBatteryHealthWearPercentageTitle
+           << latest_battery_health_->battery_wear_percentage << kNewline
+           << kNewline;
+  }
+  if (latest_memory_usage_) {
+    output << kMemoryUsageSectionName << kNewline
+           << kMemoryUsageTotalMemoryTitle
+           << latest_memory_usage_->total_memory_kib << kNewline
+           << kMemoryUsageAvailableMemoryTitle
+           << latest_memory_usage_->available_memory_kib << kNewline
+           << kMemoryUsageFreeMemoryTitle
+           << latest_memory_usage_->free_memory_kib << kNewline << kNewline;
+  }
+  if (latest_cpu_usage_) {
+    output << kCpuUsageSectionName << kNewline << kCpuUsageUserTitle
+           << latest_cpu_usage_->percent_usage_user << kNewline
+           << kCpuUsageSystemTitle << latest_cpu_usage_->percent_usage_system
+           << kNewline << kCpuUsageFreeTitle
+           << latest_cpu_usage_->percent_usage_free << kNewline
+           << kCpuUsageAvgTempTitle
+           << latest_cpu_usage_->average_cpu_temp_celsius << kNewline
+           << kCpuUsageScalingFrequencyTitle
+           << latest_cpu_usage_->scaling_current_frequency_khz << kNewline
+           << kNewline;
+  }
+
+  return output.str();
+}
+
+}  // namespace diagnostics
+}  // namespace chromeos

chromeos/components/diagnostics_ui/backend/telemetry_log.h

+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROMEOS_COMPONENTS_DIAGNOSTICS_UI_BACKEND_TELEMETRY_LOG_H_
+#define CHROMEOS_COMPONENTS_DIAGNOSTICS_UI_BACKEND_TELEMETRY_LOG_H_
+
+#include <string>
+
+#include "chromeos/components/diagnostics_ui/mojom/system_data_provider.mojom.h"
+
+namespace chromeos {
+namespace diagnostics {
+
+class TelemetryLog {
+ public:
+  TelemetryLog();
+  ~TelemetryLog();
+
+  TelemetryLog(const TelemetryLog&) = delete;
+  TelemetryLog& operator=(const TelemetryLog&) = delete;
+
+  void UpdateSystemInfo(mojom::SystemInfoPtr latest_system_info);
+  void UpdateBatteryChargeStatus(
+      mojom::BatteryChargeStatusPtr latest_battery_charge_status);
+  void UpdateBatteryHealth(mojom::BatteryHealthPtr latest_battery_health);
+  void UpdateMemoryUsage(mojom::MemoryUsagePtr latest_memory_usage);
+  void UpdateCpuUsage(mojom::CpuUsagePtr latest_cpu_usage);
+
+  // Returns the telemetry log as a string.
+  std::string GetTelemetryLog() const;
+
+ private:
+  mojom::SystemInfoPtr latest_system_info_;
+  mojom::BatteryChargeStatusPtr latest_battery_charge_status_;
+  mojom::BatteryHealthPtr latest_battery_health_;
+  mojom::MemoryUsagePtr latest_memory_usage_;
+  mojom::CpuUsagePtr latest_cpu_usage_;
+};
+
+}  // namespace diagnostics
+}  // namespace chromeos
+
+#endif  // CHROMEOS_COMPONENTS_DIAGNOSTICS_UI_BACKEND_TELEMETRY_LOG_H_

chromeos/components/diagnostics_ui/backend/telemetry_log_unittest.cc

+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chromeos/components/diagnostics_ui/backend/telemetry_log.h"
+
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "chromeos/components/diagnostics_ui/mojom/system_data_provider.mojom.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace diagnostics {
+namespace {
+
+const char kNewline[] = "\n";
+
+mojom::SystemInfoPtr CreateSystemInfoPtr(const std::string& board_name,
+                                         const std::string& marketing_name,
+                                         const std::string& cpu_model,
+                                         uint32_t total_memory_kib,
+                                         uint16_t cpu_threads_count,
+                                         uint32_t cpu_max_clock_speed_khz,
+                                         bool has_battery,
+                                         const std::string& milestone_version) {
+  auto version_info = mojom::VersionInfo::New(milestone_version);
+  auto device_capabilities = mojom::DeviceCapabilities::New(has_battery);
+
+  auto system_info = mojom::SystemInfo::New(
+      board_name, marketing_name, cpu_model, total_memory_kib,
+      cpu_threads_count, cpu_max_clock_speed_khz, std::move(version_info),
+      std::move(device_capabilities));
+  return system_info;
+}
+
+// Returns the lines of the log as a vector of strings.
+std::vector<std::string> GetLogLines(const std::string& log) {
+  return base::SplitString(log, kNewline,
+                           base::WhitespaceHandling::TRIM_WHITESPACE,
+                           base::SplitResult::SPLIT_WANT_NONEMPTY);
+}
+
+}  // namespace
+
+class TelemetryLogTest : public testing::Test {
+ public:
+  TelemetryLogTest() = default;
+
+  ~TelemetryLogTest() override = default;
+};
+
+TEST_F(TelemetryLogTest, DetailedLogContents) {
+  const std::string expected_board_name = "board_name";
+  const std::string expected_marketing_name = "marketing_name";
+  const std::string expected_cpu_model = "cpu_model";
+  const uint32_t expected_total_memory_kib = 1234;
+  const uint16_t expected_cpu_threads_count = 5678;
+  const uint32_t expected_cpu_max_clock_speed_khz = 91011;
+  const bool expected_has_battery = true;
+  const std::string expected_milestone_version = "M99";
+
+  mojom::SystemInfoPtr test_info = CreateSystemInfoPtr(
+      expected_board_name, expected_marketing_name, expected_cpu_model,
+      expected_total_memory_kib, expected_cpu_threads_count,
+      expected_cpu_max_clock_speed_khz, expected_has_battery,
+      expected_milestone_version);
+
+  TelemetryLog log;
+
+  log.UpdateSystemInfo(test_info.Clone());
+
+  const std::string log_as_string = log.GetTelemetryLog();
+  const std::vector<std::string> log_lines = GetLogLines(log_as_string);
+
+  // Expect one title line and 8 content lines.
+  EXPECT_EQ(9u, log_lines.size());
+
+  EXPECT_EQ("Board Name: " + expected_board_name, log_lines[1]);
+  EXPECT_EQ("Marketing Name: " + expected_marketing_name, log_lines[2]);
+  EXPECT_EQ("CpuModel Name: " + expected_cpu_model, log_lines[3]);
+  EXPECT_EQ(
+      "Total Memory (kib): " + base::NumberToString(expected_total_memory_kib),
+      log_lines[4]);
+  EXPECT_EQ(
+      "Thread Count:  " + base::NumberToString(expected_cpu_threads_count),
+      log_lines[5]);
+  EXPECT_EQ("Cpu Max Clock Speed (kHz):  " +
+                base::NumberToString(expected_cpu_max_clock_speed_khz),
+            log_lines[6]);
+  EXPECT_EQ("Milestone Version: " + expected_milestone_version, log_lines[7]);
+  EXPECT_EQ("Has Battery: " + base::NumberToString(expected_has_battery),
+            log_lines[8]);
+}
+
+TEST_F(TelemetryLogTest, ChangeContents) {
+  const std::string expected_board_name = "board_name";
+  const std::string expected_marketing_name = "marketing_name";
+  const std::string expected_cpu_model = "cpu_model";
+  const uint32_t expected_total_memory_kib = 1234;
+  const uint16_t expected_cpu_threads_count = 5678;
+  const uint32_t expected_cpu_max_clock_speed_khz = 91011;
+  const bool expected_has_battery = true;
+  const std::string expected_milestone_version = "M99";
+
+  mojom::SystemInfoPtr test_info = CreateSystemInfoPtr(
+      expected_board_name, expected_marketing_name, expected_cpu_model,
+      expected_total_memory_kib, expected_cpu_threads_count,
+      expected_cpu_max_clock_speed_khz, expected_has_battery,
+      expected_milestone_version);
+
+  TelemetryLog log;
+
+  log.UpdateSystemInfo(test_info.Clone());
+
+  test_info->board_name = "new board_name";
+
+  log.UpdateSystemInfo(test_info.Clone());
+
+  const std::string log_as_string = log.GetTelemetryLog();
+  const std::vector<std::string> log_lines = GetLogLines(log_as_string);
+
+  EXPECT_EQ("Board Name: new board_name", log_lines[1]);
+}
+
+}  // namespace diagnostics
+}  // namespace chromeos