1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "components/rappor/rappor_service.h"
6
7 #include "base/base64.h"
8 #include "base/metrics/field_trial.h"
9 #include "base/prefs/pref_registry_simple.h"
10 #include "base/prefs/pref_service.h"
11 #include "base/rand_util.h"
12 #include "base/stl_util.h"
13 #include "base/time/time.h"
14 #include "components/metrics/metrics_hashes.h"
15 #include "components/rappor/log_uploader.h"
16 #include "components/rappor/proto/rappor_metric.pb.h"
17 #include "components/rappor/rappor_metric.h"
18 #include "components/rappor/rappor_pref_names.h"
19 #include "components/variations/variations_associated_data.h"
20
21 namespace rappor {
22
23 namespace {
24
25 // Seconds before the initial log is generated.
26 const int kInitialLogIntervalSeconds = 15;
27 // Interval between ongoing logs.
28 const int kLogIntervalSeconds = 30 * 60;
29
30 const char kMimeType[] = "application/vnd.chrome.rappor";
31
32 // Constants for the RAPPOR rollout field trial.
33 const char kRapporRolloutFieldTrialName[] = "RapporRollout";
34
35 // Constant for the finch parameter name for the server URL
36 const char kRapporRolloutServerUrlParam[] = "ServerUrl";
37
GetServerUrl()38 GURL GetServerUrl() {
39 return GURL(chrome_variations::GetVariationParamValue(
40 kRapporRolloutFieldTrialName,
41 kRapporRolloutServerUrlParam));
42 }
43
44 const RapporParameters kRapporParametersForType[NUM_RAPPOR_TYPES] = {
45 // ETLD_PLUS_ONE_RAPPOR_TYPE
46 {128 /* Num cohorts */,
47 16 /* Bloom filter size bytes */,
48 2 /* Bloom filter hash count */,
49 rappor::PROBABILITY_50 /* Fake data probability */,
50 rappor::PROBABILITY_50 /* Fake one probability */,
51 rappor::PROBABILITY_75 /* One coin probability */,
52 rappor::PROBABILITY_25 /* Zero coin probability */},
53 };
54
55 } // namespace
56
RapporService()57 RapporService::RapporService() : cohort_(-1) {}
58
~RapporService()59 RapporService::~RapporService() {
60 STLDeleteValues(&metrics_map_);
61 }
62
Start(PrefService * pref_service,net::URLRequestContextGetter * request_context)63 void RapporService::Start(PrefService* pref_service,
64 net::URLRequestContextGetter* request_context) {
65 const GURL server_url = GetServerUrl();
66 if (!server_url.is_valid())
67 return;
68 DCHECK(!uploader_);
69 LoadSecret(pref_service);
70 LoadCohort(pref_service);
71 uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
72 log_rotation_timer_.Start(
73 FROM_HERE,
74 base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
75 this,
76 &RapporService::OnLogInterval);
77 }
78
OnLogInterval()79 void RapporService::OnLogInterval() {
80 DCHECK(uploader_);
81 RapporReports reports;
82 if (ExportMetrics(&reports)) {
83 std::string log_text;
84 bool success = reports.SerializeToString(&log_text);
85 DCHECK(success);
86 uploader_->QueueLog(log_text);
87 }
88 log_rotation_timer_.Start(FROM_HERE,
89 base::TimeDelta::FromSeconds(kLogIntervalSeconds),
90 this,
91 &RapporService::OnLogInterval);
92 }
93
94 // static
RegisterPrefs(PrefRegistrySimple * registry)95 void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
96 registry->RegisterStringPref(prefs::kRapporSecret, std::string());
97 registry->RegisterIntegerPref(prefs::kRapporCohortDeprecated, -1);
98 registry->RegisterIntegerPref(prefs::kRapporCohortSeed, -1);
99 }
100
LoadCohort(PrefService * pref_service)101 void RapporService::LoadCohort(PrefService* pref_service) {
102 DCHECK(!IsInitialized());
103 // Ignore and delete old cohort parameter.
104 pref_service->ClearPref(prefs::kRapporCohortDeprecated);
105
106 cohort_ = pref_service->GetInteger(prefs::kRapporCohortSeed);
107 // If the user is already assigned to a valid cohort, we're done.
108 if (cohort_ >= 0 && cohort_ < RapporParameters::kMaxCohorts)
109 return;
110
111 // This is the first time the client has started the service (or their
112 // preferences were corrupted). Randomly assign them to a cohort.
113 cohort_ = base::RandGenerator(RapporParameters::kMaxCohorts);
114 pref_service->SetInteger(prefs::kRapporCohortSeed, cohort_);
115 }
116
LoadSecret(PrefService * pref_service)117 void RapporService::LoadSecret(PrefService* pref_service) {
118 DCHECK(secret_.empty());
119 std::string secret_base64 = pref_service->GetString(prefs::kRapporSecret);
120 if (!secret_base64.empty()) {
121 bool decoded = base::Base64Decode(secret_base64, &secret_);
122 if (decoded && secret_.size() == HmacByteVectorGenerator::kEntropyInputSize)
123 return;
124 // If the preference fails to decode, or is the wrong size, it must be
125 // corrupt, so continue as though it didn't exist yet and generate a new
126 // one.
127 }
128
129 secret_ = HmacByteVectorGenerator::GenerateEntropyInput();
130 base::Base64Encode(secret_, &secret_base64);
131 pref_service->SetString(prefs::kRapporSecret, secret_base64);
132 }
133
ExportMetrics(RapporReports * reports)134 bool RapporService::ExportMetrics(RapporReports* reports) {
135 if (metrics_map_.empty())
136 return false;
137
138 DCHECK_GE(cohort_, 0);
139 reports->set_cohort(cohort_);
140
141 for (std::map<std::string, RapporMetric*>::const_iterator it =
142 metrics_map_.begin();
143 it != metrics_map_.end();
144 ++it) {
145 const RapporMetric* metric = it->second;
146 RapporReports::Report* report = reports->add_report();
147 report->set_name_hash(metrics::HashMetricName(it->first));
148 ByteVector bytes = metric->GetReport(secret_);
149 report->set_bits(std::string(bytes.begin(), bytes.end()));
150 }
151 STLDeleteValues(&metrics_map_);
152 return true;
153 }
154
IsInitialized() const155 bool RapporService::IsInitialized() const {
156 return cohort_ >= 0;
157 }
158
RecordSample(const std::string & metric_name,RapporType type,const std::string & sample)159 void RapporService::RecordSample(const std::string& metric_name,
160 RapporType type,
161 const std::string& sample) {
162 // Ignore the sample if the service hasn't started yet.
163 if (!IsInitialized())
164 return;
165 DCHECK_LT(type, NUM_RAPPOR_TYPES);
166 RecordSampleInternal(metric_name, kRapporParametersForType[type], sample);
167 }
168
RecordSampleInternal(const std::string & metric_name,const RapporParameters & parameters,const std::string & sample)169 void RapporService::RecordSampleInternal(const std::string& metric_name,
170 const RapporParameters& parameters,
171 const std::string& sample) {
172 DCHECK(IsInitialized());
173 RapporMetric* metric = LookUpMetric(metric_name, parameters);
174 metric->AddSample(sample);
175 }
176
LookUpMetric(const std::string & metric_name,const RapporParameters & parameters)177 RapporMetric* RapporService::LookUpMetric(const std::string& metric_name,
178 const RapporParameters& parameters) {
179 DCHECK(IsInitialized());
180 std::map<std::string, RapporMetric*>::const_iterator it =
181 metrics_map_.find(metric_name);
182 if (it != metrics_map_.end()) {
183 RapporMetric* metric = it->second;
184 DCHECK_EQ(parameters.ToString(), metric->parameters().ToString());
185 return metric;
186 }
187
188 RapporMetric* new_metric = new RapporMetric(metric_name, parameters, cohort_);
189 metrics_map_[metric_name] = new_metric;
190 return new_metric;
191 }
192
193 } // namespace rappor
194