[net/dns] Instrument DnsConfigService to measure performance and failures.

net/dns/dns_config_service.cc

 // Copyright (c) 2012 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/dns/dns_config_service.h"
 
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 
 namespace net {
 
 // Default values are taken from glibc resolv.h.
 DnsConfig::DnsConfig()
     : append_to_multi_label_name(true),
       ndots(1),
       timeout(base::TimeDelta::FromSeconds(5)),
@@ skipping 79 matching lines @@
   DCHECK(callback_.is_null());
   NetworkChangeNotifier::AddDNSObserver(this);
   callback_ = callback;
   if (NetworkChangeNotifier::IsWatchingDNS())
     OnDNSChanged(NetworkChangeNotifier::CHANGE_DNS_WATCH_STARTED);
   // else: Wait until signal before reading.
 }
 
 void DnsConfigService::InvalidateConfig() {
   DCHECK(CalledOnValidThread());
+  base::TimeTicks now = base::TimeTicks::Now();
+  if (!last_invalidate_config_time_.is_null()) {
+    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.ConfigNotifyPeriod",

[cbentzel, 2012/06/15 20:29:36]

ConfigNotifyIntervval perhaps?

[szym, 2012/06/15 21:22:19]

Done.

+                             now - last_invalidate_config_time_);
+  }
+  last_invalidate_config_time_ = now;
   if (!have_config_)
     return;
   have_config_ = false;
   StartTimer();
 }
 
 void DnsConfigService::InvalidateHosts() {
   DCHECK(CalledOnValidThread());
+  base::TimeTicks now = base::TimeTicks::Now();
+  if (!last_invalidate_hosts_time_.is_null()) {
+    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.HostsNotifyPeriod",
+                             now - last_invalidate_hosts_time_);
+  }
+  last_invalidate_hosts_time_ = now;
   if (!have_hosts_)
     return;
   have_hosts_ = false;
   StartTimer();
 }
 
 void DnsConfigService::OnConfigRead(const DnsConfig& config) {
   DCHECK(CalledOnValidThread());
   DCHECK(config.IsValid());
 
+  bool changed = false;
   if (!config.EqualsIgnoreHosts(dns_config_)) {
     dns_config_.CopyIgnoreHosts(config);
     need_update_ = true;
+    changed = true;
   }
+  UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigChange", changed);
 
   have_config_ = true;
   if (have_hosts_)
     OnCompleteConfig();
 }
 
 void DnsConfigService::OnHostsRead(const DnsHosts& hosts) {
   DCHECK(CalledOnValidThread());
 
+  bool changed = false;
   if (hosts != dns_config_.hosts) {
     dns_config_.hosts = hosts;
     need_update_ = true;
+    changed = true;
   }
+  UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostsChange", changed);
 
   have_hosts_ = true;
   if (have_config_)
     OnCompleteConfig();
 }
 
 void DnsConfigService::StartTimer() {
   DCHECK(CalledOnValidThread());
   if (last_sent_empty_) {
     DCHECK(!timer_.IsRunning());
@@ skipping 33 matching lines @@
   timer_.Stop();
   if (!need_update_)
     return;
   need_update_ = false;
   last_sent_empty_ = false;
   callback_.Run(dns_config_);
 }
 
 }  // namespace net