feat: support fullUrl in EndpointConfiguration to bypass default signal path appending

android-agent/api/android-agent.api

@@ -33,9 +33,11 @@ public final class io/opentelemetry/android/agent/dsl/DiskBufferingConfiguration
 
 public final class io/opentelemetry/android/agent/dsl/EndpointConfiguration {
 	public final fun getCompression ()Lio/opentelemetry/android/agent/connectivity/Compression;
+	public final fun getFullUrl ()Ljava/lang/String;
 	public final fun getHeaders ()Ljava/util/Map;
 	public final fun getUrl ()Ljava/lang/String;
 	public final fun setCompression (Lio/opentelemetry/android/agent/connectivity/Compression;)V
+	public final fun setFullUrl (Ljava/lang/String;)V
 	public final fun setHeaders (Ljava/util/Map;)V
 	public final fun setUrl (Ljava/lang/String;)V
 }

android-agent/src/main/kotlin/io/opentelemetry/android/agent/connectivity/HttpEndpointConnectivity.kt

@@ -2,67 +2,68 @@
  * Copyright The OpenTelemetry Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-
 package io.opentelemetry.android.agent.connectivity
 
 internal class HttpEndpointConnectivity private constructor(
     private val url: String,
     private val headers: Map<String, String>,
     private val compression: Compression,
     private val sslContext: SSLContextConnectivity?,
-    private val clientTls: ClientTlsConnectivity? = null
+    private val clientTls: ClientTlsConnectivity? = null,
 ) : EndpointConnectivity {
     companion object {
         fun forTraces(
             baseUrl: String,
+            fullUrl: Boolean = false,
             headers: Map<String, String>,
             compression: Compression,
             sslContext: SSLContextConnectivity?,
-            clientTls: ClientTlsConnectivity?
-        ): HttpEndpointConnectivity = HttpEndpointConnectivity(
-            baseUrl.trimEnd('/') + "/v1/traces",
-            headers,
-            compression,
-            sslContext,
-            clientTls
-        )
+            clientTls: ClientTlsConnectivity?,
+        ): HttpEndpointConnectivity =
+            HttpEndpointConnectivity(
+                if (fullUrl) baseUrl else baseUrl.trimEnd('/') + "/v1/traces",
+                headers,
+                compression,
+                sslContext,
+                clientTls,
+            )
 
         fun forLogs(
             baseUrl: String,
+            fullUrl: Boolean = false,
             headers: Map<String, String>,
             compression: Compression,
             sslContext: SSLContextConnectivity?,
-            clientTls: ClientTlsConnectivity?
-        ): HttpEndpointConnectivity = HttpEndpointConnectivity(
-            baseUrl.trimEnd('/') + "/v1/logs",
-            headers,
-            compression,
-            sslContext,
-            clientTls
-        )
+            clientTls: ClientTlsConnectivity?,
+        ): HttpEndpointConnectivity =
+            HttpEndpointConnectivity(
+                if (fullUrl) baseUrl else baseUrl.trimEnd('/') + "/v1/logs",
+                headers,
+                compression,
+                sslContext,
+                clientTls,
+            )
 
         fun forMetrics(
             baseUrl: String,
+            fullUrl: Boolean = false,
             headers: Map<String, String>,
             compression: Compression,
             sslContext: SSLContextConnectivity?,
-            clientTls: ClientTlsConnectivity?
-        ): HttpEndpointConnectivity = HttpEndpointConnectivity(
-            baseUrl.trimEnd('/') + "/v1/metrics",
-            headers,
-            compression,
-            sslContext,
-            clientTls
-        )
+            clientTls: ClientTlsConnectivity?,
+        ): HttpEndpointConnectivity =
+            HttpEndpointConnectivity(
+                if (fullUrl) baseUrl else baseUrl.trimEnd('/') + "/v1/metrics",
+                headers,
+                compression,
+                sslContext,
+                clientTls,
+            )
     }
 
     override fun getUrl(): String = url
-
     override fun getHeaders(): Map<String, String> = headers
-
     override fun getCompression(): Compression = compression
-
     override fun getSslContext(): SSLContextConnectivity? = sslContext
-
     override fun getClientTls(): ClientTlsConnectivity? = clientTls
 }

android-agent/src/main/kotlin/io/opentelemetry/android/agent/dsl/EndpointConfiguration.kt

@@ -2,7 +2,6 @@
  * Copyright The OpenTelemetry Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-
 package io.opentelemetry.android.agent.dsl
 
 import io.opentelemetry.android.agent.connectivity.Compression
