diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/net/PeerServiceResolverImpl.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/service/peer/internal/ServicePeerResolver.java
index cc741640fb..d7d7f5faed 100644
--- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/net/PeerServiceResolverImpl.java
+++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/service/peer/internal/ServicePeerResolver.java
@@ -3,51 +3,125 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.instrumentation.api.incubator.semconv.net;
+package io.opentelemetry.instrumentation.api.incubator.semconv.service.peer.internal;
 
+import static java.util.Collections.emptyList;
 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.api.OpenTelemetry;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.DeclarativeConfigUtil;
 import io.opentelemetry.instrumentation.api.incubator.semconv.net.internal.UrlParser;
+import io.opentelemetry.instrumentation.api.internal.SemconvStability;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.BiConsumer;
 import java.util.function.Supplier;
 import javax.annotation.Nullable;
 
-class PeerServiceResolverImpl implements PeerServiceResolver {
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+public class ServicePeerResolver {
+
+  // copied from PeerIncubatingAttributes
+  private static final AttributeKey<String> PEER_SERVICE = AttributeKey.stringKey("peer.service");
+  // copied from ServiceIncubatingAttributes
+  private static final AttributeKey<String> SERVICE_PEER_NAME =
+      AttributeKey.stringKey("service.peer.name");
+  private static final AttributeKey<String> SERVICE_PEER_NAMESPACE =
+      AttributeKey.stringKey("service.peer.namespace");
 
   private static final Comparator<ServiceMatcher> matcherComparator =
       nullsFirst(
           comparing(ServiceMatcher::getPort, nullsFirst(naturalOrder()))
               .thenComparing(comparing(ServiceMatcher::getPath, nullsFirst(naturalOrder()))));
 
-  private final Map<String, Map<ServiceMatcher, String>> mapping = new HashMap<>();
-
-  PeerServiceResolverImpl(Map<String, String> 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<ServiceMatcher, String> matchers =
-              mapping.computeIfAbsent(host, x -> new HashMap<>());
-          matchers.putIfAbsent(ServiceMatcher.create(port, path), serviceName);
-        });
+  private final Map<String, Map<ServiceMatcher, ServicePeer>> servicePeerMapping = new HashMap<>();
+
+  public ServicePeerResolver(OpenTelemetry openTelemetry) {
+    DeclarativeConfigUtil.getInstrumentationConfig(openTelemetry, "common")
+        .getStructuredList("service_peer_mapping", emptyList())
+        .forEach(
+            entry -> {
+              String peer = entry.getString("peer");
+              String serviceName = entry.getString("service_name");
+              String serviceNamespace = entry.getString("service_namespace");
+              if (peer != null && (serviceName != null || serviceNamespace != null)) {
+                addMapping(peer, serviceName, serviceNamespace);
+              }
+            });
+  }
+
+  @SuppressWarnings("deprecation") // used by deprecated PeerServiceResolver
+  public ServicePeerResolver(Map<String, String> peerServiceNameMapping) {
+    peerServiceNameMapping.forEach((peer, serviceName) -> addMapping(peer, serviceName, null));
+  }
+
+  private void addMapping(
+      String peer, @Nullable String serviceName, @Nullable String serviceNamespace) {
+    if (serviceName == null && serviceNamespace == null) {
+      return;
+    }
+    ServicePeer info = new ServicePeer(serviceName, serviceNamespace);
+    String url = "https://" + peer;
+    String host = UrlParser.getHost(url);
+    Integer port = UrlParser.getPort(url);
+    String path = UrlParser.getPath(url);
+    Map<ServiceMatcher, ServicePeer> matchers =
+        servicePeerMapping.computeIfAbsent(host, x -> new HashMap<>());
+    matchers.putIfAbsent(ServiceMatcher.create(port, path), info);
   }
 
-  @Override
   public boolean isEmpty() {
-    return mapping.isEmpty();
+    return servicePeerMapping.isEmpty();
+  }
+
+  @SuppressWarnings("deprecation") // old semconv
+  public void resolve(
+      String host,
+      @Nullable Integer port,
+      Supplier<String> pathSupplier,
+      BiConsumer<AttributeKey<String>, String> attributeSetter) {
+    ServicePeer servicePeer = resolveServicePeer(host, port, pathSupplier);
+    if (servicePeer == null) {
+      return;
+    }
+
+    String name = servicePeer.name;
+    if (name != null) {
+      if (SemconvStability.emitOldServicePeerSemconv()) {
+        attributeSetter.accept(PEER_SERVICE, name);
+      }
+      if (SemconvStability.emitStableServicePeerSemconv()) {
+        attributeSetter.accept(SERVICE_PEER_NAME, name);
+      }
+    }
+    if (SemconvStability.emitStableServicePeerSemconv()) {
+      String namespace = servicePeer.namespace;
+      if (namespace != null) {
+        attributeSetter.accept(SERVICE_PEER_NAMESPACE, namespace);
+      }
+    }
+  }
+
+  // TODO: remove this method when deprecated PeerServiceResolver is removed
+  @Nullable
+  public String resolveServiceName(
+      String host, @Nullable Integer port, Supplier<String> pathSupplier) {
+    ServicePeer peer = resolveServicePeer(host, port, pathSupplier);
+    return peer != null ? peer.name : null;
   }
 
-  @Override
   @Nullable
-  public String resolveService(String host, @Nullable Integer port, Supplier<String> pathSupplier) {
-    Map<ServiceMatcher, String> matchers = mapping.get(host);
+  ServicePeer resolveServicePeer(
+      String host, @Nullable Integer port, Supplier<String> pathSupplier) {
+    Map<ServiceMatcher, ServicePeer> matchers = servicePeerMapping.get(host);
     if (matchers == null) {
       return null;
     }
@@ -58,11 +132,31 @@ class PeerServiceResolverImpl implements PeerServiceResolver {
         .orElse(null);
   }
 
+  // TODO: remove this method when deprecated PeerServiceResolver is removed
+  @SuppressWarnings("deprecation") // bridges deprecated PeerServiceResolver
+  public static ServicePeerResolver fromPeerServiceResolver(
+      io.opentelemetry.instrumentation.api.incubator.semconv.net.PeerServiceResolver resolver) {
+    return new ServicePeerResolver(new HashMap<>()) {
+      @Override
+      public boolean isEmpty() {
+        return resolver.isEmpty();
+      }
+
+      @Override
+      @Nullable
+      ServicePeer resolveServicePeer(
+          String host, @Nullable Integer port, Supplier<String> pathSupplier) {
+        String serviceName = resolver.resolveService(host, port, pathSupplier);
+        return serviceName != null ? new ServicePeer(serviceName, null) : null;
+      }
+    };
+  }
+
   @AutoValue
   abstract static class ServiceMatcher {
 
     static ServiceMatcher create(@Nullable Integer port, @Nullable String path) {
-      return new AutoValue_PeerServiceResolverImpl_ServiceMatcher(port, path);
+      return new AutoValue_ServicePeerResolver_ServiceMatcher(port, path);
     }
 
     @Nullable
@@ -92,4 +186,15 @@ class PeerServiceResolverImpl implements PeerServiceResolver {
       return true;
     }
   }
+
+  private static final class ServicePeer {
+
+    @Nullable private final String name;
+    @Nullable private final String namespace;
+
+    ServicePeer(@Nullable String name, @Nullable String namespace) {
+      this.name = name;
+      this.namespace = namespace;
+    }
+  }
 }