comments

Signed-off-by: sezen.leblay <[email protected]>

Author: sezen-datadog

dd-trace-core/src/main/java/datadog/trace/common/metrics/MetricKey.java

@@ -61,8 +61,8 @@ public MetricKey(
             + 29791 * this.operationName.hashCode()
             + 961 * this.type.hashCode()
             + 31 * httpStatusCode
-            + 29 * this.httpMethod.hashCode()
-            + 27 * this.httpEndpoint.hashCode()
+            + -1796951359 * this.httpMethod.hashCode()
+            + 129082719 * this.httpEndpoint.hashCode()
             + (this.synthetics ? 1 : 0);
   }
 

dd-trace-core/src/main/java/datadog/trace/core/DDSpan.java

@@ -150,11 +150,6 @@ private void finishAndAddToTrace(final long durationNano) {
       setLongRunningVersion(-this.longRunningVersion);
       this.metrics.onSpanFinished();
 
-      // Apply HTTP endpoint tagging for HTTP server spans before publishing
-      // This ensures endpoint tagging is applied when all tags are available
-      datadog.trace.common.metrics.HttpEndpointTagging.setEndpointTag(
-          context, datadog.trace.api.Config.get());
-
       TraceCollector.PublishState publishState = context.getTraceCollector().onPublish(this);
       log.debug("Finished span ({}): {}", publishState, this);
     } else {

dd-trace-core/src/main/java/datadog/trace/core/tagprocessor/HttpEndpointPostProcessor.java

@@ -0,0 +1,30 @@
+package datadog.trace.core.tagprocessor;
+
+import datadog.trace.api.Config;
+import datadog.trace.api.TagMap;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpanLink;
+import datadog.trace.core.DDSpanContext;
+import java.util.List;
+
+/**
+ * TagsPostProcessor that applies HTTP endpoint tagging logic to spans. This processor computes and
+ * sets the http.endpoint tag based on http.route and http.url tags when appropriate.
+ */
+public final class HttpEndpointPostProcessor extends TagsPostProcessor {
+  private final Config config;
+
+  public HttpEndpointPostProcessor() {
+    this(Config.get());
+  }
+
+  // Visible for testing
+  HttpEndpointPostProcessor(Config config) {
+    this.config = config;
+  }
+
+  @Override
+  public void processTags(
+      TagMap unsafeTags, DDSpanContext spanContext, List<AgentSpanLink> spanLinks) {
+    HttpEndpointTagging.setEndpointTag(spanContext, config);
+  }
+}

dd-trace-core/src/main/java/datadog/trace/common/metrics/HttpEndpointTagging.java renamed to dd-trace-core/src/main/java/datadog/trace/core/tagprocessor/HttpEndpointTagging.java

@@ -1,19 +1,22 @@
-package datadog.trace.common.metrics;
+package datadog.trace.core.tagprocessor;
 
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_ENDPOINT;
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_ROUTE;
 import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_URL;
 
+import datadog.trace.api.Config;
 import datadog.trace.core.CoreSpan;
+import datadog.trace.core.DDSpanContext;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * Utility class for HTTP endpoint tagging logic. Handles route eligibility checks and URL path
- * parameterization for trace metrics.
+ * parameterization for spans.
  *
  * <p>This implementation ensures: 1. Only applies to HTTP service entry spans (server spans) 2.
  * Limits cardinality through URL path parameterization 3. Uses http.route when available and
@@ -48,12 +51,16 @@ private HttpEndpointTagging() {
    * @return true if route is eligible, false otherwise
    */
   public static boolean isRouteEligible(String route) {
-    if (route == null || route.trim().isEmpty()) {
+    if (route == null) {
       return false;
     }
 
     route = route.trim();
 
+    if (route.isEmpty()) {
+      return false;
+    }
+
     // Route must start with / to be a valid path
     if (!route.startsWith("/")) {
       return false;
@@ -64,11 +71,6 @@ public static boolean isRouteEligible(String route) {
       return false;
     }
 
-    // Reject routes that are just wildcards
-    if (route.matches("^[*/]+$")) {
-      return false;
-    }
-
     // Route is eligible for endpoint tagging
     return true;
   }
@@ -145,11 +147,16 @@ public static String parameterizeUrlPath(String path) {
    * @return parameterized endpoint path or '/'
    */
   public static String computeEndpointFromUrl(String url) {
-    if (url == null || url.trim().isEmpty()) {
+    if (url == null) {
       return "/";
     }
 
-    java.util.regex.Matcher matcher = URL_PATTERN.matcher(url.trim());
+    url = url.trim();
+    if (url.isEmpty()) {
+      return "/";
+    }
+
+    Matcher matcher = URL_PATTERN.matcher(url);
     if (!matcher.matches()) {
       log.debug("Failed to parse URL for endpoint computation: {}", url);
       return "/";
@@ -193,29 +200,22 @@ public static void setEndpointTag(CoreSpan<?> span) {
 
   /**
    * Sets the HTTP endpoint tag on a span context based on configuration flags. This overload
-   * accepts DDSpanContext for use in TagInterceptor and other core components.
+   * accepts DDSpanContext for use in tag post-processors and other core components.
    *
    * @param spanContext The span context to potentially tag
    * @param config The tracer configuration containing feature flags
    */
-  public static void setEndpointTag(
-      datadog.trace.core.DDSpanContext spanContext, datadog.trace.api.Config config) {
+  public static void setEndpointTag(DDSpanContext spanContext, Config config) {
     if (!config.isResourceRenamingEnabled()) {
       return;
     }
 
     Object route = spanContext.unsafeGetTag(HTTP_ROUTE);
-    boolean shouldUseRoute = false;
 
     // Check if we should use route (when not forcing simplified endpoints)
     if (!config.isResourceRenamingAlwaysSimplifiedEndpoint()
         && route != null
         && isRouteEligible(route.toString())) {
-      shouldUseRoute = true;
-    }
-
-    // If we should use route and not set endpoint tag, return early
-    if (shouldUseRoute) {
       return;
     }
 
@@ -236,23 +236,17 @@ && isRouteEligible(route.toString())) {
    * @param span The span to potentially tag
    * @param config The tracer configuration containing feature flags
    */
-  public static void setEndpointTag(CoreSpan<?> span, datadog.trace.api.Config config) {
+  public static void setEndpointTag(CoreSpan<?> span, Config config) {
     if (!config.isResourceRenamingEnabled()) {
       return;
     }
 
     Object route = span.getTag(HTTP_ROUTE);
-    boolean shouldUseRoute = false;
 
     // Check if we should use route (when not forcing simplified endpoints)
     if (!config.isResourceRenamingAlwaysSimplifiedEndpoint()
         && route != null
         && isRouteEligible(route.toString())) {
-      shouldUseRoute = true;
-    }
-
-    // If we should use route and not set endpoint tag, return early
-    if (shouldUseRoute) {
       return;
     }
 

dd-trace-core/src/main/java/datadog/trace/core/tagprocessor/TagsPostProcessorFactory.java

@@ -13,8 +13,9 @@ private static class Lazy {
     private static TagsPostProcessor lazyProcessor = createLazyChain();
 
     private static TagsPostProcessor createEagerChain() {
-      final List<TagsPostProcessor> processors = new ArrayList<>(2);
+      final List<TagsPostProcessor> processors = new ArrayList<>(3);
       processors.add(new PeerServiceCalculator());
+      processors.add(new HttpEndpointPostProcessor());
       if (addBaseService) {
         processors.add(new BaseServiceAdder(Config.get().getServiceName()));
       }

dd-trace-core/src/test/groovy/datadog/trace/common/metrics/HttpEndpointTaggingIntegrationTest.groovy

@@ -1,5 +1,6 @@
 package datadog.trace.common.metrics
 
+import datadog.trace.core.tagprocessor.HttpEndpointTagging
 import datadog.trace.test.util.DDSpecification
 
 class HttpEndpointTaggingIntegrationTest extends DDSpecification {

dd-trace-core/src/test/groovy/datadog/trace/common/metrics/HttpEndpointTaggingTest.groovy renamed to dd-trace-core/src/test/groovy/datadog/trace/core/tagprocessor/HttpEndpointTaggingTest.groovy

@@ -1,4 +1,4 @@
-package datadog.trace.common.metrics
+package datadog.trace.core.tagprocessor
 
 import datadog.trace.test.util.DDSpecification