OkHttp中使用EventListener統計請求詳細耗時遇到的問題

背景

在項目中，我們會抽樣統計接口請求詳細的耗時信息，比如dns耗時，連接耗時，https握手耗時等等，通常我們都是使用okhttp的EventListener來統計，但是結果出來後我們發現，有小部分連接耗時都大於（response結束 - request開始）的時間。

問題

該問題主要是因爲我們項目中接口請求的OkHttpClient是單例的，在使用EventListener時，這一個EventListener會handle所有的請求，如果請求併發的話，其中的數據就會錯亂。查看okhttp javadoc可以知道，確實是有問題的。

在看doc文檔的時候發現eventListenerFactory方法感覺就是我們想要的， 每個請求通過factory創建一個新的EventListen。驗證後確實沒問題，不過有個問題是EventListener是請求過程中回調的方式，如果埋點發送不想在EventListener裏面發的話，做起來還是有點困難。不過在閱讀文檔的時候發現，可以通過okhttp3.Request.Builder#tag(java.lang.Class<? super T>, T)解決。相關代碼如下：
1、定義一個需要統計結果的model類，

public class NetEventModel {

    public long fetch_duration; //請求發出到拿到數據，不包括本地排隊時間
    public long dns_duration; //dns解析時間
    public long connect_duration; // 創建socket通道時間
    public long secure_duration; // ssl握手時間，connect_duration包含secure_duration
    public long request_duration; // writeBytes的時間
    public long response_duration; // readBytes的時間
    public long serve_duration; // 相當於responseStartDate - requestEndDate

}

2、創建Request的時候通過request builder把這個model通過tag設置進去。

        Request.Builder builder = new Request.Builder();
        builder.headers(Headers.of(headers));
        builder.url(url);
        if (model != null)
            builder.tag(NetEventModel.class, model);
        request = builder.build();

3、創建EventListenerFactory, 通過call對象拿到request從而拿到第二部設進去的model。

class PicEventListenerFactory implements EventListener.Factory {
    @Override
    public EventListener create(Call call) {
        NetEventModel tag = call.request().tag(NetEventModel.class);
        return tag != null ? new NetEventListener(tag) : EventListener.NONE;
    }
}

4、具體負責統計的NetEventListener

public class NetEventListener extends EventListener {
    private long callStart;
    //建立連接
    private long dnsStart;
    private long connectStart;
    private long secureConnectStart;

    //連接已經建立
    private long requestStart;
    private long responseStart;

    public long MAX_TIME = 30000;

    private NetEventModel model;

    public NetEventListener(NetEventModel model) {
        this.model = model;
    }

    public NetEventModel getModel() {
        return model;
    }

    @Override
    public void callStart(Call call) {
        callStart = System.currentTimeMillis();
    }

    @Override
    public void dnsStart(Call call, String domainName) {
        dnsStart = System.currentTimeMillis();
    }

    @Override
    public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
        model.dns_duration = System.currentTimeMillis() - dnsStart;

        if (model.dns_duration >= MAX_TIME) {
            model.dns_duration = 0;
        }
    }

    @Override
    public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
        connectStart = System.currentTimeMillis();
    }

    @Override
    public void secureConnectStart(Call call) {
        secureConnectStart = System.currentTimeMillis();
    }

    @Override
    public void secureConnectEnd(Call call, Handshake handshake) {
        model.secure_duration = System.currentTimeMillis() - secureConnectStart;

        if (model.secure_duration >= MAX_TIME) {
            model.secure_duration = 0;
        }
    }

    @Override
    public void connectEnd(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol) {
        model.connect_duration = System.currentTimeMillis() - connectStart;

        if (model.connect_duration >= MAX_TIME) {
            model.connect_duration = 0;
        }

        //因爲connectionAcquired可能會有多次，那麼請求從此處開始計時
        requestStart =  System.currentTimeMillis();
        model.request_duration = 0;
    }

    @Override
    public void connectFailed(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol, IOException ioe) {
        model.connect_duration = System.currentTimeMillis() - connectStart;

        if (model.connect_duration >= MAX_TIME) {
            model.connect_duration = 0;
        }
    }

    @Override
    public void requestHeadersEnd(Call call, Request request) {
        model.request_duration = System.currentTimeMillis() - requestStart;

        if (model.request_duration >= MAX_TIME) {
            model.request_duration = 0;
        }
    }

    @Override
    public void requestBodyEnd(Call call, long byteCount) {
        model.request_duration = System.currentTimeMillis() - requestStart;

        if (model.request_duration >= MAX_TIME) {
            model.request_duration = 0;
        }
    }

    @Override
    public void responseHeadersStart(Call call) {
        responseStart = System.currentTimeMillis();
        model.response_duration = 0;
    }

    @Override
    public void responseHeadersEnd(Call call, Response response) {
        model.response_duration = System.currentTimeMillis() - responseStart;

        if (model.response_duration >= MAX_TIME) {
            model.response_duration = 0;
        }
    }

    @Override
    public void responseBodyStart(Call call) {
        if (responseStart == 0) {
            responseStart = System.currentTimeMillis();
        }
    }

    @Override
    public void responseBodyEnd(Call call, long byteCount) {
        model.response_duration = System.currentTimeMillis() - responseStart;

        if (model.response_duration >= MAX_TIME) {
            model.response_duration = 0;
        }

        model.serve_duration = responseStart - (requestStart + model.request_duration);

        if (model.serve_duration >= MAX_TIME) {
            model.serve_duration = 0;
        }
    }

    @Override
    public void callEnd(Call call) {
        model.fetch_duration = System.currentTimeMillis() - callStart;

        if (model.fetch_duration >= MAX_TIME) {
            model.fetch_duration = 0;
        }
    }

    @Override
    public void callFailed(Call call, IOException ioe) {
        model.fetch_duration = System.currentTimeMillis() - callStart;

        if (model.fetch_duration >= MAX_TIME) {
            model.fetch_duration = 0;
        }
    }
}

這樣請求結束後，就可以通過NetEventModel對象拿到本次請求詳細的耗時數據。