Record connection, registration, and receiving activities.

google_apis/gcm/monitoring/gcm_stats_recorder.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 "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 
 #include <deque>
 #include <vector>
 
+#include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace gcm {
 
 const uint32 MAX_LOGGED_ACTIVITY_COUNT = 100;
 
 namespace {
@@ skipping 27 matching lines @@
     case gcm::MCSClient::NO_CONNECTION_ON_ZERO_TTL:
       return "NO_CONNECTION_ON_ZERO_TTL";
     case gcm::MCSClient::TTL_EXCEEDED:
       return "TTL_EXCEEDED";
     default:
       NOTREACHED();
       return "UNKNOWN";
   }
 }
 
+// Helper for getting string representation of the
+// ConnectionFactory::ConnectionResetReason enum.
+std::string GetConnectionResetReasonString(
+    gcm::ConnectionFactory::ConnectionResetReason reason) {
+  switch (reason) {
+    case gcm::ConnectionFactory::LOGIN_FAILURE:
+      return "LOGIN_FAILURE";
+    case gcm::ConnectionFactory::CLOSE_COMMAND:
+      return "CLOSE_COMMAND";
+    case gcm::ConnectionFactory::HEARTBEAT_FAILURE:
+      return "HEARTBEAT_FAILURE";
+    case gcm::ConnectionFactory::SOCKET_FAILURE:
+      return "SOCKET_FAILURE";
+    case gcm::ConnectionFactory::NETWORK_CHANGE:
+      return "NETWORK_CHANGE";
+    default:
+      NOTREACHED();
+      return "UNKNOWN_REASON";
+  }
+}
+
+// Helper for getting string representation of the RegistrationRequest::Status
+// enum.
+std::string GetRegistrationStatusString(
+    gcm::RegistrationRequest::Status status) {
+  switch (status) {
+    case gcm::RegistrationRequest::SUCCESS:
+      return "SUCCESS";
+    case gcm::RegistrationRequest::INVALID_PARAMETERS:
+      return "INVALID_PARAMETERS";
+    case gcm::RegistrationRequest::INVALID_SENDER:
+      return "INVALID_SENDER";
+    case gcm::RegistrationRequest::AUTHENTICATION_FAILED:
+      return "AUTHENTICATION_FAILED";
+    case gcm::RegistrationRequest::DEVICE_REGISTRATION_ERROR:
+      return "DEVICE_REGISTRATION_ERROR";
+    case gcm::RegistrationRequest::UNKNOWN_ERROR:
+      return "UNKNOWN_ERROR";
+    case gcm::RegistrationRequest::URL_FETCHING_FAILED:
+      return "URL_FETCHING_FAILED";
+    case gcm::RegistrationRequest::HTTP_NOT_OK:
+      return "HTTP_NOT_OK";
+    case gcm::RegistrationRequest::RESPONSE_PARSING_FAILED:
+      return "RESPONSE_PARSING_FAILED";
+    case gcm::RegistrationRequest::REACHED_MAX_RETRIES:
+      return "REACHED_MAX_RETRIES";
+    default:
+      NOTREACHED();
+      return "UNKNOWN_STATUS";
+  }
+}
+
+// Helper for getting string representation of the RegistrationRequest::Status
+// enum.
+std::string GetUnregistrationStatusString(
+    gcm::UnregistrationRequest::Status status) {
+  switch (status) {
+    case gcm::UnregistrationRequest::SUCCESS:
+      return "SUCCESS";
+    case gcm::UnregistrationRequest::URL_FETCHING_FAILED:
+      return "URL_FETCHING_FAILED";
+    case gcm::UnregistrationRequest::NO_RESPONSE_BODY:
+      return "NO_RESPONSE_BODY";
+    case gcm::UnregistrationRequest::RESPONSE_PARSING_FAILED:
+      return "RESPONSE_PARSING_FAILED";
+    case gcm::UnregistrationRequest::INCORRECT_APP_ID:
+      return "INCORRECT_APP_ID";
+    case gcm::UnregistrationRequest::INVALID_PARAMETERS:
+      return "INVALID_PARAMETERS";
+    case gcm::UnregistrationRequest::SERVICE_UNAVAILABLE:
+      return "SERVICE_UNAVAILABLE";
+    case gcm::UnregistrationRequest::INTERNAL_SERVER_ERROR:
+      return "INTERNAL_SERVER_ERROR";
+    case gcm::UnregistrationRequest::HTTP_NOT_OK:
+      return "HTTP_NOT_OK";
+    case gcm::UnregistrationRequest::UNKNOWN_ERROR:
+      return "UNKNOWN_ERROR";
+    default:
+      NOTREACHED();
+      return "UNKNOWN_STATUS";
+  }
+}
+
 }  // namespace
 
 GCMStatsRecorder::Activity::Activity()
     : time(base::Time::Now()) {
 }
 
 GCMStatsRecorder::Activity::~Activity() {
 }
 
+GCMStatsRecorder::ConnectionActivity::ConnectionActivity() {
+}
+
+GCMStatsRecorder::ConnectionActivity::~ConnectionActivity() {
+}
+
+GCMStatsRecorder::RegistrationActivity::RegistrationActivity() {
+}
+
+GCMStatsRecorder::RegistrationActivity::~RegistrationActivity() {
+}
+
+GCMStatsRecorder::ReceivingActivity::ReceivingActivity()
+    : message_byte_size(0) {
+}
+
+GCMStatsRecorder::ReceivingActivity::~ReceivingActivity() {
+}
+
 GCMStatsRecorder::SendingActivity::SendingActivity() {
 }
 
 GCMStatsRecorder::SendingActivity::~SendingActivity() {
 }
 
 GCMStatsRecorder::GCMStatsRecorder() : is_recording_(false) {
 }
 
 GCMStatsRecorder::~GCMStatsRecorder() {
 }
 
 void GCMStatsRecorder::SetRecording(bool recording) {
   is_recording_ = recording;
 }
 
 void GCMStatsRecorder::Clear() {
   sending_activities_.clear();
 }
 
-void GCMStatsRecorder::CollectSendingActivities(
-    std::vector<SendingActivity>* activities) const {
-  activities->insert(activities->begin(),
-                     sending_activities_.begin(),
-                     sending_activities_.end());
+void GCMStatsRecorder::RecordConnection(
+    const std::string& event,
+    const std::string& details) {
+  ConnectionActivity data;
+  ConnectionActivity* inserted_data = InsertCircularBuffer(
+      &connection_activities_, data);
+  inserted_data->event = event;
+  inserted_data->details = details;
+}
+
+void GCMStatsRecorder::RecordConnectionInitiated(const std::string& host) {
+  if (is_recording_)

[Nicolas Zea, 2014/04/23 23:37:04]

I think it's clearer to just do if (!is_recording) return for these methods, to
make it clear there's nothing we do when we're not recording

[juyik, 2014/04/24 00:53:45]

Done.

+    RecordConnection("Connection initiated", host);
+}
+
+void GCMStatsRecorder::RecordConnectionDelayedDueToBackoff(int64 delay_msec) {
+  if (is_recording_) {
+    RecordConnection("Connection backoff",
+                     base::StringPrintf("Delayed for %" PRId64 " msec",
+                                        delay_msec));
+  }
+}
+
+void GCMStatsRecorder::RecordConnectionSuccess() {
+  if (is_recording_) {
+    RecordConnection("Connection succeeded", std::string());
+  }
+}
+
+void GCMStatsRecorder::RecordConnectionResetSignaled(
+      ConnectionFactory::ConnectionResetReason reason) {
+  if (is_recording_) {
+    RecordConnection("Connection reset",
+                     GetConnectionResetReasonString(reason));
+  }
+}
+
+void GCMStatsRecorder::RecordRegistration(
+    const std::string& app_id,
+    const std::string& sender_ids,
+    const std::string& event,
+    const std::string& details) {
+  RegistrationActivity data;
+  RegistrationActivity* inserted_data = InsertCircularBuffer(
+      &registration_activities_, data);
+  inserted_data->app_id = app_id;
+  inserted_data->sender_ids = sender_ids;
+  inserted_data->event = event;
+  inserted_data->details = details;
+}
+
+void GCMStatsRecorder::RecordRegistrationSent(
+    const std::string& app_id,
+    const std::string& sender_ids) {
+  UMA_HISTOGRAM_COUNTS("GCM.RegistrationRequest", 1);
+  if (is_recording_) {
+    RecordRegistration(app_id, sender_ids,
+                       "Registration request sent", std::string());
+  }
+}
+
+void GCMStatsRecorder::RecordRegistrationResponse(
+    const std::string& app_id,
+    const std::vector<std::string>& sender_ids,
+    RegistrationRequest::Status status) {
+  if (is_recording_) {
+    RecordRegistration(app_id, JoinString(sender_ids, ","),
+                       "Registration response received",
+                       GetRegistrationStatusString(status));
+  }
+}
+
+void GCMStatsRecorder::RecordRegistrationRetryRequested(
+    const std::string& app_id,
+    const std::vector<std::string>& sender_ids,
+    int retries_left) {
+  if (is_recording_) {
+    RecordRegistration(app_id, JoinString(sender_ids, ","),
+                       "Registration retry requested",
+                       base::StringPrintf("Retries left: %d", retries_left));
+  }
+}
+
+void GCMStatsRecorder::RecordUnregistrationSent(
+    const std::string& app_id) {
+  UMA_HISTOGRAM_COUNTS("GCM.UnregistrationRequest", 1);
+  if (is_recording_) {
+    RecordRegistration(app_id, std::string(), "Unregistration request sent",
+                       std::string());
+  }
+}
+
+void GCMStatsRecorder::RecordUnregistrationResponse(
+    const std::string& app_id,
+    UnregistrationRequest::Status status) {
+  if (is_recording_) {
+    RecordRegistration(app_id,
+                       std::string(),
+                       "Unregistration response received",
+                       GetUnregistrationStatusString(status));
+  }
+}
+
+void GCMStatsRecorder::RecordUnregistrationRetryDelayed(
+    const std::string& app_id,
+    int64 delay_msec) {
+  if (is_recording_) {
+    RecordRegistration(app_id,
+                       std::string(),
+                       "Unregistration retry delayed",
+                       base::StringPrintf("Delayed for %" PRId64 " msec",
+                                          delay_msec));
+  }
+}
+
+void GCMStatsRecorder::RecordReceiving(
+    const std::string& app_id,
+    const std::string& from,
+    int message_byte_size,
+    const std::string& event,
+    const std::string& details) {
+  ReceivingActivity data;
+  ReceivingActivity* inserted_data = InsertCircularBuffer(
+      &receiving_activities_, data);
+  inserted_data->app_id = app_id;
+  inserted_data->from = from;
+  inserted_data->message_byte_size = message_byte_size;
+  inserted_data->event = event;
+  inserted_data->details = details;
+}
+
+void GCMStatsRecorder::RecordDataMessageRecieved(
+    const std::string& app_id,
+    const std::string& from,
+    int message_byte_size,
+    bool to_registered_app,
+    bool is_message_dropped) {
+  if (to_registered_app)
+    UMA_HISTOGRAM_COUNTS("GCM.DataMessageReceived", 1);
+  if (is_recording_) {
+    if (!to_registered_app) {
+      RecordReceiving(app_id, from, message_byte_size, "Data msg received",
+                      to_registered_app ? std::string() :
+                                          "No such registered app found");
+    } else if (is_message_dropped) {
+      RecordReceiving(app_id, from, message_byte_size, "Data msg received",
+                      "Message has been deleted on server");
+    } else {
+      RecordReceiving(app_id, from, message_byte_size, "Data msg received",
+                      std::string());
+    }
+  }
+}
+
+void GCMStatsRecorder::CollectActivities(
+    std::vector<ConnectionActivity>* connection_activities,
+    std::vector<RegistrationActivity>* registration_activities,
+    std::vector<ReceivingActivity>* receiving_activities,
+    std::vector<SendingActivity>* sending_activities) const {
+  connection_activities->insert(connection_activities->begin(),
+                                connection_activities_.begin(),
+                                connection_activities_.end());
+  registration_activities->insert(registration_activities->begin(),
+                                  registration_activities_.begin(),
+                                  registration_activities_.end());
+  receiving_activities->insert(receiving_activities->begin(),
+                               receiving_activities_.begin(),
+                               receiving_activities_.end());
+  sending_activities->insert(sending_activities->begin(),
+                             sending_activities_.begin(),
+                             sending_activities_.end());
 }
 
 void GCMStatsRecorder::RecordSending(const std::string& app_id,
                                      const std::string& receiver_id,
                                      const std::string& message_id,
                                      const std::string& event,
                                      const std::string& details) {
   SendingActivity data;
   SendingActivity* inserted_data = InsertCircularBuffer(
       &sending_activities_, data);
@@ skipping 40 matching lines @@
     const std::string& receiver_id,
     const std::string& message_id) {
   UMA_HISTOGRAM_COUNTS("GCM.IncomingSendErrors", 1);
   if (is_recording_) {
     RecordSending(app_id, receiver_id, message_id, "Received 'send error' msg",
                   std::string());
   }
 }
 
 }  // namespace gcm