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