123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609 |
- // 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 <limits>
- #include <memory>
- #include <utility>
- #include <vector>
- #include "base/metrics/histogram_base.h"
- #include "base/metrics/histogram_functions.h"
- #include "base/metrics/histogram_macros.h"
- #include "base/values.h"
- #include "net/base/ip_address.h"
- #include "net/cert/x509_certificate.h"
- #include "net/quic/address_utils.h"
- #include "net/quic/quic_address_mismatch.h"
- #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake_message.h"
- #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_protocol.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_connection_id.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_socket_address_coder.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_time.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
- using quic::kMaxOutgoingPacketSize;
- using std::string;
- namespace net {
- namespace {
- void UpdatePublicResetAddressMismatchHistogram(
- const IPEndPoint& server_hello_address,
- const IPEndPoint& public_reset_address) {
- int sample = GetAddressMismatch(server_hello_address, public_reset_address);
- // We are seemingly talking to an older server that does not support the
- // feature, so we can't report the results in the histogram.
- if (sample < 0) {
- return;
- }
- UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.PublicResetAddressMismatch2",
- static_cast<QuicAddressMismatch>(sample),
- QUIC_ADDRESS_MISMATCH_MAX);
- }
- // If |address| is an IPv4-mapped IPv6 address, returns ADDRESS_FAMILY_IPV4
- // instead of ADDRESS_FAMILY_IPV6. Othewise, behaves like GetAddressFamily().
- AddressFamily GetRealAddressFamily(const IPAddress& address) {
- return address.IsIPv4MappedIPv6() ? ADDRESS_FAMILY_IPV4
- : GetAddressFamily(address);
- }
- } // namespace
- QuicConnectionLogger::QuicConnectionLogger(
- quic::QuicSession* session,
- const char* const connection_description,
- std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
- const NetLogWithSource& net_log)
- : session_(session),
- connection_description_(connection_description),
- socket_performance_watcher_(std::move(socket_performance_watcher)),
- event_logger_(session, net_log) {}
- QuicConnectionLogger::~QuicConnectionLogger() {
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.OutOfOrderPacketsReceived",
- num_out_of_order_received_packets_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.OutOfOrderLargePacketsReceived",
- num_out_of_order_large_received_packets_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.IncorrectConnectionIDsReceived",
- num_incorrect_connection_ids_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.UndecryptablePacketsReceived",
- num_undecryptable_packets_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.DuplicatePacketsReceived",
- num_duplicate_packets_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.BlockedFrames.Received",
- num_blocked_frames_received_);
- UMA_HISTOGRAM_COUNTS_1M("Net.QuicSession.BlockedFrames.Sent",
- num_blocked_frames_sent_);
- const quic::QuicConnectionStats& stats = session_->connection()->GetStats();
- UMA_HISTOGRAM_TIMES("Net.QuicSession.MinRTT",
- base::Microseconds(stats.min_rtt_us));
- UMA_HISTOGRAM_TIMES("Net.QuicSession.SmoothedRTT",
- base::Microseconds(stats.srtt_us));
- if (num_frames_received_ > 0) {
- int duplicate_stream_frame_per_thousand =
- num_duplicate_frames_received_ * 1000 / num_frames_received_;
- if (num_packets_received_ < 100) {
- UMA_HISTOGRAM_CUSTOM_COUNTS(
- "Net.QuicSession.StreamFrameDuplicatedShortConnection",
- duplicate_stream_frame_per_thousand, 1, 1000, 75);
- } else {
- UMA_HISTOGRAM_CUSTOM_COUNTS(
- "Net.QuicSession.StreamFrameDuplicatedLongConnection",
- duplicate_stream_frame_per_thousand, 1, 1000, 75);
- }
- }
- RecordAggregatePacketLossRate();
- }
- void QuicConnectionLogger::OnFrameAddedToPacket(const quic::QuicFrame& frame) {
- switch (frame.type) {
- case quic::PADDING_FRAME:
- break;
- case quic::STREAM_FRAME:
- break;
- case quic::ACK_FRAME: {
- break;
- }
- case quic::RST_STREAM_FRAME:
- base::UmaHistogramSparse("Net.QuicSession.RstStreamErrorCodeClient",
- frame.rst_stream_frame->error_code);
- break;
- case quic::CONNECTION_CLOSE_FRAME:
- break;
- case quic::GOAWAY_FRAME:
- break;
- case quic::WINDOW_UPDATE_FRAME:
- break;
- case quic::BLOCKED_FRAME:
- ++num_blocked_frames_sent_;
- break;
- case quic::STOP_WAITING_FRAME:
- break;
- case quic::PING_FRAME:
- UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
- session_->IsConnectionFlowControlBlocked());
- UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
- session_->IsStreamFlowControlBlocked());
- break;
- case quic::MTU_DISCOVERY_FRAME:
- break;
- case quic::NEW_CONNECTION_ID_FRAME:
- break;
- case quic::MAX_STREAMS_FRAME:
- break;
- case quic::STREAMS_BLOCKED_FRAME:
- break;
- case quic::PATH_RESPONSE_FRAME:
- break;
- case quic::PATH_CHALLENGE_FRAME:
- break;
- case quic::STOP_SENDING_FRAME:
- base::UmaHistogramSparse("Net.QuicSession.StopSendingErrorCodeClient",
- frame.stop_sending_frame.error_code);
- break;
- case quic::MESSAGE_FRAME:
- break;
- case quic::CRYPTO_FRAME:
- break;
- case quic::NEW_TOKEN_FRAME:
- break;
- case quic::RETIRE_CONNECTION_ID_FRAME:
- break;
- default:
- DCHECK(false) << "Illegal frame type: " << frame.type;
- }
- event_logger_.OnFrameAddedToPacket(frame);
- }
- void QuicConnectionLogger::OnStreamFrameCoalesced(
- const quic::QuicStreamFrame& frame) {
- event_logger_.OnStreamFrameCoalesced(frame);
- }
- void QuicConnectionLogger::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) {
- // 4.4.1.4. Minimum Packet Size
- // The payload of a UDP datagram carrying the Initial packet MUST be
- // expanded to at least 1200 octets
- const quic::QuicPacketLength kMinClientInitialPacketLength = 1200;
- switch (encryption_level) {
- case quic::ENCRYPTION_INITIAL:
- UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.Initial",
- packet_length, 1, kMaxOutgoingPacketSize, 50);
- if (packet_length < kMinClientInitialPacketLength) {
- UMA_HISTOGRAM_CUSTOM_COUNTS(
- "Net.QuicSession.TooSmallInitialSentPacket",
- kMinClientInitialPacketLength - packet_length, 1,
- kMinClientInitialPacketLength, 50);
- }
- break;
- case quic::ENCRYPTION_HANDSHAKE:
- UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.Hanshake",
- packet_length, 1, kMaxOutgoingPacketSize, 50);
- break;
- case quic::ENCRYPTION_ZERO_RTT:
- UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.SendPacketSize.0RTT",
- packet_length, 1, kMaxOutgoingPacketSize, 50);
- break;
- case quic::ENCRYPTION_FORWARD_SECURE:
- UMA_HISTOGRAM_CUSTOM_COUNTS(
- "Net.QuicSession.SendPacketSize.ForwardSecure", packet_length, 1,
- kMaxOutgoingPacketSize, 50);
- break;
- case quic::NUM_ENCRYPTION_LEVELS:
- NOTREACHED();
- break;
- }
- event_logger_.OnPacketSent(packet_number, packet_length, has_crypto_handshake,
- transmission_type, encryption_level,
- retransmittable_frames, nonretransmittable_frames,
- sent_time);
- }
- void QuicConnectionLogger::OnPacketLoss(
- quic::QuicPacketNumber lost_packet_number,
- quic::EncryptionLevel encryption_level,
- quic::TransmissionType transmission_type,
- quic::QuicTime detection_time) {
- event_logger_.OnPacketLoss(lost_packet_number, encryption_level,
- transmission_type, detection_time);
- }
- void QuicConnectionLogger::OnPingSent() {
- no_packet_received_after_ping_ = true;
- }
- void QuicConnectionLogger::OnPacketReceived(
- const quic::QuicSocketAddress& self_address,
- const quic::QuicSocketAddress& peer_address,
- const quic::QuicEncryptedPacket& packet) {
- if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
- local_address_from_self_ = ToIPEndPoint(self_address);
- UMA_HISTOGRAM_ENUMERATION(
- "Net.QuicSession.ConnectionTypeFromSelf",
- GetRealAddressFamily(ToIPEndPoint(self_address).address()),
- ADDRESS_FAMILY_LAST);
- }
- previous_received_packet_size_ = last_received_packet_size_;
- last_received_packet_size_ = packet.length();
- event_logger_.OnPacketReceived(self_address, peer_address, packet);
- }
- void QuicConnectionLogger::OnUnauthenticatedHeader(
- const quic::QuicPacketHeader& header) {
- event_logger_.OnUnauthenticatedHeader(header);
- }
- void QuicConnectionLogger::OnIncorrectConnectionId(
- quic::QuicConnectionId connection_id) {
- ++num_incorrect_connection_ids_;
- }
- void QuicConnectionLogger::OnUndecryptablePacket(
- quic::EncryptionLevel decryption_level,
- bool dropped) {
- ++num_undecryptable_packets_;
- event_logger_.OnUndecryptablePacket(decryption_level, dropped);
- }
- void QuicConnectionLogger::OnAttemptingToProcessUndecryptablePacket(
- quic::EncryptionLevel decryption_level) {
- event_logger_.OnAttemptingToProcessUndecryptablePacket(decryption_level);
- }
- void QuicConnectionLogger::OnDuplicatePacket(
- quic::QuicPacketNumber packet_number) {
- ++num_duplicate_packets_;
- event_logger_.OnDuplicatePacket(packet_number);
- }
- void QuicConnectionLogger::OnProtocolVersionMismatch(
- quic::ParsedQuicVersion received_version) {
- // TODO(rtenneti): Add logging.
- }
- void QuicConnectionLogger::OnPacketHeader(const quic::QuicPacketHeader& header,
- quic::QuicTime receive_time,
- quic::EncryptionLevel level) {
- if (!first_received_packet_number_.IsInitialized()) {
- first_received_packet_number_ = header.packet_number;
- } else if (header.packet_number < first_received_packet_number_) {
- // Ignore packets with packet numbers less than
- // first_received_packet_number_.
- return;
- }
- ++num_packets_received_;
- if (!largest_received_packet_number_.IsInitialized()) {
- largest_received_packet_number_ = header.packet_number;
- } else if (largest_received_packet_number_ < header.packet_number) {
- uint64_t delta = header.packet_number - largest_received_packet_number_;
- if (delta > 1) {
- // There is a gap between the largest packet previously received and
- // the current packet. This indicates either loss, or out-of-order
- // delivery.
- UMA_HISTOGRAM_COUNTS_1M(
- "Net.QuicSession.PacketGapReceived",
- static_cast<base::HistogramBase::Sample>(delta - 1));
- }
- largest_received_packet_number_ = header.packet_number;
- }
- if (header.packet_number - first_received_packet_number_ <
- received_packets_.size()) {
- received_packets_[header.packet_number - first_received_packet_number_] =
- true;
- }
- if (last_received_packet_number_.IsInitialized() &&
- header.packet_number < last_received_packet_number_) {
- ++num_out_of_order_received_packets_;
- if (previous_received_packet_size_ < last_received_packet_size_)
- ++num_out_of_order_large_received_packets_;
- UMA_HISTOGRAM_COUNTS_1M(
- "Net.QuicSession.OutOfOrderGapReceived",
- static_cast<base::HistogramBase::Sample>(last_received_packet_number_ -
- header.packet_number));
- } else if (no_packet_received_after_ping_) {
- if (last_received_packet_number_.IsInitialized()) {
- UMA_HISTOGRAM_COUNTS_1M(
- "Net.QuicSession.PacketGapReceivedNearPing",
- static_cast<base::HistogramBase::Sample>(
- header.packet_number - last_received_packet_number_));
- }
- no_packet_received_after_ping_ = false;
- }
- last_received_packet_number_ = header.packet_number;
- event_logger_.OnPacketHeader(header, receive_time, level);
- }
- void QuicConnectionLogger::OnStreamFrame(const quic::QuicStreamFrame& frame) {
- event_logger_.OnStreamFrame(frame);
- }
- void QuicConnectionLogger::OnPathChallengeFrame(
- const quic::QuicPathChallengeFrame& frame) {
- event_logger_.OnPathChallengeFrame(frame);
- }
- void QuicConnectionLogger::OnPathResponseFrame(
- const quic::QuicPathResponseFrame& frame) {
- event_logger_.OnPathResponseFrame(frame);
- }
- void QuicConnectionLogger::OnCryptoFrame(const quic::QuicCryptoFrame& frame) {
- event_logger_.OnCryptoFrame(frame);
- }
- void QuicConnectionLogger::OnStopSendingFrame(
- const quic::QuicStopSendingFrame& frame) {
- base::UmaHistogramSparse("Net.QuicSession.StopSendingErrorCodeServer",
- frame.error_code);
- event_logger_.OnStopSendingFrame(frame);
- }
- void QuicConnectionLogger::OnStreamsBlockedFrame(
- const quic::QuicStreamsBlockedFrame& frame) {
- event_logger_.OnStreamsBlockedFrame(frame);
- }
- void QuicConnectionLogger::OnMaxStreamsFrame(
- const quic::QuicMaxStreamsFrame& frame) {
- event_logger_.OnMaxStreamsFrame(frame);
- }
- void QuicConnectionLogger::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) {
- const size_t kApproximateLargestSoloAckBytes = 100;
- if (last_received_packet_number_ - first_received_packet_number_ <
- received_acks_.size() &&
- last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
- received_acks_[last_received_packet_number_ -
- first_received_packet_number_] = true;
- }
- event_logger_.OnIncomingAck(ack_packet_number, ack_decrypted_level, frame,
- ack_receive_time, largest_observed, rtt_updated,
- least_unacked_sent_packet);
- }
- void QuicConnectionLogger::OnStopWaitingFrame(
- const quic::QuicStopWaitingFrame& frame) {
- event_logger_.OnStopWaitingFrame(frame);
- }
- void QuicConnectionLogger::OnRstStreamFrame(
- const quic::QuicRstStreamFrame& frame) {
- base::UmaHistogramSparse("Net.QuicSession.RstStreamErrorCodeServer",
- frame.error_code);
- event_logger_.OnRstStreamFrame(frame);
- }
- void QuicConnectionLogger::OnConnectionCloseFrame(
- const quic::QuicConnectionCloseFrame& frame) {
- event_logger_.OnConnectionCloseFrame(frame);
- }
- void QuicConnectionLogger::OnWindowUpdateFrame(
- const quic::QuicWindowUpdateFrame& frame,
- const quic::QuicTime& receive_time) {
- event_logger_.OnWindowUpdateFrame(frame, receive_time);
- }
- void QuicConnectionLogger::OnBlockedFrame(const quic::QuicBlockedFrame& frame) {
- ++num_blocked_frames_received_;
- event_logger_.OnBlockedFrame(frame);
- }
- void QuicConnectionLogger::OnGoAwayFrame(const quic::QuicGoAwayFrame& frame) {
- UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.GoAwayReceivedForConnectionMigration",
- frame.error_code == quic::QUIC_ERROR_MIGRATING_PORT);
- event_logger_.OnGoAwayFrame(frame);
- }
- void QuicConnectionLogger::OnPingFrame(
- const quic::QuicPingFrame& frame,
- quic::QuicTime::Delta ping_received_delay) {
- event_logger_.OnPingFrame(frame, ping_received_delay);
- }
- void QuicConnectionLogger::OnPaddingFrame(const quic::QuicPaddingFrame& frame) {
- event_logger_.OnPaddingFrame(frame);
- }
- void QuicConnectionLogger::OnNewConnectionIdFrame(
- const quic::QuicNewConnectionIdFrame& frame) {
- event_logger_.OnNewConnectionIdFrame(frame);
- }
- void QuicConnectionLogger::OnNewTokenFrame(
- const quic::QuicNewTokenFrame& frame) {
- event_logger_.OnNewTokenFrame(frame);
- }
- void QuicConnectionLogger::OnRetireConnectionIdFrame(
- const quic::QuicRetireConnectionIdFrame& frame) {
- event_logger_.OnRetireConnectionIdFrame(frame);
- }
- void QuicConnectionLogger::OnMessageFrame(const quic::QuicMessageFrame& frame) {
- event_logger_.OnMessageFrame(frame);
- }
- void QuicConnectionLogger::OnHandshakeDoneFrame(
- const quic::QuicHandshakeDoneFrame& frame) {
- event_logger_.OnHandshakeDoneFrame(frame);
- }
- void QuicConnectionLogger::OnCoalescedPacketSent(
- const quic::QuicCoalescedPacket& coalesced_packet,
- size_t length) {
- event_logger_.OnCoalescedPacketSent(coalesced_packet, length);
- }
- void QuicConnectionLogger::OnPublicResetPacket(
- const quic::QuicPublicResetPacket& packet) {
- UpdatePublicResetAddressMismatchHistogram(
- local_address_from_shlo_, ToIPEndPoint(packet.client_address));
- event_logger_.OnPublicResetPacket(packet);
- }
- void QuicConnectionLogger::OnVersionNegotiationPacket(
- const quic::QuicVersionNegotiationPacket& packet) {
- event_logger_.OnVersionNegotiationPacket(packet);
- }
- void QuicConnectionLogger::OnCryptoHandshakeMessageReceived(
- const quic::CryptoHandshakeMessage& message) {
- if (message.tag() == quic::kSHLO) {
- absl::string_view address;
- quic::QuicSocketAddressCoder decoder;
- if (message.GetStringPiece(quic::kCADR, &address) &&
- decoder.Decode(address.data(), address.size())) {
- local_address_from_shlo_ =
- IPEndPoint(ToIPAddress(decoder.ip()), decoder.port());
- UMA_HISTOGRAM_ENUMERATION(
- "Net.QuicSession.ConnectionTypeFromPeer",
- GetRealAddressFamily(local_address_from_shlo_.address()),
- ADDRESS_FAMILY_LAST);
- int sample = GetAddressMismatch(local_address_from_shlo_,
- local_address_from_self_);
- // We are seemingly talking to an older server that does not support the
- // feature, so we can't report the results in the histogram.
- if (sample >= 0) {
- UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.SelfShloAddressMismatch",
- static_cast<QuicAddressMismatch>(sample),
- QUIC_ADDRESS_MISMATCH_MAX);
- }
- }
- }
- event_logger_.OnCryptoHandshakeMessageReceived(message);
- }
- void QuicConnectionLogger::OnCryptoHandshakeMessageSent(
- const quic::CryptoHandshakeMessage& message) {
- event_logger_.OnCryptoHandshakeMessageSent(message);
- }
- void QuicConnectionLogger::OnConnectionClosed(
- const quic::QuicConnectionCloseFrame& frame,
- quic::ConnectionCloseSource source) {
- event_logger_.OnConnectionClosed(frame, source);
- }
- void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
- const quic::ParsedQuicVersion& version) {
- event_logger_.OnSuccessfulVersionNegotiation(version);
- }
- void QuicConnectionLogger::UpdateReceivedFrameCounts(
- quic::QuicStreamId stream_id,
- int num_frames_received,
- int num_duplicate_frames_received) {
- if (!quic::QuicUtils::IsCryptoStreamId(session_->transport_version(),
- stream_id)) {
- num_frames_received_ += num_frames_received;
- num_duplicate_frames_received_ += num_duplicate_frames_received;
- }
- }
- void QuicConnectionLogger::OnCertificateVerified(
- const CertVerifyResult& result) {
- event_logger_.OnCertificateVerified(result);
- }
- base::HistogramBase* QuicConnectionLogger::Get6PacketHistogram(
- const char* which_6) const {
- // This histogram takes a binary encoding of the 6 consecutive packets
- // received. As a result, there are 64 possible sample-patterns.
- string prefix("Net.QuicSession.6PacketsPatternsReceived_");
- return base::LinearHistogram::FactoryGet(
- prefix + which_6 + connection_description_, 1, 64, 65,
- base::HistogramBase::kUmaTargetedHistogramFlag);
- }
- float QuicConnectionLogger::ReceivedPacketLossRate() const {
- if (!largest_received_packet_number_.IsInitialized())
- return 0.0f;
- float num_packets =
- largest_received_packet_number_ - first_received_packet_number_ + 1;
- float num_missing = num_packets - num_packets_received_;
- return num_missing / num_packets;
- }
- void QuicConnectionLogger::OnRttChanged(quic::QuicTime::Delta rtt) const {
- // Notify socket performance watcher of the updated RTT value.
- if (!socket_performance_watcher_)
- return;
- int64_t microseconds = rtt.ToMicroseconds();
- if (microseconds != 0 &&
- socket_performance_watcher_->ShouldNotifyUpdatedRTT()) {
- socket_performance_watcher_->OnUpdatedRTTAvailable(
- base::Microseconds(rtt.ToMicroseconds()));
- }
- }
- void QuicConnectionLogger::OnTransportParametersSent(
- const quic::TransportParameters& transport_parameters) {
- event_logger_.OnTransportParametersSent(transport_parameters);
- }
- void QuicConnectionLogger::OnTransportParametersReceived(
- const quic::TransportParameters& transport_parameters) {
- event_logger_.OnTransportParametersReceived(transport_parameters);
- }
- void QuicConnectionLogger::OnTransportParametersResumed(
- const quic::TransportParameters& transport_parameters) {
- event_logger_.OnTransportParametersResumed(transport_parameters);
- }
- void QuicConnectionLogger::OnZeroRttRejected(int reason) {
- event_logger_.OnZeroRttRejected(reason);
- }
- void QuicConnectionLogger::RecordAggregatePacketLossRate() const {
- // For short connections under 22 packets in length, we'll rely on the
- // Net.QuicSession.21CumulativePacketsReceived_* histogram to indicate packet
- // loss rates. This way we avoid tremendously anomalous contributions to our
- // histogram. (e.g., if we only got 5 packets, but lost 1, we'd otherwise
- // record a 20% loss in this histogram!). We may still get some strange data
- // (1 loss in 22 is still high :-/).
- if (!largest_received_packet_number_.IsInitialized() ||
- largest_received_packet_number_ - first_received_packet_number_ < 22)
- return;
- string prefix("Net.QuicSession.PacketLossRate_");
- base::HistogramBase* histogram = base::Histogram::FactoryGet(
- prefix + connection_description_, 1, 1000, 75,
- base::HistogramBase::kUmaTargetedHistogramFlag);
- histogram->Add(static_cast<base::HistogramBase::Sample>(
- ReceivedPacketLossRate() * 1000));
- }
- } // namespace net
|