components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.cc

   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/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/metrics/sparse_histogram.h"
  12 #include "base/prefs/pref_member.h"
  13 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/http/http_response_headers.h"
  16 #include "net/http/http_status_code.h"
  17 #include "net/proxy/proxy_retry_info.h"
  18 #include "net/proxy/proxy_server.h"
  19 #include "net/proxy/proxy_service.h"
  20 #include "net/url_request/url_request.h"
  21 #include "net/url_request/url_request_context.h"
  22
  23 using base::MessageLoopProxy;
  24 using net::HostPortPair;
  25 using net::ProxyServer;
  26 using net::ProxyService;
  27 using net::NetworkChangeNotifier;
  28 using net::URLRequest;
  29
  30 namespace data_reduction_proxy {
  31
  32 namespace {
  33
  34 const int kMinFailedRequestsWhenUnavailable = 1;
  35 const int kMaxSuccessfulRequestsWhenUnavailable = 0;
  36 const int kMaxFailedRequestsBeforeReset = 3;
  37
  38 // Records a net error code that resulted in bypassing the data reduction
  39 // proxy (|is_primary| is true) or the data reduction proxy fallback.
  40 void RecordDataReductionProxyBypassOnNetworkError(
  41     bool is_primary,
  42     const ProxyServer& proxy_server,
  43     int net_error) {
  44   if (is_primary) {
  45     UMA_HISTOGRAM_SPARSE_SLOWLY(
  46         "DataReductionProxy.BypassOnNetworkErrorPrimary",
  47         std::abs(net_error));
  48     return;
  49   }
  50   UMA_HISTOGRAM_SPARSE_SLOWLY(
  51       "DataReductionProxy.BypassOnNetworkErrorFallback",
  52       std::abs(net_error));
  53 }
  54
  55 }  // namespace
  56
  57 // static
  58 void DataReductionProxyUsageStats::RecordDataReductionProxyBypassInfo(
  59     bool is_primary,
  60     bool bypass_all,
  61     const net::ProxyServer& proxy_server,
  62     DataReductionProxyBypassType bypass_type) {
  63   if (bypass_all) {
  64     if (is_primary) {
  65       UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BlockTypePrimary",
  66                                 bypass_type, BYPASS_EVENT_TYPE_MAX);
  67     } else {
  68       UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BlockTypeFallback",
  69                                 bypass_type, BYPASS_EVENT_TYPE_MAX);
  70     }
  71   } else {
  72     if (is_primary) {
  73       UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BypassTypePrimary",
  74                                 bypass_type, BYPASS_EVENT_TYPE_MAX);
  75     } else {
  76       UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BypassTypeFallback",
  77                                 bypass_type, BYPASS_EVENT_TYPE_MAX);
  78     }
  79   }
  80 }
  81
  82 // static
  83 void DataReductionProxyUsageStats::DetectAndRecordMissingViaHeaderResponseCode(
  84       bool is_primary,
  85       const net::HttpResponseHeaders* headers) {
  86   if (HasDataReductionProxyViaHeader(headers, NULL)) {
  87     // The data reduction proxy via header is present, so don't record anything.
  88     return;
  89   }
  90
  91   if (is_primary) {
  92     UMA_HISTOGRAM_SPARSE_SLOWLY(
  93         "DataReductionProxy.MissingViaHeader.ResponseCode.Primary",
  94         headers->response_code());
  95   } else {
  96     UMA_HISTOGRAM_SPARSE_SLOWLY(
  97         "DataReductionProxy.MissingViaHeader.ResponseCode.Fallback",
  98         headers->response_code());
  99   }
 100 }
 101
 102 DataReductionProxyUsageStats::DataReductionProxyUsageStats(
 103     DataReductionProxyParams* params,
 104     const scoped_refptr<MessageLoopProxy>& ui_thread_proxy)
 105     : data_reduction_proxy_params_(params),
 106       last_bypass_type_(BYPASS_EVENT_TYPE_MAX),
 107       triggering_request_(true),
 108       ui_thread_proxy_(ui_thread_proxy),
 109       successful_requests_through_proxy_count_(0),
 110       proxy_net_errors_count_(0),
 111       unavailable_(false) {
 112   DCHECK(params);
 113
 114   NetworkChangeNotifier::AddNetworkChangeObserver(this);
 115 };
 116
 117 DataReductionProxyUsageStats::~DataReductionProxyUsageStats() {
 118   NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 119 };
 120
 121 void DataReductionProxyUsageStats::OnUrlRequestCompleted(
 122     const net::URLRequest* request, bool started) {
 123   DCHECK(thread_checker_.CalledOnValidThread());
 124
 125   if (request->status().status() == net::URLRequestStatus::SUCCESS &&
 126       data_reduction_proxy_params_->WasDataReductionProxyUsed(request, NULL)) {
 127     successful_requests_through_proxy_count_++;
 128     NotifyUnavailabilityIfChanged();
 129   }
 130 }
 131
 132 void DataReductionProxyUsageStats::OnNetworkChanged(
 133     NetworkChangeNotifier::ConnectionType type) {
 134   DCHECK(thread_checker_.CalledOnValidThread());
 135   ClearRequestCounts();
 136 }
 137
 138 void DataReductionProxyUsageStats::ClearRequestCounts() {
 139   DCHECK(thread_checker_.CalledOnValidThread());
 140   successful_requests_through_proxy_count_ = 0;
 141   proxy_net_errors_count_ = 0;
 142 }
 143
 144 void DataReductionProxyUsageStats::NotifyUnavailabilityIfChanged() {
 145   bool prev_unavailable = unavailable_;
 146   unavailable_ =
 147       (proxy_net_errors_count_ >= kMinFailedRequestsWhenUnavailable &&
 148           successful_requests_through_proxy_count_ <=
 149               kMaxSuccessfulRequestsWhenUnavailable);
 150   if (prev_unavailable != unavailable_) {
 151     ui_thread_proxy_->PostTask(FROM_HERE, base::Bind(
 152         &DataReductionProxyUsageStats::NotifyUnavailabilityOnUIThread,
 153         base::Unretained(this),
 154         unavailable_));
 155   }
 156 }
 157
 158 void DataReductionProxyUsageStats::NotifyUnavailabilityOnUIThread(
 159     bool unavailable) {
 160   DCHECK(ui_thread_proxy_->BelongsToCurrentThread());
 161   if (!unavailable_callback_.is_null())
 162     unavailable_callback_.Run(unavailable);
 163 }
 164
 165 void DataReductionProxyUsageStats::SetBypassType(
 166     DataReductionProxyBypassType type) {
 167   last_bypass_type_ = type;
 168   triggering_request_ = true;
 169 }
 170
 171 void DataReductionProxyUsageStats::RecordBytesHistograms(
 172     net::URLRequest* request,
 173     const BooleanPrefMember& data_reduction_proxy_enabled,
 174     const net::ProxyConfig& data_reduction_proxy_config) {
 175   RecordBypassedBytesHistograms(request, data_reduction_proxy_enabled,
 176                                 data_reduction_proxy_config);
 177   RecordMissingViaHeaderBytes(request);
 178 }
 179
 180 void DataReductionProxyUsageStats::RecordBypassedBytesHistograms(
 181     net::URLRequest* request,
 182     const BooleanPrefMember& data_reduction_proxy_enabled,
 183     const net::ProxyConfig& data_reduction_proxy_config) {
 184   int64 content_length = request->received_response_content_length();
 185
 186   if (data_reduction_proxy_enabled.GetValue() &&
 187       !data_reduction_proxy_config.Equals(
 188           request->context()->proxy_service()->config())) {
 189     RecordBypassedBytes(last_bypass_type_,
 190                         DataReductionProxyUsageStats::MANAGED_PROXY_CONFIG,
 191                         content_length);
 192     return;
 193   }
 194
 195   if (data_reduction_proxy_params_->WasDataReductionProxyUsed(request, NULL)) {
 196     RecordBypassedBytes(last_bypass_type_,
 197                         DataReductionProxyUsageStats::NOT_BYPASSED,
 198                         content_length);
 199     return;
 200   }
 201
 202   if (data_reduction_proxy_enabled.GetValue() &&
 203       request->url().SchemeIs(url::kHttpsScheme)) {
 204     RecordBypassedBytes(last_bypass_type_,
 205                         DataReductionProxyUsageStats::SSL,
 206                         content_length);
 207     return;
 208   }
 209
 210   if (data_reduction_proxy_enabled.GetValue() &&
 211       data_reduction_proxy_params_->IsBypassedByDataReductionProxyLocalRules(
 212           *request, data_reduction_proxy_config)) {
 213     RecordBypassedBytes(last_bypass_type_,
 214                         DataReductionProxyUsageStats::LOCAL_BYPASS_RULES,
 215                         content_length);
 216     return;
 217   }
 218
 219   // Only record separate triggering request UMA for short, medium, and long
 220   // bypass events.
 221   if (triggering_request_ &&
 222      (last_bypass_type_ ==  BYPASS_EVENT_TYPE_SHORT ||
 223       last_bypass_type_ ==  BYPASS_EVENT_TYPE_MEDIUM ||
 224       last_bypass_type_ ==  BYPASS_EVENT_TYPE_LONG)) {
 225     std::string mime_type;
 226     request->GetMimeType(&mime_type);
 227     // MIME types are named by <media-type>/<subtype>. Check to see if the
 228     // media type is audio or video. Only record when triggered by short bypass,
 229     // there isn't an audio or video bucket for medium or long bypasses.
 230     if (last_bypass_type_ ==  BYPASS_EVENT_TYPE_SHORT &&
 231        (mime_type.compare(0, 6, "audio/") == 0  ||
 232         mime_type.compare(0, 6, "video/") == 0)) {
 233       RecordBypassedBytes(last_bypass_type_,
 234                           DataReductionProxyUsageStats::AUDIO_VIDEO,
 235                           content_length);
 236       return;
 237     }
 238
 239     RecordBypassedBytes(last_bypass_type_,
 240                         DataReductionProxyUsageStats::TRIGGERING_REQUEST,
 241                         content_length);
 242     triggering_request_ = false;
 243     return;
 244   }
 245
 246   if (last_bypass_type_ != BYPASS_EVENT_TYPE_MAX) {
 247     RecordBypassedBytes(last_bypass_type_,
 248                         DataReductionProxyUsageStats::BYPASSED_BYTES_TYPE_MAX,
 249                         content_length);
 250     return;
 251   }
 252
 253   if (data_reduction_proxy_params_->AreDataReductionProxiesBypassed(*request,
 254                                                                     NULL)) {
 255     RecordBypassedBytes(last_bypass_type_,
 256                         DataReductionProxyUsageStats::NETWORK_ERROR,
 257                         content_length);
 258   }
 259 }
 260
 261 void DataReductionProxyUsageStats::OnProxyFallback(
 262     const net::ProxyServer& bypassed_proxy,
 263     int net_error) {
 264   DataReductionProxyTypeInfo data_reduction_proxy_info;
 265   if (bypassed_proxy.is_valid() && !bypassed_proxy.is_direct() &&
 266       data_reduction_proxy_params_->IsDataReductionProxy(
 267       bypassed_proxy.host_port_pair(), &data_reduction_proxy_info)) {
 268     if (data_reduction_proxy_info.is_ssl)
 269       return;
 270
 271     proxy_net_errors_count_++;
 272
 273     // To account for the case when the proxy is reachable for sometime, and
 274     // then gets blocked, we reset counts when number of errors exceed
 275     // the threshold.
 276     if (proxy_net_errors_count_ >= kMaxFailedRequestsBeforeReset &&
 277         successful_requests_through_proxy_count_ >
 278             kMaxSuccessfulRequestsWhenUnavailable) {
 279       ClearRequestCounts();
 280     } else {
 281       NotifyUnavailabilityIfChanged();
 282     }
 283
 284     if (!data_reduction_proxy_info.is_fallback) {
 285       RecordDataReductionProxyBypassInfo(
 286           true, false, bypassed_proxy, BYPASS_EVENT_TYPE_NETWORK_ERROR);
 287       RecordDataReductionProxyBypassOnNetworkError(
 288           true, bypassed_proxy, net_error);
 289     } else {
 290       RecordDataReductionProxyBypassInfo(
 291           false, false, bypassed_proxy, BYPASS_EVENT_TYPE_NETWORK_ERROR);
 292       RecordDataReductionProxyBypassOnNetworkError(
 293           false, bypassed_proxy, net_error);
 294     }
 295   }
 296 }
 297
 298 void DataReductionProxyUsageStats::RecordBypassedBytes(
 299     DataReductionProxyBypassType bypass_type,
 300     DataReductionProxyUsageStats::BypassedBytesType bypassed_bytes_type,
 301     int64 content_length) {
 302   // Individual histograms are needed to count the bypassed bytes for each
 303   // bypass type so that we can see the size of requests. This helps us
 304   // remove outliers that would skew the sum of bypassed bytes for each type.
 305   switch (bypassed_bytes_type) {
 306     case DataReductionProxyUsageStats::NOT_BYPASSED:
 307       UMA_HISTOGRAM_COUNTS(
 308           "DataReductionProxy.BypassedBytes.NotBypassed", content_length);
 309       break;
 310     case DataReductionProxyUsageStats::SSL:
 311       UMA_HISTOGRAM_COUNTS(
 312           "DataReductionProxy.BypassedBytes.SSL", content_length);
 313       break;
 314     case DataReductionProxyUsageStats::LOCAL_BYPASS_RULES:
 315       UMA_HISTOGRAM_COUNTS(
 316           "DataReductionProxy.BypassedBytes.LocalBypassRules",
 317           content_length);
 318       break;
 319     case DataReductionProxyUsageStats::MANAGED_PROXY_CONFIG:
 320       UMA_HISTOGRAM_COUNTS(
 321           "DataReductionProxy.BypassedBytes.ManagedProxyConfig",
 322           content_length);
 323       break;
 324     case DataReductionProxyUsageStats::AUDIO_VIDEO:
 325       if (last_bypass_type_ == BYPASS_EVENT_TYPE_SHORT) {
 326         UMA_HISTOGRAM_COUNTS(
 327             "DataReductionProxy.BypassedBytes.ShortAudioVideo",
 328             content_length);
 329       }
 330       break;
 331     case DataReductionProxyUsageStats::TRIGGERING_REQUEST:
 332       switch (bypass_type) {
 333         case BYPASS_EVENT_TYPE_SHORT:
 334           UMA_HISTOGRAM_COUNTS(
 335               "DataReductionProxy.BypassedBytes.ShortTriggeringRequest",
 336               content_length);
 337           break;
 338         case BYPASS_EVENT_TYPE_MEDIUM:
 339           UMA_HISTOGRAM_COUNTS(
 340               "DataReductionProxy.BypassedBytes.MediumTriggeringRequest",
 341               content_length);
 342           break;
 343         case BYPASS_EVENT_TYPE_LONG:
 344           UMA_HISTOGRAM_COUNTS(
 345               "DataReductionProxy.BypassedBytes.LongTriggeringRequest",
 346               content_length);
 347           break;
 348         default:
 349           break;
 350       }
 351       break;
 352     case DataReductionProxyUsageStats::NETWORK_ERROR:
 353       UMA_HISTOGRAM_COUNTS(
 354           "DataReductionProxy.BypassedBytes.NetworkErrorOther",
 355           content_length);
 356       break;
 357     case DataReductionProxyUsageStats::BYPASSED_BYTES_TYPE_MAX:
 358       switch (bypass_type) {
 359         case BYPASS_EVENT_TYPE_CURRENT:
 360           UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.Current",
 361                                content_length);
 362           break;
 363         case BYPASS_EVENT_TYPE_SHORT:
 364           UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.ShortAll",
 365                                content_length);
 366           break;
 367         case BYPASS_EVENT_TYPE_MEDIUM:
 368           UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.MediumAll",
 369                                content_length);
 370           break;
 371         case BYPASS_EVENT_TYPE_LONG:
 372           UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.LongAll",
 373                                content_length);
 374           break;
 375         case BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_4XX:
 376           UMA_HISTOGRAM_COUNTS(
 377               "DataReductionProxy.BypassedBytes.MissingViaHeader4xx",
 378               content_length);
 379           break;
 380         case BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_OTHER:
 381           UMA_HISTOGRAM_COUNTS(
 382               "DataReductionProxy.BypassedBytes.MissingViaHeaderOther",
 383               content_length);
 384           break;
 385         case BYPASS_EVENT_TYPE_MALFORMED_407:
 386           UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.Malformed407",
 387                                content_length);
 388          break;
 389         case BYPASS_EVENT_TYPE_STATUS_500_HTTP_INTERNAL_SERVER_ERROR:
 390           UMA_HISTOGRAM_COUNTS(
 391               "DataReductionProxy.BypassedBytes."
 392               "Status500HttpInternalServerError",
 393               content_length);
 394           break;
 395         case BYPASS_EVENT_TYPE_STATUS_502_HTTP_BAD_GATEWAY:
 396           UMA_HISTOGRAM_COUNTS(
 397               "DataReductionProxy.BypassedBytes.Status502HttpBadGateway",
 398               content_length);
 399           break;
 400         case BYPASS_EVENT_TYPE_STATUS_503_HTTP_SERVICE_UNAVAILABLE:
 401           UMA_HISTOGRAM_COUNTS(
 402               "DataReductionProxy.BypassedBytes."
 403               "Status503HttpServiceUnavailable",
 404               content_length);
 405           break;
 406         default:
 407           break;
 408       }
 409       break;
 410   }
 411 }
 412
 413 void DataReductionProxyUsageStats::RecordMissingViaHeaderBytes(
 414     URLRequest* request) {
 415   // Responses that were served from cache should have been filtered out
 416   // already.
 417   DCHECK(!request->was_cached());
 418
 419   if (!data_reduction_proxy_params_->WasDataReductionProxyUsed(request, NULL) ||
 420       HasDataReductionProxyViaHeader(request->response_headers(), NULL)) {
 421     // Only track requests that used the data reduction proxy and had responses
 422     // that were missing the data reduction proxy via header.
 423     return;
 424   }
 425
 426   if (request->GetResponseCode() >= net::HTTP_BAD_REQUEST &&
 427       request->GetResponseCode() < net::HTTP_INTERNAL_SERVER_ERROR) {
 428     // Track 4xx responses that are missing via headers separately.
 429     UMA_HISTOGRAM_COUNTS("DataReductionProxy.MissingViaHeader.Bytes.4xx",
 430                          request->received_response_content_length());
 431   } else {
 432     UMA_HISTOGRAM_COUNTS("DataReductionProxy.MissingViaHeader.Bytes.Other",
 433                          request->received_response_content_length());
 434   }
 435 }
 436
 437 }  // namespace data_reduction_proxy
 438
 439