Split out okhttp4 sender

buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts

@@ -81,15 +81,20 @@ fun getClasspathForVersion(version: String): List<File> {
   group = "virtual_group"
   try {
     return getAllPublishedModules().map {
-      val depModule = "io.opentelemetry:${it.base.archivesName.get()}:$version@jar"
-      val depJar = "${it.base.archivesName.get()}-$version.jar"
-      val configuration: Configuration = configurations.detachedConfiguration(
-        dependencies.create(depModule),
-      )
-      files(configuration.files).filter { file ->
-        file.name.equals(depJar)
-      }.singleFile
-    }.toList()
+      try {
+        val depModule = "io.opentelemetry:${it.base.archivesName.get()}:$version@jar"
+        val depJar = "${it.base.archivesName.get()}-$version.jar"
+        val configuration: Configuration = configurations.detachedConfiguration(
+          dependencies.create(depModule),
+        )
+        files(configuration.files).filter { file ->
+          file.name.equals(depJar)
+        }.singleFile
+      } catch (e: Exception) {
+        println("Failed to fetch artifact for version ${it.base.archivesName.get()}:$version. If this artifact is has not yet been published, ignore.")
+        null
+      }
+    }.toList().filterNotNull()
   } finally {
     group = existingGroup
   }

dependencyManagement/build.gradle.kts

@@ -18,7 +18,6 @@ val opencensusVersion = "0.31.1"
 val prometheusServerVersion = "1.3.10"
 val armeriaVersion = "1.36.0"
 val junitVersion = "5.14.2"
