1 // Copyright 2020 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/dns/httpssvc_metrics.h"
6
7 #include <string_view>
8
9 #include "base/containers/contains.h"
10 #include "base/feature_list.h"
11 #include "base/metrics/histogram.h"
12 #include "base/metrics/histogram_base.h"
13 #include "base/metrics/histogram_functions.h"
14 #include "base/not_fatal_until.h"
15 #include "base/notreached.h"
16 #include "base/numerics/clamped_math.h"
17 #include "base/strings/string_split.h"
18 #include "base/strings/string_util.h"
19 #include "net/base/features.h"
20 #include "net/dns/dns_util.h"
21 #include "net/dns/public/dns_protocol.h"
22
23 namespace net {
24
TranslateDnsRcodeForHttpssvcExperiment(uint8_t rcode)25 enum HttpssvcDnsRcode TranslateDnsRcodeForHttpssvcExperiment(uint8_t rcode) {
26 switch (rcode) {
27 case dns_protocol::kRcodeNOERROR:
28 return HttpssvcDnsRcode::kNoError;
29 case dns_protocol::kRcodeFORMERR:
30 return HttpssvcDnsRcode::kFormErr;
31 case dns_protocol::kRcodeSERVFAIL:
32 return HttpssvcDnsRcode::kServFail;
33 case dns_protocol::kRcodeNXDOMAIN:
34 return HttpssvcDnsRcode::kNxDomain;
35 case dns_protocol::kRcodeNOTIMP:
36 return HttpssvcDnsRcode::kNotImp;
37 case dns_protocol::kRcodeREFUSED:
38 return HttpssvcDnsRcode::kRefused;
39 default:
40 return HttpssvcDnsRcode::kUnrecognizedRcode;
41 }
42 NOTREACHED();
43 }
44
HttpssvcMetrics(bool secure)45 HttpssvcMetrics::HttpssvcMetrics(bool secure) : secure_(secure) {}
46
~HttpssvcMetrics()47 HttpssvcMetrics::~HttpssvcMetrics() {
48 RecordMetrics();
49 }
50
SaveForAddressQuery(base::TimeDelta resolve_time,enum HttpssvcDnsRcode rcode)51 void HttpssvcMetrics::SaveForAddressQuery(base::TimeDelta resolve_time,
52 enum HttpssvcDnsRcode rcode) {
53 address_resolve_times_.push_back(resolve_time);
54
55 if (rcode != HttpssvcDnsRcode::kNoError)
56 disqualified_ = true;
57 }
58
SaveForHttps(enum HttpssvcDnsRcode rcode,const std::vector<bool> & condensed_records,base::TimeDelta https_resolve_time)59 void HttpssvcMetrics::SaveForHttps(enum HttpssvcDnsRcode rcode,
60 const std::vector<bool>& condensed_records,
61 base::TimeDelta https_resolve_time) {
62 DCHECK(!rcode_https_.has_value());
63 rcode_https_ = rcode;
64
65 num_https_records_ = condensed_records.size();
66
67 // We only record one "parsable" sample per HTTPS query. In case multiple
68 // matching records are present in the response, we combine their parsable
69 // values with logical AND.
70 const bool parsable = !base::Contains(condensed_records, false);
71
72 DCHECK(!is_https_parsable_.has_value());
73 is_https_parsable_ = parsable;
74
75 DCHECK(!https_resolve_time_.has_value());
76 https_resolve_time_ = https_resolve_time;
77 }
78
BuildMetricName(std::string_view leaf_name) const79 std::string HttpssvcMetrics::BuildMetricName(std::string_view leaf_name) const {
80 std::string_view type_str = "RecordHttps";
81 std::string_view secure = secure_ ? "Secure" : "Insecure";
82 // This part is just a legacy from old experiments but now meaningless.
83 std::string_view expectation = "ExpectNoerror";
84
85 // Example metric name:
86 // Net.DNS.HTTPSSVC.RecordHttps.Secure.ExpectNoerror.DnsRcode
87 // TODO(crbug.com/40239736): Simplify the metric names.
88 return base::JoinString(
89 {"Net.DNS.HTTPSSVC", type_str, secure, expectation, leaf_name}, ".");
90 }
91
RecordMetrics()92 void HttpssvcMetrics::RecordMetrics() {
93 DCHECK(!already_recorded_);
94 already_recorded_ = true;
95
96 // We really have no metrics to record without an HTTPS query resolve time and
97 // `address_resolve_times_`. If this HttpssvcMetrics is in an inconsistent
98 // state, disqualify any metrics from being recorded.
99 if (!https_resolve_time_.has_value() || address_resolve_times_.empty()) {
100 disqualified_ = true;
101 }
102 if (disqualified_)
103 return;
104
105 base::UmaHistogramMediumTimes(BuildMetricName("ResolveTimeExperimental"),
106 *https_resolve_time_);
107
108 // Record the address resolve times.
109 const std::string kMetricResolveTimeAddressRecord =
110 BuildMetricName("ResolveTimeAddress");
111 for (base::TimeDelta resolve_time_other : address_resolve_times_) {
112 base::UmaHistogramMediumTimes(kMetricResolveTimeAddressRecord,
113 resolve_time_other);
114 }
115
116 // ResolveTimeRatio is the HTTPS query resolve time divided by the slower of
117 // the A or AAAA resolve times. Arbitrarily choosing precision at two decimal
118 // places.
119 std::vector<base::TimeDelta>::iterator slowest_address_resolve =
120 std::max_element(address_resolve_times_.begin(),
121 address_resolve_times_.end());
122 CHECK(slowest_address_resolve != address_resolve_times_.end(),
123 base::NotFatalUntil::M130);
124
125 // It's possible to get here with a zero resolve time in tests. Avoid
126 // divide-by-zero below by returning early; this data point is invalid anyway.
127 if (slowest_address_resolve->is_zero())
128 return;
129
130 // Compute a percentage showing how much larger the HTTPS query resolve time
131 // was compared to the slowest A or AAAA query.
132 //
133 // Computation happens on TimeDelta objects, which use CheckedNumeric. This
134 // will crash if the system clock leaps forward several hundred millennia
135 // (numeric_limits<int64_t>::max() microseconds ~= 292,000 years).
136 //
137 // Then scale the value of the percent by dividing by `kPercentScale`. Sample
138 // values are bounded between 1 and 20. A recorded sample of 10 means that the
139 // HTTPS query resolve time took 100% of the slower A/AAAA resolve time. A
140 // sample of 20 means that the HTTPS query resolve time was 200% relative to
141 // the A/AAAA resolve time, twice as long.
142 constexpr int64_t kMaxRatio = 20;
143 constexpr int64_t kPercentScale = 10;
144 const int64_t resolve_time_percent = base::ClampFloor<int64_t>(
145 *https_resolve_time_ / *slowest_address_resolve * 100);
146 base::UmaHistogramExactLinear(BuildMetricName("ResolveTimeRatio"),
147 resolve_time_percent / kPercentScale,
148 kMaxRatio);
149
150 if (num_https_records_ > 0) {
151 DCHECK(rcode_https_.has_value());
152 if (*rcode_https_ == HttpssvcDnsRcode::kNoError) {
153 base::UmaHistogramBoolean(BuildMetricName("Parsable"),
154 is_https_parsable_.value_or(false));
155 } else {
156 // Record boolean indicating whether we received an HTTPS record and
157 // an error simultaneously.
158 base::UmaHistogramBoolean(BuildMetricName("RecordWithError"), true);
159 }
160 }
161
162 base::UmaHistogramEnumeration(BuildMetricName("DnsRcode"), *rcode_https_);
163 }
164
165 } // namespace net
166