Measure network error rates with and without data reduction proxy

chrome/browser/net/chrome_network_delegate.cc

 // Copyright (c) 2012 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 "chrome/browser/net/chrome_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/client_hints.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/domain_reliability/monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "net/base/host_port_pair.h"
+#include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 #if defined(OS_ANDROID)
@@ skipping 90 matching lines @@
     reason = DATA_URL;
   else if (target_url.SchemeIs(url::kHttpScheme))
     reason = HTTP_URL;
   base::debug::Alias(&reason);
   base::RecordAction(
       base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer"));
   base::debug::DumpWithoutCrashing();
   NOTREACHED();
 }
 
+// Record network errors that HTTP requests complete with, including OK and
+// ABORTED.
+void RecordNetworkErrorHistograms(const net::URLRequest* request) {
+  if (request->url().SchemeIs("http")) {
+    UMA_HISTOGRAM_SPARSE_SLOWLY("Net.HttpRequestCompletionErrorCodes",
+                                std::abs(request->status().error()));
+
+    if (request->load_flags() & net::LOAD_MAIN_FRAME) {
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Net.HttpRequestCompletionErrorCodes.MainFrame",

[mmenke, 2014/12/12 21:09:30]

Not needed.  See Net.ErrorCodesForMainFrame3 and Net.ErrorCodesForSubresources2

[sclittle, 2014/12/12 22:10:20]

Please clarify, for "not needed", are you referring to both the histograms here
or just the MainFrame one?

The idea behind having these histograms is that we could compare net error rates
for HTTP requests between users who have the data reduction proxy enabled and
users who don't. By looking at these histograms together with
DRP.RequestCompletionErrorCodes, we could work out what the net error rates are
for requests that bypass the DRP, and get a better overall idea of the effects
of network flakiness on DRP usage.

The idea behind drilling down on the main frame requests is that when a client
is on a network on which the DRP isn't immediately usable (e.g. captive portal),
errors caused by this would typically show up on main frame resource loads, and
since these captive portals or other things could handle HTTP traffic
differently than other traffic (such as HTTPS), it would be nice to look at just
HTTP main frame request net error rates. Also, from looking at
Net.ErrorCodesForMainFrame3 and Net.ErrorCodesForSubresources2, the rates of
some errors between these two differ in interesting ways, so it could be useful
to narrow that down to just HTTP requests so we can better apply this data to
DRP usage.

If you believe that the existing Net.ErrorCodesForMainFrame3 and
Net.ErrorCodesForSubresources2 histograms already allow for this sort of thing,
then I'll remove these new ones.

[mmenke, 2014/12/15 16:55:43]

Ahh...you're right, they're different, I missed the http restriction.  Suppose
these also cover requests that don't come through the RDH.  This does include
incognito requests, though, which would bypass the DRP even if it were enabled,
so not completely comparable, but close.

I'm still not a huge fan of having all these near identical histograms logged
all over the place.  Histograms aren't free.  Don't have a better suggestion,
though.

Could just compare the other histograms with DRP on and off, but that doesn't
give you the fallback vs non-fallback error numbers, I suppose.

+          std::abs(request->status().error()));
+    }
+  }
+}
+
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers)
     : profile_(NULL),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(NULL),
       force_safe_search_(NULL),
       force_google_safe_search_(NULL),
@@ skipping 215 matching lines @@
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "423948 ChromeNetworkDelegate::OnRawBytesRead2"));
 
     task_manager->model()->NotifyBytesRead(request, bytes_read);
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started) {
+  RecordNetworkErrorHistograms(request);
+
   TRACE_EVENT_ASYNC_END0("net", "URLRequest", request);
   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
 #if defined(OS_ANDROID)
     // For better accuracy, we use the actual bytes read instead of the length
     // specified with the Content-Length header, which may be inaccurate,
     // or missing, as is the case with chunked encoding.
     int64 received_content_length = request->received_response_content_length();
 
     if (precache::PrecacheManager::IsPrecachingEnabled()) {
       // Record precache metrics when a fetch is completed successfully, if
@@ skipping 209 matching lines @@
 bool ChromeNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
     const net::URLRequest& request,
     const GURL& target_url,
     const GURL& referrer_url) const {
   base::debug::StackTrace callstack;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&ReportInvalidReferrerSend, target_url,
                                      referrer_url, callstack));
   return true;
 }