Define a few simple UMA metrics for the component updater.

components/component_updater/component_updater_service.cc

 // 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 "components/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
+#include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/component_updater/component_updater_service_internal.h"
 #include "components/component_updater/timer.h"
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 using CrxInstaller = update_client::CrxInstaller;
@@ skipping 192 matching lines @@
     if (delta < base::TimeDelta::FromSeconds(config_->OnDemandDelay()))
       return false;
   }
 
   return OnDemandUpdateInternal(id);
 }
 
 bool CrxUpdateService::OnDemandUpdateInternal(const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.Calls.Count", 0, 2);
+
   update_client_->Install(
       id, base::Bind(&CrxUpdateService::OnUpdate, base::Unretained(this)),
-      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this)));
+      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this),
+                 base::TimeTicks::Now()));
 
   return true;
 }
 
 bool CrxUpdateService::CheckForUpdates() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.Calls.Count", 1, 2);

[Ilya Sherman, 2016/03/09 20:13:50]

nit: I'd recommend defining a C++ enum, and emitting named values like
"UPDATE_TYPE_MANUAL" and "UPDATE_TYPE_AUTOMATED", and replacing "2" with
"UPDATE_TYPE_COUNT".

[Ilya Sherman, 2016/03/09 20:13:50]

nit: I'd recommend having a wrapper function around the
UMA_HISTOGRAM_ENUMERATION macro, so that you only need to write the
"ComponentUpdater.Calls.Count" string in one place, and therefore it's harder to
typo the string in one code path and not the other.

[Sorin Jianu, 2016/03/09 22:26:21]

Done.

[Sorin Jianu, 2016/03/09 22:26:21]

Acknowledged.

+
   std::vector<std::string> ids;
   for (const auto id : components_order_) {
     DCHECK(components_.find(id) != components_.end());
     ids.push_back(id);
   }
 
   update_client_->Update(
       ids, base::Bind(&CrxUpdateService::OnUpdate, base::Unretained(this)),
-      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this)));
+      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this),
+                 base::TimeTicks::Now()));
 
   return true;
 }
 
 scoped_refptr<base::SequencedTaskRunner>
 CrxUpdateService::GetSequencedTaskRunner() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return blocking_task_runner_;
 }
 
@@ skipping 23 matching lines @@
   DCHECK(components->empty());
 
   for (const auto& id : ids) {
     const auto registered_component(GetComponent(id));
     if (registered_component) {
       components->push_back(*registered_component);
     }
   }
 }
 
-void CrxUpdateService::OnUpdateComplete(int error) {
+void CrxUpdateService::OnUpdateComplete(const base::TimeTicks& start_time,
+                                        int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update completed with error " << error;
 
+  UMA_HISTOGRAM_BOOLEAN("ComponentUpdater.UpdateCompleteResult", error != 0);
+  UMA_HISTOGRAM_TIMES("ComponentUpdater.UpdateCompleteTime",
+                      base::TimeTicks::Now() - start_time);
+
   for (const auto id : components_pending_unregistration_) {
     if (!update_client_->IsUpdating(id)) {
       const auto component = GetComponent(id);
       if (component)
         DoUnregisterComponent(*component);
     }
   }
 }
 
 void CrxUpdateService::OnEvent(Events event, const std::string& id) {
@@ skipping 35 matching lines @@
 // TODO(sorin): consider making this a singleton.
 scoped_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   auto update_client = update_client::UpdateClientFactory(config);
   return scoped_ptr<ComponentUpdateService>(
       new CrxUpdateService(config, std::move(update_client)));
 }
 
 }  // namespace component_updater