[net] Add AsyncDNS.TTL histogram.

net/base/host_resolver_impl.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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 187 matching lines @@
     }
   } else {
     if (speculative) {
       DNS_HISTOGRAM("DNS.TotalTime_speculative", duration);
     } else {
       DNS_HISTOGRAM("DNS.TotalTime", duration);
     }
   }
 }
 
+void RecordTTL(base::TimeDelta ttl) {
+  UMA_HISTOGRAM_CUSTOM_COUNTS("AsyncDNS.TTL", ttl.InSeconds(), 1, 86400, 100);
+}
+
 //-----------------------------------------------------------------------------
 
 // Wraps call to SystemHostResolverProc as an instance of HostResolverProc.
 // TODO(szym): This should probably be declared in host_resolver_proc.h.
 class CallSystemHostResolverProc : public HostResolverProc {
  public:
   CallSystemHostResolverProc() : HostResolverProc(NULL) {}
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
@@ skipping 1239 matching lines @@
           UmaAsyncDnsResolveStatus(RESOLVE_STATUS_PROC_SUCCESS);
         }
         UMA_HISTOGRAM_CUSTOM_ENUMERATION("AsyncDNS.ResolveError",
                                          std::abs(dns_task_error_),
                                          GetAllErrorCodesForUma());
       } else {
         UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
       }
     }
 
-    base::TimeDelta ttl = base::TimeDelta::FromSeconds(
-        kNegativeCacheEntryTTLSeconds);
-    if (net_error == OK)
-      ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
-
-    CompleteRequests(net_error, addr_list, ttl);
+    CompleteRequests(net_error, addr_list, base::TimeDelta::FromSeconds(-1));

[cbentzel, 2012/10/11 18:27:30]

At the point that the kNegativeCacheEntry/kCacheEntry replacement is done in
CompleteRequests, you lose a lot of context for why this is done.

It might be better to add an original_ttl or "real_ttl" arguments to
CompleteRequests to make it clearer.

   }
 
   void StartDnsTask() {
     DCHECK(resolver_->HaveDnsConfig());
     dns_task_.reset(new DnsTask(
         resolver_->dns_client_.get(),
         key_,
         base::Bind(&Job::OnDnsTaskComplete, base::Unretained(this)),
         net_log_));
 
@@ skipping 468 matching lines @@
   if (!info.allow_cached_response() || !cache_.get())
     return false;
 
   const HostCache::Entry* cache_entry = cache_->Lookup(
       key, base::TimeTicks::Now());
   if (!cache_entry)
     return false;
 
   *net_error = cache_entry->error;
   if (*net_error == OK) {
+    if (cache_entry->original_ttl >= base::TimeDelta())
+      RecordTTL(cache_entry->original_ttl);
     *addresses = cache_entry->addrlist;
     EnsurePortOnAddressList(info.port(), addresses);
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromHosts(const Key& key,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   DCHECK(addresses);
@@ skipping 23 matching lines @@
   }
 
   *addresses = AddressList::CreateFromIPAddress(it->second, info.port());
   return true;
 }
 
 void HostResolverImpl::CacheResult(const Key& key,
                                    int net_error,
                                    const AddressList& addr_list,
                                    base::TimeDelta ttl) {
-  if (cache_.get())
-    cache_->Set(key, net_error, addr_list, base::TimeTicks::Now(), ttl);
+  bool have_ttl = (ttl >= base::TimeDelta());
+  if (!have_ttl) {
+    if (net_error == OK) {
+      ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
+    } else {
+      ttl = base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
+    }
+  }
+
+  if (cache_.get()) {
+    HostCache::Entry* entry = cache_->Set(
+        key, net_error, addr_list, base::TimeTicks::Now(), ttl);
+    if (have_ttl) {
+      RecordTTL(ttl);
+      entry->original_ttl = ttl;
+    } else {
+      entry->original_ttl = base::TimeDelta::FromSeconds(-1);
+    }
+  }
 }
 
 void HostResolverImpl::RemoveJob(Job* job) {
   DCHECK(job);
   JobMap::iterator it = jobs_.find(job->key());
   if (it != jobs_.end() && it->second == job)
     jobs_.erase(it);
 }
 
 void HostResolverImpl::DiscardIPv6ProbeJob() {
@@ skipping 130 matching lines @@
   // |this| may be deleted inside AbortAllInProgressJobs().
   if (self)
     TryServingAllJobsFromHosts();
 }
 
 bool HostResolverImpl::HaveDnsConfig() const {
   return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL);
 }
 
 }  // namespace net