Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0e8090b1 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes Id0d536ff,I4fcd0ad7 into oc-dev

* changes:
  Connectivity metrics: add transports to connect stats
  Connectivity metrics: log DnsEvents in-band
parents f5d5e5e4 5eb9053c
Loading
Loading
Loading
Loading
+35 −50
Original line number Diff line number Diff line
@@ -16,53 +16,47 @@

package android.net.metrics;

import android.net.NetworkCapabilities;
import android.system.OsConstants;
import android.util.IntArray;
import android.util.SparseIntArray;
import com.android.internal.util.BitUtils;
import com.android.internal.util.TokenBucket;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.ConnectStatistics;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.Pair;

/**
 * A class that aggregates connect() statistics and helps build
 * IpConnectivityLogClass.ConnectStatistics instances.
 *
 * A class that aggregates connect() statistics.
 * {@hide}
 */
public class ConnectStats {
    private final static int EALREADY     = OsConstants.EALREADY;
    private final static int EINPROGRESS  = OsConstants.EINPROGRESS;

    /** Network id of the network associated with the event, or 0 if unspecified. */
    public final int netId;
    /** Transports of the network associated with the event, as defined in NetworkCapabilities. */
    public final long transports;
    /** How many events resulted in a given errno. */
    private final SparseIntArray mErrnos = new SparseIntArray();
    /** Latencies of blocking connects. TODO: add non-blocking connects latencies. */
    private final IntArray mLatencies = new IntArray();
    public final SparseIntArray errnos = new SparseIntArray();
    /** Latencies of successful blocking connects. TODO: add non-blocking connects latencies. */
    public final IntArray latencies = new IntArray();
    /** TokenBucket for rate limiting latency recording. */
    private final TokenBucket mLatencyTb;
    public final TokenBucket mLatencyTb;
    /** Maximum number of latency values recorded. */
    private final int mMaxLatencyRecords;
    public final int mMaxLatencyRecords;
    /** Total count of successful connects. */
    private int mConnectCount = 0;
    public int connectCount = 0;
    /** Total count of successful connects done in blocking mode. */
    private int mConnectBlockingCount = 0;
    public int connectBlockingCount = 0;
    /** Total count of successful connects with IPv6 socket address. */
    private int mIpv6ConnectCount = 0;
    public int ipv6ConnectCount = 0;

    public ConnectStats(TokenBucket tb, int maxLatencyRecords) {
    public ConnectStats(int netId, long transports, TokenBucket tb, int maxLatencyRecords) {
        this.netId = netId;
        this.transports = transports;
        mLatencyTb = tb;
        mMaxLatencyRecords = maxLatencyRecords;
    }

    public ConnectStatistics toProto() {
        ConnectStatistics stats = new ConnectStatistics();
        stats.connectCount = mConnectCount;
        stats.connectBlockingCount = mConnectBlockingCount;
        stats.ipv6AddrCount = mIpv6ConnectCount;
        stats.latenciesMs = mLatencies.toArray();
        stats.errnosCounters = toPairArrays(mErrnos);
        return stats;
    }

    public void addEvent(int errno, int latencyMs, String ipAddr) {
        if (isSuccess(errno)) {
            countConnect(errno, ipAddr);
@@ -73,12 +67,12 @@ public class ConnectStats {
    }

    private void countConnect(int errno, String ipAddr) {
        mConnectCount++;
        connectCount++;
        if (!isNonBlocking(errno)) {
            mConnectBlockingCount++;
            connectBlockingCount++;
        }
        if (isIPv6(ipAddr)) {
            mIpv6ConnectCount++;
            ipv6ConnectCount++;
        }
    }

@@ -91,16 +85,16 @@ public class ConnectStats {
            // Rate limited
            return;
        }
        if (mLatencies.size() >= mMaxLatencyRecords) {
        if (latencies.size() >= mMaxLatencyRecords) {
            // Hard limit the total number of latency measurements.
            return;
        }
        mLatencies.add(ms);
        latencies.add(ms);
    }

    private void countError(int errno) {
        final int newcount = mErrnos.get(errno, 0) + 1;
        mErrnos.put(errno, newcount);
        final int newcount = errnos.get(errno, 0) + 1;
        errnos.put(errno, newcount);
    }

    private static boolean isSuccess(int errno) {
@@ -117,27 +111,18 @@ public class ConnectStats {
        return ipAddr.contains(":");
    }

    private static Pair[] toPairArrays(SparseIntArray counts) {
        final int s = counts.size();
        Pair[] pairs = new Pair[s];
        for (int i = 0; i < s; i++) {
            Pair p = new Pair();
            p.key = counts.keyAt(i);
            p.value = counts.valueAt(i);
            pairs[i] = p;
        }
        return pairs;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("ConnectStats(")
                .append(String.format("%d success, ", mConnectCount))
                .append(String.format("%d blocking, ", mConnectBlockingCount))
                .append(String.format("%d IPv6 dst", mIpv6ConnectCount));
        for (int i = 0; i < mErrnos.size(); i++) {
            String errno = OsConstants.errnoName(mErrnos.keyAt(i));
            int count = mErrnos.valueAt(i);
        StringBuilder builder = new StringBuilder("ConnectStats(").append(netId).append(", ");
        for (int t : BitUtils.unpackBits(transports)) {
            builder.append(NetworkCapabilities.transportNameOf(t)).append(", ");
        }
        builder.append(String.format("%d success, ", connectCount));
        builder.append(String.format("%d blocking, ", connectBlockingCount));
        builder.append(String.format("%d IPv6 dst", ipv6ConnectCount));
        for (int i = 0; i < errnos.size(); i++) {
            String errno = OsConstants.errnoName(errnos.keyAt(i));
            int count = errnos.valueAt(i);
            builder.append(String.format(", %s: %d", errno, count));
        }
        return builder.append(")").toString();
+47 −44
Original line number Diff line number Diff line
@@ -16,67 +16,70 @@

package android.net.metrics;

import android.os.Parcel;
import android.os.Parcelable;
import android.net.NetworkCapabilities;
import java.util.Arrays;
import com.android.internal.util.BitUtils;

/**
 * A DNS event recorded by NetdEventListenerService.
 * {@hide}
 */
final public class DnsEvent implements Parcelable {
    public final int netId;
final public class DnsEvent {

    private static final int SIZE_LIMIT = 20000;

    // The event type is currently only 1 or 2, so we store it as a byte.
    public final byte[] eventTypes;
    // Network id of the network associated with the event, or 0 if unspecified.
    public final int netId;
    // Transports of the network associated with the event, as defined in NetworkCapabilities.
    // It is the caller responsability to ensure the value of transports does not change between
    // calls to addResult.
    public final long transports;
    // The number of DNS queries recorded. Queries are stored in the structure-of-array style where
    // the eventTypes, returnCodes, and latenciesMs arrays have the same length and the i-th event
    // is spread across the three array at position i.
    public int eventCount;
    // The types of DNS queries as defined in INetdEventListener.
    public byte[] eventTypes;
    // Current getaddrinfo codes go from 1 to EAI_MAX = 15. gethostbyname returns errno, but there
    // are fewer than 255 errno values. So we store the result code in a byte as well.
    public final byte[] returnCodes;
    // The latency is an integer because a) short arrays aren't parcelable and b) a short can only
    // store a maximum latency of 32757 or 65535 ms, which is too short for pathologically slow
    // queries.
    public final int[] latenciesMs;
    public byte[] returnCodes;
    // Latencies in milliseconds of queries, stored as ints.
    public int[] latenciesMs;

    public DnsEvent(int netId, byte[] eventTypes, byte[] returnCodes, int[] latenciesMs) {
    public DnsEvent(int netId, long transports, int initialCapacity) {
        this.netId = netId;
        this.eventTypes = eventTypes;
        this.returnCodes = returnCodes;
        this.latenciesMs = latenciesMs;
        this.transports = transports;
        eventTypes = new byte[initialCapacity];
        returnCodes = new byte[initialCapacity];
        latenciesMs = new int[initialCapacity];
    }

    private DnsEvent(Parcel in) {
        this.netId = in.readInt();
        this.eventTypes = in.createByteArray();
        this.returnCodes = in.createByteArray();
        this.latenciesMs = in.createIntArray();
    public void addResult(byte eventType, byte returnCode, int latencyMs) {
        if (eventCount >= SIZE_LIMIT) {
            // TODO: implement better rate limiting that does not biases metrics.
            return;
        }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(netId);
        out.writeByteArray(eventTypes);
        out.writeByteArray(returnCodes);
        out.writeIntArray(latenciesMs);
        if (eventCount == eventTypes.length) {
            resize((int) (1.4 * eventCount));
        }

    @Override
    public int describeContents() {
        return 0;
        eventTypes[eventCount] = eventType;
        returnCodes[eventCount] = returnCode;
        latenciesMs[eventCount] = latencyMs;
        eventCount++;
    }

    @Override
    public String toString() {
        return String.format("DnsEvent(%d, %d events)", netId, eventTypes.length);
    public void resize(int newLength) {
        eventTypes = Arrays.copyOf(eventTypes, newLength);
        returnCodes = Arrays.copyOf(returnCodes, newLength);
        latenciesMs = Arrays.copyOf(latenciesMs, newLength);
    }

    public static final Parcelable.Creator<DnsEvent> CREATOR = new Parcelable.Creator<DnsEvent>() {
    @Override
        public DnsEvent createFromParcel(Parcel in) {
            return new DnsEvent(in);
    public String toString() {
        StringBuilder builder = new StringBuilder("DnsEvent(").append(netId).append(", ");
        for (int t : BitUtils.unpackBits(transports)) {
            builder.append(NetworkCapabilities.transportNameOf(t)).append(", ");
        }

        @Override
        public DnsEvent[] newArray(int size) {
            return new DnsEvent[size];
        return builder.append(eventCount).append(" events)").toString();
    }
    };
}
+57 −26
Original line number Diff line number Diff line
@@ -23,9 +23,6 @@ import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
import static android.net.NetworkCapabilities.TRANSPORT_VPN;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;
import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;
import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityLog;
import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.NetworkId;

import android.net.ConnectivityMetricsEvent;
import android.net.metrics.ApfProgramEvent;
@@ -34,6 +31,7 @@ import android.net.metrics.DefaultNetworkEvent;
import android.net.metrics.DhcpClientEvent;
import android.net.metrics.DhcpErrorEvent;
import android.net.metrics.DnsEvent;
import android.net.metrics.ConnectStats;
import android.net.metrics.IpManagerEvent;
import android.net.metrics.IpReachabilityEvent;
import android.net.metrics.NetworkEvent;
@@ -41,7 +39,12 @@ import android.net.metrics.RaEvent;
import android.net.metrics.ValidationProbeEvent;
import android.os.Parcelable;
import android.util.SparseArray;
import android.util.SparseIntArray;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityLog;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.NetworkId;
import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.Pair;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@@ -77,20 +80,51 @@ final public class IpConnectivityEventBuilder {
    }

    public static IpConnectivityEvent toProto(ConnectivityMetricsEvent ev) {
        final IpConnectivityEvent out = new IpConnectivityEvent();
        final IpConnectivityEvent out = buildEvent(ev.netId, ev.transports, ev.ifname);
        out.timeMs = ev.timestamp;
        if (!setEvent(out, ev.data)) {
            return null;
        }
        out.timeMs = ev.timestamp;
        out.networkId = ev.netId;
        out.transports = ev.transports;
        if (ev.ifname != null) {
          out.ifName = ev.ifname;
        return out;
    }

    public static IpConnectivityEvent toProto(ConnectStats in) {
        IpConnectivityLogClass.ConnectStatistics stats =
                new IpConnectivityLogClass.ConnectStatistics();
        stats.connectCount = in.connectCount;
        stats.connectBlockingCount = in.connectBlockingCount;
        stats.ipv6AddrCount = in.ipv6ConnectCount;
        stats.latenciesMs = in.latencies.toArray();
        stats.errnosCounters = toPairArray(in.errnos);
        final IpConnectivityEvent out = buildEvent(in.netId, in.transports, null);
        out.setConnectStatistics(stats);
        return out;
    }
        inferLinkLayer(out);


    public static IpConnectivityEvent toProto(DnsEvent in) {
        IpConnectivityLogClass.DNSLookupBatch dnsLookupBatch =
                new IpConnectivityLogClass.DNSLookupBatch();
        in.resize(in.eventCount);
        dnsLookupBatch.eventTypes = bytesToInts(in.eventTypes);
        dnsLookupBatch.returnCodes = bytesToInts(in.returnCodes);
        dnsLookupBatch.latenciesMs = in.latenciesMs;
        final IpConnectivityEvent out = buildEvent(in.netId, in.transports, null);
        out.setDnsLookupBatch(dnsLookupBatch);
        return out;
    }

    private static IpConnectivityEvent buildEvent(int netId, long transports, String ifname) {
        final IpConnectivityEvent ev = new IpConnectivityEvent();
        ev.networkId = netId;
        ev.transports = transports;
        if (ifname != null) {
            ev.ifName = ifname;
        }
        inferLinkLayer(ev);
        return ev;
    }

    private static boolean setEvent(IpConnectivityEvent out, Parcelable in) {
        if (in instanceof DhcpErrorEvent) {
            setDhcpErrorEvent(out, (DhcpErrorEvent) in);
@@ -102,11 +136,6 @@ final public class IpConnectivityEventBuilder {
            return true;
        }

        if (in instanceof DnsEvent) {
            setDnsEvent(out, (DnsEvent) in);
            return true;
        }

        if (in instanceof IpManagerEvent) {
            setIpManagerEvent(out, (IpManagerEvent) in);
            return true;
@@ -163,16 +192,6 @@ final public class IpConnectivityEventBuilder {
        out.setDhcpEvent(dhcpEvent);
    }

    private static void setDnsEvent(IpConnectivityEvent out, DnsEvent in) {
        IpConnectivityLogClass.DNSLookupBatch dnsLookupBatch =
                new IpConnectivityLogClass.DNSLookupBatch();
        dnsLookupBatch.networkId = netIdOf(in.netId);
        dnsLookupBatch.eventTypes = bytesToInts(in.eventTypes);
        dnsLookupBatch.returnCodes = bytesToInts(in.returnCodes);
        dnsLookupBatch.latenciesMs = in.latenciesMs;
        out.setDnsLookupBatch(dnsLookupBatch);
    }

    private static void setIpManagerEvent(IpConnectivityEvent out, IpManagerEvent in) {
        IpConnectivityLogClass.IpProvisioningEvent ipProvisioningEvent =
                new IpConnectivityLogClass.IpProvisioningEvent();
@@ -268,6 +287,18 @@ final public class IpConnectivityEventBuilder {
        return out;
    }

    private static Pair[] toPairArray(SparseIntArray counts) {
        final int s = counts.size();
        Pair[] pairs = new Pair[s];
        for (int i = 0; i < s; i++) {
            Pair p = new Pair();
            p.key = counts.keyAt(i);
            p.value = counts.valueAt(i);
            pairs[i] = p;
        }
        return pairs;
    }

    private static NetworkId netIdOf(int netid) {
        final NetworkId ni = new NetworkId();
        ni.networkId = netid;
+2 −1
Original line number Diff line number Diff line
@@ -76,7 +76,8 @@ final public class IpConnectivityMetrics extends SystemService {

    @VisibleForTesting
    public final Impl impl = new Impl();
    private NetdEventListenerService mNetdListener;
    @VisibleForTesting
    NetdEventListenerService mNetdListener;

    @GuardedBy("mLock")
    private ArrayList<ConnectivityMetricsEvent> mBuffer;
+63 −111

File changed.

Preview size limit exceeded, changes collapsed.

Loading