1 // Copyright (c) 2013 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 NET_QUIC_QUIC_CONNECTION_LOGGER_H_ 6 #define NET_QUIC_QUIC_CONNECTION_LOGGER_H_ 7 8 #include <bitset> 9 10 #include "net/base/ip_endpoint.h" 11 #include "net/base/net_log.h" 12 #include "net/base/network_change_notifier.h" 13 #include "net/quic/quic_connection.h" 14 #include "net/quic/quic_protocol.h" 15 16 namespace net { 17 18 class CryptoHandshakeMessage; 19 20 // This class is a debug visitor of a QuicConnection which logs 21 // events to |net_log|. 22 class NET_EXPORT_PRIVATE QuicConnectionLogger 23 : public QuicConnectionDebugVisitor { 24 public: 25 explicit QuicConnectionLogger(const BoundNetLog& net_log); 26 27 virtual ~QuicConnectionLogger(); 28 29 // QuicPacketGenerator::DebugDelegateInterface 30 virtual void OnFrameAddedToPacket(const QuicFrame& frame) OVERRIDE; 31 32 // QuicConnectionDebugVisitorInterface 33 virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number, 34 EncryptionLevel level, 35 TransmissionType transmission_type, 36 const QuicEncryptedPacket& packet, 37 WriteResult result) OVERRIDE; 38 virtual void OnPacketRetransmitted( 39 QuicPacketSequenceNumber old_sequence_number, 40 QuicPacketSequenceNumber new_sequence_number) OVERRIDE; 41 virtual void OnPacketReceived(const IPEndPoint& self_address, 42 const IPEndPoint& peer_address, 43 const QuicEncryptedPacket& packet) OVERRIDE; 44 virtual void OnProtocolVersionMismatch(QuicVersion version) OVERRIDE; 45 virtual void OnPacketHeader(const QuicPacketHeader& header) OVERRIDE; 46 virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE; 47 virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE; 48 virtual void OnCongestionFeedbackFrame( 49 const QuicCongestionFeedbackFrame& frame) OVERRIDE; 50 virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE; 51 virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE; 52 virtual void OnConnectionCloseFrame( 53 const QuicConnectionCloseFrame& frame) OVERRIDE; 54 virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE; 55 virtual void OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE; 56 virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE; 57 virtual void OnPingFrame(const QuicPingFrame& frame) OVERRIDE; 58 virtual void OnPublicResetPacket( 59 const QuicPublicResetPacket& packet) OVERRIDE; 60 virtual void OnVersionNegotiationPacket( 61 const QuicVersionNegotiationPacket& packet) OVERRIDE; 62 virtual void OnRevivedPacket(const QuicPacketHeader& revived_header, 63 base::StringPiece payload) OVERRIDE; 64 65 void OnCryptoHandshakeMessageReceived( 66 const CryptoHandshakeMessage& message); 67 void OnCryptoHandshakeMessageSent( 68 const CryptoHandshakeMessage& message); 69 void OnConnectionClosed(QuicErrorCode error, bool from_peer); 70 void OnSuccessfulVersionNegotiation(const QuicVersion& version); 71 void UpdateReceivedFrameCounts(QuicStreamId stream_id, 72 int num_frames_received, 73 int num_duplicate_frames_received); 74 75 private: 76 // Do a factory get for a histogram for recording data, about individual 77 // packet sequence numbers, that was gathered in the vectors 78 // received_packets_ and received_acks_. |statistic_name| identifies which 79 // element of data is recorded, and is used to form the histogram name. 80 base::HistogramBase* GetPacketSequenceNumberHistogram( 81 const char* statistic_name) const; 82 // Do a factory get for a histogram to record a 6-packet loss-sequence as a 83 // sample. The histogram will record the 64 distinct possible combinations. 84 // |which_6| is used to adjust the name of the histogram to distinguish the 85 // first 6 packets in a connection, vs. some later 6 packets. 86 base::HistogramBase* Get6PacketHistogram(const char* which_6) const; 87 // Do a factory get for a histogram to record cumulative stats across a 21 88 // packet sequence. |which_21| is used to adjust the name of the histogram 89 // to distinguish the first 21 packets' loss data, vs. some later 21 packet 90 // sequences' loss data. 91 base::HistogramBase* Get21CumulativeHistogram(const char* which_21) const; 92 // Add samples associated with a |bit_mask_of_packets| to the given histogram 93 // that was provided by Get21CumulativeHistogram(). The LSB of that mask 94 // corresponds to the oldest packet sequence number in the series of packets, 95 // and the bit in the 2^20 position corresponds to the most recently received 96 // packet. Of the maximum of 21 bits that are valid (correspond to packets), 97 // only the most significant |valid_bits_in_mask| are processed. 98 // A bit value of 0 indicates that a packet was never received, and a 1 99 // indicates the packet was received. 100 static void AddTo21CumulativeHistogram(base::HistogramBase* histogram, 101 int bit_mask_of_packets, 102 int valid_bits_in_mask); 103 // For connections longer than 21 received packets, this call will calculate 104 // the overall packet loss rate, and record it into a histogram. 105 void RecordAggregatePacketLossRate() const; 106 // At destruction time, this records results of |pacaket_received_| into 107 // histograms for specific connection types. 108 void RecordLossHistograms() const; 109 110 BoundNetLog net_log_; 111 // The last packet sequence number received. 112 QuicPacketSequenceNumber last_received_packet_sequence_number_; 113 // The size of the most recently received packet. 114 size_t last_received_packet_size_; 115 // The largest packet sequence number received. In the case where a packet is 116 // received late (out of order), this value will not be updated. 117 QuicPacketSequenceNumber largest_received_packet_sequence_number_; 118 // The largest packet sequence number which the peer has failed to 119 // receive, according to the missing packet set in their ack frames. 120 QuicPacketSequenceNumber largest_received_missing_packet_sequence_number_; 121 // Number of times that the current received packet sequence number is 122 // smaller than the last received packet sequence number. 123 size_t num_out_of_order_received_packets_; 124 // The number of times that OnPacketHeader was called. 125 // If the network replicates packets, then this number may be slightly 126 // different from the real number of distinct packets received. 127 QuicPacketSequenceNumber num_packets_received_; 128 // Number of times a truncated ACK frame was sent. 129 size_t num_truncated_acks_sent_; 130 // Number of times a truncated ACK frame was received. 131 size_t num_truncated_acks_received_; 132 // The kCADR value provided by the server in ServerHello. 133 IPEndPoint local_address_from_shlo_; 134 // The first local address from which a packet was received. 135 IPEndPoint local_address_from_self_; 136 // Count of the number of frames received. 137 int num_frames_received_; 138 // Count of the number of duplicate frames received. 139 int num_duplicate_frames_received_; 140 // Vector of inital packets status' indexed by packet sequence numbers, where 141 // false means never received. Zero is not a valid packet sequence number, so 142 // that offset is never used, and we'll track 150 packets. 143 std::bitset<151> received_packets_; 144 // Vector to indicate which of the initial 150 received packets turned out to 145 // contain solo ACK frames. An element is true iff an ACK frame was in the 146 // corresponding packet, and there was very little else. 147 std::bitset<151> received_acks_; 148 // The available type of connection (WiFi, 3G, etc.) when connection was first 149 // used. 150 const char* const connection_description_; 151 152 DISALLOW_COPY_AND_ASSIGN(QuicConnectionLogger); 153 }; 154 155 } // namespace net 156 157 #endif // NET_QUIC_QUIC_CONNECTION_LOGGER_H_ 158