changes telemetry

Author: anna-git

.gitignore

@@ -9,3 +9,6 @@ dist/
 out/
 MODULE.bazel.lock
 .vscode
+.cache/
+.cursor/
+.DS_Store

compile_commands.json

@@ -0,0 +1 @@
+/Users/anna.yafi/go/src/github.com/DataDog/dd-trace-cpp/out/build/local-curl/compile_commands.json

include/datadog/config.h

@@ -1,5 +1,12 @@
 #pragma once
 
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
 #include "error.h"
 #include "optional.h"
 
@@ -56,26 +63,98 @@ struct ConfigMetadata {
       : name(n), value(std::move(v)), origin(orig), error(std::move(err)) {}
 };
 
-// Return a vector containing the configuration values chosen from one of the 
-// specified `from_env`, `from_user`, and `fallback`. This function defines 
-// the relative precedence among configuration values, from lower to higher, 
-// originating from the default configuration, programmatic configuration, 
-// and environment.
-template <typename Value, typename DefaultValue>
-std::vector<std::pair<ConfigMetadata::Origin, Value>> pick(
+// Return the chosen configuration value from one of the specified `from_env`, 
+// `from_user`, and `fallback`. This function defines the relative precedence 
+// among configuration values, from lower to higher, originating from the 
+// default configuration, programmatic configuration, and environment.
+// 
+// This overload directly populates both telemetry_configs[config_name] and
+// metadata[config_name] using the stringified value, avoiding duplicate
+// string computations. Both telemetry_configs and config_name are required.
+// Returns the chosen value directly (no origin needed since it's in metadata).
+template <typename Value, typename DefaultValue, typename Stringifier = std::nullptr_t>
+Value pick(
     const Optional<Value>& from_env, const Optional<Value>& from_user,
-    DefaultValue fallback) {
-  std::vector<std::pair<ConfigMetadata::Origin, Value>> result;
-  result.emplace_back(ConfigMetadata::Origin::DEFAULT, fallback);
-
-  if (from_user) {
-    result.emplace_back(ConfigMetadata::Origin::CODE, *from_user);
-  }
-  if (from_env) {
-    result.emplace_back(ConfigMetadata::Origin::ENVIRONMENT_VARIABLE,
-                        *from_env);
-  }
-  return result;
+    DefaultValue fallback,
+    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>* telemetry_configs,
+    std::unordered_map<ConfigName, ConfigMetadata>* metadata,
+    ConfigName config_name,
+    Stringifier to_string_fn = nullptr) {
+      
+    auto stringify = [&](const Value& v) -> std::string {
+      if constexpr (!std::is_same_v<Stringifier, std::nullptr_t>) {
+        return to_string_fn(v);     // use provided function
+      } else if constexpr (std::is_constructible_v<std::string, Value>) {
+        return std::string(v);       // default behaviour (works for string-like types)
+      } else {
+        static_assert(!std::is_same_v<Value, Value>, 
+                      "Non-string types require a stringifier function");
+        return "";  // unreachable
+      }
+    };
+      
+    std::vector<ConfigMetadata> telemetry_entries;
+    Value chosen_value = fallback;
+    
+    auto add_entry = [&](ConfigMetadata::Origin origin, const Value& val) {
+      std::string val_str = stringify(val);
+      telemetry_entries.emplace_back(ConfigMetadata{config_name, val_str, origin});
+      chosen_value = val;
+    };
+    
+    add_entry(ConfigMetadata::Origin::DEFAULT, fallback);
+
+    if (from_user) {
+        add_entry(ConfigMetadata::Origin::CODE, *from_user);
+    }
+
+    if (from_env) {
+        add_entry(ConfigMetadata::Origin::ENVIRONMENT_VARIABLE, *from_env);
+    }
+
+    (*telemetry_configs)[config_name] = std::move(telemetry_entries);
+    (*metadata)[config_name] = (*telemetry_configs)[config_name].back();
+
+    return chosen_value;
+}
+
+// Overload without telemetry - for simpler use cases where telemetry 
+// population is not needed.
+template <typename Value, typename DefaultValue, typename Stringifier = std::nullptr_t>
+std::vector<std::tuple<ConfigMetadata::Origin, Value, std::string>> pick(
+    const Optional<Value>& from_env, const Optional<Value>& from_user,
+    DefaultValue fallback, Stringifier to_string_fn = nullptr) {
+      
+    auto stringify = [&](const Value& v) -> std::string {
+      if constexpr (!std::is_same_v<Stringifier, std::nullptr_t>) {
+        return to_string_fn(v);     // use provided function
+      } else if constexpr (std::is_constructible_v<std::string, Value>) {
+        return std::string(v);       // default behaviour (works for string-like types)
+      } else {
+        static_assert(!std::is_same_v<Value, Value>, 
+                      "Non-string types require a stringifier function");
+        return "";  // unreachable
+      }
+    };
+      
+    std::vector<std::tuple<ConfigMetadata::Origin, Value, std::string>> result;
+    
+    auto add_entry = [&](ConfigMetadata::Origin origin, const Value& val) {
+      std::string val_str = stringify(val);
+      result.emplace_back(origin, val, val_str);
+    };
+    
+    add_entry(ConfigMetadata::Origin::DEFAULT, fallback);
+
+    if (from_user) {
+        add_entry(ConfigMetadata::Origin::CODE, *from_user);
+    }
+
+    if (from_env) {
+        add_entry(ConfigMetadata::Origin::ENVIRONMENT_VARIABLE, *from_env);
+    }
+
+    return result;
 }
 
 }  // namespace tracing

src/datadog/trace_sampler_config.cpp

@@ -225,10 +225,10 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
     result.rules.emplace_back(std::move(finalized_rule));
   }
 
-  const auto [origin, max_per_second] =
+  const auto [origin, max_per_second, max_per_second_string] =
       pick(env_config->max_per_second, config.max_per_second, 100).back();
   result.metadata[ConfigName::TRACE_SAMPLING_LIMIT] = ConfigMetadata(
-      ConfigName::TRACE_SAMPLING_LIMIT, std::to_string(max_per_second), origin);
+      ConfigName::TRACE_SAMPLING_LIMIT, max_per_second_string, origin);
 
   const auto allowed_types = {FP_NORMAL, FP_SUBNORMAL};
   if (!(max_per_second > 0) ||