Add network timing attributes to okhttp3 library

instrumentation/okhttp/okhttp-3.0/library/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 dependencies {
-  library("com.squareup.okhttp3:okhttp:3.0.0")
+  library("com.squareup.okhttp3:okhttp:3.11.0")
 
   testImplementation(project(":instrumentation:okhttp:okhttp-3.0:testing"))
 }

instrumentation/okhttp/okhttp-3.0/library/src/http2Test/java/io/opentelemetry/instrumentation/okhttp/v3_0/OkHttp3Http2Test.java

@@ -6,14 +6,17 @@
 package io.opentelemetry.instrumentation.okhttp.v3_0;
 
 import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
 
+import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest;
 import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions;
 import okhttp3.Call;
 import okhttp3.OkHttpClient;
 import okhttp3.Protocol;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 class OkHttp3Http2Test extends AbstractOkHttp3Test {
@@ -39,4 +42,41 @@ protected void configure(HttpClientTestOptions.Builder optionsBuilder) {
     optionsBuilder.disableTestHttps();
     optionsBuilder.setHttpProtocolVersion(uri -> "2");
   }
+
+  public Call.Factory createCallFactoryWithNetworkTiming(OkHttpClient.Builder clientBuilder) {
+    clientBuilder.protocols(singletonList(Protocol.H2_PRIOR_KNOWLEDGE));
+    return OkHttpTelemetry.builder(testing.getOpenTelemetry())
+        .setCapturedRequestHeaders(singletonList(AbstractHttpClientTest.TEST_REQUEST_HEADER))
+        .setCapturedResponseHeaders(singletonList(AbstractHttpClientTest.TEST_RESPONSE_HEADER))
+        .build()
+        .newCallFactoryWithNetworkTiming(clientBuilder.build());
+  }
+
+  @Test
+  void networkTimingClient() throws Exception {
+    okhttp3.Request request =
+        new okhttp3.Request.Builder().url(resolveAddress("/success").toString()).build();
+    okhttp3.Response response =
+        createCallFactoryWithNetworkTiming(new OkHttpClient.Builder()).newCall(request).execute();
+    assertThat(response.code()).isEqualTo(200);
+
+    testing.waitAndAssertTraces(
+        trace -> {
+          trace.hasSpansSatisfyingExactly(
+              span -> {
+                assertClientSpan(span, resolveAddress("/success"), "GET", 200, null)
+                    .hasNoParent()
+                    .hasAttributesSatisfying(
+                        attrs -> {
+                          boolean hasTiming =
+                              attrs.asMap().keySet().stream()
+                                  .map(AttributeKey::getKey)
+                                  .anyMatch(
+                                      k -> k.endsWith(".start_time") || k.endsWith(".end_time"));
+                          assertThat(hasTiming).isTrue();
+                        });
+              },
+              span -> assertServerSpan(span).hasParent(trace.getSpan(0)));
+        });
+  }
 }

instrumentation/okhttp/okhttp-3.0/library/src/main/java/io/opentelemetry/instrumentation/okhttp/v3_0/OkHttpTelemetry.java

@@ -9,6 +9,7 @@
 import io.opentelemetry.context.propagation.ContextPropagators;
 import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
 import io.opentelemetry.instrumentation.okhttp.v3_0.internal.ConnectionErrorSpanInterceptor;
+import io.opentelemetry.instrumentation.okhttp.v3_0.internal.NetworkTimingEventListener;
 import io.opentelemetry.instrumentation.okhttp.v3_0.internal.TracingInterceptor;
 import okhttp3.Call;
 import okhttp3.Callback;
@@ -59,4 +60,27 @@ public Call.Factory newCallFactory(OkHttpClient baseClient) {
     OkHttpClient tracingClient = builder.build();
     return new TracingCallFactory(tracingClient);
   }
