Add activity recording capability to gcm internals page. User can refresh, start/stop recording, an…

google_apis/gcm/engine/mcs_client.cc

 // Copyright 2013 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/engine/mcs_client.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 45 matching lines @@
     return false;
   std::vector<std::string> new_list;
   for (int i = 0; i < selective_ack.id_size(); ++i) {
     DCHECK(!selective_ack.id(i).empty());
     new_list.push_back(selective_ack.id(i));
   }
   id_list->swap(new_list);
   return true;
 }
 
+// Helper for getting string representation of the MessageSendStatus enum.
+std::string GetMessageSendStatusString(

[fgorski, 2014/03/18 21:28:37]

This should happen closer to UI. MCS client should not care about what gets
printed.

[juyik, 2014/03/20 01:09:53]

Following my comments about SoC principle in gcm_stats_recorder.h, these are
string representations of MCS client states so they should stay with the MCS
logic owner. And if the enum ever changes, it would be easier to change this
function since it stays closer to the enum definition.

+    gcm::MCSClient::MessageSendStatus status) {
+  switch (status) {
+    case gcm::MCSClient::QUEUED:
+      return "QUEUED";
+    case gcm::MCSClient::SENT:
+      return "SENT";
+    case gcm::MCSClient::QUEUE_SIZE_LIMIT_REACHED:
+      return "QUEUE_SIZE_LIMIT_REACHED";
+    case gcm::MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
+      return "APP_QUEUE_SIZE_LIMIT_REACHED";
+    case gcm::MCSClient::MESSAGE_TOO_LARGE:
+      return "MESSAGE_TOO_LARGE";
+    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";
+  }
+}
+
 }  // namespace
 
 class CollapseKey {
  public:
   explicit CollapseKey(const mcs_proto::DataMessageStanza& message);
   ~CollapseKey();
 
   // Comparison operator for use in maps.
   bool operator<(const CollapseKey& right) const;
 
@@ skipping 45 matching lines @@
 
   // The protobuf of the message itself.
   MCSProto protobuf;
 };
 
 ReliablePacketInfo::ReliablePacketInfo()
   : stream_id(0), tag(0) {
 }
 ReliablePacketInfo::~ReliablePacketInfo() {}
 
+int MCSClient::GetSendQueueSize() const {
+  return to_send_.size();

[fgorski, 2014/03/18 21:28:37]

Could we pass these values to the recorder every time we complete processing the
queues? It seems like we are adding to the interface of different classes when
we could centralize around the log collector/recorder.

[juyik, 2014/03/20 01:09:53]

It seems that having a snapshot of these items (like queue size, username,
android id, etc) is sufficiently useful; it is not necessary to build a change
history/log for them. So if we're not building a history, then notify the
recorder on every change is not very efficient and costs a lot of execution
cycles. Besides, some of the items might get changed from multiple code paths,
so adding recording code to all those paths clutters the code. And if a new code
path is added to change the item, it is easy to miss the recording step.

+}
+
+int MCSClient::GetUnackedQueueSize() const {
+  return to_resend_.size();
+}
+
 std::string MCSClient::GetStateString() const {
   switch(state_) {
     case UNINITIALIZED:
       return "UNINITIALIZED";
     case LOADED:
       return "LOADED";
     case CONNECTING:
       return "CONNECTING";
     case CONNECTED:
       return "CONNECTED";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 MCSClient::MCSClient(const std::string& version_string,
                      base::Clock* clock,
                      ConnectionFactory* connection_factory,
-                     GCMStore* gcm_store)
+                     GCMStore* gcm_store,
+                     GCMStatsRecorder* recorder)
     : version_string_(version_string),
       clock_(clock),
       state_(UNINITIALIZED),
       android_id_(0),
       security_token_(0),
       connection_factory_(connection_factory),
       connection_handler_(NULL),
       last_device_to_server_stream_id_received_(0),
       last_server_to_device_stream_id_received_(0),
       stream_id_out_(0),
       stream_id_in_(0),
       gcm_store_(gcm_store),
+      recorder_(recorder),
       weak_ptr_factory_(this) {
 }
 
 MCSClient::~MCSClient() {
 }
 
 void MCSClient::Initialize(
     const ErrorCallback& error_callback,
     const OnMessageReceivedCallback& message_received_callback,
     const OnMessageSentCallback& message_sent_callback,
@@ skipping 315 matching lines @@
   if (packet_info->tag == kDataMessageStanzaTag) {
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
             packet_info->protobuf.get());
     uint64 sent = data_message->sent();
     DCHECK_GT(sent, 0U);
     int queued = (clock_->Now().ToInternalValue() /
         base::Time::kMicrosecondsPerSecond) - sent;
     DVLOG(1) << "Message was queued for " << queued << " seconds.";
     data_message->set_queued(queued);
+    recorder_->RecordSendWithDetails(
+        data_message->category(),
+        gcm::GCMStatsRecorder::Intermediate,
+        data_message->to(),
+        data_message->id(),
+        packet_info->protobuf->ByteSize(),
+        "SENT TO WIRE");
   }
 
   // Set the proper last received stream id to acknowledge received server
   // packets.
   DVLOG(1) << "Setting last stream id received to "
            << stream_id_in_;
   SetLastStreamIdReceived(stream_id_in_,
                           packet_info->protobuf.get());
   if (stream_id_in_ != last_server_to_device_stream_id_received_) {
     last_server_to_device_stream_id_received_ = stream_id_in_;
@@ skipping 347 matching lines @@
 }
 
 void MCSClient::NotifyMessageSendStatus(
     const google::protobuf::MessageLite& protobuf,
     MessageSendStatus status) {
   if (GetMCSProtoTag(protobuf) != kDataMessageStanzaTag)
     return;
 
   const mcs_proto::DataMessageStanza* data_message_stanza =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf);
+  recorder_->RecordSendWithDetails(
+      data_message_stanza->category(),
+      status == SENT ? gcm::GCMStatsRecorder::Success :
+          (status == QUEUED ? gcm::GCMStatsRecorder::Intermediate :
+              gcm::GCMStatsRecorder::Failure),
+      data_message_stanza->to(),
+      data_message_stanza->id(),
+      protobuf.ByteSize(),
+      GetMessageSendStatusString(status));
   message_sent_callback_.Run(
       data_message_stanza->device_user_id(),
       data_message_stanza->category(),
       data_message_stanza->id(),
       status);
 }
 
 void MCSClient::SetGCMStoreForTesting(GCMStore* gcm_store) {
   gcm_store_ = gcm_store;
 }
 
 MCSClient::MCSPacketInternal MCSClient::PopMessageForSend() {
   MCSPacketInternal packet = to_send_.front();
   to_send_.pop_front();
 
   if (packet->tag == kDataMessageStanzaTag) {
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(packet->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid())
       collapse_key_map_.erase(collapse_key);
   }
 
   return packet;
 }
 
 } // namespace gcm