@@ -13,9 +12,17 @@ import io.opentelemetry.android.agent.connectivity.Compression
 @OpenTelemetryDslMarker
 class EndpointConfiguration internal constructor(
     /**
-     * URL for HTTP export requests.
+     * Base URL for HTTP export requests. The signal-specific path (e.g. /v1/logs) will be
+     * appended automatically.
      */
     var url: String,
+    /**
+     * Full URL for HTTP export requests. When set, this URL is used as-is without appending
+     * any signal-specific path. Use this to specify a completely custom endpoint path,
+     * for example "https://example.com/v2/logs".
+     * Note: when set, this overrides the baseUrl from the surrounding httpExport block entirely.
+     */
+    var fullUrl: String? = null,
     /**
      * Headers that should be attached to HTTP export requests.
      */

android-agent/src/main/kotlin/io/opentelemetry/android/agent/dsl/HttpExportConfiguration.kt

@@ -2,7 +2,6 @@
  * Copyright The OpenTelemetry Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-
 package io.opentelemetry.android.agent.dsl
 
 import io.opentelemetry.android.Incubating
@@ -50,33 +49,40 @@ class HttpExportConfiguration internal constructor() {
     internal fun spansEndpoint(): HttpEndpointConnectivity =
         HttpEndpointConnectivity.forTraces(
             chooseUrlSource(spansConfig),
+            isFullUrl(spansConfig),
             spansConfig.headers + baseHeaders,
             chooseCompression(spansConfig.compression),
             sslContext,
-            clientTls
+            clientTls,
         )
 
     internal fun logsEndpoint(): HttpEndpointConnectivity =
         HttpEndpointConnectivity.forLogs(
             chooseUrlSource(logsConfig),
+            isFullUrl(logsConfig),
             logsConfig.headers + baseHeaders,
             chooseCompression(logsConfig.compression),
             sslContext,
-            clientTls
+            clientTls,
         )
 
     internal fun metricsEndpoint(): HttpEndpointConnectivity =
         HttpEndpointConnectivity.forMetrics(
             chooseUrlSource(metricsConfig),
+            isFullUrl(metricsConfig),
             metricsConfig.headers + baseHeaders,
             chooseCompression(metricsConfig.compression),
             sslContext,
-            clientTls
+            clientTls,
         )
 
-    private fun chooseUrlSource(cfg: EndpointConfiguration): String = cfg.url.ifBlank { baseUrl }
+    private fun chooseUrlSource(cfg: EndpointConfiguration): String =
+        cfg.fullUrl ?: cfg.url.ifBlank { baseUrl }
+
+    private fun isFullUrl(cfg: EndpointConfiguration): Boolean = cfg.fullUrl != null
 
-    private fun chooseCompression(signalConfigCompression: Compression?): Compression = signalConfigCompression ?: this.compression
+    private fun chooseCompression(signalConfigCompression: Compression?): Compression =
+        signalConfigCompression ?: this.compression
 
     /**
      * Override the default configuration for the v1/traces endpoint only.

android-agent/src/test/kotlin/io/opentelemetry/android/agent/connectivity/HttpEndpointConnectivityTest.kt

@@ -17,11 +17,11 @@ class HttpEndpointConnectivityTest {
         val sslContext = SSLContextConnectivity(mockk(), mockk())
         val clientTls: ClientTlsConnectivity = mockk()
         val tracesConnectivity =
-            HttpEndpointConnectivity.forTraces("http://some.endpoint", headers, compression, sslContext, clientTls)
+            HttpEndpointConnectivity.forTraces("http://some.endpoint", false, headers, compression, sslContext, clientTls)
         val logsConnectivity =
-            HttpEndpointConnectivity.forLogs("http://some.endpoint/", headers, compression, sslContext, clientTls)
+            HttpEndpointConnectivity.forLogs("http://some.endpoint/", false, headers, compression, sslContext, clientTls)
         val metricsConnectivity =
-            HttpEndpointConnectivity.forMetrics("http://some.endpoint", headers, compression, sslContext, clientTls)
+            HttpEndpointConnectivity.forMetrics("http://some.endpoint", false, headers, compression, sslContext, clientTls)
 
         assertThat(tracesConnectivity.getUrl()).isEqualTo("http://some.endpoint/v1/traces")
         assertThat(tracesConnectivity.getHeaders()).isEqualTo(headers)