components/gcm_driver/gcm_stats_recorder_impl.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_
   6 #define COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_
   7
   8 #include <deque>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/time/time.h"
  13 #include "components/gcm_driver/gcm_activity.h"
  14 #include "google_apis/gcm/engine/connection_factory.h"
  15 #include "google_apis/gcm/engine/mcs_client.h"
  16 #include "google_apis/gcm/engine/registration_request.h"
  17 #include "google_apis/gcm/engine/unregistration_request.h"
  18 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
  19
  20 namespace gcm {
  21
  22 // Records GCM internal stats and activities for debugging purpose. Recording
  23 // can be turned on/off by calling SetRecording(...) function. It is turned off
  24 // by default.
  25 // This class is not thread safe. It is meant to be owned by a gcm client
  26 // instance.
  27 class GCMStatsRecorderImpl : public GCMStatsRecorder {
  28  public:
  29   GCMStatsRecorderImpl();
  30   virtual ~GCMStatsRecorderImpl();
  31
  32   // Indicates whether the recorder is currently recording activities or not.
  33   bool is_recording() const {
  34     return is_recording_;
  35   }
  36
  37   // Turns recording on/off.
  38   void SetRecording(bool recording);
  39
  40   // Set a delegate to receive callback from the recorder.
  41   void SetDelegate(Delegate* delegate);
  42
  43   // Clear all recorded activities.
  44   void Clear();
  45
  46   // GCMStatsRecorder implementation:
  47   virtual void RecordCheckinInitiated(uint64 android_id) OVERRIDE;
  48   virtual void RecordCheckinDelayedDueToBackoff(int64 delay_msec) OVERRIDE;
  49   virtual void RecordCheckinSuccess() OVERRIDE;
  50   virtual void RecordCheckinFailure(std::string status,
  51                                     bool will_retry) OVERRIDE;
  52   virtual void RecordConnectionInitiated(const std::string& host) OVERRIDE;
  53   virtual void RecordConnectionDelayedDueToBackoff(int64 delay_msec) OVERRIDE;
  54   virtual void RecordConnectionSuccess() OVERRIDE;
  55   virtual void RecordConnectionFailure(int network_error) OVERRIDE;
  56   virtual void RecordConnectionResetSignaled(
  57       ConnectionFactory::ConnectionResetReason reason) OVERRIDE;
  58   virtual void RecordRegistrationSent(const std::string& app_id,
  59                                       const std::string& sender_ids) OVERRIDE;
  60   virtual void RecordRegistrationResponse(
  61       const std::string& app_id,
  62       const std::vector<std::string>& sender_ids,
  63       RegistrationRequest::Status status) OVERRIDE;
  64   virtual void RecordRegistrationRetryRequested(
  65       const std::string& app_id,
  66       const std::vector<std::string>& sender_ids,
  67       int retries_left) OVERRIDE;
  68   virtual void RecordUnregistrationSent(const std::string& app_id) OVERRIDE;
  69   virtual void RecordUnregistrationResponse(
  70       const std::string& app_id,
  71       UnregistrationRequest::Status status) OVERRIDE;
  72   virtual void RecordUnregistrationRetryDelayed(const std::string& app_id,
  73                                                 int64 delay_msec) OVERRIDE;
  74   virtual void RecordDataMessageReceived(
  75       const std::string& app_id,
  76       const std::string& from,
  77       int message_byte_size,
  78       bool to_registered_app,
  79       ReceivedMessageType message_type) OVERRIDE;
  80   virtual void RecordDataSentToWire(const std::string& app_id,
  81                                     const std::string& receiver_id,
  82                                     const std::string& message_id,
  83                                     int queued) OVERRIDE;
  84   virtual void RecordNotifySendStatus(const std::string& app_id,
  85                                       const std::string& receiver_id,
  86                                       const std::string& message_id,
  87                                       MCSClient::MessageSendStatus status,
  88                                       int byte_size,
  89                                       int ttl) OVERRIDE;
  90   virtual void RecordIncomingSendError(const std::string& app_id,
  91                                        const std::string& receiver_id,
  92                                        const std::string& message_id) OVERRIDE;
  93
  94   // Collect all recorded activities into the struct.
  95   void CollectActivities(RecordedActivities* recorder_activities) const;
  96
  97   const std::deque<CheckinActivity>& checkin_activities() const {
  98     return checkin_activities_;
  99   }
 100   const std::deque<ConnectionActivity>& connection_activities() const {
 101     return connection_activities_;
 102   }
 103   const std::deque<RegistrationActivity>& registration_activities() const {
 104     return registration_activities_;
 105   }
 106   const std::deque<ReceivingActivity>& receiving_activities() const {
 107     return receiving_activities_;
 108   }
 109   const std::deque<SendingActivity>& sending_activities() const {
 110     return sending_activities_;
 111   }
 112
 113  protected:
 114   // Notify the recorder delegate, if it exists, that an activity has been
 115   // recorded.
 116   void NotifyActivityRecorded();
 117
 118   void RecordCheckin(const std::string& event,
 119                      const std::string& details);
 120
 121   void RecordConnection(const std::string& event,
 122                         const std::string& details);
 123
 124   void RecordRegistration(const std::string& app_id,
 125                           const std::string& sender_id,
 126                           const std::string& event,
 127                           const std::string& details);
 128
 129   void RecordReceiving(const std::string& app_id,
 130                        const std::string& from,
 131                        int message_byte_size,
 132                        const std::string& event,
 133                        const std::string& details);
 134
 135   void RecordSending(const std::string& app_id,
 136                      const std::string& receiver_id,
 137                      const std::string& message_id,
 138                      const std::string& event,
 139                      const std::string& details);
 140
 141   bool is_recording_;
 142   Delegate* delegate_;
 143
 144   std::deque<CheckinActivity> checkin_activities_;
 145   std::deque<ConnectionActivity> connection_activities_;
 146   std::deque<RegistrationActivity> registration_activities_;
 147   std::deque<ReceivingActivity> receiving_activities_;
 148   std::deque<SendingActivity> sending_activities_;
 149
 150   base::TimeTicks last_connection_initiation_time_;
 151   base::TimeTicks last_connection_success_time_;
 152   bool data_message_received_since_connected_;
 153   base::TimeTicks last_received_data_message_burst_start_time_;
 154   base::TimeTicks last_received_data_message_time_within_burst_;
 155   int64 received_data_message_burst_size_;
 156
 157   DISALLOW_COPY_AND_ASSIGN(GCMStatsRecorderImpl);
 158 };
 159
 160 }  // namespace gcm
 161
 162 #endif  // COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_