Address review comments; preserve final /

Author: cataphract

BUILD.bazel

@@ -17,7 +17,7 @@ cc_library(
       "src/datadog/datadog_agent_config.cpp",
       "src/datadog/datadog_agent.cpp",
       "src/datadog/default_http_client_null.cpp",
-      "src/datadog/endpoint_guessing.cpp",
+      "src/datadog/endpoint_inferral.cpp",
       "src/datadog/environment.cpp",
       "src/datadog/error.cpp",
       "src/datadog/extraction_util.cpp",
@@ -61,7 +61,7 @@ cc_library(
       "src/datadog/datadog_agent.h",
       "src/datadog/default_http_client.h",
       "src/datadog/extracted_data.h",
-      "src/datadog/endpoint_guessing.h",
+      "src/datadog/endpoint_inferral.h",
       "src/datadog/extraction_util.h",
       "src/datadog/glob.h",
       "src/datadog/hex.h",
@@ -99,6 +99,7 @@ cc_library(
       "include/datadog/event_scheduler.h",
       "include/datadog/expected.h",
       "include/datadog/http_client.h",
+      "include/datadog/http_endpoint_calculation_mode.h",
       "include/datadog/id_generator.h",
       "include/datadog/injection_options.h",
       "include/datadog/logger.h",

CMakeLists.txt

@@ -173,7 +173,7 @@ target_sources(dd-trace-cpp-objects
     src/datadog/collector_response.cpp
     src/datadog/datadog_agent_config.cpp
     src/datadog/datadog_agent.cpp
-    src/datadog/endpoint_guessing.cpp
+    src/datadog/endpoint_inferral.cpp
     src/datadog/environment.cpp
     src/datadog/error.cpp
     src/datadog/extraction_util.cpp

include/datadog/http_client.h

@@ -26,6 +26,7 @@ class HTTPClient {
     std::string scheme;     // http, https, or unix
     std::string authority;  // domain:port or /path/to/socket
     std::string path;       // resource, e.g. /v0.4/traces
+    std::string query;      // query string without '?'
 
     static Expected<HTTPClient::URL> parse(StringView input);
   };

include/datadog/http_endpoint_calculation_mode.h

@@ -0,0 +1,34 @@
+#pragma once
+
+// This component provides an enumeration that controls how the http.endpoint
+// tag is calculated for HTTP spans.
+
+#include <cstdint>
+
+namespace datadog {
+namespace tracing {
+
+// `HttpEndpointCalculationMode` determines when and how the http.endpoint tag
+// is inferred from http.url for HTTP spans.
+//
+// The http.endpoint tag provides a normalized, parameterized version of the
+// HTTP path (e.g., "/users/{param:int}" instead of "/users/123"). This helps
+// aggregate similar requests and reduce cardinality in monitoring systems.
+enum class HttpEndpointCalculationMode : std::uint8_t {
+  // Do not calculate http.endpoint. The tag will not be set unless explicitly
+  // provided by the user.
+  DISABLED,
+
+  // Calculate http.endpoint from http.url only when http.route is not present.
+  // This mode acts as a fallback - if instrumentation provides http.route,
+  // use that; otherwise, infer http.endpoint from the URL path.
+  FALLBACK,
+
+  // Always calculate http.endpoint from http.url, even when http.route is
+  // present. Both tags will be set, allowing for comparison between
+  // user-provided routes and automatically inferred endpoints.
+  ALWAYS_CALCULATE,
+};
+
+}  // namespace tracing
+}  // namespace datadog

include/datadog/trace_segment.h

@@ -80,7 +80,7 @@ class TraceSegment {
 
   std::shared_ptr<ConfigManager> config_manager_;
 
-  ResourceRenamingMode resource_renaming_mode_;
+  HttpEndpointCalculationMode resource_renaming_mode_;
 
   bool tracing_enabled_;
 
@@ -100,7 +100,7 @@ class TraceSegment {
                Optional<std::string> additional_w3c_tracestate,
                Optional<std::string> additional_datadog_w3c_tracestate,
                std::unique_ptr<SpanData> local_root,
-               ResourceRenamingMode resource_renaming_mode,
+               HttpEndpointCalculationMode resource_renaming_mode,
                bool tracing_enabled = true);
 
   const SpanDefaults& defaults() const;

include/datadog/tracer.h

@@ -55,7 +55,7 @@ class Tracer {
   bool baggage_injection_enabled_;
   bool baggage_extraction_enabled_;
   bool tracing_enabled_;
-  ResourceRenamingMode resource_renaming_mode_;
+  HttpEndpointCalculationMode resource_renaming_mode_;
 
  public:
   // Create a tracer configured using the specified `config`, and optionally:

include/datadog/tracer_config.h

@@ -15,6 +15,7 @@
 #include "clock.h"
 #include "datadog_agent_config.h"
 #include "expected.h"
+#include "http_endpoint_calculation_mode.h"
 #include "propagation_style.h"
 #include "runtime_id.h"
 #include "span_defaults.h"
@@ -189,12 +190,6 @@ struct TracerConfig {
   Optional<bool> resource_renaming_always_simplified_endpoint;
 };
 
-enum class ResourceRenamingMode : std::uint8_t {
-  DISABLED,
-  FALLBACK,  // only if http.route is not present
-  ALWAYS_CALCULATE,
-};
-
 // `FinalizedTracerConfig` contains `Tracer` implementation details derived from
 // a valid `TracerConfig` and accompanying environment.
 // `FinalizedTracerConfig` must be obtained by calling `finalize_config`.
@@ -233,7 +228,7 @@ class FinalizedTracerConfig final {
   std::shared_ptr<EventScheduler> event_scheduler;
   std::shared_ptr<HTTPClient> http_client;
   bool tracing_enabled;
-  ResourceRenamingMode resource_renaming_mode;
+  HttpEndpointCalculationMode resource_renaming_mode;
 };
 
 // Return a `FinalizedTracerConfig` from the specified `config` and from any

src/datadog/endpoint_guessing.h

@@ -1,4 +1,4 @@
-#include "endpoint_guessing.h"
+#include "endpoint_inferral.h"
 
 #include <cstdint>
 
@@ -8,14 +8,14 @@ namespace {
 
 constexpr size_t MAX_COMPONENTS = 8;
 
-inline constexpr bool is_digit(char c) noexcept { return c >= '0' && c <= '9'; }
-inline constexpr bool is_hex_alpha(char c) noexcept {
+inline constexpr bool is_digit(char c) { return c >= '0' && c <= '9'; }
+inline constexpr bool is_hex_alpha(char c) {
   return (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 }
-inline constexpr bool is_delim(char c) noexcept {
+inline constexpr bool is_delim(char c) {
   return c == '.' || c == '_' || c == '-';
 }
-inline constexpr bool is_str_special(char c) noexcept {
+inline constexpr bool is_str_special(char c) {
   return c == '%' || c == '&' || c == '\'' || c == '(' || c == ')' ||
          c == '*' || c == '+' || c == ',' || c == ':' || c == '=' || c == '@';
 }
@@ -38,7 +38,7 @@ enum component_type : std::uint8_t {
   is_str = 1 << 4,
 };
 
-std::string_view to_string(component_type type) noexcept {
+StringView to_string(component_type type) {
   switch (type) {
     case component_type::is_int:
       return "{param:int}";
@@ -50,16 +50,17 @@ std::string_view to_string(component_type type) noexcept {
       return "{param:hex_id}";
     case component_type::is_str:
       return "{param:str}";
-    default:
+    case component_type::none:
+      // should not be reached
       return "";
   }
+  // should never reach here
+  return "";
 }
 
-inline uint8_t bool2mask(bool x) noexcept {
-  return static_cast<uint8_t>(-int{x});  // 0 -> 0x00, 1 -> 0xFF
-}
+inline uint8_t bool2mask(bool x) { return x ? 0xFF : 0x00; }
 
-component_type component_replacement(std::string_view path) noexcept {
+component_type component_replacement(StringView path) noexcept {
   // viable_components is a bitset of the component types not yet excluded
   std::uint8_t viable_components = 0x1F;  // (is_str << 1) - 1
   bool found_special_char = false;
@@ -121,31 +122,26 @@ component_type component_replacement(std::string_view path) noexcept {
 }
 }  // namespace
 
-std::string guess_endpoint(std::string_view orig_path) {
-  auto path = orig_path;
-
-  // remove the query string if any
-  auto query_pos = path.find('?');
-  if (query_pos != std::string_view::npos) {
-    path = path.substr(0, query_pos);
-  }
-
+std::string infer_endpoint(StringView path) {
+  // Expects a clean path without query string (e.g., "/api/users/123")
   if (path.empty() || path.front() != '/') {
     return "/";
   }
 
   std::string result{};
   size_t component_count = 0;
+  bool final_slash = true;
 
-  path.remove_prefix(1);
+  path.remove_prefix(1);  // drop the leading '/'
   while (!path.empty()) {
     auto slash_pos = path.find('/');
 
-    std::string_view component = path.substr(0, slash_pos);
+    StringView component = path.substr(0, slash_pos);
 
-    // remove current component from the path
-    if (slash_pos == std::string_view::npos) {
-      path = std::string_view{};
+    // remove current component from the path (for the next iteration)
+    if (slash_pos == StringView::npos) {
+      path = StringView{};
+      final_slash = false;
     } else {
       path.remove_prefix(slash_pos + 1);
     }
@@ -173,6 +169,10 @@ std::string guess_endpoint(std::string_view orig_path) {
     return "/";
   }
 
+  if (final_slash) {
+    result.append("/");
+  }
+
   return result;
 }
 

src/datadog/endpoint_guessing.cpp src/datadog/endpoint_inferral.cppsrc/datadog/endpoint_guessing.cpp renamed to src/datadog/endpoint_inferral.cpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <datadog/string_view.h>
+
+#include <string>
+
+namespace datadog::tracing {
+
+// Infer the endpoint pattern from a URL path by replacing parameters with
+// placeholders like {param:int}, {param:hex}, etc.
+//
+// The input should be a clean path without query string (e.g.,
+// "/api/users/123"). URL parsing should be handled by the caller using
+// HTTPClient::URL::parse().
+std::string infer_endpoint(StringView path);
+
+}  // namespace datadog::tracing