+
+  /**
+   * Construct a new OpenTelemetry tracing-enabled {@link okhttp3.Call.Factory} using the provided
+   * {@link OkHttpClient} instance, with a NetworkTimingEventListener added to capture timing
+   * attributes.
+   *
+   * <p>Using this method will result in proper propagation and span parenting, for both {@linkplain
+   * Call#execute() synchronous} and {@linkplain Call#enqueue(Callback) asynchronous} usages.
+   *
+   * @param baseClient An instance of OkHttpClient configured as desired.
+   * @return a {@link Call.Factory} for creating new {@link Call} instances.
+   */
+  public Call.Factory newCallFactoryWithNetworkTiming(OkHttpClient baseClient) {
+    OkHttpClient.Builder builder = baseClient.newBuilder();
+    // add our interceptors before other interceptors
+    builder.interceptors().add(0, new ContextInterceptor());
+    builder.interceptors().add(1, new ConnectionErrorSpanInterceptor(instrumenter));
+    builder.networkInterceptors().add(0, new TracingInterceptor(instrumenter, propagators));
+    // Add NetworkTimingEventListener to capture timing attributes
+    builder.eventListenerFactory(new NetworkTimingEventListener.Factory());
+    OkHttpClient tracingClient = builder.build();
+    return new TracingCallFactory(tracingClient);
+  }
 }

instrumentation/okhttp/okhttp-3.0/library/src/main/java/io/opentelemetry/instrumentation/okhttp/v3_0/TracingCallFactory.java

@@ -76,16 +76,24 @@ public void cancel() {
     }
 
     @Override
