Introduce ProfilerMetricsProvider

chrome/browser/metrics/profiler_metrics_provider.cc

Index: chrome/browser/metrics/profiler_metrics_provider.cc
diff --git a/chrome/browser/metrics/profiler_metrics_provider.cc b/chrome/browser/metrics/profiler_metrics_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2845d6ed7c305840d17ac35535da81f286ba790a
--- /dev/null
+++ b/chrome/browser/metrics/profiler_metrics_provider.cc
@@ -0,0 +1,157 @@
+// Copyright 2014 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 "chrome/browser/metrics/profiler_metrics_provider.h"
+
+#include <ctype.h>
+#include <vector>
+
+#include "base/tracked_objects.h"
+#include "components/metrics/metrics_log_base.h"
+#include "components/nacl/common/nacl_process_type.h"
+#include "content/public/common/process_type.h"
+
+using metrics::MetricsLogBase;
+using metrics::ProfilerEventProto;
+using tracked_objects::ProcessDataSnapshot;
+
+namespace {
+
+ProfilerEventProto::TrackedObject::ProcessType AsProtobufProcessType(
+    int process_type) {
+  switch (process_type) {
+    case content::PROCESS_TYPE_BROWSER:
+      return ProfilerEventProto::TrackedObject::BROWSER;
+    case content::PROCESS_TYPE_RENDERER:
+      return ProfilerEventProto::TrackedObject::RENDERER;
+    case content::PROCESS_TYPE_PLUGIN:
+      return ProfilerEventProto::TrackedObject::PLUGIN;
+    case content::PROCESS_TYPE_WORKER:
+      return ProfilerEventProto::TrackedObject::WORKER;
+    case content::PROCESS_TYPE_UTILITY:
+      return ProfilerEventProto::TrackedObject::UTILITY;
+    case content::PROCESS_TYPE_ZYGOTE:
+      return ProfilerEventProto::TrackedObject::ZYGOTE;
+    case content::PROCESS_TYPE_SANDBOX_HELPER:
+      return ProfilerEventProto::TrackedObject::SANDBOX_HELPER;
+    case content::PROCESS_TYPE_GPU:
+      return ProfilerEventProto::TrackedObject::GPU;
+    case content::PROCESS_TYPE_PPAPI_PLUGIN:
+      return ProfilerEventProto::TrackedObject::PPAPI_PLUGIN;
+    case content::PROCESS_TYPE_PPAPI_BROKER:
+      return ProfilerEventProto::TrackedObject::PPAPI_BROKER;
+    case PROCESS_TYPE_NACL_LOADER:
+      return ProfilerEventProto::TrackedObject::NACL_LOADER;
+    case PROCESS_TYPE_NACL_BROKER:
+      return ProfilerEventProto::TrackedObject::NACL_BROKER;
+    default:
+      NOTREACHED();
+      return ProfilerEventProto::TrackedObject::UNKNOWN;
+  }
+}
+
+// Maps a thread name by replacing trailing sequence of digits with "*".
+// Examples:
+// 1. "BrowserBlockingWorker1/23857" => "BrowserBlockingWorker1/*"
+// 2. "Chrome_IOThread" => "Chrome_IOThread"
+std::string MapThreadName(const std::string& thread_name) {
+  size_t i = thread_name.length();
+
+  while (i > 0 && isdigit(thread_name[i - 1])) {
+    --i;
+  }
+
+  if (i == thread_name.length())
+    return thread_name;
+
+  return thread_name.substr(0, i) + '*';
+}
+
+// Normalizes a source filename (which is platform- and build-method-dependent)
+// by extracting the last component of the full file name.
+// Example: "c:\b\build\slave\win\build\src\chrome\app\chrome_main.cc" =>
+// "chrome_main.cc".
+std::string NormalizeFileName(const std::string& file_name) {
+  const size_t offset = file_name.find_last_of("\\/");
+  return offset != std::string::npos ? file_name.substr(offset + 1) : file_name;
+}
+
+void WriteProfilerData(const ProcessDataSnapshot& profiler_data,
+                       int process_type,
+                       ProfilerEventProto* performance_profile) {
+  for (std::vector<tracked_objects::TaskSnapshot>::const_iterator it =
+           profiler_data.tasks.begin();
+       it != profiler_data.tasks.end();
+       ++it) {
+    const tracked_objects::DeathDataSnapshot& death_data = it->death_data;
+    ProfilerEventProto::TrackedObject* tracked_object =
+        performance_profile->add_tracked_object();
+    tracked_object->set_birth_thread_name_hash(
+        MetricsLogBase::Hash(MapThreadName(it->birth.thread_name)));
+    tracked_object->set_exec_thread_name_hash(
+        MetricsLogBase::Hash(MapThreadName(it->death_thread_name)));
+    tracked_object->set_source_file_name_hash(
+        MetricsLogBase::Hash(NormalizeFileName(it->birth.location.file_name)));
+    tracked_object->set_source_function_name_hash(
+        MetricsLogBase::Hash(it->birth.location.function_name));
+    tracked_object->set_source_line_number(it->birth.location.line_number);
+    tracked_object->set_exec_count(death_data.count);
+    tracked_object->set_exec_time_total(death_data.run_duration_sum);
+    tracked_object->set_exec_time_sampled(death_data.run_duration_sample);
+    tracked_object->set_queue_time_total(death_data.queue_duration_sum);
+    tracked_object->set_queue_time_sampled(death_data.queue_duration_sample);
+    tracked_object->set_process_type(AsProtobufProcessType(process_type));
+    tracked_object->set_process_id(profiler_data.process_id);
+  }
+}
+
+}  // namespace
+
+ProfilerMetricsProvider::ProfilerMetricsProvider() {
+}
+
+ProfilerMetricsProvider::~ProfilerMetricsProvider() {
+}
+
+void ProfilerMetricsProvider::ProvideGeneralMetrics(
+    metrics::ChromeUserMetricsExtension* uma_proto) {
+  if (tracked_objects::GetTimeSourceType() !=
+      tracked_objects::TIME_SOURCE_TYPE_WALL_TIME) {
+    // We currently only support the default time source, wall clock time.
+    return;
+  }
+
+  ProfilerEventProto* profile;
+  if (!uma_proto->profiler_event_size()) {
+    // For the first process's data, add a new field to the protocol buffer.
+    profile = uma_proto->add_profiler_event();
+    profile->set_profile_type(ProfilerEventProto::STARTUP_PROFILE);
+    profile->set_time_source(ProfilerEventProto::WALL_CLOCK_TIME);
+  } else {
+    // For the remaining calls, re-use the existing field.
+    profile = uma_proto->mutable_profiler_event(0);
+  }
+
+  // Note that |profile| might already contain data, so it's important to do a
+  // merge rather than an overwrite here.

[Alexei Svitkine (slow), 2014/06/02 15:17:06]

I don't agree with this comment.

I don't think there would be a case where there's existing profiler data on the
log. In the previous code, this is being done in
MetricsLog::RecordProfilerData() - which may be called multiple times for the
same log - hence this comment would have applied. But with the MetricsProvider,
there will be only one ProvideGeneralMetrics() call per log, so there shouldn't
be any existing profiler data.

In fact, the if statement above should never hit the else in the current code.

I suggest restructuring the code to be as follows:

- Introduce a |bool has_profiler_data_| and set it to true when
RecordProfilerData() is called.
- Then, in this function, simply do:

if (has_profiler_data_) {
  profiler_event_cache_.set_profile_type(ProfilerEventProto::STARTUP_PROFILE);
  profiler_event_cache_.set_time_source(ProfilerEventProto::WALL_CLOCK_TIME);
  uma_proto->add_profiler_event()->Swap(&profiler_event_cache_);
  has_profiler_data_ = false;
}

This will also ensure that the root profiler event doesn't get added to UMA logs
that aren't the initial one (which I believe is a bug with your current code).

[blundell, 2014/06/02 19:56:44]

Aha, thanks for the expertise!
Done.

+  profile->MergeFrom(profiler_event_cache_);
+
+  // Clear the cache so that this data doesn't get propagated to any different
+  // log that later calls ProvideGeneralMetrics() (nb. that the data already
+  // written into the current log won't be lost if it makes another call to
+  // ProvideGeneralMetrics() since new data is always merged).
+  profiler_event_cache_.Clear();
+}
+
+void ProfilerMetricsProvider::RecordProfilerData(
+    const tracked_objects::ProcessDataSnapshot& process_data,
+    int process_type) {
+  if (tracked_objects::GetTimeSourceType() !=
+      tracked_objects::TIME_SOURCE_TYPE_WALL_TIME) {
+    // We currently only support the default time source, wall clock time.
+    return;
+  }
+
+  WriteProfilerData(process_data, process_type, &profiler_event_cache_);
+}