Parallelizable download metrics.

content/browser/download/download_stats.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 "content/browser/download/download_stats.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 321 matching lines @@
   FILE_PATH_LITERAL(".img"),
   FILE_PATH_LITERAL(".imgpart"),
   FILE_PATH_LITERAL(".ndif"),
   FILE_PATH_LITERAL(".smi"),
   FILE_PATH_LITERAL(".sparsebundle"),
   FILE_PATH_LITERAL(".sparseimage"),
   FILE_PATH_LITERAL(".toast"),
   FILE_PATH_LITERAL(".udif"),
 };
 
+// The maximum size of the file that every bucket should hold.
+const int64_t kParallelizableBucketKb[] = {512, 1024, 3072, 10240, 51200};
+
+// Suffixes for parallelizable downloads bucketed by file size. Each suffix will
+// generate a new histogram.
+const char* kParallelizableBucketName[] = {"0.5MB", "1MB",  "3MB",
+                                           "10MB",  "50MB", "GT50MB"};
+
 // Maps extensions to their matching UMA histogram int value.
 int GetDangerousFileType(const base::FilePath& file_path) {
   for (size_t i = 0; i < arraysize(kDangerousFileTypes); ++i) {
     if (file_path.MatchesExtension(kDangerousFileTypes[i]))
       return i + 1;
   }
   return 0;  // Unknown extension.
 }
 
 // Helper method to calculate the bandwidth given the data length and time.
@@ skipping 437 matching lines @@
 void RecordParallelDownloadAddStreamSuccess(bool success) {
   UMA_HISTOGRAM_BOOLEAN("Download.ParallelDownloadAddStreamSuccess", success);
 }
 
 void RecordParallelizableDownloadStats(
     size_t bytes_downloaded_with_parallel_streams,
     base::TimeDelta time_with_parallel_streams,
     size_t bytes_downloaded_without_parallel_streams,
     base::TimeDelta time_without_parallel_streams,
     bool uses_parallel_requests) {
+  RecordParallelizableDownloadAverageStats(
+      bytes_downloaded_with_parallel_streams +
+          bytes_downloaded_without_parallel_streams,
+      time_with_parallel_streams + time_without_parallel_streams);
+
   int64_t bandwidth_without_parallel_streams = 0;
   if (bytes_downloaded_without_parallel_streams > 0) {
     bandwidth_without_parallel_streams = CalculateBandwidthBytesPerSecond(
         bytes_downloaded_without_parallel_streams,
         time_without_parallel_streams);
     if (uses_parallel_requests) {
       RecordBandwidthMetric(
           "Download.ParallelizableDownloadBandwidth."
           "WithParallelRequestsSingleStream",
           bandwidth_without_parallel_streams);
@@ skipping 47 matching lines @@
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Download.EstimatedTimeSavedWithParallelDownload",
         time_saved.InMilliseconds(), 0, kMillisecondsPerHour, 50);
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Download.EstimatedTimeWastedWithParallelDownload",
         -time_saved.InMilliseconds(), 0, kMillisecondsPerHour, 50);
   }
 }
 
+void RecordParallelizableDownloadAverageStats(
+    int64_t bytes_downloaded,
+    const base::TimeDelta& time_span) {
+  if (time_span.is_zero() || bytes_downloaded <= 0)
+    return;
+
+  int64_t average_bandwidth =
+      CalculateBandwidthBytesPerSecond(bytes_downloaded, time_span);
+  int64_t file_size_kb = bytes_downloaded / 1024;
+  RecordBandwidthMetric("Download.ParallelizableDownloadBandwidth",
+                        average_bandwidth);
+  UMA_HISTOGRAM_LONG_TIMES("Download.Parallelizable.DownloadTime", time_span);
+  int64_t max = 1024 * 1024 * 1024;

[qinmin, 2017/05/17 19:43:26]

nit: make this a constant

[xingliu, 2017/05/17 21:20:18]

Done.

+  UMA_HISTOGRAM_CUSTOM_COUNTS("Download.Parallelizable.FileSize", file_size_kb,
+                              1, max, /* 1 TB as maximum. */
+                              256);

[Ilya Sherman, 2017/05/17 19:13:07]

It looks like you are recording a histogram with 256 buckets.  That's quite
expensive!  Could you use fewer buckets?  The standard is to use 50 buckets. 
How much granularity do you need?

[xingliu, 2017/05/17 21:20:18]

Done. Also lower the maximum size. 

+
+  // Download size suffix for average bandwidth and download time metrics.
+  size_t i = 0;
+  for (size_t n = arraysize(kParallelizableBucketKb); i < n; ++i) {
+    if (file_size_kb <= kParallelizableBucketKb[i])
+      break;
+  }
+  std::string suffix = kParallelizableBucketName[i];
+  RecordBandwidthMetric("Download.ParallelizableDownloadBandwidth." + suffix,
+                        average_bandwidth);
+  base::UmaHistogramLongTimes("Download.Parallelizable.DownloadTime." + suffix,
+                              time_span);
+}
+
 void RecordParallelDownloadCreationEvent(ParallelDownloadCreationEvent event) {
   UMA_HISTOGRAM_ENUMERATION("Download.ParallelDownload.CreationEvent", event,
                             ParallelDownloadCreationEvent::COUNT);
 }
 
 void RecordDownloadFileRenameResultAfterRetry(
     base::TimeDelta time_since_first_failure,
     DownloadInterruptReason interrupt_reason) {
   if (interrupt_reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
     UMA_HISTOGRAM_TIMES("Download.TimeToRenameSuccessAfterInitialFailure",
@@ skipping 76 matching lines @@
 }
 
 void RecordDownloadHttpResponseCode(int response_code) {
   UMA_HISTOGRAM_CUSTOM_ENUMERATION(
       "Download.HttpResponseCode",
       net::HttpUtil::MapStatusCodeForHistogram(response_code),
       net::HttpUtil::GetStatusCodesForHistogram());
 }
 
 }  // namespace content