-    public Call clone() throws CloneNotSupportedException {
+    public Call clone() {
       if (cloneMethod == null) {
-        return (Call) super.clone();
+        try {
+          return (Call) super.clone();
+        } catch (CloneNotSupportedException e) {
+          throw new AssertionError(e);
+        }
       }
       try {
         // we pull the current context here, because the cloning might be happening in a different
         // context than the original call creation.
         return new TracingCall((Call) cloneMethod.invoke(delegate), Context.current());
       } catch (IllegalAccessException | InvocationTargetException e) {
-        return (Call) super.clone();
+        try {
+          return (Call) super.clone();
+        } catch (CloneNotSupportedException cloneException) {
+          throw new AssertionError(cloneException);
+        }
       }
     }
 

instrumentation/okhttp/okhttp-3.0/library/src/main/java/io/opentelemetry/instrumentation/okhttp/v3_0/internal/NetworkTimingEventListener.java

@@ -0,0 +1,179 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.okhttp.v3_0.internal;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.Span;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.util.List;
+import javax.annotation.Nullable;
+import okhttp3.Call;
+import okhttp3.Connection;
+import okhttp3.EventListener;
+import okhttp3.Handshake;
+import okhttp3.Protocol;
+import okhttp3.Request;
+import okhttp3.Response;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+public final class NetworkTimingEventListener extends EventListener {
+
+  // Raw timestamp attribute keys
+  private static final AttributeKey<Long> CALL_START = AttributeKey.longKey("http.call.start_time");
+  private static final AttributeKey<Long> DNS_START = AttributeKey.longKey("http.dns.start_time");
+  private static final AttributeKey<Long> DNS_END = AttributeKey.longKey("http.dns.end_time");
+  private static final AttributeKey<Long> CONNECT_START =
+      AttributeKey.longKey("http.connect.start_time");
+  private static final AttributeKey<Long> CONNECT_END =
+      AttributeKey.longKey("http.connect.end_time");
+  private static final AttributeKey<Long> SECURE_CONNECT_START =
+      AttributeKey.longKey("http.secure_connect.start_time");
+  private static final AttributeKey<Long> SECURE_CONNECT_END =
+      AttributeKey.longKey("http.secure_connect.end_time");
+  private static final AttributeKey<Long> REQUEST_HEADERS_START =
+      AttributeKey.longKey("http.request.headers.start_time");
+  private static final AttributeKey<Long> REQUEST_HEADERS_END =
+      AttributeKey.longKey("http.request.headers.end_time");
+  private static final AttributeKey<Long> REQUEST_BODY_START =
+      AttributeKey.longKey("http.request.body.start_time");
+  private static final AttributeKey<Long> REQUEST_BODY_END =
+      AttributeKey.longKey("http.request.body.end_time");
+  private static final AttributeKey<Long> RESPONSE_HEADERS_START =
+      AttributeKey.longKey("http.response.headers.start_time");
+  private static final AttributeKey<Long> RESPONSE_HEADERS_END =
+      AttributeKey.longKey("http.response.headers.end_time");
+  private static final AttributeKey<Long> RESPONSE_BODY_START =
+      AttributeKey.longKey("http.response.body.start_time");
+  private static final AttributeKey<Long> RESPONSE_BODY_END =
+      AttributeKey.longKey("http.response.body.end_time");
+  private static final AttributeKey<Long> CALL_END = AttributeKey.longKey("http.call.end_time");
+
+  // Singleton instance of stateless NetworkTimingEventListener
+  private static final NetworkTimingEventListener INSTANCE = new NetworkTimingEventListener();
+
+  private NetworkTimingEventListener() {}
+
+  @Override
+  public void callStart(Call call) {
+    Span.current().setAttribute(CALL_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void dnsStart(Call call, String domainName) {
+    Span.current().setAttribute(DNS_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
+    Span.current().setAttribute(DNS_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
+    Span.current().setAttribute(CONNECT_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void secureConnectStart(Call call) {
+    Span.current().setAttribute(SECURE_CONNECT_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void secureConnectEnd(Call call, @Nullable Handshake handshake) {
+    Span.current().setAttribute(SECURE_CONNECT_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void connectEnd(
+      Call call, InetSocketAddress inetSocketAddress, Proxy proxy, @Nullable Protocol protocol) {
+    Span.current().setAttribute(CONNECT_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void connectFailed(
+      Call call,
+      InetSocketAddress inetSocketAddress,
+      Proxy proxy,
+      @Nullable Protocol protocol,
+      IOException ioe) {}
+
+  @Override
+  public void connectionAcquired(Call call, Connection connection) {}
+
+  @Override
+  public void connectionReleased(Call call, Connection connection) {}
+
+  @Override
+  public void requestHeadersStart(Call call) {
+    Span.current().setAttribute(REQUEST_HEADERS_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void requestHeadersEnd(Call call, Request request) {
+    Span.current().setAttribute(REQUEST_HEADERS_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void requestBodyStart(Call call) {
+    Span.current().setAttribute(REQUEST_BODY_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void requestBodyEnd(Call call, long byteCount) {
+    Span.current().setAttribute(REQUEST_BODY_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void responseHeadersStart(Call call) {
+    Span.current().setAttribute(RESPONSE_HEADERS_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void responseHeadersEnd(Call call, Response response) {
+    Span.current().setAttribute(RESPONSE_HEADERS_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void responseBodyStart(Call call) {
+    Span.current().setAttribute(RESPONSE_BODY_START, System.currentTimeMillis());
+  }
+
+  @Override
+  public void responseBodyEnd(Call call, long byteCount) {
+    Span.current().setAttribute(RESPONSE_BODY_END, System.currentTimeMillis());
+  }
+
+  @Override
+  public void callEnd(Call call) {
+    Span.current().setAttribute(CALL_END, System.currentTimeMillis());
+  }
+
+  /**
+   * Factory for creating NetworkTimingEventListener instances. A singleton instance is returned as
+   * the listener is stateless and thread-safe.
+   *
+   * <p>NetworkTimingEventListener captures raw network timing timestamps and adds them as
+   * attributes to the current OpenTelemetry span.
+   *
+   * <p>Works with both synchronous and asynchronous OkHttp calls when used with proper context
+   * propagation.
+   *
+   * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+   * at any time.
+   */
+  public static final class Factory implements EventListener.Factory {
+    @Override
+    public EventListener create(Call call) {
+      return INSTANCE;
+    }
+  }
+}

instrumentation/okhttp/okhttp-3.0/library/src/main/java/io/opentelemetry/instrumentation/okhttp/v3_0/internal/OkHttpAttributesGetter.java

@@ -62,12 +62,13 @@ public String getNetworkProtocolName(Interceptor.Chain chain, @Nullable Response
         return "http";
       case SPDY_3:
         return "spdy";
+      default:
+        // added in 3.11.0
+        if ("H2_PRIOR_KNOWLEDGE".equals(response.protocol().name())) {
+          return "http";
+        }
+        return null;
     }
-    // added in 3.11.0
-    if ("H2_PRIOR_KNOWLEDGE".equals(response.protocol().name())) {
-      return "http";
-    }
-    return null;
   }
 
   @Nullable
@@ -85,12 +86,13 @@ public String getNetworkProtocolVersion(Interceptor.Chain chain, @Nullable Respo
         return "2";
       case SPDY_3:
         return "3.1";
+      default:
+        // added in 3.11.0
+        if ("H2_PRIOR_KNOWLEDGE".equals(response.protocol().name())) {
+          return "2";
+        }
+        return null;
     }
-    // added in 3.11.0
-    if ("H2_PRIOR_KNOWLEDGE".equals(response.protocol().name())) {
-      return "2";
-    }
-    return null;
   }
 
   @Override