-val okhttpVersion = "5.3.2"
 
 val DEPENDENCY_BOMS = listOf(
   // for some reason boms show up as runtime dependencies in license and vulnerability scans
@@ -29,7 +28,6 @@ val DEPENDENCY_BOMS = listOf(
   "com.fasterxml.jackson:jackson-bom:2.21.0",
   "com.google.guava:guava-bom:33.5.0-jre",
   "com.google.protobuf:protobuf-bom:4.33.5",
-  "com.squareup.okhttp3:okhttp-bom:$okhttpVersion",
   "com.squareup.okio:okio-bom:3.16.4", // applies to transitive dependencies of okhttp
   "io.grpc:grpc-bom:1.79.0",
   "io.netty:netty-bom:4.2.10.Final",
@@ -73,7 +71,6 @@ val DEPENDENCIES = listOf(
   "com.google.code.findbugs:jsr305:3.0.2",
   "com.google.guava:guava-beta-checker:1.0",
   "com.sun.net.httpserver:http:20070405",
-  "com.squareup.okhttp3:okhttp:$okhttpVersion",
   "com.tngtech.archunit:archunit-junit5:1.4.1",
   "com.uber.nullaway:nullaway:0.13.1",
   "edu.berkeley.cs.jqf:jqf-fuzz:1.7", // jqf-fuzz version 1.8+ requires Java 11+

exporters/otlp/all/build.gradle.kts

@@ -42,45 +42,38 @@ val testJavaVersion: String? by project
 
 testing {
   suites {
-    listOf(
-      "LATEST",
-      "4.11.0"
-    ).forEach {
-      register<JvmTestSuite>("testOkHttpVersion$it") {
-        sources {
-          java {
-            setSrcDirs(listOf("src/testDefaultSender/java"))
-          }
-        }
-        dependencies {
-          implementation(project(":exporters:sender:okhttp"))
-          implementation(project(":exporters:otlp:testing-internal"))
-
-          implementation(platform("com.squareup.okhttp3:okhttp-bom")) {
-            // Only impose dependency constraint if not testing the LATEST version, which is defined in /dependencyManagement/build.gradle.kts
-            if (!it.equals("LATEST")) {
-              version {
-                strictly(it)
-              }
-            }
-          }
+    register<JvmTestSuite>("testOkHttp5") {
+      dependencies {
+        implementation(project(":exporters:sender:okhttp"))
+        implementation(project(":exporters:otlp:testing-internal"))
 
-          implementation("com.squareup.okhttp3:okhttp")
-          implementation("io.grpc:grpc-stub")
-        }
+        implementation("com.squareup.okhttp3:okhttp:5.3.2")
+        implementation("io.grpc:grpc-stub")
+      }
+    }
+    register<JvmTestSuite>("testOkHttp4") {
+      dependencies {
+        implementation(project(":exporters:sender:okhttp4"))
+        implementation(project(":exporters:otlp:testing-internal"))
 
-        targets {
-          all {
-            testTask {
-              // Only enable test suite for non-LATEST in GitHub CI (CI=true)
-              enabled = it.equals("LATEST") || "true".equals(System.getenv("CI"))
-              systemProperty("expected.okhttp.version", it)
-            }
+        implementation("com.squareup.okhttp3:okhttp:4.12.0")
+        implementation("io.grpc:grpc-stub")
+      }
+      targets {
+        all {
+          testTask {
+            systemProperty(
+              "io.opentelemetry.sdk.common.export.GrpcSenderProvider",
+              "io.opentelemetry.exporter.sender.okhttp4.internal.OkHttpGrpcSenderProvider"
+            )
+            systemProperty(
+              "io.opentelemetry.sdk.common.export.HttpSenderProvider",
+              "io.opentelemetry.exporter.sender.okhttp4.internal.OkHttpHttpSenderProvider"
+            )
           }
         }
       }
     }
-
     register<JvmTestSuite>("testGrpcNetty") {
       dependencies {
         implementation(project(":exporters:sender:grpc-managed-channel"))

exporters/otlp/all/src/testOkhttp4/java/io/opentelemetry/exporter/otlp/OkHttp4VersionTest.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import okhttp3.OkHttp;
+import org.junit.jupiter.api.Test;
+
+class OkHttp4VersionTest {
+  @Test
+  void expectedOkHttpVersion() {
+    assertThat(OkHttp.VERSION).startsWith("4");
+  }
+}

exporters/otlp/all/src/testOkhttp4/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterTest.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.logs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.exporter.internal.marshal.Marshaler;
+import io.opentelemetry.exporter.internal.otlp.logs.ResourceLogsMarshaler;
+import io.opentelemetry.exporter.otlp.testing.internal.AbstractGrpcTelemetryExporterTest;
+import io.opentelemetry.exporter.otlp.testing.internal.FakeTelemetryUtil;
+import io.opentelemetry.exporter.otlp.testing.internal.TelemetryExporter;
+import io.opentelemetry.exporter.otlp.testing.internal.TelemetryExporterBuilder;
+import io.opentelemetry.exporter.sender.okhttp4.internal.OkHttpGrpcSender;
+import io.opentelemetry.proto.logs.v1.ResourceLogs;
+import io.opentelemetry.sdk.logs.data.LogRecordData;
+import java.io.Closeable;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class OtlpGrpcLogRecordExporterTest
+    extends AbstractGrpcTelemetryExporterTest<LogRecordData, ResourceLogs> {
+
+  OtlpGrpcLogRecordExporterTest() {
+    super("log", ResourceLogs.getDefaultInstance());
+  }
+
+  @Test
+  void usingOkHttp() throws Exception {
+    try (Closeable exporter = OtlpGrpcLogRecordExporter.builder().build()) {
+      assertThat(exporter).extracting("delegate.grpcSender").isInstanceOf(OkHttpGrpcSender.class);
+    }
+  }
+
+  @Override
+  protected TelemetryExporterBuilder<LogRecordData> exporterBuilder() {
+    return TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder());
+  }
+
+  @Override
+  protected TelemetryExporterBuilder<LogRecordData> toBuilder(
+      TelemetryExporter<LogRecordData> exporter) {
+    return TelemetryExporterBuilder.wrap(
+        ((OtlpGrpcLogRecordExporter) exporter.unwrap()).toBuilder());
+  }
+
+  @Override
+  protected LogRecordData generateFakeTelemetry() {
+    return FakeTelemetryUtil.generateFakeLogRecordData();
+  }
+
+  @Override
+  protected Marshaler[] toMarshalers(List<LogRecordData> telemetry) {
+    return ResourceLogsMarshaler.create(telemetry);
+  }
+}

exporters/otlp/all/src/testOkhttp4/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterTest.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.metrics;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import io.opentelemetry.exporter.internal.marshal.Marshaler;
+import io.opentelemetry.exporter.internal.otlp.metrics.ResourceMetricsMarshaler;
+import io.opentelemetry.exporter.otlp.testing.internal.AbstractGrpcTelemetryExporterTest;
+import io.opentelemetry.exporter.otlp.testing.internal.FakeTelemetryUtil;
+import io.opentelemetry.exporter.otlp.testing.internal.TelemetryExporter;
+import io.opentelemetry.exporter.otlp.testing.internal.TelemetryExporterBuilder;
+import io.opentelemetry.exporter.sender.okhttp4.internal.OkHttpGrpcSender;
+import io.opentelemetry.proto.metrics.v1.ResourceMetrics;
+import io.opentelemetry.sdk.metrics.Aggregation;
+import io.opentelemetry.sdk.metrics.InstrumentType;
+import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.export.AggregationTemporalitySelector;
+import io.opentelemetry.sdk.metrics.export.DefaultAggregationSelector;
+import io.opentelemetry.sdk.metrics.export.MetricExporter;
+import java.io.Closeable;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+
+class OtlpGrpcMetricExporterTest
+    extends AbstractGrpcTelemetryExporterTest<MetricData, ResourceMetrics> {
+
+  OtlpGrpcMetricExporterTest() {
+    super("metric", ResourceMetrics.getDefaultInstance());
+  }
+
+  /** Test configuration specific to metric exporter. */
+  @Test
+  void validMetricConfig() {
+    assertThatCode(
+            () ->
+                OtlpGrpcMetricExporter.builder()
+                    .setAggregationTemporalitySelector(
+                        AggregationTemporalitySelector.deltaPreferred()))
+        .doesNotThrowAnyException();
+    assertThat(
+            OtlpGrpcMetricExporter.builder()
+                .setAggregationTemporalitySelector(AggregationTemporalitySelector.deltaPreferred())
+                .build()
+                .getAggregationTemporality(InstrumentType.COUNTER))
+        .isEqualTo(AggregationTemporality.DELTA);
+    assertThat(
+            OtlpGrpcMetricExporter.builder()
+                .build()
+                .getAggregationTemporality(InstrumentType.COUNTER))
+        .isEqualTo(AggregationTemporality.CUMULATIVE);
+
+    assertThat(
+            OtlpGrpcMetricExporter.builder()
+                .setDefaultAggregationSelector(
+                    DefaultAggregationSelector.getDefault()
+                        .with(InstrumentType.HISTOGRAM, Aggregation.drop()))
+                .build()
+                .getDefaultAggregation(InstrumentType.HISTOGRAM))
+        .isEqualTo(Aggregation.drop());
+  }
+
+  /** Test configuration specific to metric exporter. */
+  @Test
+  void invalidMetricConfig() {
+    assertThatThrownBy(
+            () -> OtlpGrpcMetricExporter.builder().setAggregationTemporalitySelector(null))
+        .isInstanceOf(NullPointerException.class)
+        .hasMessage("aggregationTemporalitySelector");
+
+    assertThatThrownBy(() -> OtlpGrpcMetricExporter.builder().setDefaultAggregationSelector(null))
+        .isInstanceOf(NullPointerException.class)
+        .hasMessage("defaultAggregationSelector");
+  }
+
+  /** Test configuration specific to metric exporter. */
+  @Test
+  void stringRepresentation() {
+    try (MetricExporter metricExporter = OtlpGrpcMetricExporter.builder().build()) {
+      assertThat(metricExporter.toString())
+          .matches(
+              "OtlpGrpcMetricExporter\\{"
+                  + "endpoint=http://localhost:4317, "
+                  + "fullMethodName=.*, "
+                  + "timeoutNanos="
+                  + TimeUnit.SECONDS.toNanos(10)
+                  + ", "
+                  + "connectTimeoutNanos="
+                  + TimeUnit.SECONDS.toNanos(10)
+                  + ", "
+                  + "compressorEncoding=null, "
+                  + "headers=Headers\\{User-Agent=OBFUSCATED\\}, "
+                  + "retryPolicy=RetryPolicy\\{.*\\}, "
+                  + "componentLoader=.*, "
+                  + "exporterType=OTLP_GRPC_METRIC_EXPORTER, "
+                  + "internalTelemetrySchemaVersion=LEGACY, "
+                  + "aggregationTemporalitySelector=AggregationTemporalitySelector\\{.*\\}, "
+                  + "defaultAggregationSelector=DefaultAggregationSelector\\{.*\\}, "
+                  + "memoryMode=REUSABLE_DATA"
+                  + "\\}");
+    }
+  }
+
+  @Test
+  void usingOkHttp() throws Exception {
+    try (Closeable exporter = OtlpGrpcMetricExporter.builder().build()) {
+      assertThat(exporter).extracting("delegate.grpcSender").isInstanceOf(OkHttpGrpcSender.class);
+    }
+  }
+
+  @Override
+  protected TelemetryExporterBuilder<MetricData> exporterBuilder() {
+    return TelemetryExporterBuilder.wrap(OtlpGrpcMetricExporter.builder());
+  }
+
+  @Override
+  protected TelemetryExporterBuilder<MetricData> toBuilder(TelemetryExporter<MetricData> exporter) {
+    return TelemetryExporterBuilder.wrap(((OtlpGrpcMetricExporter) exporter.unwrap()).toBuilder());
+  }
+
+  @Override
+  protected MetricData generateFakeTelemetry() {
+    return FakeTelemetryUtil.generateFakeMetricData();
+  }
+
+  @Override
+  protected Marshaler[] toMarshalers(List<MetricData> telemetry) {
+    return ResourceMetricsMarshaler.create(telemetry);
+  }
+}