Add logging of host lookups made by TurnPort to the RtcEventLog.

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 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.
  */
 
 #include "webrtc/p2p/base/turnport.h"
 
 #include <algorithm>
 #include <functional>
 
+#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/rtc_base/asyncpacketsocket.h"
 #include "webrtc/rtc_base/byteorder.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/nethelpers.h"
 #include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/socketaddress.h"
 #include "webrtc/rtc_base/stringencode.h"
@@ skipping 157 matching lines @@
 
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    rtc::AsyncPacketSocket* socket,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
-                   const std::string& origin)
-    : Port(thread,
-           RELAY_PORT_TYPE,
-           factory,
-           network,
-           username,
-           password),
+                   const std::string& origin,
+                   webrtc::RtcEventLog* event_log)
+    : Port(thread, RELAY_PORT_TYPE, factory, network, username, password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(socket),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
-      allocate_mismatch_retries_(0) {
+      allocate_mismatch_retries_(0),
+      event_log_(event_log) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    uint16_t min_port,
                    uint16_t max_port,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
-                   const std::string& origin)
+                   const std::string& origin,
+                   webrtc::RtcEventLog* event_log)
     : Port(thread,
            RELAY_PORT_TYPE,
            factory,
            network,
            min_port,
            max_port,
            username,
            password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(NULL),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
-      allocate_mismatch_retries_(0) {
+      allocate_mismatch_retries_(0),
+      event_log_(event_log) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
 TurnPort::~TurnPort() {
   // TODO(juberti): Should this even be necessary?
 
   // release the allocation by sending a refresh with
   // lifetime 0.
   if (ready()) {
@@ skipping 448 matching lines @@
   if (resolver_->GetError() != 0 && server_address_.proto == PROTO_TCP) {
     if (!CreateTurnClientSocket()) {
       OnAllocateError();
     }
     return;
   }
 
   // Copy the original server address in |resolved_address|. For TLS based
   // sockets we need hostname along with resolved address.
   rtc::SocketAddress resolved_address = server_address_.address;
-  if (resolver_->GetError() != 0 ||
-      !resolver_->GetResolvedAddress(Network()->GetBestIP().family(),
-                                     &resolved_address)) {
-    LOG_J(LS_WARNING, this) << "TURN host lookup received error "
-                            << resolver_->GetError();
+
+  bool found = resolver_->GetError() == 0 &&
+               resolver_->GetResolvedAddress(Network()->GetBestIP().family(),
+                                             &resolved_address);
+  if (event_log_) {
+    int error = resolver_->GetError();
+    event_log_->LogHostLookupResult(
+        found ? 0 : (error == 0 ? -1 : error),
+        resolver_->GetResolveElapsedTimeMilliseconds());
+  }
+
+  if (!found) {
+    LOG_J(LS_WARNING, this)
+        << "TURN host lookup for " << resolved_address.hostname()
+        << " received error " << resolver_->GetError() << " after "
+        << resolver_->GetResolveElapsedTimeMilliseconds() << " ms";
     error_ = resolver_->GetError();
     OnAllocateError();
     return;
   }
+
+  LOG_J(LS_INFO, this) << "TURN host lookup for " << resolved_address.hostname()
+                       << " completed in "
+                       << resolver_->GetResolveElapsedTimeMilliseconds()
+                       << " ms";
+
   // Signal needs both resolved and unresolved address. After signal is sent
   // we can copy resolved address back into |server_address_|.
   SignalResolvedServerAddress(this, server_address_.address,
                               resolved_address);
   server_address_.address = resolved_address;
   PrepareAddress();
 }
 
 void TurnPort::OnSendStunPacket(const void* data, size_t size,
                                 StunRequest* request) {
@@ skipping 861 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket