Add UMA histogram to show how many retries we had to do to execute a DeviceManagementRequestJob.

components/policy/core/common/cloud/device_management_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.
 
 #include "components/policy/core/common/cloud/device_management_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
@@ skipping 199 matching lines @@
 
   // The request context to use for this job.
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   // Used to get notified if the job has been canceled while waiting for retry.
   base::WeakPtrFactory<DeviceManagementRequestJobImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRequestJobImpl);
 };
 
+// Used in the Enterprise.DMServerRequestSuccess histogram, shows how many
+// retries we had to do to execute the DeviceManagementRequestJob.
+enum DMServerRequestSuccess {
+  // No retries happened, the request succeeded for the first try.
+  REQUEST_NO_RETRY = 0,
+
+  // 1..kMaxRetries: number of retries
+
+  // The request failed (too many retries or non-retriable error).
+  REQUEST_FAILED = 10,
+  // The server responded with an error.
+  REQUEST_ERROR,
+
+  REQUEST_MAX
+};
+
 DeviceManagementRequestJobImpl::DeviceManagementRequestJobImpl(
     JobType type,
     const std::string& agent_parameter,
     const std::string& platform_parameter,
     DeviceManagementService* service,
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : DeviceManagementRequestJob(type, agent_parameter, platform_parameter),
       service_(service),
       bypass_proxy_(false),
       retries_count_(0),
       request_context_(request_context),
       weak_ptr_factory_(this) {}
 
 DeviceManagementRequestJobImpl::~DeviceManagementRequestJobImpl() {
   service_->RemoveJob(this);
 }
 
 void DeviceManagementRequestJobImpl::Run() {
   service_->AddJob(this);
 }
 
 void DeviceManagementRequestJobImpl::HandleResponse(
     const net::URLRequestStatus& status,
     int response_code,
     const std::string& data) {
   if (status.status() != net::URLRequestStatus::SUCCESS) {
+    UMA_HISTOGRAM_ENUMERATION("Enterprise.DMServerRequestSuccess",
+                              DMServerRequestSuccess::REQUEST_FAILED,
+                              DMServerRequestSuccess::REQUEST_MAX);
     LOG(WARNING) << "DMServer request failed, status: " << status.status()
                  << ", error: " << status.error();
     em::DeviceManagementResponse dummy_response;
     callback_.Run(DM_STATUS_REQUEST_FAILED, status.error(), dummy_response);
     return;
   }
 
-  if (response_code != kSuccess)
+  if (response_code != kSuccess) {
+    UMA_HISTOGRAM_ENUMERATION("Enterprise.DMServerRequestSuccess",
+                              DMServerRequestSuccess::REQUEST_ERROR,
+                              DMServerRequestSuccess::REQUEST_MAX);
     LOG(WARNING) << "DMServer sent an error response: " << response_code;
+  } else {
+    // Success with retries_count_ retries.
+    UMA_HISTOGRAM_ENUMERATION("Enterprise.DMServerRequestSuccess",
+                              retries_count_,
+                              DMServerRequestSuccess::REQUEST_MAX);
+  }
 
   switch (response_code) {
     case kSuccess: {
       em::DeviceManagementResponse response;
       if (!response.ParseFromString(data)) {
         ReportError(DM_STATUS_RESPONSE_DECODING_ERROR);
         return;
       }
       callback_.Run(DM_STATUS_SUCCESS, net::OK, response);
       return;
@@ skipping 333 matching lines @@
     }
   }
 
   const JobQueue::iterator elem =
       std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
   if (elem != queued_jobs_.end())
     queued_jobs_.erase(elem);
 }
 
 }  // namespace policy