diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractor.java new file mode 100644 index 0000000000..b583c91baa --- /dev/null +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractor.java @@ -0,0 +1,95 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.http; + +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceResolver; +import io.opentelemetry.instrumentation.api.instrumenter.url.UrlParser; +import io.opentelemetry.semconv.SemanticAttributes; +import java.util.function.Supplier; +import javax.annotation.Nullable; + +/** + * Extractor of the {@code peer.service} span attribute, described in the + * specification. + */ +public final class HttpClientPeerServiceAttributesExtractor + implements AttributesExtractor { + + private final HttpClientAttributesGetter attributesGetter; + private final PeerServiceResolver peerServiceResolver; + + // visible for tests + HttpClientPeerServiceAttributesExtractor( + HttpClientAttributesGetter attributesGetter, + PeerServiceResolver peerServiceResolver) { + this.attributesGetter = attributesGetter; + this.peerServiceResolver = peerServiceResolver; + } + + /** + * Returns a new {@link HttpClientPeerServiceAttributesExtractor} that will use the passed {@code + * attributesGetter} instance to determine the value of the {@code peer.service} attribute. + */ + public static + HttpClientPeerServiceAttributesExtractor create( + HttpClientAttributesGetter attributesGetter, + PeerServiceResolver peerServiceResolver) { + return new HttpClientPeerServiceAttributesExtractor<>(attributesGetter, peerServiceResolver); + } + + @Override + public void onStart(AttributesBuilder attributes, Context parentContext, REQUEST request) {} + + @Override + public void onEnd( + AttributesBuilder attributes, + Context context, + REQUEST request, + @Nullable RESPONSE response, + @Nullable Throwable error) { + + if (peerServiceResolver.isEmpty()) { + // optimization for common case + return; + } + + String serverAddress = attributesGetter.getServerAddress(request); + Integer serverPort = attributesGetter.getServerPort(request); + Supplier pathSupplier = () -> getUrlPath(attributesGetter, request); + String peerService = mapToPeerService(serverAddress, serverPort, pathSupplier); + if (peerService == null) { + String serverSocketDomain = attributesGetter.getServerSocketDomain(request, response); + Integer serverSocketPort = attributesGetter.getServerSocketPort(request, response); + peerService = mapToPeerService(serverSocketDomain, serverSocketPort, null); + } + if (peerService != null) { + attributes.put(SemanticAttributes.PEER_SERVICE, peerService); + } + } + + @Nullable + private String mapToPeerService( + @Nullable String host, @Nullable Integer port, @Nullable Supplier pathSupplier) { + if (host == null) { + return null; + } + return peerServiceResolver.resolveService(host, port, pathSupplier); + } + + @Nullable + private String getUrlPath( + HttpClientAttributesGetter attributesGetter, REQUEST request) { + String urlFull = attributesGetter.getUrlFull(request); + if (urlFull == null) { + return null; + } + return UrlParser.getPath(urlFull); + } +} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractor.java index 5903f7113d..bad87e614c 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractor.java @@ -11,7 +11,6 @@ import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.network.ServerAttributesGetter; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; -import java.util.Map; import javax.annotation.Nullable; /** @@ -23,24 +22,24 @@ public final class PeerServiceAttributesExtractor implements AttributesExtractor { private final ServerAttributesGetter attributesGetter; - private final Map peerServiceMapping; + private final PeerServiceResolver peerServiceResolver; // visible for tests PeerServiceAttributesExtractor( ServerAttributesGetter attributesGetter, - Map peerServiceMapping) { + PeerServiceResolver peerServiceResolver) { this.attributesGetter = attributesGetter; - this.peerServiceMapping = peerServiceMapping; + this.peerServiceResolver = peerServiceResolver; } /** * Returns a new {@link PeerServiceAttributesExtractor} that will use the passed {@code - * netAttributesExtractor} instance to determine the value of the {@code peer.service} attribute. + * attributesGetter} instance to determine the value of the {@code peer.service} attribute. */ public static AttributesExtractor create( ServerAttributesGetter attributesGetter, - Map peerServiceMapping) { - return new PeerServiceAttributesExtractor<>(attributesGetter, peerServiceMapping); + PeerServiceResolver peerServiceResolver) { + return new PeerServiceAttributesExtractor<>(attributesGetter, peerServiceResolver); } @Override @@ -54,16 +53,18 @@ public final class PeerServiceAttributesExtractor @Nullable RESPONSE response, @Nullable Throwable error) { - if (peerServiceMapping.isEmpty()) { + if (peerServiceResolver.isEmpty()) { // optimization for common case return; } String serverAddress = attributesGetter.getServerAddress(request); - String peerService = mapToPeerService(serverAddress); + Integer serverPort = attributesGetter.getServerPort(request); + String peerService = mapToPeerService(serverAddress, serverPort); if (peerService == null && SemconvStability.emitOldHttpSemconv()) { String serverSocketDomain = attributesGetter.getServerSocketDomain(request, response); - peerService = mapToPeerService(serverSocketDomain); + Integer serverSocketPort = attributesGetter.getServerSocketPort(request, response); + peerService = mapToPeerService(serverSocketDomain, serverSocketPort); } if (peerService != null) { attributes.put(SemanticAttributes.PEER_SERVICE, peerService); @@ -71,10 +72,10 @@ public final class PeerServiceAttributesExtractor } @Nullable - private String mapToPeerService(@Nullable String endpoint) { - if (endpoint == null) { + private String mapToPeerService(@Nullable String host, @Nullable Integer port) { + if (host == null) { return null; } - return peerServiceMapping.get(endpoint); + return peerServiceResolver.resolveService(host, port, null); } } diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolver.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolver.java new file mode 100644 index 0000000000..cc7f15b535 --- /dev/null +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolver.java @@ -0,0 +1,23 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.net; + +import java.util.Map; +import java.util.function.Supplier; +import javax.annotation.Nullable; + +public interface PeerServiceResolver { + + public boolean isEmpty(); + + @Nullable + public String resolveService( + String host, @Nullable Integer port, @Nullable Supplier pathSupplier); + + static PeerServiceResolver create(Map mapping) { + return new PeerServiceResolverImpl(mapping); + } +} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverImpl.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverImpl.java new file mode 100644 index 0000000000..99473cbdcf --- /dev/null +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverImpl.java @@ -0,0 +1,99 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.net; + +import static java.util.Comparator.comparing; +import static java.util.Comparator.naturalOrder; +import static java.util.Comparator.nullsFirst; + +import com.google.auto.value.AutoValue; +import io.opentelemetry.instrumentation.api.instrumenter.url.UrlParser; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Supplier; +import javax.annotation.Nullable; + +class PeerServiceResolverImpl implements PeerServiceResolver { + + private static final Comparator matcherComparator = + nullsFirst( + comparing(ServiceMatcher::getPort, nullsFirst(naturalOrder())) + .thenComparing(comparing(ServiceMatcher::getPath, nullsFirst(naturalOrder())))); + + private final Map> mapping = new HashMap<>(); + + PeerServiceResolverImpl(Map peerServiceMapping) { + peerServiceMapping.forEach( + (key, serviceName) -> { + String url = "https://" + key; + String host = UrlParser.getHost(url); + Integer port = UrlParser.getPort(url); + String path = UrlParser.getPath(url); + Map matchers = + mapping.computeIfAbsent(host, x -> new HashMap<>()); + matchers.putIfAbsent(ServiceMatcher.create(port, path), serviceName); + }); + } + + @Override + public boolean isEmpty() { + return mapping.isEmpty(); + } + + @Override + @Nullable + public String resolveService( + String host, @Nullable Integer port, @Nullable Supplier pathSupplier) { + Map matchers = mapping.get(host); + if (matchers == null) { + return null; + } + return matchers.entrySet().stream() + .filter(entry -> entry.getKey().matches(port, pathSupplier)) + .max((o1, o2) -> matcherComparator.compare(o1.getKey(), o2.getKey())) + .map(Map.Entry::getValue) + .orElse(null); + } + + @AutoValue + abstract static class ServiceMatcher { + + static ServiceMatcher create(Integer port, String path) { + return new AutoValue_PeerServiceResolverImpl_ServiceMatcher(port, path); + } + + @Nullable + abstract Integer getPort(); + + @Nullable + abstract String getPath(); + + public boolean matches(Integer port, Supplier pathSupplier) { + if (this.getPort() != null) { + if (!this.getPort().equals(port)) { + return false; + } + } + if (this.getPath() != null && this.getPath().length() > 0) { + if (pathSupplier == null) { + return false; + } + String path = pathSupplier.get(); + if (path == null) { + return false; + } + if (!path.startsWith(this.getPath())) { + return false; + } + if (port != null) { + return port.equals(this.getPort()); + } + } + return true; + } + } +} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParser.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParser.java new file mode 100644 index 0000000000..e3f0426be4 --- /dev/null +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParser.java @@ -0,0 +1,144 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.url; + +import java.util.function.Predicate; +import javax.annotation.Nullable; + +public class UrlParser { + + @Nullable + public static String getHost(String url) { + + int startIndex = getHostStartIndex(url); + if (startIndex == -1) { + return null; + } + + int endIndexExclusive = getHostEndIndexExclusive(url, startIndex); + if (endIndexExclusive == startIndex) { + return null; + } + + return url.substring(startIndex, endIndexExclusive); + } + + @Nullable + public static Integer getPort(String url) { + + int hostStartIndex = getHostStartIndex(url); + if (hostStartIndex == -1) { + return null; + } + + int hostEndIndexExclusive = getHostEndIndexExclusive(url, hostStartIndex); + if (hostEndIndexExclusive == hostStartIndex) { + return null; + } + + if (hostEndIndexExclusive < url.length() && url.charAt(hostEndIndexExclusive) != ':') { + return null; + } + + int portStartIndex = hostEndIndexExclusive + 1; + + int portEndIndexExclusive = getPortEndIndexExclusive(url, portStartIndex); + if (portEndIndexExclusive == portStartIndex) { + return null; + } + + return safeParse(url.substring(portStartIndex, portEndIndexExclusive)); + } + + @Nullable + public static String getPath(String url) { + + int hostStartIndex = getHostStartIndex(url); + if (hostStartIndex == -1) { + return null; + } + + int hostEndIndexExclusive = getHostEndIndexExclusive(url, hostStartIndex); + if (hostEndIndexExclusive == hostStartIndex) { + return null; + } + + int pathStartIndex = url.indexOf('/', hostEndIndexExclusive); + if (pathStartIndex == -1) { + return null; + } + + int pathEndIndexExclusive = getPathEndIndexExclusive(url, pathStartIndex); + if (pathEndIndexExclusive == pathStartIndex) { + return null; + } + + return url.substring(pathStartIndex, pathEndIndexExclusive); + } + + private static int getHostStartIndex(String url) { + + int schemeEndIndex = url.indexOf(':'); + if (schemeEndIndex == -1) { + // not a valid url + return -1; + } + + int len = url.length(); + if (len <= schemeEndIndex + 2 + || url.charAt(schemeEndIndex + 1) != '/' + || url.charAt(schemeEndIndex + 2) != '/') { + // has no authority component + return -1; + } + + return schemeEndIndex + 3; + } + + private static int getHostEndIndexExclusive(String url, int startIndex) { + // look for the end of the host: + // ':' ==> start of port, or + // '/', '?', '#' ==> start of path + return getEndIndexExclusive( + url, startIndex, c -> (c == ':' || c == '/' || c == '?' || c == '#')); + } + + private static int getPortEndIndexExclusive(String url, int startIndex) { + // look for the end of the port: + // '/', '?', '#' ==> start of path + return getEndIndexExclusive(url, startIndex, c -> (c == '/' || c == '?' || c == '#')); + } + + private static int getPathEndIndexExclusive(String url, int startIndex) { + // look for the end of the path: + // '?', '#' ==> end of path + return getEndIndexExclusive(url, startIndex, c -> (c == '?' || c == '#')); + } + + private static int getEndIndexExclusive( + String url, int startIndex, Predicate predicate) { + int index; + int len = url.length(); + for (index = startIndex; index < len; index++) { + char c = url.charAt(index); + if (predicate.test(c)) { + break; + } + } + return index; + } + + @Nullable + private static Integer safeParse(String port) { + try { + return Integer.valueOf(port); + } catch (NumberFormatException e) { + return null; + } + } + + private UrlParser() {} +} diff --git a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractorTest.java b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractorTest.java new file mode 100644 index 0000000000..ab08aca02e --- /dev/null +++ b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientPeerServiceAttributesExtractorTest.java @@ -0,0 +1,137 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.http; + +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; +import static java.util.Collections.singletonMap; +import static org.assertj.core.api.Assertions.entry; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceResolver; +import io.opentelemetry.semconv.SemanticAttributes; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +@ExtendWith(MockitoExtension.class) +class HttpClientPeerServiceAttributesExtractorTest { + @Mock HttpClientAttributesGetter httpAttributesExtractor; + + @Test + void shouldNotSetAnyValueIfNetExtractorReturnsNulls() { + // given + PeerServiceResolver peerServiceResolver = + PeerServiceResolver.create(singletonMap("1.2.3.4", "myService")); + + HttpClientPeerServiceAttributesExtractor underTest = + new HttpClientPeerServiceAttributesExtractor<>( + httpAttributesExtractor, peerServiceResolver); + + Context context = Context.root(); + + // when + AttributesBuilder attributes = Attributes.builder(); + underTest.onStart(attributes, context, "request"); + underTest.onEnd(attributes, context, "request", "response", null); + + // then + assertTrue(attributes.build().isEmpty()); + } + + @Test + void shouldNotSetAnyValueIfPeerNameDoesNotMatch() { + // given + PeerServiceResolver peerServiceResolver = + PeerServiceResolver.create(singletonMap("example.com", "myService")); + + HttpClientPeerServiceAttributesExtractor underTest = + new HttpClientPeerServiceAttributesExtractor<>( + httpAttributesExtractor, peerServiceResolver); + + when(httpAttributesExtractor.getServerAddress(any())).thenReturn("example2.com"); + + Context context = Context.root(); + + // when + AttributesBuilder startAttributes = Attributes.builder(); + underTest.onStart(startAttributes, context, "request"); + AttributesBuilder endAttributes = Attributes.builder(); + underTest.onEnd(endAttributes, context, "request", "response", null); + + // then + assertTrue(startAttributes.build().isEmpty()); + assertTrue(endAttributes.build().isEmpty()); + } + + @Test + void shouldSetPeerNameIfItMatches() { + // given + Map peerServiceMapping = new HashMap<>(); + peerServiceMapping.put("example.com", "myService"); + peerServiceMapping.put("1.2.3.4", "someOtherService"); + + PeerServiceResolver peerServiceResolver = PeerServiceResolver.create(peerServiceMapping); + + HttpClientPeerServiceAttributesExtractor underTest = + new HttpClientPeerServiceAttributesExtractor<>( + httpAttributesExtractor, peerServiceResolver); + + when(httpAttributesExtractor.getServerAddress(any())).thenReturn("example.com"); + + Context context = Context.root(); + + // when + AttributesBuilder startAttributes = Attributes.builder(); + underTest.onStart(startAttributes, context, "request"); + AttributesBuilder endAttributes = Attributes.builder(); + underTest.onEnd(endAttributes, context, "request", "response", null); + + // then + assertThat(startAttributes.build()).isEmpty(); + assertThat(endAttributes.build()) + .containsOnly(entry(SemanticAttributes.PEER_SERVICE, "myService")); + verify(httpAttributesExtractor, never()).getServerSocketDomain(any(), any()); + } + + @Test + void shouldSetSockPeerNameIfItMatchesAndNoPeerNameProvided() { + // given + Map peerServiceMapping = new HashMap<>(); + peerServiceMapping.put("example.com", "myService"); + peerServiceMapping.put("1.2.3.4", "someOtherService"); + + PeerServiceResolver peerServiceResolver = PeerServiceResolver.create(peerServiceMapping); + + HttpClientPeerServiceAttributesExtractor underTest = + new HttpClientPeerServiceAttributesExtractor<>( + httpAttributesExtractor, peerServiceResolver); + + when(httpAttributesExtractor.getServerSocketDomain(any(), any())).thenReturn("example.com"); + + Context context = Context.root(); + + // when + AttributesBuilder startAttributes = Attributes.builder(); + underTest.onStart(startAttributes, context, "request"); + AttributesBuilder endAttributes = Attributes.builder(); + underTest.onEnd(endAttributes, context, "request", "response", null); + + // then + assertThat(startAttributes.build()).isEmpty(); + assertThat(endAttributes.build()) + .containsOnly(entry(SemanticAttributes.PEER_SERVICE, "myService")); + } +} diff --git a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractorTest.java b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractorTest.java index b28727e99c..c1595b817b 100644 --- a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractorTest.java +++ b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceAttributesExtractorTest.java @@ -35,10 +35,11 @@ class PeerServiceAttributesExtractorTest { @Test void shouldNotSetAnyValueIfNetExtractorReturnsNulls() { // given - Map peerServiceMapping = singletonMap("1.2.3.4", "myService"); + PeerServiceResolver peerServiceResolver = + PeerServiceResolver.create(singletonMap("1.2.3.4", "myService")); PeerServiceAttributesExtractor underTest = - new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceMapping); + new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceResolver); Context context = Context.root(); @@ -54,10 +55,11 @@ class PeerServiceAttributesExtractorTest { @Test void shouldNotSetAnyValueIfPeerNameDoesNotMatch() { // given - Map peerServiceMapping = singletonMap("example.com", "myService"); + PeerServiceResolver peerServiceResolver = + PeerServiceResolver.create(singletonMap("example.com", "myService")); PeerServiceAttributesExtractor underTest = - new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceMapping); + new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceResolver); when(netAttributesExtractor.getServerAddress(any())).thenReturn("example2.com"); @@ -81,8 +83,10 @@ class PeerServiceAttributesExtractorTest { peerServiceMapping.put("example.com", "myService"); peerServiceMapping.put("1.2.3.4", "someOtherService"); + PeerServiceResolver peerServiceResolver = PeerServiceResolver.create(peerServiceMapping); + PeerServiceAttributesExtractor underTest = - new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceMapping); + new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceResolver); when(netAttributesExtractor.getServerAddress(any())).thenReturn("example.com"); @@ -111,8 +115,10 @@ class PeerServiceAttributesExtractorTest { peerServiceMapping.put("example.com", "myService"); peerServiceMapping.put("1.2.3.4", "someOtherService"); + PeerServiceResolver peerServiceResolver = PeerServiceResolver.create(peerServiceMapping); + PeerServiceAttributesExtractor underTest = - new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceMapping); + new PeerServiceAttributesExtractor<>(netAttributesExtractor, peerServiceResolver); when(netAttributesExtractor.getServerSocketDomain(any(), any())).thenReturn("example.com"); diff --git a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverTest.java b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverTest.java new file mode 100644 index 0000000000..3d9660be6a --- /dev/null +++ b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/net/PeerServiceResolverTest.java @@ -0,0 +1,38 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.net; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; + +class PeerServiceResolverTest { + + @Test + void test() { + Map peerServiceMapping = new HashMap<>(); + peerServiceMapping.put("example.com:8080", "myService"); + peerServiceMapping.put("example.com", "myServiceBase"); + peerServiceMapping.put("1.2.3.4", "someOtherService"); + peerServiceMapping.put("1.2.3.4:8080/api", "someOtherService8080"); + peerServiceMapping.put("1.2.3.4/api", "someOtherServiceAPI"); + + PeerServiceResolver peerServiceResolver = PeerServiceResolver.create(peerServiceMapping); + + assertEquals("myServiceBase", peerServiceResolver.resolveService("example.com", null, null)); + assertEquals("myService", peerServiceResolver.resolveService("example.com", 8080, () -> "/")); + assertEquals( + "someOtherService8080", peerServiceResolver.resolveService("1.2.3.4", 8080, () -> "/api")); + assertEquals( + "someOtherService", peerServiceResolver.resolveService("1.2.3.4", 9000, () -> "/api")); + assertEquals( + "someOtherService", peerServiceResolver.resolveService("1.2.3.4", 8080, () -> null)); + assertEquals( + "someOtherServiceAPI", peerServiceResolver.resolveService("1.2.3.4", null, () -> "/api")); + } +} diff --git a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParserTest.java b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParserTest.java new file mode 100644 index 0000000000..b5996087b5 --- /dev/null +++ b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlParserTest.java @@ -0,0 +1,249 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.instrumenter.url; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; + +class UrlParserTest { + + @Test + void testGetHost() { + assertThat(UrlParser.getHost("https://localhost")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost/")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost?")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost/?")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost?query")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost/?query")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost#")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost/#")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost#fragment")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost/#fragment")).isEqualTo("localhost"); + } + + @Test + void testGetHostWithPort() { + assertThat(UrlParser.getHost("https://localhost:8080")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost:8080/")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost:8080?")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost:8080/?")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost:8080?query")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost:8080/?query")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost:8080#")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost:8080/#")).isEqualTo("localhost"); + + assertThat(UrlParser.getHost("https://localhost:8080#fragment")).isEqualTo("localhost"); + assertThat(UrlParser.getHost("https://localhost:8080/#fragment")).isEqualTo("localhost"); + } + + @Test + void testGetHostWithNoAuthority() { + assertThat(UrlParser.getHost("https:")).isNull(); + assertThat(UrlParser.getHost("https:/")).isNull(); + + assertThat(UrlParser.getHost("https:?")).isNull(); + assertThat(UrlParser.getHost("https:/?")).isNull(); + + assertThat(UrlParser.getHost("https:?query")).isNull(); + assertThat(UrlParser.getHost("https:/?query")).isNull(); + + assertThat(UrlParser.getHost("https:#")).isNull(); + assertThat(UrlParser.getHost("https:/#")).isNull(); + + assertThat(UrlParser.getHost("https:#fragment")).isNull(); + assertThat(UrlParser.getHost("https:/#fragment")).isNull(); + } + + @Test + void testGetHostWithNoScheme() { + assertThat(UrlParser.getHost("")).isNull(); + assertThat(UrlParser.getHost("/")).isNull(); + + assertThat(UrlParser.getHost("?")).isNull(); + assertThat(UrlParser.getHost("/?")).isNull(); + + assertThat(UrlParser.getHost("?query")).isNull(); + assertThat(UrlParser.getHost("/?query")).isNull(); + + assertThat(UrlParser.getHost("#")).isNull(); + assertThat(UrlParser.getHost("/#")).isNull(); + + assertThat(UrlParser.getHost("#fragment")).isNull(); + assertThat(UrlParser.getHost("/#fragment")).isNull(); + } + + @Test + void testGetPort() { + assertThat(UrlParser.getPort("https://localhost")).isNull(); + assertThat(UrlParser.getPort("https://localhost/")).isNull(); + + assertThat(UrlParser.getPort("https://localhost?")).isNull(); + assertThat(UrlParser.getPort("https://localhost/?")).isNull(); + + assertThat(UrlParser.getPort("https://localhost?query")).isNull(); + assertThat(UrlParser.getPort("https://localhost/?query")).isNull(); + + assertThat(UrlParser.getPort("https://localhost#")).isNull(); + assertThat(UrlParser.getPort("https://localhost/#")).isNull(); + + assertThat(UrlParser.getPort("https://localhost#fragment")).isNull(); + assertThat(UrlParser.getPort("https://localhost/#fragment")).isNull(); + } + + @Test + void testGetPortWithPort() { + assertThat(UrlParser.getPort("https://localhost:8080")).isEqualTo(8080); + assertThat(UrlParser.getPort("https://localhost:8080/")).isEqualTo(8080); + + assertThat(UrlParser.getPort("https://localhost:8080?")).isEqualTo(8080); + assertThat(UrlParser.getPort("https://localhost:8080/?")).isEqualTo(8080); + + assertThat(UrlParser.getPort("https://localhost:8080?query")).isEqualTo(8080); + assertThat(UrlParser.getPort("https://localhost:8080/?query")).isEqualTo(8080); + + assertThat(UrlParser.getPort("https://localhost:8080#")).isEqualTo(8080); + assertThat(UrlParser.getPort("https://localhost:8080/#")).isEqualTo(8080); + + assertThat(UrlParser.getPort("https://localhost:8080#fragment")).isEqualTo(8080); + assertThat(UrlParser.getPort("https://localhost:8080/#fragment")).isEqualTo(8080); + } + + @Test + void testGetPortWithNoAuthority() { + assertThat(UrlParser.getPort("https:")).isNull(); + assertThat(UrlParser.getPort("https:/")).isNull(); + + assertThat(UrlParser.getPort("https:?")).isNull(); + assertThat(UrlParser.getPort("https:/?")).isNull(); + + assertThat(UrlParser.getPort("https:?query")).isNull(); + assertThat(UrlParser.getPort("https:/?query")).isNull(); + + assertThat(UrlParser.getPort("https:#")).isNull(); + assertThat(UrlParser.getPort("https:/#")).isNull(); + + assertThat(UrlParser.getPort("https:#fragment")).isNull(); + assertThat(UrlParser.getPort("https:/#fragment")).isNull(); + } + + @Test + void testGetPortWithNoScheme() { + assertThat(UrlParser.getPort("")).isNull(); + assertThat(UrlParser.getPort("/")).isNull(); + + assertThat(UrlParser.getPort("?")).isNull(); + assertThat(UrlParser.getPort("/?")).isNull(); + + assertThat(UrlParser.getPort("?query")).isNull(); + assertThat(UrlParser.getPort("/?query")).isNull(); + + assertThat(UrlParser.getPort("#")).isNull(); + assertThat(UrlParser.getPort("/#")).isNull(); + + assertThat(UrlParser.getPort("#fragment")).isNull(); + assertThat(UrlParser.getPort("/#fragment")).isNull(); + } + + @Test + void testGetPath() { + assertThat(UrlParser.getPath("https://localhost")).isNull(); + assertThat(UrlParser.getPath("https://localhost/")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost/api/v1")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost?")).isNull(); + assertThat(UrlParser.getPath("https://localhost/?")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost/api/v1?")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost?query")).isNull(); + assertThat(UrlParser.getPath("https://localhost/?query")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost/api/v1?query")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost#")).isNull(); + assertThat(UrlParser.getPath("https://localhost/#")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost/api/v1#")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost#fragment")).isNull(); + assertThat(UrlParser.getPath("https://localhost/#fragment")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost/api/v1#fragment")).isEqualTo("/api/v1"); + } + + @Test + void testGetPathWithPort() { + assertThat(UrlParser.getPath("https://localhost:8080")).isNull(); + assertThat(UrlParser.getPath("https://localhost:8080/")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost:8080/api/v1")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost:8080?")).isNull(); + assertThat(UrlParser.getPath("https://localhost:8080/?")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost:8080/api/v1?")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost:8080?query")).isNull(); + assertThat(UrlParser.getPath("https://localhost:8080/?query")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost:8080/api/v1?query")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost:8080#")).isNull(); + assertThat(UrlParser.getPath("https://localhost:8080/#")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost:8080/api/v1#")).isEqualTo("/api/v1"); + + assertThat(UrlParser.getPath("https://localhost:8080#fragment")).isNull(); + assertThat(UrlParser.getPath("https://localhost:8080/#fragment")).isEqualTo("/"); + assertThat(UrlParser.getPath("https://localhost:8080/api/v1#fragment")).isEqualTo("/api/v1"); + } + + @Test + void testGetPathWithNoAuthority() { + assertThat(UrlParser.getPath("https:")).isNull(); + assertThat(UrlParser.getPath("https:/")).isNull(); + assertThat(UrlParser.getPath("https:/api/v1")).isNull(); + + assertThat(UrlParser.getPath("https:?")).isNull(); + assertThat(UrlParser.getPath("https:/?")).isNull(); + assertThat(UrlParser.getPath("https:/api/v1?")).isNull(); + + assertThat(UrlParser.getPath("https:?query")).isNull(); + assertThat(UrlParser.getPath("https:/?query")).isNull(); + assertThat(UrlParser.getPath("https:/api/v1?query")).isNull(); + + assertThat(UrlParser.getPath("https:#")).isNull(); + assertThat(UrlParser.getPath("https:/#")).isNull(); + assertThat(UrlParser.getPath("https:/api/v1#")).isNull(); + + assertThat(UrlParser.getPath("https:#fragment")).isNull(); + assertThat(UrlParser.getPath("https:/#fragment")).isNull(); + assertThat(UrlParser.getPath("https:/api/v1#fragment")).isNull(); + } + + @Test + void testGetPathtWithNoScheme() { + assertThat(UrlParser.getPath("")).isNull(); + assertThat(UrlParser.getPath("/")).isNull(); + assertThat(UrlParser.getPath("/api/v1")).isNull(); + + assertThat(UrlParser.getPath("?")).isNull(); + assertThat(UrlParser.getPath("/?")).isNull(); + assertThat(UrlParser.getPath("/api/v1?")).isNull(); + + assertThat(UrlParser.getPath("?query")).isNull(); + assertThat(UrlParser.getPath("/?query")).isNull(); + assertThat(UrlParser.getPath("/api/v1?query")).isNull(); + + assertThat(UrlParser.getPath("#")).isNull(); + assertThat(UrlParser.getPath("/#")).isNull(); + assertThat(UrlParser.getPath("/api/v1#")).isNull(); + + assertThat(UrlParser.getPath("#fragment")).isNull(); + assertThat(UrlParser.getPath("/#fragment")).isNull(); + assertThat(UrlParser.getPath("/api/v1#fragment")).isNull(); + } +} diff --git a/instrumentation/akka/akka-http-10.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/akkahttp/client/AkkaHttpClientSingletons.java b/instrumentation/akka/akka-http-10.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/akkahttp/client/AkkaHttpClientSingletons.java index 5c2887f628..88aedf7ce0 100644 --- a/instrumentation/akka/akka-http-10.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/akkahttp/client/AkkaHttpClientSingletons.java +++ b/instrumentation/akka/akka-http-10.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/akkahttp/client/AkkaHttpClientSingletons.java @@ -14,9 +14,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.SpanKindExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import io.opentelemetry.javaagent.instrumentation.akkahttp.AkkaHttpUtil; @@ -43,8 +43,8 @@ public class AkkaHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/apache-dubbo-2.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachedubbo/v2_7/OpenTelemetryFilter.java b/instrumentation/apache-dubbo-2.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachedubbo/v2_7/OpenTelemetryFilter.java index fa37cc29fa..9a0c7387a9 100644 --- a/instrumentation/apache-dubbo-2.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachedubbo/v2_7/OpenTelemetryFilter.java +++ b/instrumentation/apache-dubbo-2.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachedubbo/v2_7/OpenTelemetryFilter.java @@ -27,7 +27,7 @@ public class OpenTelemetryFilter implements Filter { .addAttributesExtractor( PeerServiceAttributesExtractor.create( new DubboClientNetworkAttributesGetter(), - CommonConfig.get().getPeerServiceMapping())) + CommonConfig.get().getPeerServiceResolver())) .build() .newFilter(); } diff --git a/instrumentation/apache-httpasyncclient-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpasyncclient/ApacheHttpAsyncClientSingletons.java b/instrumentation/apache-httpasyncclient-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpasyncclient/ApacheHttpAsyncClientSingletons.java index e8aa7ffe57..a563e52799 100644 --- a/instrumentation/apache-httpasyncclient-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpasyncclient/ApacheHttpAsyncClientSingletons.java +++ b/instrumentation/apache-httpasyncclient-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpasyncclient/ApacheHttpAsyncClientSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import org.apache.http.HttpResponse; @@ -41,8 +41,8 @@ public final class ApacheHttpAsyncClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/apache-httpclient/apache-httpclient-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v2_0/ApacheHttpClientSingletons.java b/instrumentation/apache-httpclient/apache-httpclient-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v2_0/ApacheHttpClientSingletons.java index 6f2d3194b5..2db8ee2f77 100644 --- a/instrumentation/apache-httpclient/apache-httpclient-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v2_0/ApacheHttpClientSingletons.java +++ b/instrumentation/apache-httpclient/apache-httpclient-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v2_0/ApacheHttpClientSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import org.apache.commons.httpclient.HttpMethod; @@ -41,8 +41,8 @@ public final class ApacheHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/apache-httpclient/apache-httpclient-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v4_0/ApacheHttpClientSingletons.java b/instrumentation/apache-httpclient/apache-httpclient-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v4_0/ApacheHttpClientSingletons.java index 91f14f48b9..188e81ad0a 100644 --- a/instrumentation/apache-httpclient/apache-httpclient-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v4_0/ApacheHttpClientSingletons.java +++ b/instrumentation/apache-httpclient/apache-httpclient-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v4_0/ApacheHttpClientSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import org.apache.http.HttpResponse; @@ -41,8 +41,8 @@ public final class ApacheHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/apache-httpclient/apache-httpclient-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v5_0/ApacheHttpClientSingletons.java b/instrumentation/apache-httpclient/apache-httpclient-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v5_0/ApacheHttpClientSingletons.java index 89d55f6266..811204405a 100644 --- a/instrumentation/apache-httpclient/apache-httpclient-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v5_0/ApacheHttpClientSingletons.java +++ b/instrumentation/apache-httpclient/apache-httpclient-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachehttpclient/v5_0/ApacheHttpClientSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import org.apache.hc.core5.http.HttpRequest; import org.apache.hc.core5.http.HttpResponse; @@ -42,8 +42,8 @@ public final class ApacheHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/armeria-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/armeria/v1_3/ArmeriaSingletons.java b/instrumentation/armeria-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/armeria/v1_3/ArmeriaSingletons.java index 4d49fa06c1..260d9f6076 100644 --- a/instrumentation/armeria-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/armeria/v1_3/ArmeriaSingletons.java +++ b/instrumentation/armeria-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/armeria/v1_3/ArmeriaSingletons.java @@ -8,7 +8,7 @@ package io.opentelemetry.javaagent.instrumentation.armeria.v1_3; import com.linecorp.armeria.client.HttpClient; import com.linecorp.armeria.server.HttpService; import io.opentelemetry.api.GlobalOpenTelemetry; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.armeria.v1_3.ArmeriaTelemetry; import io.opentelemetry.instrumentation.armeria.v1_3.internal.ArmeriaHttpClientAttributesGetter; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; @@ -28,9 +28,9 @@ public final class ArmeriaSingletons { .setCapturedClientResponseHeaders(CommonConfig.get().getClientResponseHeaders()) .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .addClientAttributeExtractor( - PeerServiceAttributesExtractor.create( + HttpClientPeerServiceAttributesExtractor.create( ArmeriaHttpClientAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())) + CommonConfig.get().getPeerServiceResolver())) .setEmitExperimentalHttpClientMetrics( CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) .setEmitExperimentalHttpServerMetrics( diff --git a/instrumentation/async-http-client/async-http-client-1.9/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v1_9/AsyncHttpClientSingletons.java b/instrumentation/async-http-client/async-http-client-1.9/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v1_9/AsyncHttpClientSingletons.java index 2a329f4394..bdc9584f4f 100644 --- a/instrumentation/async-http-client/async-http-client-1.9/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v1_9/AsyncHttpClientSingletons.java +++ b/instrumentation/async-http-client/async-http-client-1.9/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v1_9/AsyncHttpClientSingletons.java @@ -13,9 +13,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; public final class AsyncHttpClientSingletons { @@ -42,8 +42,8 @@ public final class AsyncHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/async-http-client/async-http-client-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v2_0/AsyncHttpClientSingletons.java b/instrumentation/async-http-client/async-http-client-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v2_0/AsyncHttpClientSingletons.java index d339fa8cf2..8efc890584 100644 --- a/instrumentation/async-http-client/async-http-client-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v2_0/AsyncHttpClientSingletons.java +++ b/instrumentation/async-http-client/async-http-client-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/asynchttpclient/v2_0/AsyncHttpClientSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import org.asynchttpclient.Response; @@ -41,8 +41,8 @@ public final class AsyncHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addAttributesExtractor(new AsyncHttpClientAdditionalAttributesExtractor()) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { diff --git a/instrumentation/couchbase/couchbase-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/couchbase/v2_0/CouchbaseSingletons.java b/instrumentation/couchbase/couchbase-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/couchbase/v2_0/CouchbaseSingletons.java index 6050f79d0a..58421bd250 100644 --- a/instrumentation/couchbase/couchbase-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/couchbase/v2_0/CouchbaseSingletons.java +++ b/instrumentation/couchbase/couchbase-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/couchbase/v2_0/CouchbaseSingletons.java @@ -36,7 +36,7 @@ public final class CouchbaseSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addContextCustomizer( (context, couchbaseRequest, startAttributes) -> CouchbaseRequestInfo.init(context, couchbaseRequest)); diff --git a/instrumentation/google-http-client-1.19/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/googlehttpclient/GoogleHttpClientSingletons.java b/instrumentation/google-http-client-1.19/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/googlehttpclient/GoogleHttpClientSingletons.java index 25497c4c80..b832fcb076 100644 --- a/instrumentation/google-http-client-1.19/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/googlehttpclient/GoogleHttpClientSingletons.java +++ b/instrumentation/google-http-client-1.19/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/googlehttpclient/GoogleHttpClientSingletons.java @@ -13,9 +13,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; public class GoogleHttpClientSingletons { @@ -42,8 +42,8 @@ public class GoogleHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpUrlConnectionSingletons.java b/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpUrlConnectionSingletons.java index f20c3b8321..0f97457560 100644 --- a/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpUrlConnectionSingletons.java +++ b/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpUrlConnectionSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import java.net.HttpURLConnection; @@ -39,8 +39,8 @@ public final class HttpUrlConnectionSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addAttributesExtractor( HttpMethodAttributeExtractor.create( CommonConfig.get().getKnownHttpRequestMethods())) diff --git a/instrumentation/java-http-client/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpclient/JavaHttpClientSingletons.java b/instrumentation/java-http-client/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpclient/JavaHttpClientSingletons.java index f11fc34cf0..95b531c68a 100644 --- a/instrumentation/java-http-client/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpclient/JavaHttpClientSingletons.java +++ b/instrumentation/java-http-client/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpclient/JavaHttpClientSingletons.java @@ -9,7 +9,7 @@ import static java.util.Collections.singletonList; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.httpclient.internal.HttpHeadersSetter; import io.opentelemetry.instrumentation.httpclient.internal.JavaHttpClientAttributesGetter; import io.opentelemetry.instrumentation.httpclient.internal.JavaHttpClientInstrumenterFactory; @@ -35,9 +35,9 @@ public class JavaHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), builder -> builder.setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), singletonList( - PeerServiceAttributesExtractor.create( + HttpClientPeerServiceAttributesExtractor.create( JavaHttpClientAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())), + CommonConfig.get().getPeerServiceResolver())), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); } diff --git a/instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java b/instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java index 282f0249a7..cd20a638f5 100644 --- a/instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java +++ b/instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java @@ -49,7 +49,7 @@ public final class JdbcSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/jedis/jedis-1.4/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v1_4/JedisSingletons.java b/instrumentation/jedis/jedis-1.4/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v1_4/JedisSingletons.java index 02dbf4aecf..13f374e702 100644 --- a/instrumentation/jedis/jedis-1.4/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v1_4/JedisSingletons.java +++ b/instrumentation/jedis/jedis-1.4/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v1_4/JedisSingletons.java @@ -32,7 +32,7 @@ public final class JedisSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/jedis/jedis-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v3_0/JedisSingletons.java b/instrumentation/jedis/jedis-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v3_0/JedisSingletons.java index 079395c9f5..2314f4905f 100644 --- a/instrumentation/jedis/jedis-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v3_0/JedisSingletons.java +++ b/instrumentation/jedis/jedis-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v3_0/JedisSingletons.java @@ -32,7 +32,7 @@ public final class JedisSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/jedis/jedis-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v4_0/JedisSingletons.java b/instrumentation/jedis/jedis-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v4_0/JedisSingletons.java index fcd59f8716..f03f6ec09c 100644 --- a/instrumentation/jedis/jedis-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v4_0/JedisSingletons.java +++ b/instrumentation/jedis/jedis-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jedis/v4_0/JedisSingletons.java @@ -32,7 +32,7 @@ public final class JedisSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/jetty-httpclient/jetty-httpclient-9.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jetty/httpclient/v9_2/JettyHttpClientSingletons.java b/instrumentation/jetty-httpclient/jetty-httpclient-9.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jetty/httpclient/v9_2/JettyHttpClientSingletons.java index 80df4f80ca..14f01404c3 100644 --- a/instrumentation/jetty-httpclient/jetty-httpclient-9.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jetty/httpclient/v9_2/JettyHttpClientSingletons.java +++ b/instrumentation/jetty-httpclient/jetty-httpclient-9.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jetty/httpclient/v9_2/JettyHttpClientSingletons.java @@ -9,7 +9,7 @@ import static java.util.Collections.singletonList; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.jetty.httpclient.v9_2.internal.JettyClientHttpAttributesGetter; import io.opentelemetry.instrumentation.jetty.httpclient.v9_2.internal.JettyClientInstrumenterFactory; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; @@ -28,9 +28,9 @@ public class JettyHttpClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), builder -> builder.setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), singletonList( - PeerServiceAttributesExtractor.create( + HttpClientPeerServiceAttributesExtractor.create( JettyClientHttpAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())), + CommonConfig.get().getPeerServiceResolver())), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); public static Instrumenter instrumenter() { diff --git a/instrumentation/jodd-http-4.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/joddhttp/v4_2/JoddHttpSingletons.java b/instrumentation/jodd-http-4.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/joddhttp/v4_2/JoddHttpSingletons.java index 9ee19d238d..5002867a05 100644 --- a/instrumentation/jodd-http-4.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/joddhttp/v4_2/JoddHttpSingletons.java +++ b/instrumentation/jodd-http-4.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/joddhttp/v4_2/JoddHttpSingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import jodd.http.HttpRequest; import jodd.http.HttpResponse; @@ -41,8 +41,8 @@ public final class JoddHttpSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/lettuce/lettuce-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSingletons.java b/instrumentation/lettuce/lettuce-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSingletons.java index a8db8f6fd7..9c554cb74c 100644 --- a/instrumentation/lettuce/lettuce-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSingletons.java +++ b/instrumentation/lettuce/lettuce-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSingletons.java @@ -47,7 +47,7 @@ public final class LettuceSingletons { .addAttributesExtractor(ServerAttributesExtractor.create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addAttributesExtractor(new LettuceConnectAttributesExtractor()) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/lettuce/lettuce-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v5_0/LettuceSingletons.java b/instrumentation/lettuce/lettuce-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v5_0/LettuceSingletons.java index e72819b512..0c18603d6a 100644 --- a/instrumentation/lettuce/lettuce-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v5_0/LettuceSingletons.java +++ b/instrumentation/lettuce/lettuce-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/lettuce/v5_0/LettuceSingletons.java @@ -48,7 +48,7 @@ public final class LettuceSingletons { ServerAttributesExtractor.create(connectNetworkAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - connectNetworkAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + connectNetworkAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addAttributesExtractor(new LettuceConnectAttributesExtractor()) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/netty/netty-3.8/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v3_8/client/NettyClientSingletons.java b/instrumentation/netty/netty-3.8/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v3_8/client/NettyClientSingletons.java index 8fcef38b74..99f35e6379 100644 --- a/instrumentation/netty/netty-3.8/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v3_8/client/NettyClientSingletons.java +++ b/instrumentation/netty/netty-3.8/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v3_8/client/NettyClientSingletons.java @@ -12,9 +12,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.SpanKindExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.netty.common.internal.NettyConnectionRequest; import io.opentelemetry.instrumentation.netty.common.internal.NettyErrorHolder; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; @@ -47,8 +47,8 @@ public final class NettyClientSingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()) .addContextCustomizer( (context, requestAndChannel, startAttributes) -> NettyErrorHolder.init(context)); @@ -63,9 +63,9 @@ public final class NettyClientSingletons { .addAttributesExtractor( HttpClientAttributesExtractor.create(NettyConnectHttpAttributesGetter.INSTANCE)) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( + HttpClientPeerServiceAttributesExtractor.create( NettyConnectHttpAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())) + CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/netty/netty-4-common/library/src/main/java/io/opentelemetry/instrumentation/netty/v4/common/internal/client/NettyClientInstrumenterFactory.java b/instrumentation/netty/netty-4-common/library/src/main/java/io/opentelemetry/instrumentation/netty/v4/common/internal/client/NettyClientInstrumenterFactory.java index e404540bc1..ebea1eebaf 100644 --- a/instrumentation/netty/netty-4-common/library/src/main/java/io/opentelemetry/instrumentation/netty/v4/common/internal/client/NettyClientInstrumenterFactory.java +++ b/instrumentation/netty/netty-4-common/library/src/main/java/io/opentelemetry/instrumentation/netty/v4/common/internal/client/NettyClientInstrumenterFactory.java @@ -16,14 +16,15 @@ import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttribut import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractorBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractorBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceResolver; import io.opentelemetry.instrumentation.netty.common.internal.NettyConnectionRequest; import io.opentelemetry.instrumentation.netty.v4.common.HttpRequestAndChannel; import java.util.List; -import java.util.Map; import java.util.function.Consumer; /** @@ -36,7 +37,7 @@ public final class NettyClientInstrumenterFactory { private final String instrumentationName; private final NettyConnectionInstrumentationFlag connectionTelemetryState; private final NettyConnectionInstrumentationFlag sslTelemetryState; - private final Map peerServiceMapping; + private final PeerServiceResolver peerServiceResolver; private final boolean emitExperimentalHttpClientMetrics; public NettyClientInstrumenterFactory( @@ -44,13 +45,13 @@ public final class NettyClientInstrumenterFactory { String instrumentationName, NettyConnectionInstrumentationFlag connectionTelemetryState, NettyConnectionInstrumentationFlag sslTelemetryState, - Map peerServiceMapping, + PeerServiceResolver peerServiceResolver, boolean emitExperimentalHttpClientMetrics) { this.openTelemetry = openTelemetry; this.instrumentationName = instrumentationName; this.connectionTelemetryState = connectionTelemetryState; this.sslTelemetryState = sslTelemetryState; - this.peerServiceMapping = peerServiceMapping; + this.peerServiceResolver = peerServiceResolver; this.emitExperimentalHttpClientMetrics = emitExperimentalHttpClientMetrics; } @@ -76,7 +77,8 @@ public final class NettyClientInstrumenterFactory { .setSpanStatusExtractor(HttpSpanStatusExtractor.create(httpAttributesGetter)) .addAttributesExtractor(extractorBuilder.build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create(httpAttributesGetter, peerServiceMapping)) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, peerServiceResolver)) .addAttributesExtractors(additionalHttpAttributeExtractors) .addOperationMetrics(HttpClientMetrics.get()); if (emitExperimentalHttpClientMetrics) { @@ -99,7 +101,7 @@ public final class NettyClientInstrumenterFactory { Instrumenter.builder( openTelemetry, instrumentationName, NettyConnectionRequest::spanName) .addAttributesExtractor( - PeerServiceAttributesExtractor.create(getter, peerServiceMapping)); + HttpClientPeerServiceAttributesExtractor.create(getter, peerServiceResolver)); if (connectionTelemetryFullyEnabled) { // when the connection telemetry is fully enabled, CONNECT spans are created for every @@ -141,7 +143,7 @@ public final class NettyClientInstrumenterFactory { io.opentelemetry.instrumentation.api.instrumenter.net.NetClientAttributesExtractor .create(netAttributesGetter)) .addAttributesExtractor( - PeerServiceAttributesExtractor.create(netAttributesGetter, peerServiceMapping)) + PeerServiceAttributesExtractor.create(netAttributesGetter, peerServiceResolver)) .buildInstrumenter( sslTelemetryFullyEnabled ? SpanKindExtractor.alwaysInternal() diff --git a/instrumentation/netty/netty-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_0/client/NettyClientSingletons.java b/instrumentation/netty/netty-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_0/client/NettyClientSingletons.java index a53d588dc0..fd186eb058 100644 --- a/instrumentation/netty/netty-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_0/client/NettyClientSingletons.java +++ b/instrumentation/netty/netty-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_0/client/NettyClientSingletons.java @@ -47,7 +47,7 @@ public final class NettyClientSingletons { "io.opentelemetry.netty-4.0", enabledOrErrorOnly(connectionTelemetryEnabled), enabledOrErrorOnly(sslTelemetryEnabled), - CommonConfig.get().getPeerServiceMapping(), + CommonConfig.get().getPeerServiceResolver(), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); INSTRUMENTER = factory.createHttpInstrumenter( diff --git a/instrumentation/netty/netty-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_1/NettyClientSingletons.java b/instrumentation/netty/netty-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_1/NettyClientSingletons.java index 20532c074d..ea8d06100a 100644 --- a/instrumentation/netty/netty-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_1/NettyClientSingletons.java +++ b/instrumentation/netty/netty-4.1/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/netty/v4_1/NettyClientSingletons.java @@ -47,7 +47,7 @@ public final class NettyClientSingletons { "io.opentelemetry.netty-4.1", enabledOrErrorOnly(connectionTelemetryEnabled), enabledOrErrorOnly(sslTelemetryEnabled), - CommonConfig.get().getPeerServiceMapping(), + CommonConfig.get().getPeerServiceResolver(), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); INSTRUMENTER = factory.createHttpInstrumenter( diff --git a/instrumentation/netty/netty-4.1/library/src/main/java/io/opentelemetry/instrumentation/netty/v4_1/NettyClientTelemetryBuilder.java b/instrumentation/netty/netty-4.1/library/src/main/java/io/opentelemetry/instrumentation/netty/v4_1/NettyClientTelemetryBuilder.java index 23440e2d56..c313b1ed33 100644 --- a/instrumentation/netty/netty-4.1/library/src/main/java/io/opentelemetry/instrumentation/netty/v4_1/NettyClientTelemetryBuilder.java +++ b/instrumentation/netty/netty-4.1/library/src/main/java/io/opentelemetry/instrumentation/netty/v4_1/NettyClientTelemetryBuilder.java @@ -11,6 +11,7 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractorBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractorBuilder; +import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceResolver; import io.opentelemetry.instrumentation.netty.v4.common.HttpRequestAndChannel; import io.opentelemetry.instrumentation.netty.v4.common.internal.client.NettyClientInstrumenterFactory; import io.opentelemetry.instrumentation.netty.v4.common.internal.client.NettyConnectionInstrumentationFlag; @@ -119,7 +120,7 @@ public final class NettyClientTelemetryBuilder { "io.opentelemetry.netty-4.1", NettyConnectionInstrumentationFlag.DISABLED, NettyConnectionInstrumentationFlag.DISABLED, - Collections.emptyMap(), + PeerServiceResolver.create(Collections.emptyMap()), emitExperimentalHttpClientMetrics) .createHttpInstrumenter( extractorConfigurer, spanNameExtractorConfigurer, additionalAttributesExtractors)); diff --git a/instrumentation/okhttp/okhttp-2.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v2_2/OkHttp2Singletons.java b/instrumentation/okhttp/okhttp-2.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v2_2/OkHttp2Singletons.java index 9246fa9d58..d8dec01846 100644 --- a/instrumentation/okhttp/okhttp-2.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v2_2/OkHttp2Singletons.java +++ b/instrumentation/okhttp/okhttp-2.2/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v2_2/OkHttp2Singletons.java @@ -17,9 +17,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; public final class OkHttp2Singletons { @@ -48,8 +48,8 @@ public final class OkHttp2Singletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/okhttp/okhttp-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v3_0/OkHttp3Singletons.java b/instrumentation/okhttp/okhttp-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v3_0/OkHttp3Singletons.java index c2dbf07be1..eb120a2def 100644 --- a/instrumentation/okhttp/okhttp-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v3_0/OkHttp3Singletons.java +++ b/instrumentation/okhttp/okhttp-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/okhttp/v3_0/OkHttp3Singletons.java @@ -11,8 +11,8 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.context.Context; import io.opentelemetry.context.Scope; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientResendCount; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.okhttp.v3_0.internal.ConnectionErrorSpanInterceptor; import io.opentelemetry.instrumentation.okhttp.v3_0.internal.OkHttpAttributesGetter; import io.opentelemetry.instrumentation.okhttp.v3_0.internal.OkHttpInstrumenterFactory; @@ -35,8 +35,8 @@ public final class OkHttp3Singletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), builder -> builder.setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), singletonList( - PeerServiceAttributesExtractor.create( - OkHttpAttributesGetter.INSTANCE, CommonConfig.get().getPeerServiceMapping())), + HttpClientPeerServiceAttributesExtractor.create( + OkHttpAttributesGetter.INSTANCE, CommonConfig.get().getPeerServiceResolver())), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); public static final Interceptor CONTEXT_INTERCEPTOR = diff --git a/instrumentation/opensearch/opensearch-rest-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opensearch/rest/OpenSearchRestInstrumenterFactory.java b/instrumentation/opensearch/opensearch-rest-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opensearch/rest/OpenSearchRestInstrumenterFactory.java index bbb8d0c499..ab33020075 100644 --- a/instrumentation/opensearch/opensearch-rest-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opensearch/rest/OpenSearchRestInstrumenterFactory.java +++ b/instrumentation/opensearch/opensearch-rest-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opensearch/rest/OpenSearchRestInstrumenterFactory.java @@ -32,7 +32,7 @@ public final class OpenSearchRestInstrumenterFactory { .create(netAttributesGetter)) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - netAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + netAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/instrumentation/pekko-http-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/pekkohttp/v1_0/client/PekkoHttpClientSingletons.java b/instrumentation/pekko-http-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/pekkohttp/v1_0/client/PekkoHttpClientSingletons.java index ef28811f52..8ce54a3ae6 100644 --- a/instrumentation/pekko-http-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/pekkohttp/v1_0/client/PekkoHttpClientSingletons.java +++ b/instrumentation/pekko-http-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/pekkohttp/v1_0/client/PekkoHttpClientSingletons.java @@ -42,7 +42,7 @@ public class PekkoHttpClientSingletons { .build()) .addAttributesExtractor( PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/play/play-ws/play-ws-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/playws/PlayWsClientInstrumenterFactory.java b/instrumentation/play/play-ws/play-ws-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/playws/PlayWsClientInstrumenterFactory.java index ad08215e91..2372993ead 100644 --- a/instrumentation/play/play-ws/play-ws-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/playws/PlayWsClientInstrumenterFactory.java +++ b/instrumentation/play/play-ws/play-ws-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/playws/PlayWsClientInstrumenterFactory.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import play.shaded.ahc.org.asynchttpclient.Request; import play.shaded.ahc.org.asynchttpclient.Response; @@ -38,8 +38,8 @@ public final class PlayWsClientInstrumenterFactory { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/r2dbc-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/r2dbc/v1_0/R2dbcSingletons.java b/instrumentation/r2dbc-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/r2dbc/v1_0/R2dbcSingletons.java index 5829464bc8..d165b1be0c 100644 --- a/instrumentation/r2dbc-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/r2dbc/v1_0/R2dbcSingletons.java +++ b/instrumentation/r2dbc-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/r2dbc/v1_0/R2dbcSingletons.java @@ -18,7 +18,7 @@ public final class R2dbcSingletons { .setStatementSanitizationEnabled(CommonConfig.get().isStatementSanitizationEnabled()) .addAttributeExtractor( PeerServiceAttributesExtractor.create( - R2dbcNetAttributesGetter.INSTANCE, CommonConfig.get().getPeerServiceMapping())) + R2dbcNetAttributesGetter.INSTANCE, CommonConfig.get().getPeerServiceResolver())) .build(); public static R2dbcTelemetry telemetry() { diff --git a/instrumentation/reactor/reactor-netty/reactor-netty-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/reactornetty/v1_0/ReactorNettySingletons.java b/instrumentation/reactor/reactor-netty/reactor-netty-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/reactornetty/v1_0/ReactorNettySingletons.java index 9af6959387..d05acb6b04 100644 --- a/instrumentation/reactor/reactor-netty/reactor-netty-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/reactornetty/v1_0/ReactorNettySingletons.java +++ b/instrumentation/reactor/reactor-netty/reactor-netty-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/reactornetty/v1_0/ReactorNettySingletons.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.netty.v4.common.internal.client.NettyClientInstrumenterFactory; import io.opentelemetry.instrumentation.netty.v4.common.internal.client.NettyConnectionInstrumentationFlag; import io.opentelemetry.instrumentation.netty.v4.common.internal.client.NettyConnectionInstrumenter; @@ -61,8 +61,8 @@ public final class ReactorNettySingletons { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); @@ -77,7 +77,7 @@ public final class ReactorNettySingletons { ? NettyConnectionInstrumentationFlag.ENABLED : NettyConnectionInstrumentationFlag.DISABLED, NettyConnectionInstrumentationFlag.DISABLED, - CommonConfig.get().getPeerServiceMapping(), + CommonConfig.get().getPeerServiceResolver(), CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()); CONNECTION_INSTRUMENTER = instrumenterFactory.createConnectionInstrumenter(); } diff --git a/instrumentation/spring/spring-webflux/spring-webflux-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/webflux/v5_0/client/WebClientHelper.java b/instrumentation/spring/spring-webflux/spring-webflux-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/webflux/v5_0/client/WebClientHelper.java index d1bbd05591..f2c257f6cc 100644 --- a/instrumentation/spring/spring-webflux/spring-webflux-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/webflux/v5_0/client/WebClientHelper.java +++ b/instrumentation/spring/spring-webflux/spring-webflux-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/webflux/v5_0/client/WebClientHelper.java @@ -9,7 +9,7 @@ import static java.util.Collections.singletonList; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.spring.webflux.v5_3.internal.ClientInstrumenterFactory; import io.opentelemetry.instrumentation.spring.webflux.v5_3.internal.WebClientHttpAttributesGetter; import io.opentelemetry.instrumentation.spring.webflux.v5_3.internal.WebClientTracingFilter; @@ -32,9 +32,9 @@ public final class WebClientHelper { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), builder -> builder.setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()), singletonList( - PeerServiceAttributesExtractor.create( + HttpClientPeerServiceAttributesExtractor.create( WebClientHttpAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())), + CommonConfig.get().getPeerServiceResolver())), InstrumentationConfig.get() .getBoolean( "otel.instrumentation.spring-webflux.experimental-span-attributes", false), diff --git a/instrumentation/vertx/vertx-http-client/vertx-http-client-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/client/VertxClientInstrumenterFactory.java b/instrumentation/vertx/vertx-http-client/vertx-http-client-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/client/VertxClientInstrumenterFactory.java index c0b5052389..a0a876d556 100644 --- a/instrumentation/vertx/vertx-http-client/vertx-http-client-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/client/VertxClientInstrumenterFactory.java +++ b/instrumentation/vertx/vertx-http-client/vertx-http-client-common/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/client/VertxClientInstrumenterFactory.java @@ -11,9 +11,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.InstrumenterBuilder; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientExperimentalMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientPeerServiceAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceAttributesExtractor; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import io.vertx.core.http.HttpClientRequest; import io.vertx.core.http.HttpClientResponse; @@ -38,8 +38,8 @@ public final class VertxClientInstrumenterFactory { .setKnownMethods(CommonConfig.get().getKnownHttpRequestMethods()) .build()) .addAttributesExtractor( - PeerServiceAttributesExtractor.create( - httpAttributesGetter, CommonConfig.get().getPeerServiceMapping())) + HttpClientPeerServiceAttributesExtractor.create( + httpAttributesGetter, CommonConfig.get().getPeerServiceResolver())) .addOperationMetrics(HttpClientMetrics.get()); if (CommonConfig.get().shouldEmitExperimentalHttpClientMetrics()) { builder.addOperationMetrics(HttpClientExperimentalMetrics.get()); diff --git a/instrumentation/vertx/vertx-sql-client-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v4_0/sql/VertxSqlClientSingletons.java b/instrumentation/vertx/vertx-sql-client-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v4_0/sql/VertxSqlClientSingletons.java index 82800b91d8..7bb4434f42 100644 --- a/instrumentation/vertx/vertx-sql-client-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v4_0/sql/VertxSqlClientSingletons.java +++ b/instrumentation/vertx/vertx-sql-client-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v4_0/sql/VertxSqlClientSingletons.java @@ -47,7 +47,7 @@ public final class VertxSqlClientSingletons { .addAttributesExtractor( PeerServiceAttributesExtractor.create( VertxSqlClientNetAttributesGetter.INSTANCE, - CommonConfig.get().getPeerServiceMapping())); + CommonConfig.get().getPeerServiceResolver())); INSTRUMENTER = builder.buildInstrumenter(SpanKindExtractor.alwaysClient()); } diff --git a/javaagent-extension-api/build.gradle.kts b/javaagent-extension-api/build.gradle.kts index a08d02060d..6f5667cbfc 100644 --- a/javaagent-extension-api/build.gradle.kts +++ b/javaagent-extension-api/build.gradle.kts @@ -12,6 +12,7 @@ dependencies { api("net.bytebuddy:byte-buddy-dep") implementation(project(":instrumentation-api")) + implementation(project(":instrumentation-api-semconv")) // autoconfigure is unstable, do not expose as api implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure") diff --git a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/bootstrap/internal/CommonConfig.java b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/bootstrap/internal/CommonConfig.java index 7896947497..930942fe73 100644 --- a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/bootstrap/internal/CommonConfig.java +++ b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/bootstrap/internal/CommonConfig.java @@ -7,11 +7,11 @@ package io.opentelemetry.javaagent.bootstrap.internal; import static java.util.Collections.emptyMap; +import io.opentelemetry.instrumentation.api.instrumenter.net.PeerServiceResolver; import io.opentelemetry.instrumentation.api.internal.HttpConstants; import java.util.ArrayList; import java.util.HashSet; import java.util.List; -import java.util.Map; import java.util.Set; /** @@ -26,7 +26,7 @@ public final class CommonConfig { return instance; } - private final Map peerServiceMapping; + private final PeerServiceResolver peerServiceResolver; private final List clientRequestHeaders; private final List clientResponseHeaders; private final List serverRequestHeaders; @@ -37,8 +37,9 @@ public final class CommonConfig { private final boolean emitExperimentalHttpServerMetrics; CommonConfig(InstrumentationConfig config) { - peerServiceMapping = - config.getMap("otel.instrumentation.common.peer-service-mapping", emptyMap()); + peerServiceResolver = + PeerServiceResolver.create( + config.getMap("otel.instrumentation.common.peer-service-mapping", emptyMap())); // TODO (mateusz): remove the old config names in 2.0 clientRequestHeaders = @@ -74,8 +75,8 @@ public final class CommonConfig { config.getBoolean("otel.instrumentation.http.server.emit-experimental-metrics", false); } - public Map getPeerServiceMapping() { - return peerServiceMapping; + public PeerServiceResolver getPeerServiceResolver() { + return peerServiceResolver; } public List getClientRequestHeaders() {