QUIC - Added histogram to track how often chrome sends/receives

net/quic/quic_connection_logger.cc

 // Copyright (c) 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 "net/quic/quic_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "net/quic/quic_address_mismatch.h"
 #include "net/quic/quic_socket_address_coder.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
+// Histograms to track how often chrome sends/receives flow-control BLOCKED
+// frames. Note: these values must be kept in sync with the corresponding values
+// in: tools/metrics/histograms/histograms.xml
+enum BlockedFrameType {
+  BLOCKED_FRAME_RECEIVED = 0,
+  BLOCKED_FRAME_SENT = 1,
+  NUM_BLOCKED_FRAMES = 2,
+};
+
 // We have ranges-of-buckets in the cumulative histogram (covering 21 packet
 // sequences) of length 2, 3, 4, ... 22.
 // Hence the largest sample is bounded by the sum of those numbers.
 const int kBoundingSampleInCumulativeHistogram = ((2 + 22) * 21) / 2;
 
+void RecordBlockedFrame(BlockedFrameType blocked_frame_type) {
+  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.FlowControlBlockedFrame",
+                            blocked_frame_type, NUM_BLOCKED_FRAMES);

[Ryan Hamilton, 2014/10/21 19:48:14]

Instead of recording entry each time we become blocked, I wonder if it would be
more useful to record, say, the number of total blocked frames sent/received
when a connection is finished?

[ramant (doing other things), 2014/10/21 22:05:31]

Done.

+}
+
 base::Value* NetLogQuicPacketCallback(const IPEndPoint* self_address,
                                       const IPEndPoint* peer_address,
                                       size_t packet_size,
                                       NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("self_address", self_address->ToString());
   dict->SetString("peer_address", peer_address->ToString());
   dict->SetInteger("size", packet_size);
   return dict;
 }
@@ skipping 388 matching lines @@
           base::Bind(&NetLogQuicGoAwayFrameCallback,
                      frame.goaway_frame));
       break;
     case WINDOW_UPDATE_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
           base::Bind(&NetLogQuicWindowUpdateFrameCallback,
                      frame.window_update_frame));
       break;
     case BLOCKED_FRAME:
+      RecordBlockedFrame(BLOCKED_FRAME_SENT);
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_SENT,
           base::Bind(&NetLogQuicBlockedFrameCallback,
                      frame.blocked_frame));
       break;
     case STOP_WAITING_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
           base::Bind(&NetLogQuicStopWaitingFrameCallback,
                      frame.stop_waiting_frame));
@@ skipping 174 matching lines @@
 }
 
 void QuicConnectionLogger::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
       base::Bind(&NetLogQuicWindowUpdateFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnBlockedFrame(const QuicBlockedFrame& frame) {
+  RecordBlockedFrame(BLOCKED_FRAME_RECEIVED);
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
       base::Bind(&NetLogQuicBlockedFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
       base::Bind(&NetLogQuicGoAwayFrameCallback, &frame));
 }
@@ skipping 235 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net