1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/quic/quic_connection_logger.h"
6
7 #include <algorithm>
8 #include <limits>
9 #include <memory>
10 #include <utility>
11 #include <vector>
12
13 #include "base/metrics/histogram_base.h"
14 #include "base/metrics/histogram_functions.h"
15 #include "base/metrics/histogram_macros.h"
16 #include "base/values.h"
17 #include "net/base/ip_address.h"
18 #include "net/cert/x509_certificate.h"
19 #include "net/quic/address_utils.h"
20 #include "net/quic/quic_address_mismatch.h"
21 #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake_message.h"
22 #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_protocol.h"
23 #include "net/third_party/quiche/src/quiche/quic/core/quic_connection_id.h"
24 #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
25 #include "net/third_party/quiche/src/quiche/quic/core/quic_socket_address_coder.h"
26 #include "net/third_party/quiche/src/quiche/quic/core/quic_time.h"
27 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
28
29 using quic::kMaxOutgoingPacketSize;
30 using std::string;
31
32 namespace net {
33
34 namespace {
35
36 // If |address| is an IPv4-mapped IPv6 address, returns ADDRESS_FAMILY_IPV4
37 // instead of ADDRESS_FAMILY_IPV6. Othewise, behaves like GetAddressFamily().
GetRealAddressFamily(const IPAddress & address)38 AddressFamily GetRealAddressFamily(const IPAddress& address) {
39 return address.IsIPv4MappedIPv6() ? ADDRESS_FAMILY_IPV4
40 : GetAddressFamily(address);
41 }
42
43 } // namespace
44
QuicConnectionLogger(quic::QuicSession * session,const char * const connection_description,std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,const NetLogWithSource & net_log)45 QuicConnectionLogger::QuicConnectionLogger(
46 quic::QuicSession* session,
47 const char* const connection_description,
48 std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
49 const NetLogWithSource& net_log)
50 : session_(session),
51 connection_description_(connection_description),
52 socket_performance_watcher_(std::move(socket_performance_watcher)),
53 event_logger_(session, net_log) {}
54
~QuicConnectionLogger()55 QuicConnectionLogger::~QuicConnectionLogger() {
56 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.OutOfOrderPacketsReceived",
57 num_out_of_order_received_packets_);
58 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.OutOfOrderLargePacketsReceived",
59 num_out_of_order_large_received_packets_);
60 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.IncorrectConnectionIDsReceived",
61 num_incorrect_connection_ids_);
62 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.UndecryptablePacketsReceived",
63 num_undecryptable_packets_);
64 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.DuplicatePacketsReceived",
65 num_duplicate_packets_);
66 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.BlockedFrames.Received",
67 num_blocked_frames_received_);
68 UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.BlockedFrames.Sent",
69 num_blocked_frames_sent_);
70
71 const quic::QuicConnectionStats& stats = session_->connection()->GetStats();
72 UMA_HISTOGRAM_TIMES("Net.QuicSession.MinRTT",
73 base::Microseconds(stats.min_rtt_us));
74 UMA_HISTOGRAM_TIMES("Net.QuicSession.SmoothedRTT",
75 base::Microseconds(stats.srtt_us));
76
77 if (num_frames_received_ > 0) {
78 int duplicate_stream_frame_per_thousand =
79 num_duplicate_frames_received_ * 1000 / num_frames_received_;
80 if (num_packets_received_ < 100) {
81 UMA_HISTOGRAM_CUSTOM_COUNTS(
82 "Net.QuicSession.StreamFrameDuplicatedShortConnection",
83 duplicate_stream_frame_per_thousand, 1, 1000, 75);
84 } else {
85 UMA_HISTOGRAM_CUSTOM_COUNTS(
86 "Net.QuicSession.StreamFrameDuplicatedLongConnection",
87 duplicate_stream_frame_per_thousand, 1, 1000, 75);
88 }
89 }
90
91 RecordAggregatePacketLossRate();
92 }
93
OnFrameAddedToPacket(const quic::QuicFrame & frame)94 void QuicConnectionLogger::OnFrameAddedToPacket(const quic::QuicFrame& frame) {
95 switch (frame.type) {
96 case quic::PADDING_FRAME:
97 break;
98 case quic::STREAM_FRAME:
99 break;
100 case quic::ACK_FRAME: {
101 break;
102 }
103 case quic::RST_STREAM_FRAME:
104 base::UmaHistogramSparse("Net.QuicSession.RstStreamErrorCodeClient",
105 frame.rst_stream_frame->error_code);
106 break;
107 case quic::CONNECTION_CLOSE_FRAME:
108 break;
109 case quic::GOAWAY_FRAME:
110 break;
111 case quic::WINDOW_UPDATE_FRAME:
112 break;
113 case quic::BLOCKED_FRAME:
114 ++num_blocked_frames_sent_;
115 break;
116 case quic::STOP_WAITING_FRAME:
117 break;
118 case quic::PING_FRAME:
119 UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
120 session_->IsConnectionFlowControlBlocked());
121 UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
122 session_->IsStreamFlowControlBlocked());
123 break;
124 case quic::MTU_DISCOVERY_FRAME:
125 break;
126 case quic::NEW_CONNECTION_ID_FRAME:
127 break;
128 case quic::MAX_STREAMS_FRAME:
129 break;
130 case quic::STREAMS_BLOCKED_FRAME:
131 break;
132 case quic::PATH_RESPONSE_FRAME:
133 break;
134 case quic::PATH_CHALLENGE_FRAME:
135 break;
136 case quic::STOP_SENDING_FRAME:
137 base::UmaHistogramSparse("Net.QuicSession.StopSendingErrorCodeClient",
138 frame.stop_sending_frame.error_code);
139 break;
140 case quic::MESSAGE_FRAME:
141 break;
142 case quic::CRYPTO_FRAME:
143 break;
144 case quic::NEW_TOKEN_FRAME:
145 break;
146 case quic::RETIRE_CONNECTION_ID_FRAME:
147 break;
148 default:
149 DCHECK(false) << "Illegal frame type: " << frame.type;
150 }
151 event_logger_.OnFrameAddedToPacket(frame);
152 }
153
OnStreamFrameCoalesced(const quic::QuicStreamFrame & frame)154 void QuicConnectionLogger::OnStreamFrameCoalesced(
155 const quic::QuicStreamFrame& frame) {
156 event_logger_.OnStreamFrameCoalesced(frame);
157 }
158
OnPacketSent(quic::QuicPacketNumber packet_number,quic::QuicPacketLength packet_length,bool has_crypto_handshake,quic::TransmissionType transmission_type,quic::EncryptionLevel encryption_level,const quic::QuicFrames & retransmittable_frames,const quic::QuicFrames & nonretransmittable_frames,quic::QuicTime sent_time,uint32_t batch_id)159 void QuicConnectionLogger::OnPacketSent(
160 quic::QuicPacketNumber packet_number,
161 quic::QuicPacketLength packet_length,
162 bool has_crypto_handshake,
163 quic::TransmissionType transmission_type,
164 quic::EncryptionLevel encryption_level,
165 const quic::QuicFrames& retransmittable_frames,
166 const quic::QuicFrames& nonretransmittable_frames,
167 quic::QuicTime sent_time,
168 uint32_t batch_id) {
169 // 4.4.1.4. Minimum Packet Size
170 // The payload of a UDP datagram carrying the Initial packet MUST be
171 // expanded to at least 1200 octets
172 const quic::QuicPacketLength kMinClientInitialPacketLength = 1200;
173 switch (encryption_level) {
174 case quic::ENCRYPTION_INITIAL:
175 UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.Initial",
176 packet_length, 1, kMaxOutgoingPacketSize, 50);
177 if (packet_length < kMinClientInitialPacketLength) {
178 UMA_HISTOGRAM_CUSTOM_COUNTS(
179 "Net.QuicSession.TooSmallInitialSentPacket",
180 kMinClientInitialPacketLength - packet_length, 1,
181 kMinClientInitialPacketLength, 50);
182 }
183 break;
184 case quic::ENCRYPTION_HANDSHAKE:
185 UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.Handshake",
186 packet_length, 1, kMaxOutgoingPacketSize, 50);
187 break;
188 case quic::ENCRYPTION_ZERO_RTT:
189 UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.0RTT",
190 packet_length, 1, kMaxOutgoingPacketSize, 50);
191 break;
192 case quic::ENCRYPTION_FORWARD_SECURE:
193 UMA_HISTOGRAM_CUSTOM_COUNTS(
194 "Net.QuicSession.SendPacketSize.ForwardSecure", packet_length, 1,
195 kMaxOutgoingPacketSize, 50);
196 break;
197 case quic::NUM_ENCRYPTION_LEVELS:
198 NOTREACHED();
199 break;
200 }
201
202 event_logger_.OnPacketSent(packet_number, packet_length, has_crypto_handshake,
203 transmission_type, encryption_level,
204 retransmittable_frames, nonretransmittable_frames,
205 sent_time, batch_id);
206 }
207
OnPacketLoss(quic::QuicPacketNumber lost_packet_number,quic::EncryptionLevel encryption_level,quic::TransmissionType transmission_type,quic::QuicTime detection_time)208 void QuicConnectionLogger::OnPacketLoss(
209 quic::QuicPacketNumber lost_packet_number,
210 quic::EncryptionLevel encryption_level,
211 quic::TransmissionType transmission_type,
212 quic::QuicTime detection_time) {
213 event_logger_.OnPacketLoss(lost_packet_number, encryption_level,
214 transmission_type, detection_time);
215 }
216
OnConfigProcessed(const quic::QuicSentPacketManager::DebugDelegate::SendParameters & parameters)217 void QuicConnectionLogger::OnConfigProcessed(
218 const quic::QuicSentPacketManager::DebugDelegate::SendParameters&
219 parameters) {
220 event_logger_.OnConfigProcessed(parameters);
221 }
222
OnPingSent()223 void QuicConnectionLogger::OnPingSent() {
224 no_packet_received_after_ping_ = true;
225 }
226
OnPacketReceived(const quic::QuicSocketAddress & self_address,const quic::QuicSocketAddress & peer_address,const quic::QuicEncryptedPacket & packet)227 void QuicConnectionLogger::OnPacketReceived(
228 const quic::QuicSocketAddress& self_address,
229 const quic::QuicSocketAddress& peer_address,
230 const quic::QuicEncryptedPacket& packet) {
231 if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
232 local_address_from_self_ = ToIPEndPoint(self_address);
233 UMA_HISTOGRAM_ENUMERATION(
234 "Net.QuicSession.ConnectionTypeFromSelf",
235 GetRealAddressFamily(ToIPEndPoint(self_address).address()),
236 ADDRESS_FAMILY_LAST);
237 }
238
239 previous_received_packet_size_ = last_received_packet_size_;
240 last_received_packet_size_ = packet.length();
241 event_logger_.OnPacketReceived(self_address, peer_address, packet);
242 }
243
OnUnauthenticatedHeader(const quic::QuicPacketHeader & header)244 void QuicConnectionLogger::OnUnauthenticatedHeader(
245 const quic::QuicPacketHeader& header) {
246 event_logger_.OnUnauthenticatedHeader(header);
247 }
248
OnIncorrectConnectionId(quic::QuicConnectionId connection_id)249 void QuicConnectionLogger::OnIncorrectConnectionId(
250 quic::QuicConnectionId connection_id) {
251 ++num_incorrect_connection_ids_;
252 }
253
OnUndecryptablePacket(quic::EncryptionLevel decryption_level,bool dropped)254 void QuicConnectionLogger::OnUndecryptablePacket(
255 quic::EncryptionLevel decryption_level,
256 bool dropped) {
257 ++num_undecryptable_packets_;
258 event_logger_.OnUndecryptablePacket(decryption_level, dropped);
259 }
260
OnAttemptingToProcessUndecryptablePacket(quic::EncryptionLevel decryption_level)261 void QuicConnectionLogger::OnAttemptingToProcessUndecryptablePacket(
262 quic::EncryptionLevel decryption_level) {
263 event_logger_.OnAttemptingToProcessUndecryptablePacket(decryption_level);
264 }
265
OnDuplicatePacket(quic::QuicPacketNumber packet_number)266 void QuicConnectionLogger::OnDuplicatePacket(
267 quic::QuicPacketNumber packet_number) {
268 ++num_duplicate_packets_;
269 event_logger_.OnDuplicatePacket(packet_number);
270 }
271
OnProtocolVersionMismatch(quic::ParsedQuicVersion received_version)272 void QuicConnectionLogger::OnProtocolVersionMismatch(
273 quic::ParsedQuicVersion received_version) {
274 // TODO(rtenneti): Add logging.
275 }
276
OnPacketHeader(const quic::QuicPacketHeader & header,quic::QuicTime receive_time,quic::EncryptionLevel level)277 void QuicConnectionLogger::OnPacketHeader(const quic::QuicPacketHeader& header,
278 quic::QuicTime receive_time,
279 quic::EncryptionLevel level) {
280 if (!first_received_packet_number_.IsInitialized()) {
281 first_received_packet_number_ = header.packet_number;
282 } else if (header.packet_number < first_received_packet_number_) {
283 // Ignore packets with packet numbers less than
284 // first_received_packet_number_.
285 return;
286 }
287 ++num_packets_received_;
288 if (!largest_received_packet_number_.IsInitialized()) {
289 largest_received_packet_number_ = header.packet_number;
290 } else if (largest_received_packet_number_ < header.packet_number) {
291 uint64_t delta = header.packet_number - largest_received_packet_number_;
292 if (delta > 1) {
293 // There is a gap between the largest packet previously received and
294 // the current packet. This indicates either loss, or out-of-order
295 // delivery.
296 UMA_HISTOGRAM_COUNTS_1M(
297 "Net.QuicSession.PacketGapReceived",
298 static_cast<base::HistogramBase::Sample>(delta - 1));
299 }
300 largest_received_packet_number_ = header.packet_number;
301 }
302 if (header.packet_number - first_received_packet_number_ <
303 received_packets_.size()) {
304 received_packets_[header.packet_number - first_received_packet_number_] =
305 true;
306 }
307 if (last_received_packet_number_.IsInitialized() &&
308 header.packet_number < last_received_packet_number_) {
309 ++num_out_of_order_received_packets_;
310 if (previous_received_packet_size_ < last_received_packet_size_)
311 ++num_out_of_order_large_received_packets_;
312 UMA_HISTOGRAM_COUNTS_1M(
313 "Net.QuicSession.OutOfOrderGapReceived",
314 static_cast<base::HistogramBase::Sample>(last_received_packet_number_ -
315 header.packet_number));
316 } else if (no_packet_received_after_ping_) {
317 if (last_received_packet_number_.IsInitialized()) {
318 UMA_HISTOGRAM_COUNTS_1M(
319 "Net.QuicSession.PacketGapReceivedNearPing",
320 static_cast<base::HistogramBase::Sample>(
321 header.packet_number - last_received_packet_number_));
322 }
323 no_packet_received_after_ping_ = false;
324 }
325 last_received_packet_number_ = header.packet_number;
326 event_logger_.OnPacketHeader(header, receive_time, level);
327 }
328
OnStreamFrame(const quic::QuicStreamFrame & frame)329 void QuicConnectionLogger::OnStreamFrame(const quic::QuicStreamFrame& frame) {
330 event_logger_.OnStreamFrame(frame);
331 }
332
OnPathChallengeFrame(const quic::QuicPathChallengeFrame & frame)333 void QuicConnectionLogger::OnPathChallengeFrame(
334 const quic::QuicPathChallengeFrame& frame) {
335 event_logger_.OnPathChallengeFrame(frame);
336 }
337
OnPathResponseFrame(const quic::QuicPathResponseFrame & frame)338 void QuicConnectionLogger::OnPathResponseFrame(
339 const quic::QuicPathResponseFrame& frame) {
340 event_logger_.OnPathResponseFrame(frame);
341 }
342
OnCryptoFrame(const quic::QuicCryptoFrame & frame)343 void QuicConnectionLogger::OnCryptoFrame(const quic::QuicCryptoFrame& frame) {
344 event_logger_.OnCryptoFrame(frame);
345 }
346
OnStopSendingFrame(const quic::QuicStopSendingFrame & frame)347 void QuicConnectionLogger::OnStopSendingFrame(
348 const quic::QuicStopSendingFrame& frame) {
349 base::UmaHistogramSparse("Net.QuicSession.StopSendingErrorCodeServer",
350 frame.error_code);
351 event_logger_.OnStopSendingFrame(frame);
352 }
353
OnStreamsBlockedFrame(const quic::QuicStreamsBlockedFrame & frame)354 void QuicConnectionLogger::OnStreamsBlockedFrame(
355 const quic::QuicStreamsBlockedFrame& frame) {
356 event_logger_.OnStreamsBlockedFrame(frame);
357 }
358
OnMaxStreamsFrame(const quic::QuicMaxStreamsFrame & frame)359 void QuicConnectionLogger::OnMaxStreamsFrame(
360 const quic::QuicMaxStreamsFrame& frame) {
361 event_logger_.OnMaxStreamsFrame(frame);
362 }
363
OnIncomingAck(quic::QuicPacketNumber ack_packet_number,quic::EncryptionLevel ack_decrypted_level,const quic::QuicAckFrame & frame,quic::QuicTime ack_receive_time,quic::QuicPacketNumber largest_observed,bool rtt_updated,quic::QuicPacketNumber least_unacked_sent_packet)364 void QuicConnectionLogger::OnIncomingAck(
365 quic::QuicPacketNumber ack_packet_number,
366 quic::EncryptionLevel ack_decrypted_level,
367 const quic::QuicAckFrame& frame,
368 quic::QuicTime ack_receive_time,
369 quic::QuicPacketNumber largest_observed,
370 bool rtt_updated,
371 quic::QuicPacketNumber least_unacked_sent_packet) {
372 const size_t kApproximateLargestSoloAckBytes = 100;
373 if (last_received_packet_number_ - first_received_packet_number_ <
374 received_acks_.size() &&
375 last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
376 received_acks_[last_received_packet_number_ -
377 first_received_packet_number_] = true;
378 }
379
380 event_logger_.OnIncomingAck(ack_packet_number, ack_decrypted_level, frame,
381 ack_receive_time, largest_observed, rtt_updated,
382 least_unacked_sent_packet);
383 }
384
OnRstStreamFrame(const quic::QuicRstStreamFrame & frame)385 void QuicConnectionLogger::OnRstStreamFrame(
386 const quic::QuicRstStreamFrame& frame) {
387 base::UmaHistogramSparse("Net.QuicSession.RstStreamErrorCodeServer",
388 frame.error_code);
389 event_logger_.OnRstStreamFrame(frame);
390 }
391
OnConnectionCloseFrame(const quic::QuicConnectionCloseFrame & frame)392 void QuicConnectionLogger::OnConnectionCloseFrame(
393 const quic::QuicConnectionCloseFrame& frame) {
394 event_logger_.OnConnectionCloseFrame(frame);
395 }
396
OnWindowUpdateFrame(const quic::QuicWindowUpdateFrame & frame,const quic::QuicTime & receive_time)397 void QuicConnectionLogger::OnWindowUpdateFrame(
398 const quic::QuicWindowUpdateFrame& frame,
399 const quic::QuicTime& receive_time) {
400 event_logger_.OnWindowUpdateFrame(frame, receive_time);
401 }
402
OnBlockedFrame(const quic::QuicBlockedFrame & frame)403 void QuicConnectionLogger::OnBlockedFrame(const quic::QuicBlockedFrame& frame) {
404 ++num_blocked_frames_received_;
405 event_logger_.OnBlockedFrame(frame);
406 }
407
OnGoAwayFrame(const quic::QuicGoAwayFrame & frame)408 void QuicConnectionLogger::OnGoAwayFrame(const quic::QuicGoAwayFrame& frame) {
409 UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.GoAwayReceivedForConnectionMigration",
410 frame.error_code == quic::QUIC_ERROR_MIGRATING_PORT);
411
412 event_logger_.OnGoAwayFrame(frame);
413 }
414
OnPingFrame(const quic::QuicPingFrame & frame,quic::QuicTime::Delta ping_received_delay)415 void QuicConnectionLogger::OnPingFrame(
416 const quic::QuicPingFrame& frame,
417 quic::QuicTime::Delta ping_received_delay) {
418 event_logger_.OnPingFrame(frame, ping_received_delay);
419 }
420
OnPaddingFrame(const quic::QuicPaddingFrame & frame)421 void QuicConnectionLogger::OnPaddingFrame(const quic::QuicPaddingFrame& frame) {
422 event_logger_.OnPaddingFrame(frame);
423 }
424
OnNewConnectionIdFrame(const quic::QuicNewConnectionIdFrame & frame)425 void QuicConnectionLogger::OnNewConnectionIdFrame(
426 const quic::QuicNewConnectionIdFrame& frame) {
427 event_logger_.OnNewConnectionIdFrame(frame);
428 }
429
OnNewTokenFrame(const quic::QuicNewTokenFrame & frame)430 void QuicConnectionLogger::OnNewTokenFrame(
431 const quic::QuicNewTokenFrame& frame) {
432 event_logger_.OnNewTokenFrame(frame);
433 }
434
OnRetireConnectionIdFrame(const quic::QuicRetireConnectionIdFrame & frame)435 void QuicConnectionLogger::OnRetireConnectionIdFrame(
436 const quic::QuicRetireConnectionIdFrame& frame) {
437 event_logger_.OnRetireConnectionIdFrame(frame);
438 }
439
OnMessageFrame(const quic::QuicMessageFrame & frame)440 void QuicConnectionLogger::OnMessageFrame(const quic::QuicMessageFrame& frame) {
441 event_logger_.OnMessageFrame(frame);
442 }
443
OnHandshakeDoneFrame(const quic::QuicHandshakeDoneFrame & frame)444 void QuicConnectionLogger::OnHandshakeDoneFrame(
445 const quic::QuicHandshakeDoneFrame& frame) {
446 event_logger_.OnHandshakeDoneFrame(frame);
447 }
448
OnCoalescedPacketSent(const quic::QuicCoalescedPacket & coalesced_packet,size_t length)449 void QuicConnectionLogger::OnCoalescedPacketSent(
450 const quic::QuicCoalescedPacket& coalesced_packet,
451 size_t length) {
452 event_logger_.OnCoalescedPacketSent(coalesced_packet, length);
453 }
454
OnVersionNegotiationPacket(const quic::QuicVersionNegotiationPacket & packet)455 void QuicConnectionLogger::OnVersionNegotiationPacket(
456 const quic::QuicVersionNegotiationPacket& packet) {
457 event_logger_.OnVersionNegotiationPacket(packet);
458 }
459
OnCryptoHandshakeMessageReceived(const quic::CryptoHandshakeMessage & message)460 void QuicConnectionLogger::OnCryptoHandshakeMessageReceived(
461 const quic::CryptoHandshakeMessage& message) {
462 if (message.tag() == quic::kSHLO) {
463 std::string_view address;
464 quic::QuicSocketAddressCoder decoder;
465 if (message.GetStringPiece(quic::kCADR, &address) &&
466 decoder.Decode(address.data(), address.size())) {
467 local_address_from_shlo_ =
468 IPEndPoint(ToIPAddress(decoder.ip()), decoder.port());
469 UMA_HISTOGRAM_ENUMERATION(
470 "Net.QuicSession.ConnectionTypeFromPeer",
471 GetRealAddressFamily(local_address_from_shlo_.address()),
472 ADDRESS_FAMILY_LAST);
473
474 int sample = GetAddressMismatch(local_address_from_shlo_,
475 local_address_from_self_);
476 // If `sample` is negative, we are seemingly talking to an older server
477 // that does not support the feature, so we can't report the results in
478 // the histogram.
479 if (sample >= 0) {
480 UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.SelfShloAddressMismatch",
481 static_cast<QuicAddressMismatch>(sample),
482 QUIC_ADDRESS_MISMATCH_MAX);
483 }
484 }
485 }
486 event_logger_.OnCryptoHandshakeMessageReceived(message);
487 }
488
OnCryptoHandshakeMessageSent(const quic::CryptoHandshakeMessage & message)489 void QuicConnectionLogger::OnCryptoHandshakeMessageSent(
490 const quic::CryptoHandshakeMessage& message) {
491 event_logger_.OnCryptoHandshakeMessageSent(message);
492 }
493
OnConnectionClosed(const quic::QuicConnectionCloseFrame & frame,quic::ConnectionCloseSource source)494 void QuicConnectionLogger::OnConnectionClosed(
495 const quic::QuicConnectionCloseFrame& frame,
496 quic::ConnectionCloseSource source) {
497 event_logger_.OnConnectionClosed(frame, source);
498 }
499
OnSuccessfulVersionNegotiation(const quic::ParsedQuicVersion & version)500 void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
501 const quic::ParsedQuicVersion& version) {
502 event_logger_.OnSuccessfulVersionNegotiation(version);
503 }
504
UpdateReceivedFrameCounts(quic::QuicStreamId stream_id,int num_frames_received,int num_duplicate_frames_received)505 void QuicConnectionLogger::UpdateReceivedFrameCounts(
506 quic::QuicStreamId stream_id,
507 int num_frames_received,
508 int num_duplicate_frames_received) {
509 if (!quic::QuicUtils::IsCryptoStreamId(session_->transport_version(),
510 stream_id)) {
511 num_frames_received_ += num_frames_received;
512 num_duplicate_frames_received_ += num_duplicate_frames_received;
513 }
514 }
515
OnCertificateVerified(const CertVerifyResult & result)516 void QuicConnectionLogger::OnCertificateVerified(
517 const CertVerifyResult& result) {
518 event_logger_.OnCertificateVerified(result);
519 }
520
ReceivedPacketLossRate() const521 float QuicConnectionLogger::ReceivedPacketLossRate() const {
522 if (!largest_received_packet_number_.IsInitialized())
523 return 0.0f;
524 float num_packets =
525 largest_received_packet_number_ - first_received_packet_number_ + 1;
526 float num_missing = num_packets - num_packets_received_;
527 return num_missing / num_packets;
528 }
529
OnRttChanged(quic::QuicTime::Delta rtt) const530 void QuicConnectionLogger::OnRttChanged(quic::QuicTime::Delta rtt) const {
531 // Notify socket performance watcher of the updated RTT value.
532 if (!socket_performance_watcher_)
533 return;
534
535 int64_t microseconds = rtt.ToMicroseconds();
536 if (microseconds != 0 &&
537 socket_performance_watcher_->ShouldNotifyUpdatedRTT()) {
538 socket_performance_watcher_->OnUpdatedRTTAvailable(
539 base::Microseconds(rtt.ToMicroseconds()));
540 }
541 }
542
OnTransportParametersSent(const quic::TransportParameters & transport_parameters)543 void QuicConnectionLogger::OnTransportParametersSent(
544 const quic::TransportParameters& transport_parameters) {
545 event_logger_.OnTransportParametersSent(transport_parameters);
546 }
547
OnTransportParametersReceived(const quic::TransportParameters & transport_parameters)548 void QuicConnectionLogger::OnTransportParametersReceived(
549 const quic::TransportParameters& transport_parameters) {
550 event_logger_.OnTransportParametersReceived(transport_parameters);
551 }
552
OnTransportParametersResumed(const quic::TransportParameters & transport_parameters)553 void QuicConnectionLogger::OnTransportParametersResumed(
554 const quic::TransportParameters& transport_parameters) {
555 event_logger_.OnTransportParametersResumed(transport_parameters);
556 }
557
OnZeroRttRejected(int reason)558 void QuicConnectionLogger::OnZeroRttRejected(int reason) {
559 event_logger_.OnZeroRttRejected(reason);
560 }
561
OnEncryptedClientHelloSent(std::string_view client_hello)562 void QuicConnectionLogger::OnEncryptedClientHelloSent(
563 std::string_view client_hello) {
564 event_logger_.OnEncryptedClientHelloSent(client_hello);
565 }
566
RecordAggregatePacketLossRate() const567 void QuicConnectionLogger::RecordAggregatePacketLossRate() const {
568 // We don't report packet loss rates for short connections under 22 packets in
569 // length to avoid tremendously anomalous contributions to our histogram.
570 // (e.g., if we only got 5 packets, but lost 1, we'd otherwise
571 // record a 20% loss in this histogram!). We may still get some strange data
572 // (1 loss in 22 is still high :-/).
573 if (!largest_received_packet_number_.IsInitialized() ||
574 largest_received_packet_number_ - first_received_packet_number_ < 22) {
575 return;
576 }
577
578 string prefix("Net.QuicSession.PacketLossRate_");
579 base::HistogramBase* histogram = base::Histogram::FactoryGet(
580 prefix + connection_description_, 1, 1000, 75,
581 base::HistogramBase::kUmaTargetedHistogramFlag);
582 histogram->Add(static_cast<base::HistogramBase::Sample>(
583 ReceivedPacketLossRate() * 1000));
584 }
585
586 } // namespace net
587