Bypassed Bytes UMAs

components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.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 "base/metrics/histogram.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
+#include "net/base/net_errors.h"
 #include "net/proxy/proxy_retry_info.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 
 using base::MessageLoopProxy;
 using net::HostPortPair;
 using net::ProxyServer;
+using net::ProxyService;
 using net::NetworkChangeNotifier;
 
 namespace data_reduction_proxy {
 
 DataReductionProxyUsageStats::DataReductionProxyUsageStats(
     DataReductionProxyParams* params,
     MessageLoopProxy* ui_thread_proxy,
     MessageLoopProxy* io_thread_proxy)
     : data_reduction_proxy_params_(params),
+      bypass_type_(ProxyService::BYPASS_EVENT_TYPE_MAX),
+      triggering_request_(true),
       ui_thread_proxy_(ui_thread_proxy),
       io_thread_proxy_(io_thread_proxy),
       eligible_num_requests_through_proxy_(0),
       actual_num_requests_through_proxy_(0) {
   NetworkChangeNotifier::AddNetworkChangeObserver(this);
 };
 
 DataReductionProxyUsageStats::~DataReductionProxyUsageStats() {
   NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 };
@@ skipping 53 matching lines @@
     ClearRequestCountsOnUiThread();
   }
 }
 
 void DataReductionProxyUsageStats::ClearRequestCountsOnUiThread() {
   DCHECK(ui_thread_proxy_->BelongsToCurrentThread());
   eligible_num_requests_through_proxy_ = 0;
   actual_num_requests_through_proxy_ = 0;
 }
 
+void DataReductionProxyUsageStats::SetBypassType(
+    ProxyService::DataReductionProxyBypassType type) {
+  bypass_type_ = type;
+  triggering_request_ = true;
+}
+
+void DataReductionProxyUsageStats::RecordBypassedBytesHistograms(
+    int64 content_length,
+    const net::URLRequest& request,
+    const BooleanPrefMember& data_reduction_proxy_enabled) {
+  if (data_reduction_proxy_params_->WasDataReductionProxyUsed(&request, NULL)) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::NOT_BYPASSED,
+                        content_length);
+    return;
+  }
+
+  if (data_reduction_proxy_enabled.GetValue() &&
+      request.url().SchemeIs(url::kHttpsScheme)) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::SSL,
+                        content_length);
+    return;
+  }
+
+  if (data_reduction_proxy_enabled.GetValue() &&
+      !data_reduction_proxy_params_->IsDataReductionProxyEligible(&request)) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::LOCAL_BYPASS_RULES,
+                        content_length);
+    return;
+  }
+
+  if (triggering_request_) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::TRIGGERING_REQUEST,
+                        content_length);
+    triggering_request_ = false;
+  }
+
+  std::string mime_type;
+  request.GetMimeType(&mime_type);
+  // MIME types are named by <media-type>/<subtype>. We check to see if the
+  // media type is audio or video.
+  if (mime_type.find("audio/") != string::npos  ||
+      mime_type.find("video/") != string::npos) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::AUDIO_VIDEO,
+                        content_length);
+  }
+
+  if (bypass_type_ != ProxyService::BYPASS_EVENT_TYPE_MAX) {
+    RecordBypassedBytes(bypass_type_,
+                        DataReductionProxyUsageStats::BYPASSED_BYTES_TYPE_MAX,
+                        content_length);
+    return;
+  }
+
+  if (data_reduction_proxy_params_->
+          WereDataReductionProxiesBypassed(&request, NULL)) {
+      RecordBypassedBytes(bypass_type_,
+                          DataReductionProxyUsageStats::NETWORK_ERROR,
+                          content_length);
+  }
+}
+
+void DataReductionProxyUsageStats::RecordBypassedBytes(
+    ProxyService::DataReductionProxyBypassType bypass_type,
+    DataReductionProxyUsageStats::BypassedBytesType bypassed_bytes_type,
+    int64 content_length) {
+  switch(bypassed_bytes_type) {
+
+    case DataReductionProxyUsageStats::NOT_BYPASSED:
+      UMA_HISTOGRAM_COUNTS(
+          "DataReductionProxy.BypassedBytes.NotBypassed", content_length);
+      break;
+    case DataReductionProxyUsageStats::SSL:
+      UMA_HISTOGRAM_COUNTS(
+          "DataReductionProxy.BypassedBytes.SSL", content_length);
+      break;
+    case DataReductionProxyUsageStats::LOCAL_BYPASS_RULES:
+      UMA_HISTOGRAM_COUNTS(
+          "DataReductionProxy.BypassedBytes.LocalBypassRules",
+          content_length);
+      break;
+    case DataReductionProxyUsageStats::AUDIO_VIDEO:
+      if (bypass_type_ == ProxyService::SHORT_BYPASS)
+        UMA_HISTOGRAM_COUNTS(
+            "DataReductionProxy.BypassedBytes.ShortAudioVideo",
+            content_length);
+      break;
+    case DataReductionProxyUsageStats::TRIGGERING_REQUEST:
+      switch(bypass_type) {
+
+        case ProxyService::SHORT_BYPASS:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.ShortTriggeringRequest",
+              content_length);
+          break;
+        case ProxyService::MEDIUM_BYPASS:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.MediumTriggeringRequest",
+              content_length);
+          break;
+        case ProxyService::LONG_BYPASS:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.LongTriggeringRequest",
+              content_length);
+          break;
+        default:
+          break;
+      }
+      break;
+    case DataReductionProxyUsageStats::NETWORK_ERROR:
+      UMA_HISTOGRAM_COUNTS(
+          "DataReductionProxy.BypassedBytes.NetworkErrorOther",
+          content_length);
+      break;
+    case DataReductionProxyUsageStats::BYPASSED_BYTES_TYPE_MAX:
+      switch(bypass_type) {
+
+        case ProxyService::CURRENT_BYPASS:
+          UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.Current",
+                               content_length);
+          break;
+        case ProxyService::SHORT_BYPASS:
+          UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.ShortAll",
+                               content_length);
+          break;
+        case ProxyService::MEDIUM_BYPASS:
+          UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.MediumAll",
+                               content_length);
+          break;
+        case ProxyService::LONG_BYPASS:
+          UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.LongAll",
+                               content_length);
+          break;
+        case ProxyService::MISSING_VIA_HEADER_4XX:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.MissingViaHeader4xx",
+              content_length);
+          break;
+        case ProxyService::MISSING_VIA_HEADER_OTHER:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.MissingViaHeaderOther",
+              content_length);
+          break;
+        case ProxyService::MALFORMED_407:
+          UMA_HISTOGRAM_COUNTS("DataReductionProxy.BypassedBytes.Malformed407",
+                               content_length);
+         break;
+        case ProxyService::STATUS_500_HTTP_INTERNAL_SERVER_ERROR:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes."
+              "Status500HttpInternalServerError",
+              content_length);
+          break;
+        case ProxyService::STATUS_502_HTTP_BAD_GATEWAY:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes.Status502HttpBadGateway",
+              content_length);
+          break;
+        case ProxyService::STATUS_503_HTTP_SERVICE_UNAVAILABLE:
+          UMA_HISTOGRAM_COUNTS(
+              "DataReductionProxy.BypassedBytes."
+              "Status503HttpServiceUnavailable",
+              content_length);
+          break;
+        default:
+          break;
+      }
+      break;
+  }
+}
+
 }  // namespace data_reduction_proxy