Add histograms to track UMA upload success vs. failure rates.

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 225 matching lines @@
 const size_t kUploadLogAvoidRetransmitSize = 50000;
 
 // Interval, in minutes, between state saves.
 const int kSaveStateIntervalMinutes = 5;
 
 // Used to indicate that the response code is currently not set at all --
 // RESPONSE_CODE_INVALID can sometimes be returned in response to a request if,
 // e.g., the server is down.
 const int kNoResponseCode = content::URLFetcher::RESPONSE_CODE_INVALID - 1;
 
+enum ResponseStatus {
+  UNKNOWN_FAILURE,
+  SUCCESS,
+  BAD_REQUEST,  // Invalid syntax or log too large.
+  NUM_RESPONSE_STATUSES
+};
+
+ResponseStatus ResponseCodeToStatus(int response_code) {
+  switch (response_code) {
+    case 200:
+      return SUCCESS;
+    case 400:
+      return BAD_REQUEST;
+    default:
+      return UNKNOWN_FAILURE;
+  }
+}
+
 }
 
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 // This is used to quickly log stats from child process related notifications in
 // MetricsService::child_stats_buffer_.  The buffer's contents are transferred
 // out when Local State is periodically saved.  The information is then
 // reported to the UMA server on next launch.
@@ skipping 979 matching lines @@
 // not retry the protobuf upload.  If the XML upload fails while the protobuf
 // upload succeeds, we will still avoid re-uploading the protobuf data because
 // we "zap" the data after the first upload attempt.  This means that we might
 // lose protobuf uploads when XML ones succeed; but we will never duplicate any
 // protobuf uploads.  Protobuf failures should be rare enough to where this
 // should be ok while we have the two pipelines running in parallel.
 void MetricsService::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(waiting_for_asynchronus_reporting_step_);
 
   // We're not allowed to re-use the existing |URLFetcher|s, so free them here.
+  // Note however that |source| is aliased to one of these, so we should be
+  // careful not to delete it too early.
   scoped_ptr<content::URLFetcher> s;
   if (source == current_fetch_xml_.get()) {
     s.reset(current_fetch_xml_.release());
 
     // Cache the XML responses, in case we still need to wait for the protobuf
     // response.
     response_code_ = source->GetResponseCode();
     response_status_ = StatusToString(source->GetStatus());
     source->GetResponseAsString(&response_data_);
+
+    // Log a histogram to track response success vs. failure rates.
+    UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.XML",
+                              ResponseCodeToStatus(response_code_),
+                              NUM_RESPONSE_STATUSES);
   } else if (source == current_fetch_proto_.get()) {
     s.reset(current_fetch_proto_.release());
+
+    // Log a histogram to track response success vs. failure rates.
+    UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.Protobuf",
+                              ResponseCodeToStatus(source->GetResponseCode()),
+                              NUM_RESPONSE_STATUSES);
   } else {
     NOTREACHED();
     return;
   }
 
   // If we're still waiting for one of the responses, keep waiting...
   if (current_fetch_xml_.get() || current_fetch_proto_.get())
     return;
 
   // We should only be able to reach here once we've received responses to both
   // the XML and the protobuf requests.  We should always have the response code
   // available.
   DCHECK_NE(response_code_, kNoResponseCode);
   waiting_for_asynchronus_reporting_step_ = false;
 
   // If the upload was provisionally stored, drop it now that the upload is
   // known to have gone through.
   log_manager_.DiscardLastProvisionalStore();
 
   // Confirm send so that we can move on.
-  VLOG(1) << "METRICS RESPONSE CODE: " << response_code_
+  VLOG(1) << "Metrics response code: " << response_code_
           << " status=" << response_status_;
 
   bool upload_succeeded = response_code_ == 200;
 
   // Provide boolean for error recovery (allow us to ignore response_code).
   bool discard_log = false;
 
   if (!upload_succeeded &&
       log_manager_.staged_log_text().xml.length() >
           kUploadLogAvoidRetransmitSize) {
     UMA_HISTOGRAM_COUNTS(
         "UMA.Large Rejected Log was Discarded",
         static_cast<int>(log_manager_.staged_log_text().xml.length()));
     discard_log = true;
   } else if (response_code_ == 400) {
     // Bad syntax.  Retransmission won't work.
-    UMA_HISTOGRAM_COUNTS("UMA.Unacceptable_Log_Discarded", state_);
     discard_log = true;
   }
 
   if (!upload_succeeded && !discard_log) {
-    VLOG(1) << "METRICS: transmission attempt returned a failure code: "
+    VLOG(1) << "Metrics: transmission attempt returned a failure code: "
             << response_code_ << ". Verify network connectivity";
     LogBadResponseCode();
   } else {  // Successful receipt (or we are discarding log).
-    VLOG(1) << "METRICS RESPONSE DATA: " << response_data_;
+    VLOG(1) << "Metrics response data: " << response_data_;
     switch (state_) {
       case INITIAL_LOG_READY:
         state_ = SENDING_OLD_LOGS;
         break;
 
       case SENDING_OLD_LOGS:
         // Store the updated list to disk now that the removed log is uploaded.
         StoreUnsentLogs();
         break;
 
@@ skipping 424 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }