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

core/java/android/net/metrics/ConnectStats.java

+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();

core/java/android/net/metrics/DnsEvent.java

+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();

    }

    };

}

services/core/java/com/android/server/connectivity/IpConnectivityEventBuilder.java

+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;

services/core/java/com/android/server/connectivity/IpConnectivityMetrics.java

+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;

services/core/java/com/android/server/connectivity/NetdEventListenerService.java

+63 −111

File changed.

Preview size limit exceeded, changes collapsed.