diff --git a/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy b/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy
index 91e505884b2..33a68d57755 100644
--- a/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy
+++ b/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy
@@ -517,8 +517,9 @@ class SpringBootBasedTest extends HttpServerTest<ConfigurableApplicationContext>
           parent()
           tags {
             "$Tags.COMPONENT" "aws-apigateway"
+            "$Tags.SPAN_KIND" Tags.SPAN_KIND_SERVER
             "$Tags.HTTP_METHOD" "GET"
-            "$Tags.HTTP_URL" "api.example.com/success"
+            "$Tags.HTTP_URL" "https://api.example.com/success"
             "$Tags.HTTP_ROUTE" "/success"
             "stage" "test"
             "_dd.inferred_span" 1
diff --git a/dd-trace-core/src/test/java/datadog/trace/core/propagation/InferredProxyPropagatorTests.java b/dd-trace-core/src/test/java/datadog/trace/core/propagation/InferredProxyPropagatorTests.java
index 5830a160cc7..7742fc0deb4 100644
--- a/dd-trace-core/src/test/java/datadog/trace/core/propagation/InferredProxyPropagatorTests.java
+++ b/dd-trace-core/src/test/java/datadog/trace/core/propagation/InferredProxyPropagatorTests.java
@@ -27,6 +27,7 @@ class InferredProxyPropagatorTests {
   private static final String PROXY_SYSTEM_KEY = "x-dd-proxy";
   private static final String PROXY_REQUEST_TIME_MS_KEY = "x-dd-proxy-request-time-ms";
   private static final String PROXY_PATH_KEY = "x-dd-proxy-path";
+  private static final String PROXY_RESOURCE_PATH_KEY = "x-dd-proxy-resource-path";
   private static final String PROXY_HTTP_METHOD_KEY = "x-dd-proxy-httpmethod";
   private static final String PROXY_DOMAIN_NAME_KEY = "x-dd-proxy-domain-name";
   private static final MapVisitor MAP_VISITOR = new MapVisitor();
@@ -86,6 +87,64 @@ static Stream<Arguments> invalidOrMissingHeadersProviderForPropagator() { // Ren
         of("PROXY_REQUEST_TIME_MS_KEY missing", missingTime));
   }
 
+  @Test
+  @DisplayName("Should extract x-dd-proxy-resource-path header when present")
+  void testResourcePathHeaderExtraction() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_SYSTEM_KEY, "aws-apigateway");
+    headers.put(PROXY_REQUEST_TIME_MS_KEY, "12345");
+    headers.put(PROXY_PATH_KEY, "/api/users/123");
+    headers.put(PROXY_RESOURCE_PATH_KEY, "/api/users/{id}");
+    headers.put(PROXY_HTTP_METHOD_KEY, "GET");
+    headers.put(PROXY_DOMAIN_NAME_KEY, "api.example.com");
+
+    Context context = this.propagator.extract(root(), headers, MAP_VISITOR);
+    InferredProxySpan inferredProxySpan = fromContext(context);
+    assertNotNull(inferredProxySpan);
+    assertTrue(inferredProxySpan.isValid());
+
+    // The resourcePath header should be extracted and available
+    // for use in http.route and resource.name
+  }
+
+  @Test
+  @DisplayName("Should work without x-dd-proxy-resource-path header for backwards compatibility")
+  void testExtractionWithoutResourcePath() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_SYSTEM_KEY, "aws-apigateway");
+    headers.put(PROXY_REQUEST_TIME_MS_KEY, "12345");
+    headers.put(PROXY_PATH_KEY, "/api/users/123");
+    // No PROXY_RESOURCE_PATH_KEY
+    headers.put(PROXY_HTTP_METHOD_KEY, "GET");
+    headers.put(PROXY_DOMAIN_NAME_KEY, "api.example.com");
+
+    Context context = this.propagator.extract(root(), headers, MAP_VISITOR);
+    InferredProxySpan inferredProxySpan = fromContext(context);
+    assertNotNull(inferredProxySpan);
+    assertTrue(inferredProxySpan.isValid());
+
+    // Should still be valid without resourcePath (backwards compatibility)
+  }
+
+  @Test
+  @DisplayName("Should extract x-dd-proxy-resource-path for aws-httpapi")
+  void testResourcePathHeaderExtractionForAwsHttpApi() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_SYSTEM_KEY, "aws-httpapi");
+    headers.put(PROXY_REQUEST_TIME_MS_KEY, "12345");
+    headers.put(PROXY_PATH_KEY, "/v2/items/abc-123");
+    headers.put(PROXY_RESOURCE_PATH_KEY, "/v2/items/{itemId}");
+    headers.put(PROXY_HTTP_METHOD_KEY, "POST");
+    headers.put(PROXY_DOMAIN_NAME_KEY, "httpapi.example.com");
+
+    Context context = this.propagator.extract(root(), headers, MAP_VISITOR);
+    InferredProxySpan inferredProxySpan = fromContext(context);
+    assertNotNull(inferredProxySpan);
+    assertTrue(inferredProxySpan.isValid());
+
+    // aws-httpapi should also support resourcePath extraction
+  }
+
   @ParametersAreNonnullByDefault
   private static class MapVisitor implements CarrierVisitor<Map<String, String>> {
     @Override
diff --git a/internal-api/src/main/java/datadog/trace/api/gateway/InferredProxySpan.java b/internal-api/src/main/java/datadog/trace/api/gateway/InferredProxySpan.java
index 32431a34b38..2174743198e 100644
--- a/internal-api/src/main/java/datadog/trace/api/gateway/InferredProxySpan.java
+++ b/internal-api/src/main/java/datadog/trace/api/gateway/InferredProxySpan.java
@@ -7,6 +7,8 @@
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_METHOD;
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_ROUTE;
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_URL;
+import static datadog.trace.bootstrap.instrumentation.api.Tags.SPAN_KIND;
+import static datadog.trace.bootstrap.instrumentation.api.Tags.SPAN_KIND_SERVER;
 
 import datadog.context.Context;
 import datadog.context.ContextKey;
@@ -25,15 +27,21 @@ public class InferredProxySpan implements ImplicitContextKeyed {
   static final String PROXY_SYSTEM = "x-dd-proxy";
   static final String PROXY_START_TIME_MS = "x-dd-proxy-request-time-ms";
   static final String PROXY_PATH = "x-dd-proxy-path";
+  static final String PROXY_RESOURCE_PATH = "x-dd-proxy-resource-path";
   static final String PROXY_HTTP_METHOD = "x-dd-proxy-httpmethod";
   static final String PROXY_DOMAIN_NAME = "x-dd-proxy-domain-name";
   static final String STAGE = "x-dd-proxy-stage";
+  // Optional tags
+  static final String PROXY_ACCOUNT_ID = "x-dd-proxy-account-id";
+  static final String PROXY_API_ID = "x-dd-proxy-api-id";
+  static final String PROXY_REGION = "x-dd-proxy-region";
   static final Map<String, String> SUPPORTED_PROXIES;
   static final String INSTRUMENTATION_NAME = "inferred_proxy";
 
   static {
     SUPPORTED_PROXIES = new HashMap<>();
     SUPPORTED_PROXIES.put("aws-apigateway", "aws.apigateway");
+    SUPPORTED_PROXIES.put("aws-httpapi", "aws.httpapi");
   }
 
   private final Map<String, String> headers;
@@ -75,6 +83,7 @@ public AgentSpanContext start(AgentSpanContext extracted) {
     String proxy = SUPPORTED_PROXIES.get(proxySystem);
     String httpMethod = header(PROXY_HTTP_METHOD);
     String path = header(PROXY_PATH);
+    String resourcePath = header(PROXY_RESOURCE_PATH);
     String domainName = header(PROXY_DOMAIN_NAME);
 
     AgentSpan span = AgentTracer.get().startSpan(INSTRUMENTATION_NAME, proxy, extracted, startTime);
@@ -84,30 +93,60 @@ public AgentSpanContext start(AgentSpanContext extracted) {
         domainName != null && !domainName.isEmpty() ? domainName : Config.get().getServiceName();
     span.setServiceName(serviceName);
 
-    // Component: aws-apigateway
+    // Component: aws-apigateway or aws-httpapi
     span.setTag(COMPONENT, proxySystem);
 
+    // Span kind: server
+    span.setTag(SPAN_KIND, SPAN_KIND_SERVER);
+
     // SpanType: web
     span.setTag(SPAN_TYPE, "web");
 
     // Http.method - value of x-dd-proxy-httpmethod
     span.setTag(HTTP_METHOD, httpMethod);
 
-    // Http.url - value of x-dd-proxy-domain-name + x-dd-proxy-path
-    span.setTag(HTTP_URL, domainName != null ? domainName + path : path);
+    // Http.url - https:// + x-dd-proxy-domain-name + x-dd-proxy-path
+    span.setTag(HTTP_URL, domainName != null ? "https://" + domainName + path : path);
 
-    // Http.route - value of x-dd-proxy-path
-    span.setTag(HTTP_ROUTE, path);
+    // Http.route - value of x-dd-proxy-resource-path (or x-dd-proxy-path as fallback)
+    span.setTag(HTTP_ROUTE, resourcePath != null ? resourcePath : path);
 
     // "stage" - value of x-dd-proxy-stage
     span.setTag("stage", header(STAGE));
 
+    // Optional tags - only set if present
+    String accountId = header(PROXY_ACCOUNT_ID);
+    if (accountId != null && !accountId.isEmpty()) {
+      span.setTag("account_id", accountId);
+    }
+
+    String apiId = header(PROXY_API_ID);
+    if (apiId != null && !apiId.isEmpty()) {
+      span.setTag("apiid", apiId);
+    }
+
+    String region = header(PROXY_REGION);
+    if (region != null && !region.isEmpty()) {
+      span.setTag("region", region);
+    }
+
+    // Compute and set dd_resource_key (ARN) if we have region and apiId
+    if (region != null && !region.isEmpty() && apiId != null && !apiId.isEmpty()) {
+      String arn = computeArn(proxySystem, region, apiId);
+      if (arn != null) {
+        span.setTag("dd_resource_key", arn);
+      }
+    }
+
     // _dd.inferred_span = 1 (indicates that this is an inferred span)
     span.setTag("_dd.inferred_span", 1);
 
-    // Resource Name: value of x-dd-proxy-httpmethod + " " + value of x-dd-proxy-path
+    // Resource Name: <Method> <Route> when route available, else <Method> <Path>
+    // Prefer x-dd-proxy-resource-path (route) over x-dd-proxy-path (path)
     // Use MANUAL_INSTRUMENTATION priority to prevent TagInterceptor from overriding
-    String resourceName = httpMethod != null && path != null ? httpMethod + " " + path : null;
+    String routeOrPath = resourcePath != null ? resourcePath : path;
+    String resourceName =
+        httpMethod != null && routeOrPath != null ? httpMethod + " " + routeOrPath : null;
     if (resourceName != null) {
       span.setResourceName(resourceName, MANUAL_INSTRUMENTATION);
     }
@@ -124,13 +163,67 @@ private String header(String name) {
     return this.headers.get(name);
   }
 
+  /**
+   * Compute ARN for the API Gateway resource. Format for v1 REST:
+   * arn:aws:apigateway:{region}::/restapis/{api-id} Format for v2 HTTP:
+   * arn:aws:apigateway:{region}::/apis/{api-id}
+   */
+  private String computeArn(String proxySystem, String region, String apiId) {
+    if (proxySystem == null || region == null || apiId == null) {
+      return null;
+    }
+
+    // Assume AWS partition (could be extended to support other partitions like aws-cn, aws-us-gov)
+    String partition = "aws";
+
+    // Determine resource type based on proxy system
+    String resourceType;
+    if ("aws-apigateway".equals(proxySystem)) {
+      resourceType = "restapis"; // v1 REST API
+    } else if ("aws-httpapi".equals(proxySystem)) {
+      resourceType = "apis"; // v2 HTTP API
+    } else {
+      return null; // Unknown proxy type
+    }
+
+    return String.format("arn:%s:apigateway:%s::/%s/%s", partition, region, resourceType, apiId);
+  }
+
   public void finish() {
     if (this.span != null) {
+      // Copy AppSec tags from root span if needed (distributed tracing scenario)
+      copyAppSecTagsFromRoot();
+
       this.span.finish();
       this.span = null;
     }
   }
 
+  /**
+   * Copy AppSec tags from the root span to this inferred proxy span. This is needed when
+   * distributed tracing is active, because AppSec sets tags on the absolute root span (via
+   * setTagTop), but we need them on the inferred proxy span which may be a child of the upstream
+   * root span.
+   */
+  private void copyAppSecTagsFromRoot() {
+    AgentSpan rootSpan = this.span.getLocalRootSpan();
+
+    // If root span is different from this span (distributed tracing case)
+    if (rootSpan != null && rootSpan != this.span) {
+      // Copy _dd.appsec.enabled metric (always 1 if present)
+      Object appsecEnabled = rootSpan.getTag("_dd.appsec.enabled");
+      if (appsecEnabled != null) {
+        this.span.setMetric("_dd.appsec.enabled", 1);
+      }
+
+      // Copy _dd.appsec.json tag (AppSec events)
+      Object appsecJson = rootSpan.getTag("_dd.appsec.json");
+      if (appsecJson != null) {
+        this.span.setTag("_dd.appsec.json", appsecJson.toString());
+      }
+    }
+  }
+
   @Override
   public Context storeInto(@Nonnull Context context) {
     return context.with(CONTEXT_KEY, this);
diff --git a/internal-api/src/test/java/datadog/trace/api/gateway/InferredProxySpanTests.java b/internal-api/src/test/java/datadog/trace/api/gateway/InferredProxySpanTests.java
index 963db756de3..69645fa6ffb 100644
--- a/internal-api/src/test/java/datadog/trace/api/gateway/InferredProxySpanTests.java
+++ b/internal-api/src/test/java/datadog/trace/api/gateway/InferredProxySpanTests.java
@@ -196,4 +196,404 @@ void testFinishClearsSpan() {
     // Span should be cleared after finish, so calling finish again should be safe
     inferredProxySpan.finish();
   }
+
+  @Test
+  @DisplayName("aws-httpapi proxy type should be valid and create span")
+  void testAwsHttpApiProxyType() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-httpapi");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/test");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertTrue(inferredProxySpan.isValid(), "aws-httpapi should be a valid proxy system");
+    assertNotNull(inferredProxySpan.start(null), "aws-httpapi should create a span");
+    inferredProxySpan.finish();
+  }
+
+  @ParameterizedTest(name = "Proxy system: {0}")
+  @DisplayName("Both v1 and v2 proxy systems should be supported")
+  @MethodSource("supportedProxySystems")
+  void testSupportedProxySystems(String proxySystem, String expectedSpanName) {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, proxySystem);
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertTrue(inferredProxySpan.isValid(), proxySystem + " should be valid");
+    assertNotNull(inferredProxySpan.start(null), proxySystem + " should create span");
+    inferredProxySpan.finish();
+  }
+
+  static Stream<Arguments> supportedProxySystems() {
+    return Stream.of(of("aws-apigateway", "aws.apigateway"), of("aws-httpapi", "aws.httpapi"));
+  }
+
+  @Test
+  @DisplayName("Inferred proxy span should have span.kind=server tag")
+  void testSpanKindServerTag() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/test");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("aws-httpapi span should also have span.kind=server tag")
+  void testAwsHttpApiSpanKindServerTag() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-httpapi");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/v2/resource");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("http.url should include https:// scheme when domain name is present")
+  void testHttpUrlWithHttpsScheme() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected URL: https://api.example.com/api/users
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("http.url should be path only when domain name is null")
+  void testHttpUrlWithoutHttpsSchemeWhenNoDomain() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users");
+    // No PROXY_DOMAIN_NAME
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected URL: /api/users (no scheme, just path)
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("http.url with https scheme should work for aws-httpapi")
+  void testAwsHttpApiHttpUrlWithHttpsScheme() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-httpapi");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headers.put(InferredProxySpan.PROXY_PATH, "/v2/items");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "httpapi.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected URL: https://httpapi.example.com/v2/items
+
+    inferredProxySpan.finish();
+  }
+
+  // Task 13: Tests for http.route from resourcePath with fallback
+  @Test
+  @DisplayName("http.route should use resourcePath when x-dd-proxy-resource-path is present")
+  void testHttpRouteFromResourcePath() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users/123");
+    headers.put(InferredProxySpan.PROXY_RESOURCE_PATH, "/api/users/{id}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected http.route: /api/users/{id} (from resourcePath)
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("http.route should fallback to path when x-dd-proxy-resource-path is not present")
+  void testHttpRouteFallbackToPath() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users/123");
+    // No PROXY_RESOURCE_PATH
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected http.route: /api/users/123 (fallback to path for backwards compat)
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("http.route should use resourcePath for aws-httpapi")
+  void testAwsHttpApiHttpRouteFromResourcePath() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-httpapi");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headers.put(InferredProxySpan.PROXY_PATH, "/v2/items/abc-123");
+    headers.put(InferredProxySpan.PROXY_RESOURCE_PATH, "/v2/items/{itemId}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "httpapi.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected http.route: /v2/items/{itemId}
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("resource.name should prefer route when resourcePath is present")
+  void testResourceNamePrefersRoute() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users/123");
+    headers.put(InferredProxySpan.PROXY_RESOURCE_PATH, "/api/users/{id}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected resource.name: "GET /api/users/{id}" (uses route from resourcePath)
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("resource.name should use path when resourcePath is not present")
+  void testResourceNameFallbackToPath() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users/123");
+    // No PROXY_RESOURCE_PATH
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected resource.name: "GET /api/users/123" (uses path)
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("resource.name should prefer route for POST requests")
+  void testResourceNamePrefersRouteForPost() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-httpapi");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headers.put(InferredProxySpan.PROXY_PATH, "/v2/orders/order-456");
+    headers.put(InferredProxySpan.PROXY_RESOURCE_PATH, "/v2/orders/{orderId}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected resource.name: "POST /v2/orders/{orderId}"
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("resource.name should handle complex route patterns")
+  void testResourceNameWithComplexRoute() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "PUT");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/v1/users/123/posts/456/comments/789");
+    headers.put(
+        InferredProxySpan.PROXY_RESOURCE_PATH,
+        "/api/v1/users/{userId}/posts/{postId}/comments/{commentId}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected resource.name: "PUT /api/v1/users/{userId}/posts/{postId}/comments/{commentId}"
+
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("resource.name should be null when both httpMethod and path are null")
+  void testResourceNameNullWhenBothNull() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    // No PROXY_HTTP_METHOD and no PROXY_PATH
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Expected resource.name: null
+
+    inferredProxySpan.finish();
+  }
+
+  // Note: These tests verify the copyAppSecTagsFromRoot() logic exists and doesn't crash.
+  // Full integration testing of AppSec tag propagation requires the actual tracer
+  // infrastructure and is better suited for integration tests.
+
+  @Test
+  @DisplayName("InferredProxySpan finish should not crash when no AppSec tags present")
+  void testFinishWithoutAppSecTags() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/test");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // finish() should execute copyAppSecTagsFromRoot() without errors
+    // even when no AppSec tags are present
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("InferredProxySpan finish should handle null root span gracefully")
+  void testFinishWithNullRootSpan() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/test");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // finish() should handle the case where getLocalRootSpan() might return null
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("InferredProxySpan finish should work for both v1 and v2 proxy types")
+  void testFinishWithDifferentProxyTypes() {
+    // Test with aws-apigateway (v1)
+    Map<String, String> headersV1 = new HashMap<>();
+    headersV1.put(PROXY_START_TIME_MS, "12345");
+    headersV1.put(PROXY_SYSTEM, "aws-apigateway");
+    headersV1.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headersV1.put(InferredProxySpan.PROXY_PATH, "/v1/test");
+
+    InferredProxySpan proxySpanV1 = fromHeaders(headersV1);
+    assertNotNull(proxySpanV1.start(null));
+    proxySpanV1.finish();
+
+    // Test with aws-httpapi (v2)
+    Map<String, String> headersV2 = new HashMap<>();
+    headersV2.put(PROXY_START_TIME_MS, "12345");
+    headersV2.put(PROXY_SYSTEM, "aws-httpapi");
+    headersV2.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headersV2.put(InferredProxySpan.PROXY_PATH, "/v2/test");
+
+    InferredProxySpan proxySpanV2 = fromHeaders(headersV2);
+    assertNotNull(proxySpanV2.start(null));
+    proxySpanV2.finish();
+  }
+
+  @Test
+  @DisplayName("InferredProxySpan finish should be idempotent")
+  void testFinishIsIdempotent() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/test");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // Call finish multiple times - should not crash
+    inferredProxySpan.finish();
+    inferredProxySpan.finish();
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("InferredProxySpan with all headers should finish successfully")
+  void testFinishWithAllHeaders() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(PROXY_START_TIME_MS, "12345");
+    headers.put(PROXY_SYSTEM, "aws-apigateway");
+    headers.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers.put(InferredProxySpan.PROXY_PATH, "/api/users/123");
+    headers.put(InferredProxySpan.PROXY_RESOURCE_PATH, "/api/users/{id}");
+    headers.put(InferredProxySpan.PROXY_DOMAIN_NAME, "api.example.com");
+    headers.put(InferredProxySpan.STAGE, "prod");
+
+    InferredProxySpan inferredProxySpan = fromHeaders(headers);
+    assertNotNull(inferredProxySpan.start(null));
+
+    // With all headers present, finish should work correctly
+    inferredProxySpan.finish();
+  }
+
+  @Test
+  @DisplayName("Multiple InferredProxySpan instances should finish independently")
+  void testMultipleProxySpansFinishIndependently() {
+    // Create first proxy span
+    Map<String, String> headers1 = new HashMap<>();
+    headers1.put(PROXY_START_TIME_MS, "12345");
+    headers1.put(PROXY_SYSTEM, "aws-apigateway");
+    headers1.put(InferredProxySpan.PROXY_HTTP_METHOD, "GET");
+    headers1.put(InferredProxySpan.PROXY_PATH, "/test1");
+
+    InferredProxySpan proxySpan1 = fromHeaders(headers1);
+    assertNotNull(proxySpan1.start(null));
+
+    // Create second proxy span
+    Map<String, String> headers2 = new HashMap<>();
+    headers2.put(PROXY_START_TIME_MS, "12346");
+    headers2.put(PROXY_SYSTEM, "aws-httpapi");
+    headers2.put(InferredProxySpan.PROXY_HTTP_METHOD, "POST");
+    headers2.put(InferredProxySpan.PROXY_PATH, "/test2");
+
+    InferredProxySpan proxySpan2 = fromHeaders(headers2);
+    assertNotNull(proxySpan2.start(null));
+
+    // Finish both - should work independently
+    proxySpan1.finish();
+    proxySpan2.finish();
+  }
 }