4

Author: anna-git

include/datadog/config.h

@@ -62,18 +62,13 @@ struct ConfigMetadata {
       : name(n), value(std::move(v)), origin(orig), error(std::move(err)) {}
 };
 
-// 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.
-// 
+// Return the chosen configuration value, in order of precedence: `from_env`, 
+// `from_user`, and `fallback`.
 // 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).
+// metadata[config_name] using the stringified value, with all values found, from lowest to highest precedence.
+// Returns the chosen value directly.
 // 
-// The fallback parameter accepts both raw values (e.g., true, 42, "hello") 
-// and Optional<Value>. It defaults to nullptr (converted to nullopt internally).
+// The fallback parameter is optional and defaults to nullptr.
 template <typename Value, typename Stringifier = std::nullptr_t, typename DefaultValue = std::nullptr_t>
 Value pick(
     const Optional<Value>& from_env, const Optional<Value>& from_user,
@@ -104,10 +99,9 @@ Value pick(
       chosen_value = val;
     };
 
-    // Add DEFAULT entry if fallback was provided (known at compile time)
+    // Add DEFAULT entry if fallback was provided (detected by type)
     if constexpr (!std::is_same_v<DefaultValue, std::nullptr_t>) {
-        Value fallback_value = fallback;  // Implicit conversion for raw values
-        add_entry(ConfigMetadata::Origin::DEFAULT, fallback_value);
+        add_entry(ConfigMetadata::Origin::DEFAULT, fallback);
     }
 
     if (from_user) {
@@ -119,33 +113,30 @@ Value pick(
     }
 
     (*telemetry_configs)[config_name] = std::move(telemetry_entries);
-    (*metadata)[config_name] = (*telemetry_configs)[config_name].back();
+    if (!telemetry_entries.empty()) {
+      (*metadata)[config_name] = (*telemetry_configs)[config_name].back();
+    }
 
     return chosen_value.value_or(Value{});
   }
-  
-// Overload without telemetry - returns a pair for backward compatibility
-// with std::tie usage pattern (used in telemetry/configuration.cpp).
-template <typename Value, typename DefaultValue = Value>
-std::pair<ConfigMetadata::Origin, Value> pick(
-    const Optional<Value>& from_env, 
-    const Optional<Value>& from_user,
-    DefaultValue fallback = DefaultValue{}) {
-      
-    ConfigMetadata::Origin chosen_origin = ConfigMetadata::Origin::DEFAULT;
-    Value chosen_value = Value(fallback);
-
-    if (from_user) {
-        chosen_origin = ConfigMetadata::Origin::CODE;
-        chosen_value = *from_user;
-    }
-
-    if (from_env) {
-        chosen_origin = ConfigMetadata::Origin::ENVIRONMENT_VARIABLE;
-        chosen_value = *from_env;
-    }
 
-    return {chosen_origin, chosen_value};
+  
+// Return a pair containing the configuration origin and value of a
+// configuration value chosen from one of the specified `from_env`,
+// `from_config`, and `fallback`. This function defines the relative precedence
+// among configuration values originating from the environment, programmatic
+// configuration, and default configuration.
+template <typename Value, typename DefaultValue>
+std::pair<ConfigMetadata::Origin, Value> pick(const Optional<Value> &from_env,
+                                              const Optional<Value> &from_user,
+                                              DefaultValue fallback) {
+  if (from_env) {
+    return {ConfigMetadata::Origin::ENVIRONMENT_VARIABLE, *from_env};
+  } else if (from_user) {
+    return {ConfigMetadata::Origin::CODE, *from_user};
   }
+  return {ConfigMetadata::Origin::DEFAULT, fallback};
+}
+  
 }  // namespace tracing
 }  // namespace datadog

src/datadog/tracer_config.cpp

@@ -290,7 +290,7 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig& user_config,
   final_config.defaults.service =
       pick(env_config->service, user_config.service,
            &telemetry_configs, &final_config.metadata, ConfigName::SERVICE_NAME,
-           Optional<std::string>(get_process_name()));
+           get_process_name());
 
   // Service type
   final_config.defaults.service_type =
@@ -387,14 +387,14 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig& user_config,
       pick(env_config->baggage_max_items, user_config.baggage_max_items,
            &telemetry_configs, &final_config.metadata,
            ConfigName::TRACE_BAGGAGE_MAX_ITEMS,
-           64, [](const int& i) { return std::to_string(i); });
+           64UL, [](const int& i) { return std::to_string(i); });
 
   // Baggage - max bytes
   final_config.baggage_opts.max_bytes =
       pick(env_config->baggage_max_bytes, user_config.baggage_max_bytes,
            &telemetry_configs, &final_config.metadata,
            ConfigName::TRACE_BAGGAGE_MAX_BYTES,
-           8192, [](const int& i) { return std::to_string(i); });
+           8192UL, [](const int& i) { return std::to_string(i); });
 
   if (final_config.baggage_opts.max_items <= 0 ||
       final_config.baggage_opts.max_bytes < 3) {