Convert webclient OTel metrics sem. conv. to OTel API instead of Helidon metrics API

tjquinno · tjquinno · commit 96b7e57bacf6 · 2026-02-17T18:11:13.000-06:00
diff --git a/webclient/telemetry/metrics/pom.xml b/webclient/telemetry/metrics/pom.xml
@@ -37,13 +37,17 @@
             <artifactId>helidon-common-features-api</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.metrics</groupId>
-            <artifactId>helidon-metrics-api</artifactId>
+            <groupId>io.helidon.telemetry</groupId>
+            <artifactId>helidon-telemetry-opentelemetry-config</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.metrics.providers</groupId>
-            <artifactId>helidon-metrics-providers-micrometer</artifactId>
-            <scope>runtime</scope>
+            <groupId>io.opentelemetry</groupId>
+            <artifactId>opentelemetry-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.opentelemetry</groupId>
+            <artifactId>opentelemetry-exporter-logging-otlp</artifactId>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -65,7 +69,6 @@
             <artifactId>helidon-webserver-testing-junit5</artifactId>
             <scope>test</scope>
         </dependency>
-
     </dependencies>
 
     <build>
diff --git a/webclient/telemetry/metrics/src/main/java/io/helidon/webclient/telemetry/metrics/WebClientTelemetryMetrics.java b/webclient/telemetry/metrics/src/main/java/io/helidon/webclient/telemetry/metrics/WebClientTelemetryMetrics.java
@@ -17,25 +17,33 @@
 package io.helidon.webclient.telemetry.metrics;
 
 import java.util.List;
-import java.util.concurrent.TimeUnit;
 
 import io.helidon.common.LazyValue;
 import io.helidon.config.Config;
 import io.helidon.http.Status;
-import io.helidon.metrics.api.MeterRegistry;
-import io.helidon.metrics.api.Tag;
-import io.helidon.metrics.api.Timer;
 import io.helidon.service.registry.Services;
