Home | History | Annotate | Download | only in rappor 
      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 const char kRapporDailyEventHistogram[] = "Rappor.DailyEvent.IntervalType";
     33 
     34 // Constants for the RAPPOR rollout field trial.
     35 const char kRapporRolloutFieldTrialName[] = "RapporRollout";
     36 
     37 // Constant for the finch parameter name for the server URL
     38 const char kRapporRolloutServerUrlParam[] = "ServerUrl";
     39 
     40 // Constant for the finch parameter name for the server URL
     41 const char kRapporRolloutRequireUmaParam[] = "RequireUma";
     42 
     43 // The rappor server's URL.
     44 const char kDefaultServerUrl[] = "https://clients4.google.com/rappor";
     45 
     46 GURL GetServerUrl(bool metrics_enabled) {
     47   bool require_uma = variations::GetVariationParamValue(
     48       kRapporRolloutFieldTrialName,
     49       kRapporRolloutRequireUmaParam) != "False";
     50   if (!metrics_enabled && require_uma)
     51     return GURL();  // Invalid URL disables Rappor.
     52   std::string server_url = variations::GetVariationParamValue(
     53       kRapporRolloutFieldTrialName,
     54       kRapporRolloutServerUrlParam);
     55   if (!server_url.empty())
     56     return GURL(server_url);
     57   else
     58     return GURL(kDefaultServerUrl);
     59 }
     60 
     61 const RapporParameters kRapporParametersForType[NUM_RAPPOR_TYPES] = {
     62     // ETLD_PLUS_ONE_RAPPOR_TYPE
     63     {128 /* Num cohorts */,
     64      16 /* Bloom filter size bytes */,
     65      2 /* Bloom filter hash count */,
     66      rappor::PROBABILITY_50 /* Fake data probability */,
     67      rappor::PROBABILITY_50 /* Fake one probability */,
     68      rappor::PROBABILITY_75 /* One coin probability */,
     69      rappor::PROBABILITY_25 /* Zero coin probability */},
     70 };
     71 
     72 }  // namespace
     73 
     74 RapporService::RapporService(PrefService* pref_service)
     75     : pref_service_(pref_service),
     76       cohort_(-1),
     77       daily_event_(pref_service,
     78                       prefs::kRapporLastDailySample,
     79                       kRapporDailyEventHistogram) {
     80 }
     81 
     82 RapporService::~RapporService() {
     83   STLDeleteValues(&metrics_map_);
     84 }
     85 
     86 void RapporService::AddDailyObserver(
     87     scoped_ptr<metrics::DailyEvent::Observer> observer) {
     88   daily_event_.AddObserver(observer.Pass());
     89 }
     90 
     91 void RapporService::Start(net::URLRequestContextGetter* request_context,
     92                           bool metrics_enabled) {
     93   const GURL server_url = GetServerUrl(metrics_enabled);
     94   if (!server_url.is_valid()) {
     95     DVLOG(1) << server_url.spec() << " is invalid. "
     96              << "RapporService not started.";
     97     return;
     98   }
     99   DVLOG(1) << "RapporService started. Reporting to " << server_url.spec();
    100   DCHECK(!uploader_);
    101   LoadSecret();
    102   LoadCohort();
    103   uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
    104   log_rotation_timer_.Start(
    105       FROM_HERE,
    106       base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
    107       this,
    108       &RapporService::OnLogInterval);
    109 }
    110 
    111 void RapporService::OnLogInterval() {
    112   DCHECK(uploader_);
    113   DVLOG(2) << "RapporService::OnLogInterval";
    114   daily_event_.CheckInterval();
    115   RapporReports reports;
    116   if (ExportMetrics(&reports)) {
    117     std::string log_text;
    118     bool success = reports.SerializeToString(&log_text);
    119     DCHECK(success);
    120     DVLOG(1) << "RapporService sending a report of "
    121              << reports.report_size() << " value(s).";
    122     uploader_->QueueLog(log_text);
    123   }
    124   log_rotation_timer_.Start(FROM_HERE,
    125                             base::TimeDelta::FromSeconds(kLogIntervalSeconds),
    126                             this,
    127                             &RapporService::OnLogInterval);
    128 }
    129 
    130 // static
    131 void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
    132   registry->RegisterStringPref(prefs::kRapporSecret, std::string());
    133   registry->RegisterIntegerPref(prefs::kRapporCohortDeprecated, -1);
    134   registry->RegisterIntegerPref(prefs::kRapporCohortSeed, -1);
    135   metrics::DailyEvent::RegisterPref(registry,
    136                                        prefs::kRapporLastDailySample);
    137 }
    138 
    139 void RapporService::LoadCohort() {
    140   DCHECK(!IsInitialized());
    141   // Ignore and delete old cohort parameter.
    142   pref_service_->ClearPref(prefs::kRapporCohortDeprecated);
    143 
    144   cohort_ = pref_service_->GetInteger(prefs::kRapporCohortSeed);
    145   // If the user is already assigned to a valid cohort, we're done.
    146   if (cohort_ >= 0 && cohort_ < RapporParameters::kMaxCohorts)
    147     return;
    148 
    149   // This is the first time the client has started the service (or their
    150   // preferences were corrupted).  Randomly assign them to a cohort.
    151   cohort_ = base::RandGenerator(RapporParameters::kMaxCohorts);
    152   DVLOG(2) << "Selected a new Rappor cohort: " << cohort_;
    153   pref_service_->SetInteger(prefs::kRapporCohortSeed, cohort_);
    154 }
    155 
    156 void RapporService::LoadSecret() {
    157   DCHECK(secret_.empty());
    158   std::string secret_base64 = pref_service_->GetString(prefs::kRapporSecret);
    159   if (!secret_base64.empty()) {
    160     bool decoded = base::Base64Decode(secret_base64, &secret_);
    161     if (decoded && secret_.size() == HmacByteVectorGenerator::kEntropyInputSize)
    162       return;
    163     // If the preference fails to decode, or is the wrong size, it must be
    164     // corrupt, so continue as though it didn't exist yet and generate a new
    165     // one.
    166   }
    167 
    168   DVLOG(2) << "Generated a new Rappor secret.";
    169   secret_ = HmacByteVectorGenerator::GenerateEntropyInput();
    170   base::Base64Encode(secret_, &secret_base64);
    171   pref_service_->SetString(prefs::kRapporSecret, secret_base64);
    172 }
    173 
    174 bool RapporService::ExportMetrics(RapporReports* reports) {
    175   if (metrics_map_.empty())
    176     return false;
    177 
    178   DCHECK_GE(cohort_, 0);
    179   reports->set_cohort(cohort_);
    180 
    181   for (std::map<std::string, RapporMetric*>::const_iterator it =
    182            metrics_map_.begin();
    183        it != metrics_map_.end();
    184        ++it) {
    185     const RapporMetric* metric = it->second;
    186     RapporReports::Report* report = reports->add_report();
    187     report->set_name_hash(metrics::HashMetricName(it->first));
    188     ByteVector bytes = metric->GetReport(secret_);
    189     report->set_bits(std::string(bytes.begin(), bytes.end()));
    190   }
    191   STLDeleteValues(&metrics_map_);
    192   return true;
    193 }
    194 
    195 bool RapporService::IsInitialized() const {
    196   return cohort_ >= 0;
    197 }
    198 
    199 void RapporService::RecordSample(const std::string& metric_name,
    200                                  RapporType type,
    201                                  const std::string& sample) {
    202   // Ignore the sample if the service hasn't started yet.
    203   if (!IsInitialized())
    204     return;
    205   DCHECK_LT(type, NUM_RAPPOR_TYPES);
    206   DVLOG(2) << "Recording sample \"" << sample
    207            << "\" for metric \"" << metric_name
    208            << "\" of type: " << type;
    209   RecordSampleInternal(metric_name, kRapporParametersForType[type], sample);
    210 }
    211 
    212 void RapporService::RecordSampleInternal(const std::string& metric_name,
    213                                          const RapporParameters& parameters,
    214                                          const std::string& sample) {
    215   DCHECK(IsInitialized());
    216   RapporMetric* metric = LookUpMetric(metric_name, parameters);
    217   metric->AddSample(sample);
    218 }
    219 
    220 RapporMetric* RapporService::LookUpMetric(const std::string& metric_name,
    221                                           const RapporParameters& parameters) {
    222   DCHECK(IsInitialized());
    223   std::map<std::string, RapporMetric*>::const_iterator it =
    224       metrics_map_.find(metric_name);
    225   if (it != metrics_map_.end()) {
    226     RapporMetric* metric = it->second;
    227     DCHECK_EQ(parameters.ToString(), metric->parameters().ToString());
    228     return metric;
    229   }
    230 
    231   RapporMetric* new_metric = new RapporMetric(metric_name, parameters, cohort_);
    232   metrics_map_[metric_name] = new_metric;
    233   return new_metric;
    234 }
    235 
    236 }  // namespace rappor
    237