UKM Sync Observer

components/ukm/ukm_service.cc

 // Copyright 2017 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/ukm/ukm_service.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 51 matching lines @@
 const size_t kMaxSources = 100;
 
 std::string GetServerUrl() {
   std::string server_url =
       variations::GetVariationParamValueByFeature(kUkmFeature, "ServerUrl");
   if (!server_url.empty())
     return server_url;
   return kDefaultServerUrl;
 }
 
+// Generates a new client id and stores it in prefs.
+uint64_t GenerateClientId(PrefService* pref_service) {
+  uint64_t client_id = 0;
+  while (!client_id)
+    client_id = base::RandUint64();
+  pref_service->SetInt64(prefs::kUkmClientId, client_id);
+  return client_id;
+}
+
 uint64_t LoadOrGenerateClientId(PrefService* pref_service) {
   uint64_t client_id = pref_service->GetInt64(prefs::kUkmClientId);
   if (!client_id) {

[Alexei Svitkine (slow), 2017/02/04 00:52:23]

Nit: No {}

[Steven Holte, 2017/02/06 21:57:54]

Done.

-    // Generate and store a new client id.
-    while (!client_id)
-      client_id = base::RandUint64();
-    pref_service->SetInt64(prefs::kUkmClientId, client_id);
+    client_id = GenerateClientId(pref_service);
   }
   return client_id;
 }
 
+enum class DroppedSourceReason {
+  NOT_DROPPED = 0,
+  RECORDING_DISABLED = 1,
+  MAX_SOURCES_HIT = 2,
+  NUM_DROPPED_SOURCES_REASONS
+};
+
+void RecordDroppedSource(DroppedSourceReason reason) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "UKM.Sources.Dropped", static_cast<int>(reason),
+      static_cast<int>(DroppedSourceReason::NUM_DROPPED_SOURCES_REASONS));
+}
+
 }  // namespace
 
 const base::Feature kUkmFeature = {"Ukm", base::FEATURE_DISABLED_BY_DEFAULT};
 
 UkmService::UkmService(PrefService* pref_service,
                        metrics::MetricsServiceClient* client)
     : pref_service_(pref_service),
+      recording_enabled_(false),
       client_(client),
       persisted_logs_(std::unique_ptr<ukm::PersistedLogsMetricsImpl>(
                           new ukm::PersistedLogsMetricsImpl()),
                       pref_service,
                       prefs::kUkmPersistedLogs,
                       kMinPersistedLogs,
                       kMinPersistedBytes,
                       kMaxLogRetransmitSize),
       initialize_started_(false),
       initialize_complete_(false),
@@ skipping 24 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::Initialize";
   initialize_started_ = true;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&UkmService::StartInitTask, self_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
 }
 
+void UkmService::EnableRecording() {
+  recording_enabled_ = true;
+}
+
+void UkmService::DisableRecording() {
+  recording_enabled_ = false;
+}
+
 void UkmService::EnableReporting() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::EnableReporting";
   if (!initialize_started_)
     Initialize();
   scheduler_->Start();
 }
 
 void UkmService::DisableReporting() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::DisableReporting";
   scheduler_->Stop();
   Flush();
 }
 
 void UkmService::Flush() {
   if (initialize_complete_)
     BuildAndStoreLog();
   persisted_logs_.SerializeLogs();
 }
 
 void UkmService::Purge() {
   DVLOG(1) << "UkmService::Purge";
   persisted_logs_.Purge();
   sources_.clear();
 }
 
+void UkmService::ResetClientId() {
+  client_id_ = GenerateClientId(pref_service_);
+}
+
 // static
 void UkmService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kUkmClientId, 0);
   registry->RegisterListPref(prefs::kUkmPersistedLogs);
 }
 
 void UkmService::StartInitTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::StartInitTask";
   client_id_ = LoadOrGenerateClientId(pref_service_);
@@ skipping 14 matching lines @@
   DVLOG(1) << "UkmService::RotateLog";
   if (persisted_logs_.empty()) {
     BuildAndStoreLog();
   }
   StartScheduledUpload();
 }
 
 void UkmService::BuildAndStoreLog() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::BuildAndStoreLog";
+  // Suppress generating a log if we have no new data to include.
+  if (sources_.empty())
+    return;
+
   Report report;
   report.set_client_id(client_id_);
 
   for (const auto& source : sources_) {
     Source* proto_source = report.add_sources();
     source->PopulateProto(proto_source);
   }
   UMA_HISTOGRAM_COUNTS_1000("UKM.Sources.SerializedCount", sources_.size());
   sources_.clear();
 
@@ skipping 50 matching lines @@
     persisted_logs_.SerializeLogs();
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code == 400;
   scheduler_->UploadFinished(server_is_healthy, !persisted_logs_.empty());
 }
 
 void UkmService::RecordSource(std::unique_ptr<UkmSource> source) {
+  if (!recording_enabled_) {
+    RecordDroppedSource(DroppedSourceReason::RECORDING_DISABLED);
+    return;
+  }
   if (sources_.size() >= kMaxSources) {
-    UMA_HISTOGRAM_BOOLEAN("UKM.Sources.MaxSourcesHit", true);
+    RecordDroppedSource(DroppedSourceReason::MAX_SOURCES_HIT);
     return;
   }
 
   sources_.push_back(std::move(source));
 }
 
 }  // namespace ukm