+import io.helidon.telemetry.otelconfig.HelidonOpenTelemetry;
 import io.helidon.webclient.api.WebClientServiceRequest;
 import io.helidon.webclient.api.WebClientServiceResponse;
 import io.helidon.webclient.spi.WebClientService;
 
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+
 /**
  * Webclient service for providing metrics which comply with the OpenTelemetry semantic conventions for
  * client metrics.
  */
 public class WebClientTelemetryMetrics implements WebClientService {
 
+    /*
+    Bucket boundaries as recommended by the OpenTelemetry semantic conventions.
+    https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#metric-httpclientrequestduration
+     */
+    private static final List<Double> BUCKET_BOUNDARIES =
+        List.of(0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0);
+
     static final String REQUEST_DURATION = "http.client.request.duration";
 
     static final String HTTP_REQUEST_METHOD = "http.client.request.method";
@@ -44,8 +52,10 @@ public class WebClientTelemetryMetrics implements WebClientService {
     static final String ERROR_TYPE = "error.type";
     static final String HTTP_RESPONSE_STATUS_CODE = "http.response.status.code";
     static final String URL_SCHEME = "url.scheme";
+    static final String URL_TEMPLATE = "url.template";
 
-    private final LazyValue<MeterRegistry>  meterRegistry = LazyValue.create(() -> Services.get(MeterRegistry.class));
+    private final LazyValue<DoubleHistogram> outboundHttpRequestDuration =
+            LazyValue.create(WebClientTelemetryMetrics::createHistogram);
 
     private WebClientTelemetryMetrics() {
     }
@@ -71,30 +81,46 @@ public static WebClientTelemetryMetrics create(Config config) {
 
     @Override
     public WebClientServiceResponse handle(Chain chain, WebClientServiceRequest clientRequest) {
-        long start = System.nanoTime();
+        long startTime = System.nanoTime();
 
         String errorType = "";
-        String statusCodeTagValue = "";
+        int statusCodeTagValue = 0;
         try {
             var response = chain.proceed(clientRequest);
-            statusCodeTagValue = response.status().codeText();
-            errorType = response.status().family() == Status.Family.SUCCESSFUL ? "" : statusCodeTagValue;
+            statusCodeTagValue = response.status().code();
+            errorType = response.status().family() == Status.Family.SUCCESSFUL ? "" : Integer.toString(statusCodeTagValue);
             return response;
         } catch (Exception ex) {
             errorType = ex.getClass().getSimpleName();
             throw ex;
         } finally {
-            var tags = List.of(
-                    Tag.create(HTTP_REQUEST_METHOD, clientRequest.method().text()),
-                    Tag.create(SERVER_ADDRESS, clientRequest.uri().host()),
-                    Tag.create(SERVER_PORT, Integer.toString(clientRequest.uri().port())),
-                    Tag.create(ERROR_TYPE, errorType),
-                    Tag.create(HTTP_RESPONSE_STATUS_CODE, statusCodeTagValue),
-                    Tag.create(URL_SCHEME, clientRequest.uri().scheme()));
-
-            var timer = meterRegistry.get().getOrCreate(Timer.builder(REQUEST_DURATION)
-                    .tags(tags));
-            timer.record(System.nanoTime() - start, TimeUnit.NANOSECONDS);
+            long endTime = System.nanoTime();
+            var attributes = Attributes.builder()
+                    .put(HTTP_REQUEST_METHOD, clientRequest.method().text())
+                    .put(SERVER_ADDRESS, clientRequest.uri().host())
+                    .put(SERVER_PORT, clientRequest.uri().port())
+                    .put(ERROR_TYPE, errorType)
+                    .put(HTTP_RESPONSE_STATUS_CODE, statusCodeTagValue)
+                    .put(URL_SCHEME, clientRequest.uri().scheme())
+                    .put(URL_TEMPLATE, clientRequest.uri().path().path())
+                    .build();
+
+            outboundHttpRequestDuration.get().record(endTime - startTime, attributes);
         }
     }
+
+    private static DoubleHistogram createHistogram() {
+        var config = Services.get(Config.class);
+        HelidonOpenTelemetry helidonOpenTelemetry = HelidonOpenTelemetry.builder()
+                .config(config.get(HelidonOpenTelemetry.CONFIG_KEY))
+                .build();
+        return Services.get(OpenTelemetry.class)
+                .getMeterProvider()
+                .get(helidonOpenTelemetry.prototype().service())
+                .histogramBuilder(REQUEST_DURATION)
+                .setDescription("Outbound HTTP request duration")
+                .setUnit("s") // seconds
+                .setExplicitBucketBoundariesAdvice(BUCKET_BOUNDARIES)
+                .build();
+    }
 }
diff --git a/webclient/telemetry/metrics/src/main/java/module-info.java b/webclient/telemetry/metrics/src/main/java/module-info.java
@@ -30,8 +30,9 @@
     requires static io.helidon.common.features.api;
 
     requires io.helidon.config;
-    requires io.helidon.metrics.api;
+    requires io.helidon.telemetry.otelconfig;
     requires transitive io.helidon.webclient.api;
+    requires io.opentelemetry.api;
 
     exports io.helidon.webclient.telemetry.metrics;
 }
diff --git a/webclient/telemetry/metrics/src/test/java/io/helidon/webclient/telemetry/metrics/TestClientMetrics.java b/webclient/telemetry/metrics/src/test/java/io/helidon/webclient/telemetry/metrics/TestClientMetrics.java
@@ -16,39 +16,36 @@
 
 package io.helidon.webclient.telemetry.metrics;
 
-import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
 
 import io.helidon.common.media.type.MediaTypes;
-import io.helidon.http.Method;
-import io.helidon.metrics.api.MeterRegistry;
-import io.helidon.metrics.api.Timer;
 import io.helidon.webclient.api.WebClient;
 import io.helidon.webserver.WebServer;
 import io.helidon.webserver.http.HttpRouting;
 import io.helidon.webserver.testing.junit5.ServerTest;
 import io.helidon.webserver.testing.junit5.SetUpRoute;
 
+import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingMetricExporter;
+import org.hamcrest.FeatureMatcher;
+import org.hamcrest.Matcher;
 import org.junit.jupiter.api.Test;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.hasEntry;
-import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
 
 @ServerTest
 class TestClientMetrics {
 
     private final WebServer server;
-    private final MeterRegistry meterRegistry;
 
-    TestClientMetrics(WebServer server, MeterRegistry meterRegistry) {
+    TestClientMetrics(WebServer server) {
         this.server = server;
-        this.meterRegistry = meterRegistry;
     }
 
     @SetUpRoute
@@ -57,67 +54,69 @@ static void setup(HttpRouting.Builder builder) {
     }
 
     @Test
-    void testClientMetrics() {
-        var client = WebClient.builder()
-                .baseUri("http://localhost:" + server.port())
-                .addService(WebClientTelemetryMetrics.create())
-                .build();
-
-        var response = client.get("/greet")
-                .accept(MediaTypes.TEXT_PLAIN)
-                .request(String.class);
-
-        assertThat("Response status", response.status().code(), is(200));
-
-        List<Timer> timers = meterRegistry.meters(meter -> meter.id().name().equals(WebClientTelemetryMetrics.REQUEST_DURATION))
-                .stream()
-                .filter(m -> m instanceof Timer)
-                .map(m -> (Timer) m)
-                .toList();
-
-        assertThat("Timers", timers, hasSize(equalTo(1)));
-
-        Timer goodTimer = timers.getFirst();
-
-        assertThat("Timer count", goodTimer.count(), is(greaterThan(0L)));
-        assertThat("Timer duration", goodTimer.totalTime(TimeUnit.NANOSECONDS), is(greaterThan(0D)));
-        var tags = goodTimer.id().tagsMap();
-
-        assertThat("Timer tags", tags, allOf(
-                hasEntry(WebClientTelemetryMetrics.HTTP_REQUEST_METHOD, Method.GET_NAME),
-                hasEntry(WebClientTelemetryMetrics.SERVER_ADDRESS, "localhost"),
-                hasEntry(WebClientTelemetryMetrics.SERVER_PORT, Integer.toString(server.port())),
-                hasEntry(WebClientTelemetryMetrics.ERROR_TYPE, ""),
-                hasEntry(WebClientTelemetryMetrics.HTTP_RESPONSE_STATUS_CODE, "200"),
-                hasEntry(WebClientTelemetryMetrics.URL_SCHEME, "http")));
-
-        var response404 = client.get("/missing")
-                .accept(MediaTypes.TEXT_PLAIN)
-                .request(String.class);
-
-        assertThat("Expected failed response", response404.status().code(), is(404));
-
-        timers = new ArrayList<>(meterRegistry.meters(meter -> meter.id().name().equals(WebClientTelemetryMetrics.REQUEST_DURATION))
-                .stream()
-                .filter(m -> m instanceof Timer)
-                .map(m -> (Timer) m)
-                .toList());
-        timers.remove(goodTimer);
-
-        assertThat("Bad timer count", timers, hasSize(1));
-
-        var badTimer = timers.getFirst();
-        assertThat("Timer count", badTimer.count(), is(greaterThan(0L)));
-        assertThat("Bad timer duration",  badTimer.totalTime(TimeUnit.NANOSECONDS), is(greaterThan(0D)));
-
-        tags = badTimer.id().tagsMap();
-        assertThat("Bad timer tags", tags, allOf(
-                hasEntry(WebClientTelemetryMetrics.HTTP_REQUEST_METHOD, Method.GET_NAME),
-                hasEntry(WebClientTelemetryMetrics.SERVER_ADDRESS, "localhost"),
-                hasEntry(WebClientTelemetryMetrics.SERVER_PORT, Integer.toString(server.port())),
-                hasEntry(WebClientTelemetryMetrics.ERROR_TYPE, "404"),
-                hasEntry(WebClientTelemetryMetrics.HTTP_RESPONSE_STATUS_CODE, "404"),
-                hasEntry(WebClientTelemetryMetrics.URL_SCHEME, "http")));
+    void testClientMetrics() throws InterruptedException {
+        try (TestLogHandler handler = TestLogHandler.create(Logger.getLogger(OtlpJsonLoggingMetricExporter.class.getName()))) {
 
+            var client = WebClient.builder()
+                    .baseUri("http://localhost:" + server.port())
+                    .addService(WebClientTelemetryMetrics.create())
+                    .build();
+
+            var response = client.get("/greet")
+                    .accept(MediaTypes.TEXT_PLAIN)
+                    .request(String.class);
+
+            assertThat("Response status", response.status().code(), is(200));
+
+            List<String> messages = handler.messages(1);
+
+            var patternText = ".*\"dataPoints\":.*\"count\":\"([^\"]+)\".*\"sum\":([^,]+),(.*)";
+
+            var jsonPattern = Pattern.compile(patternText);
+            var matcher = jsonPattern.matcher(messages.getFirst());
+
+            assertThat("Matched log line", matcher, allOf(
+                    matches(true),
+                    hasGroupAsInteger(1, is(1)),
+                    hasGroupAsDouble(2, not(equalTo(0D))),
+                    hasGroupAsString(3, containsString("\"key\":\"" + WebClientTelemetryMetrics.URL_TEMPLATE + "\","
+                                                                     + "\"value\":{\"stringValue\":\"/greet\""))));
+
+        }
+    }
+    static Matcher<java.util.regex.Matcher> matches(boolean expected) {
+        return new FeatureMatcher<>(is(expected), "matches text", "matches") {
+            @Override
+            protected Boolean featureValueOf(java.util.regex.Matcher actual) {
+                return actual.matches();
+            }
+        };
+    }
+
+    static Matcher<java.util.regex.Matcher> hasGroupAsString(int groupNumber, Matcher<String> matcher) {
+        return new FeatureMatcher<>(matcher, "matches group " + groupNumber, "matches") {
+            @Override
+            protected String featureValueOf(java.util.regex.Matcher actual) {
+                return actual.group(groupNumber);
+            }
+        };
+    }
+
+    static Matcher<java.util.regex.Matcher> hasGroupAsInteger(int groupNumber, Matcher<Integer> matcher) {
+        return new FeatureMatcher<>(matcher, "matches group " + groupNumber, "matches") {
+            @Override
+            protected Integer featureValueOf(java.util.regex.Matcher actual) {
+                return Integer.parseInt(actual.group(groupNumber));
+            }
+        };
+    }
+
+    static Matcher<java.util.regex.Matcher> hasGroupAsDouble(int groupNumber, Matcher<Double> matcher) {
+        return new FeatureMatcher<>(matcher, "matches group " + groupNumber, "matches") {
+            @Override
+            protected Double featureValueOf(java.util.regex.Matcher actual) {
+                return Double.parseDouble(actual.group(groupNumber));
+            }
+        };
     }
 }
diff --git a/webclient/telemetry/metrics/src/test/java/io/helidon/webclient/telemetry/metrics/TestLogHandler.java b/webclient/telemetry/metrics/src/test/java/io/helidon/webclient/telemetry/metrics/TestLogHandler.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.webclient.telemetry.metrics;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+import io.helidon.common.testing.junit5.MatcherWithRetry;
+
+import static org.hamcrest.Matchers.hasSize;
+
+class TestLogHandler extends Handler implements AutoCloseable {
+
+    private final List<String> messages = Collections.synchronizedList(new ArrayList<>());
+    private final Logger logger;
+
+    private TestLogHandler(Logger logger) {
+        this.logger = logger;
+        logger.addHandler(this);
+    }
+
+    static TestLogHandler create(Logger logger) {
+        return new TestLogHandler(logger);
+    }
+
+    @Override
+    public void publish(LogRecord record) {
+        messages.add(record.getMessage());
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void close() {
+        logger.removeHandler(this);
+    }
+
+    List<String> messages(int expectedCount) {
+        try {
+            return MatcherWithRetry.assertThatWithRetry("Expected messages", () -> List.copyOf(messages), hasSize(expectedCount));
+        } finally {
+            messages.clear();
+        }
+    }
+}
diff --git a/webclient/telemetry/metrics/src/test/resources/application.yaml b/webclient/telemetry/metrics/src/test/resources/application.yaml

Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,9 @@`
`30`	`30`	`requires static io.helidon.common.features.api;`
`31`	`31`
`32`	`32`	`requires io.helidon.config;`
`33`		`- requires io.helidon.metrics.api;`
	`33`	`+ requires io.helidon.telemetry.otelconfig;`
`34`	`34`	`requires transitive io.helidon.webclient.api;`
	`35`	`+ requires io.opentelemetry.api;`
`35`	`36`
`36`	`37`	`exports io.helidon.webclient.telemetry.metrics;`
`37`	`38`	`}`