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