1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.networkstack.metrics;
import static android.net.NetworkCapabilities.TRANSPORT_BLUETOOTH;
import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
import static android.net.NetworkCapabilities.TRANSPORT_LOWPAN;
import static android.net.NetworkCapabilities.TRANSPORT_VPN;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;
import static java.lang.System.currentTimeMillis;
import android.net.INetworkMonitor;
import android.net.NetworkCapabilities;
import android.net.captiveportal.CaptivePortalProbeResult;
import android.net.metrics.ValidationProbeEvent;
import android.net.util.NetworkStackUtils;
import android.net.util.Stopwatch;
import android.stats.connectivity.ProbeResult;
import android.stats.connectivity.ProbeType;
import android.stats.connectivity.TransportType;
import android.stats.connectivity.ValidationResult;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import com.android.networkstack.apishim.common.CaptivePortalDataShim;
/**
* Class to record the network validation into statsd.
* 1. Fill in NetworkValidationReported proto.
* 2. Write the NetworkValidationReported proto into statsd.
* @hide
*/
public class NetworkValidationMetrics {
private final NetworkValidationReported.Builder mStatsBuilder =
NetworkValidationReported.newBuilder();
private final ProbeEvents.Builder mProbeEventsBuilder = ProbeEvents.newBuilder();
private final CapportApiData.Builder mCapportApiDataBuilder = CapportApiData.newBuilder();
private final Stopwatch mWatch = new Stopwatch();
private int mValidationIndex = 0;
// Define a maximum size that can store events.
public static final int MAX_PROBE_EVENTS_COUNT = 20;
/**
* Reset this NetworkValidationMetrics and start collecting timing and metrics.
*
* <p>This must be called when validation starts.
*/
public void startCollection(@Nullable NetworkCapabilities nc) {
mStatsBuilder.clear();
mProbeEventsBuilder.clear();
mCapportApiDataBuilder.clear();
mWatch.restart();
mStatsBuilder.setTransportType(getTransportTypeFromNC(nc));
mValidationIndex++;
}
/**
* Returns the enum TransportType.
*
* <p>This method only supports a limited set of common transport type combinations that can be
* measured through metrics, and will return {@link TransportType#TT_UNKNOWN} for others. This
* ensures that, for example, metrics for a TRANSPORT_NEW_UNKNOWN | TRANSPORT_ETHERNET network
* cannot get aggregated with / compared with a "normal" TRANSPORT_ETHERNET network without
* noticing.
*
* @param nc Capabilities to extract transport type from.
* @return the TransportType which is defined in
* core/proto/android/stats/connectivity/network_stack.proto
*/
@VisibleForTesting
public static TransportType getTransportTypeFromNC(@Nullable NetworkCapabilities nc) {
if (nc == null) return TransportType.TT_UNKNOWN;
final int trCount = nc.getTransportTypes().length;
boolean hasCellular = nc.hasTransport(TRANSPORT_CELLULAR);
boolean hasWifi = nc.hasTransport(TRANSPORT_WIFI);
boolean hasBT = nc.hasTransport(TRANSPORT_BLUETOOTH);
boolean hasEthernet = nc.hasTransport(TRANSPORT_ETHERNET);
boolean hasVpn = nc.hasTransport(TRANSPORT_VPN);
boolean hasWifiAware = nc.hasTransport(TRANSPORT_WIFI_AWARE);
boolean hasLopan = nc.hasTransport(TRANSPORT_LOWPAN);
// VPN networks are not subject to validation and should not see validation stats, but
// metrics could be added to measure private DNS probes only.
if (trCount == 3 && hasCellular && hasWifi && hasVpn) {
return TransportType.TT_WIFI_CELLULAR_VPN;
}
if (trCount == 2 && hasVpn) {
if (hasWifi) return TransportType.TT_WIFI_VPN;
if (hasCellular) return TransportType.TT_CELLULAR_VPN;
if (hasBT) return TransportType.TT_BLUETOOTH_VPN;
if (hasEthernet) return TransportType.TT_ETHERNET_VPN;
}
if (trCount == 1) {
if (hasWifi) return TransportType.TT_WIFI;
if (hasCellular) return TransportType.TT_CELLULAR;
if (hasBT) return TransportType.TT_BLUETOOTH;
if (hasEthernet) return TransportType.TT_ETHERNET;
if (hasWifiAware) return TransportType.TT_WIFI_AWARE;
if (hasLopan) return TransportType.TT_LOWPAN;
// TODO: consider having a TT_VPN for VPN-only transport
}
return TransportType.TT_UNKNOWN;
}
/**
* Map {@link ValidationProbeEvent} to {@link ProbeType}.
*/
public static ProbeType probeTypeToEnum(final int probeType) {
switch(probeType) {
case ValidationProbeEvent.PROBE_DNS:
return ProbeType.PT_DNS;
case ValidationProbeEvent.PROBE_HTTP:
return ProbeType.PT_HTTP;
case ValidationProbeEvent.PROBE_HTTPS:
return ProbeType.PT_HTTPS;
case ValidationProbeEvent.PROBE_PAC:
return ProbeType.PT_PAC;
case ValidationProbeEvent.PROBE_FALLBACK:
return ProbeType.PT_FALLBACK;
case ValidationProbeEvent.PROBE_PRIVDNS:
return ProbeType.PT_PRIVDNS;
default:
return ProbeType.PT_UNKNOWN;
}
}
/**
* Map {@link CaptivePortalProbeResult} to {@link ProbeResult}.
*/
public static ProbeResult httpProbeResultToEnum(final CaptivePortalProbeResult result) {
if (result == null) return ProbeResult.PR_UNKNOWN;
if (result.isSuccessful()) {
return ProbeResult.PR_SUCCESS;
} else if (result.isDnsPrivateIpResponse()) {
return ProbeResult.PR_PRIVATE_IP_DNS;
} else if (result.isFailed()) {
return ProbeResult.PR_FAILURE;
} else if (result.isPortal()) {
return ProbeResult.PR_PORTAL;
} else {
return ProbeResult.PR_UNKNOWN;
}
}
/**
* Map validation result (as per INetworkMonitor) to {@link ValidationResult}.
*/
@VisibleForTesting
public static ValidationResult validationResultToEnum(int result, String redirectUrl) {
// TODO: consider adding a VR_PARTIAL_SUCCESS field to track cases where users accepted
// partial connectivity
if ((result & INetworkMonitor.NETWORK_VALIDATION_RESULT_VALID) != 0) {
return ValidationResult.VR_SUCCESS;
} else if (redirectUrl != null) {
return ValidationResult.VR_PORTAL;
} else if ((result & INetworkMonitor.NETWORK_VALIDATION_RESULT_PARTIAL) != 0) {
return ValidationResult.VR_PARTIAL;
} else {
return ValidationResult.VR_FAILURE;
}
}
/**
* Add a network probe event to the metrics builder.
*/
public void addProbeEvent(final ProbeType type, final long durationUs, final ProbeResult result,
@Nullable final CaptivePortalDataShim capportData) {
// When the number of ProbeEvents of mProbeEventsBuilder exceeds
// MAX_PROBE_EVENTS_COUNT, stop adding ProbeEvent.
// TODO: consider recording the total number of probes in a separate field to know how
// many probes are skipped.
if (mProbeEventsBuilder.getProbeEventCount() >= MAX_PROBE_EVENTS_COUNT) return;
int latencyUs = NetworkStackUtils.saturatedCast(durationUs);
final ProbeEvent.Builder probeEventBuilder = ProbeEvent.newBuilder()
.setLatencyMicros(latencyUs)
.setProbeType(type)
.setProbeResult(result);
if (capportData != null) {
final long secondsRemaining =
(capportData.getExpiryTimeMillis() - currentTimeMillis()) / 1000;
mCapportApiDataBuilder
.setRemainingTtlSecs(NetworkStackUtils.saturatedCast(secondsRemaining))
// TODO: rename this field to setRemainingKBytes, or use a long
.setRemainingBytes(
NetworkStackUtils.saturatedCast(capportData.getByteLimit() / 1000))
.setHasPortalUrl((capportData.getUserPortalUrl() != null))
.setHasVenueInfo((capportData.getVenueInfoUrl() != null));
probeEventBuilder.setCapportApiData(mCapportApiDataBuilder);
}
mProbeEventsBuilder.addProbeEvent(probeEventBuilder);
}
/**
* Write the network validation info to mStatsBuilder.
*/
public void setValidationResult(int result, String redirectUrl) {
mStatsBuilder.setValidationResult(validationResultToEnum(result, redirectUrl));
}
/**
* Write the NetworkValidationReported proto to statsd.
*
* <p>This is a no-op if {@link #startCollection(NetworkCapabilities)} was not called since the
* last call to this method.
*/
public NetworkValidationReported maybeStopCollectionAndSend() {
if (!mWatch.isStarted()) return null;
mStatsBuilder.setProbeEvents(mProbeEventsBuilder);
mStatsBuilder.setLatencyMicros(NetworkStackUtils.saturatedCast(mWatch.stop()));
mStatsBuilder.setValidationIndex(mValidationIndex);
// write a random value(0 ~ 999) for sampling.
mStatsBuilder.setRandomNumber((int) (Math.random() * 1000));
final NetworkValidationReported stats = mStatsBuilder.build();
final byte[] probeEvents = stats.getProbeEvents().toByteArray();
NetworkStackStatsLog.write(NetworkStackStatsLog.NETWORK_VALIDATION_REPORTED,
stats.getTransportType().getNumber(),
probeEvents,
stats.getValidationResult().getNumber(),
stats.getLatencyMicros(),
stats.getValidationIndex(),
stats.getRandomNumber());
mWatch.reset();
return stats;
}
}
|
