Add Stats to Stun ping.

webrtc/p2p/base/port.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 579 matching lines @@
   } else {
     // Log at LS_INFO if we send a stun ping response on an unwritable
     // connection.
     Connection* conn = GetConnection(addr);
     rtc::LoggingSeverity sev = (conn && !conn->writable()) ?
         rtc::LS_INFO : rtc::LS_VERBOSE;
     LOG_JV(sev, this)
         << "Sent STUN ping response"
         << ", to=" << addr.ToSensitiveString()
         << ", id=" << rtc::hex_encode(response.transaction_id());
+
+    // Update the stats of corresponding connection.
+    conn->sent_ping_responses_++;
   }
 }
 
 void Port::SendBindingErrorResponse(StunMessage* request,
                                     const rtc::SocketAddress& addr,
                                     int error_code, const std::string& reason) {
   ASSERT(request->type() == STUN_BINDING_REQUEST);
 
   // Fill in the response message.
   StunMessage response;
@@ skipping 189 matching lines @@
       requests_(port->thread()),
       rtt_(DEFAULT_RTT),
       last_ping_sent_(0),
       last_ping_received_(0),
       last_data_received_(0),
       last_ping_response_received_(0),
       recv_rate_tracker_(100, 10u),
       send_rate_tracker_(100, 10u),
       sent_packets_discarded_(0),
       sent_packets_total_(0),
+      sent_ping_requests_total_(0),
+      sent_ping_requests_before_first_response_(0),
+      sent_ping_responses_(0),
+      recv_ping_requests_(0),
+      recv_ping_responses_(0),
       reported_(false),
       state_(STATE_WAITING),
       receiving_timeout_(WEAK_CONNECTION_RECEIVE_TIMEOUT),
-      time_created_ms_(rtc::TimeMillis()) {
+      time_created_ms_(rtc::TimeMillis()),
+      received_first_response_(false) {
   // All of our connections start in WAITING state.
   // TODO(mallinath) - Start connections from STATE_FROZEN.
   // Wire up to send stun packets
   requests_.SignalSendPacket.connect(this, &Connection::OnSendStunPacket);
   LOG_J(LS_INFO, this) << "Connection created";
 }
 
 Connection::~Connection() {
 }
 
@@ skipping 162 matching lines @@
 
   const rtc::SocketAddress& remote_addr = remote_candidate_.address();
   const std::string& remote_ufrag = remote_candidate_.username();
   // Check for role conflicts.
   if (!port_->MaybeIceRoleConflict(remote_addr, msg, remote_ufrag)) {
     // Received conflicting role from the peer.
     LOG(LS_INFO) << "Received conflicting role from the peer.";
     return;
   }
 
+  recv_ping_requests_++;
+
   // This is a validated stun request from remote peer.
   port_->SendBindingResponse(msg, remote_addr);
 
   // If it timed out on writing check, start up again
   if (!pruned_ && write_state_ == STATE_WRITE_TIMEOUT) {
     set_write_state(STATE_WRITE_INIT);
   }
 
   if (port_->GetIceRole() == ICEROLE_CONTROLLED) {
     const StunByteStringAttribute* use_candidate_attr =
@@ skipping 244 matching lines @@
     PrintPingsSinceLastResponse(&pings, 5);
     LOG_JV(sev, this) << "Received STUN ping response"
                       << ", id=" << rtc::hex_encode(request->id())
                       << ", code=0"  // Makes logging easier to parse.
                       << ", rtt=" << rtt
                       << ", use_candidate=" << use_candidate
                       << ", pings_since_last_response=" << pings;
   }
 
   rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
+  recv_ping_responses_++;
+  if (!received_first_response_) {
+    received_first_response_ = true;
+  }
 
   MaybeAddPrflxCandidate(request, response);
 }
 
 void Connection::OnConnectionRequestErrorResponse(ConnectionRequest* request,
                                                   StunMessage* response) {
   const StunErrorCodeAttribute* error_attr = response->GetErrorCode();
   int error_code = STUN_ERROR_GLOBAL_FAILURE;
   if (error_attr) {
     error_code = error_attr->code();
@@ skipping 28 matching lines @@
                     << " after " << request->Elapsed() << " ms";
 }
 
 void Connection::OnConnectionRequestSent(ConnectionRequest* request) {
   // Log at LS_INFO if we send a ping on an unwritable connection.
   rtc::LoggingSeverity sev = !writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
   bool use_candidate = use_candidate_attr();
   LOG_JV(sev, this) << "Sent STUN ping"
                     << ", id=" << rtc::hex_encode(request->id())
                     << ", use_candidate=" << use_candidate;
+  sent_ping_requests_total_++;
+  if (!received_first_response_) {
+    sent_ping_requests_before_first_response_++;
+  }
 }
 
 void Connection::HandleRoleConflictFromPeer() {
   port_->SignalRoleConflict(port_);
 }
 
 void Connection::MaybeSetRemoteIceCredentialsAndGeneration(
     const std::string& ice_ufrag,
     const std::string& ice_pwd,
     int generation) {
@@ skipping 53 matching lines @@
 }
 
 size_t Connection::sent_discarded_packets() {
   return sent_packets_discarded_;
 }
 
 size_t Connection::sent_total_packets() {
   return sent_packets_total_;
 }
 
+size_t Connection::sent_ping_requests_total() {
+  return sent_ping_requests_total_;
+}
+
+size_t Connection::sent_ping_requests_before_first_response() {
+  return sent_ping_requests_before_first_response_;
+}
+
+size_t Connection::sent_ping_responses() {
+  return sent_ping_responses_;
+}
+
+size_t Connection::recv_ping_responses() {
+  return recv_ping_responses_;
+}
+
+size_t Connection::recv_ping_requests() {
+  return recv_ping_requests_;
+}
+
 void Connection::MaybeAddPrflxCandidate(ConnectionRequest* request,
                                         StunMessage* response) {
   // RFC 5245
   // The agent checks the mapped address from the STUN response.  If the
   // transport address does not match any of the local candidates that the
   // agent knows about, the mapped address represents a new candidate -- a
   // peer reflexive candidate.
   const StunAddressAttribute* addr =
       response->GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   if (!addr) {
@@ skipping 72 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket