rename telemetry_configs to metadata and remove old metadata

Author: anna-git

include/datadog/config.h

@@ -63,11 +63,12 @@ struct ConfigMetadata {
 };
 
 // Returns the final configuration value using the following
-// precedence order: environment > user code > default, and populates two maps:
-// 1. `telemetry_configs`: Records ALL configuration sources that were provided,
-//    ordered from lowest to highest precedence.
-// 2. `metadata`: Records ONLY the winning configuration value (highest
-// precedence). Template Parameters:
+// precedence order: environment > user code > default, and populates metadata:
+// `metadata`: Records ALL configuration sources that were provided,
+//    ordered from lowest to highest precedence. The last entry has the highest
+//    precedence and is the winning value.
+//
+// Template Parameters:
 //   Value: The type of the configuration value
 //   Stringifier: Optional function type to convert Value to string
 //                (defaults to std::nullptr_t, which uses string construction)
@@ -76,10 +77,8 @@ struct ConfigMetadata {
 // Parameters:
 //   from_env: Optional value from environment variables (highest precedence)
 //   from_user: Optional value from user code (middle precedence)
-//   telemetry_configs: Output map that will be populated with all config
-//                      sources found for this config_name, in precedence order
-//   metadata: Output map that will be populated with the winning config value
-//             for this config_name
+//   metadata: Output map that will be populated with all config sources found
+//             for this config_name, in precedence order (last = highest)
 //   config_name: The configuration parameter name identifier
 //   fallback: Optional default value (lowest precedence). Pass nullptr to
 //             indicate no default.
@@ -94,9 +93,7 @@ template <typename Value, typename Stringifier = std::nullptr_t,
           typename DefaultValue = std::nullptr_t>
 Value resolve_and_record_config(
     const Optional<Value>& from_env, const Optional<Value>& from_user,
-    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>*
-        telemetry_configs,
-    std::unordered_map<ConfigName, ConfigMetadata>* metadata,
+    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>* metadata,
     ConfigName config_name, DefaultValue fallback = nullptr,
     Stringifier to_string_fn = nullptr) {
   auto stringify = [&](const Value& v) -> std::string {
@@ -111,13 +108,12 @@ Value resolve_and_record_config(
     }
   };
 
-  std::vector<ConfigMetadata> telemetry_entries;
+  std::vector<ConfigMetadata> metadata_entries;
   Optional<Value> chosen_value;
 
   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});
+    metadata_entries.emplace_back(ConfigMetadata{config_name, val_str, origin});
     chosen_value = val;
   };
 
@@ -134,9 +130,8 @@ Value resolve_and_record_config(
     add_entry(ConfigMetadata::Origin::ENVIRONMENT_VARIABLE, *from_env);
   }
 
-  (*telemetry_configs)[config_name] = std::move(telemetry_entries);
-  if (!(*telemetry_configs)[config_name].empty()) {
-    (*metadata)[config_name] = (*telemetry_configs)[config_name].back();
+  if (!metadata_entries.empty()) {
+    (*metadata)[config_name] = std::move(metadata_entries);
   }
 
   return chosen_value.value_or(Value{});

include/datadog/datadog_agent_config.h

@@ -85,7 +85,7 @@ class FinalizedDatadogAgentConfig {
   std::chrono::steady_clock::duration request_timeout;
   std::chrono::steady_clock::duration shutdown_timeout;
   std::chrono::steady_clock::duration remote_configuration_poll_interval;
-  std::unordered_map<ConfigName, ConfigMetadata> metadata;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> metadata;
 
   // Origin detection
   Optional<std::string> admission_controller_uid;

include/datadog/span_sampler_config.h

@@ -49,8 +49,7 @@ class FinalizedSpanSamplerConfig {
   };
 
   std::vector<Rule> rules;
-  std::unordered_map<ConfigName, ConfigMetadata> metadata;
-  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> telemetry_configs;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> metadata;
 };
 
 Expected<FinalizedSpanSamplerConfig> finalize_config(const SpanSamplerConfig&,

include/datadog/trace_sampler_config.h

@@ -50,8 +50,7 @@ class FinalizedTraceSamplerConfig {
  public:
   double max_per_second;
   std::vector<TraceSamplerRule> rules;
-  std::unordered_map<ConfigName, ConfigMetadata> metadata;
-  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> telemetry_configs;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> metadata;
 
  public:
   /// Returns the trace sampler configuration when APM Tracing is disabled.

include/datadog/tracer_config.h

@@ -229,7 +229,7 @@ class FinalizedTracerConfig final {
   std::string integration_name;
   std::string integration_version;
   bool report_traces;
-  std::unordered_map<ConfigName, ConfigMetadata> metadata;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> metadata;
   Baggage::Options baggage_opts;
   HTTPClient::URL agent_url;
   std::shared_ptr<EventScheduler> event_scheduler;

src/datadog/config_manager.cpp

@@ -287,12 +287,18 @@ namespace rc = datadog::remote_config;
 
 ConfigManager::ConfigManager(const FinalizedTracerConfig& config)
     : clock_(config.clock),
-      default_metadata_(config.metadata),
       trace_sampler_(
           std::make_shared<TraceSampler>(config.trace_sampler, clock_)),
       rules_(config.trace_sampler.rules),
       span_defaults_(std::make_shared<SpanDefaults>(config.defaults)),
-      report_traces_(config.report_traces) {}
+      report_traces_(config.report_traces) {
+  // Extract winning value (last entry) from each config's metadata history
+  for (const auto& [name, metadata_vec] : config.metadata) {
+    if (!metadata_vec.empty()) {
+      default_metadata_[name] = metadata_vec.back();
+    }
+  }
+}
 
 rc::Products ConfigManager::get_products() { return rc::product::APM_TRACING; }
 

src/datadog/datadog_agent_config.cpp

@@ -142,8 +142,8 @@ Expected<FinalizedDatadogAgentConfig> finalize_config(
     return std::move(*error);
   }
   result.url = *parsed_url;
-  result.metadata[ConfigName::AGENT_URL] =
-      ConfigMetadata(ConfigName::AGENT_URL, url, origin);
+  result.metadata[ConfigName::AGENT_URL] = {
+      ConfigMetadata(ConfigName::AGENT_URL, url, origin)};
 
   // Starting Datadog Agent 7.62.0, the admission controller inject a unique
   // identifier through `DD_EXTERNAL_ENV`. This uid is used for origin

src/datadog/span_sampler_config.cpp

@@ -238,9 +238,8 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
   }
 
   std::vector<SpanSamplerConfig::Rule> rules = resolve_and_record_config(
-      env_rules, user_rules, &result.telemetry_configs, &result.metadata,
-      ConfigName::SPAN_SAMPLING_RULES, nullptr,
-      [](const std::vector<SpanSamplerConfig::Rule> &r) {
+      env_rules, user_rules, &result.metadata, ConfigName::SPAN_SAMPLING_RULES,
+      nullptr, [](const std::vector<SpanSamplerConfig::Rule> &r) {
         return to_string(r);
       });
 

src/datadog/trace_sampler_config.cpp

@@ -162,14 +162,14 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
 
   if (!env_config->rules.empty()) {
     rules = std::move(env_config->rules);
-    result.metadata[ConfigName::TRACE_SAMPLING_RULES] =
+    result.metadata[ConfigName::TRACE_SAMPLING_RULES] = {
         ConfigMetadata(ConfigName::TRACE_SAMPLING_RULES, to_string(rules),
-                       ConfigMetadata::Origin::ENVIRONMENT_VARIABLE);
+                       ConfigMetadata::Origin::ENVIRONMENT_VARIABLE)};
   } else if (!config.rules.empty()) {
     rules = std::move(config.rules);
-    result.metadata[ConfigName::TRACE_SAMPLING_RULES] =
+    result.metadata[ConfigName::TRACE_SAMPLING_RULES] = {
         ConfigMetadata(ConfigName::TRACE_SAMPLING_RULES, to_string(rules),
-                       ConfigMetadata::Origin::CODE);
+                       ConfigMetadata::Origin::CODE)};
   }
 
   for (const auto &rule : rules) {
@@ -192,8 +192,8 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   }
 
   Optional<double> sample_rate = resolve_and_record_config(
-      env_config->sample_rate, config.sample_rate, &result.telemetry_configs,
-      &result.metadata, ConfigName::TRACE_SAMPLING_RATE, 1.0,
+      env_config->sample_rate, config.sample_rate, &result.metadata,
+      ConfigName::TRACE_SAMPLING_RATE, 1.0,
       [](const double &d) { return to_string(d, 1); });
 
   bool is_sample_rate_provided = env_config->sample_rate || config.sample_rate;
@@ -215,8 +215,7 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   }
 
   double max_per_second = resolve_and_record_config(
-      env_config->max_per_second, config.max_per_second,
-      &result.telemetry_configs, &result.metadata,
+      env_config->max_per_second, config.max_per_second, &result.metadata,
       ConfigName::TRACE_SAMPLING_LIMIT, 100.0,
       [](const double &d) { return std::to_string(d); });
 

src/datadog/tracer_config.cpp

@@ -284,36 +284,32 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   final_config.clock = clock;
   final_config.logger = logger;
 
-  std::unordered_map<ConfigName, std::vector<ConfigMetadata>>
-      all_sources_configs;
-
   // DD_SERVICE
   final_config.defaults.service = resolve_and_record_config(
-      env_config->service, user_config.service, &all_sources_configs,
-      &final_config.metadata, ConfigName::SERVICE_NAME, get_process_name());
+      env_config->service, user_config.service, &final_config.metadata,
+      ConfigName::SERVICE_NAME, get_process_name());
 
   // Service type
   final_config.defaults.service_type =
       value_or(env_config->service_type, user_config.service_type, "web");
 
   // DD_ENV
   final_config.defaults.environment = resolve_and_record_config(
-      env_config->environment, user_config.environment, &all_sources_configs,
-      &final_config.metadata, ConfigName::SERVICE_ENV);
+      env_config->environment, user_config.environment, &final_config.metadata,
+      ConfigName::SERVICE_ENV);
 
   // DD_VERSION
   final_config.defaults.version = resolve_and_record_config(
-      env_config->version, user_config.version, &all_sources_configs,
-      &final_config.metadata, ConfigName::SERVICE_VERSION);
+      env_config->version, user_config.version, &final_config.metadata,
+      ConfigName::SERVICE_VERSION);
 
   // Span name
   final_config.defaults.name = value_or(env_config->name, user_config.name, "");
 
   // DD_TAGS
   final_config.defaults.tags = resolve_and_record_config(
-      env_config->tags, user_config.tags, &all_sources_configs,
-      &final_config.metadata, ConfigName::TAGS,
-      std::unordered_map<std::string, std::string>{},
+      env_config->tags, user_config.tags, &final_config.metadata,
+      ConfigName::TAGS, std::unordered_map<std::string, std::string>{},
       [](const auto &tags) { return join_tags(tags); });
 
   // Extraction Styles
@@ -323,8 +319,8 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
 
   final_config.extraction_styles = resolve_and_record_config(
       env_config->extraction_styles, user_config.extraction_styles,
-      &all_sources_configs, &final_config.metadata,
-      ConfigName::EXTRACTION_STYLES, default_propagation_styles,
+      &final_config.metadata, ConfigName::EXTRACTION_STYLES,
+      default_propagation_styles,
       [](const std::vector<PropagationStyle> &styles) {
         return join_propagation_styles(styles);
       });
@@ -337,8 +333,8 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   // Injection Styles
   final_config.injection_styles = resolve_and_record_config(
       env_config->injection_styles, user_config.injection_styles,
-      &all_sources_configs, &final_config.metadata,
-      ConfigName::INJECTION_STYLES, default_propagation_styles,
+      &final_config.metadata, ConfigName::INJECTION_STYLES,
+      default_propagation_styles,
       [](const std::vector<PropagationStyle> &styles) {
         return join_propagation_styles(styles);
       });
@@ -351,14 +347,14 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   // Startup Logs
   final_config.log_on_startup = resolve_and_record_config(
       env_config->log_on_startup, user_config.log_on_startup,
-      &all_sources_configs, &final_config.metadata, ConfigName::STARTUP_LOGS,
-      true, [](const bool &b) { return to_string(b); });
+      &final_config.metadata, ConfigName::STARTUP_LOGS, true,
+      [](const bool &b) { return to_string(b); });
 
   // Report traces
   final_config.report_traces = resolve_and_record_config(
       env_config->report_traces, user_config.report_traces,
-      &all_sources_configs, &final_config.metadata, ConfigName::REPORT_TRACES,
-      true, [](const bool &b) { return to_string(b); });
+      &final_config.metadata, ConfigName::REPORT_TRACES, true,
+      [](const bool &b) { return to_string(b); });
 
   // Report hostname
   final_config.report_hostname =
@@ -371,8 +367,8 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   // 128b Trace IDs
   final_config.generate_128bit_trace_ids = resolve_and_record_config(
       env_config->generate_128bit_trace_ids,
-      user_config.generate_128bit_trace_ids, &all_sources_configs,
-      &final_config.metadata, ConfigName::GENEREATE_128BIT_TRACE_IDS, true,
+      user_config.generate_128bit_trace_ids, &final_config.metadata,
+      ConfigName::GENEREATE_128BIT_TRACE_IDS, true,
       [](const bool &b) { return to_string(b); });
 
   // Integration name & version
@@ -385,15 +381,13 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   // Baggage - max items
   final_config.baggage_opts.max_items = resolve_and_record_config(
       env_config->baggage_max_items, user_config.baggage_max_items,
-      &all_sources_configs, &final_config.metadata,
-      ConfigName::TRACE_BAGGAGE_MAX_ITEMS, 64UL,
+      &final_config.metadata, ConfigName::TRACE_BAGGAGE_MAX_ITEMS, 64UL,
       [](const size_t &i) { return std::to_string(i); });
 
   // Baggage - max bytes
   final_config.baggage_opts.max_bytes = resolve_and_record_config(
       env_config->baggage_max_bytes, user_config.baggage_max_bytes,
-      &all_sources_configs, &final_config.metadata,
-      ConfigName::TRACE_BAGGAGE_MAX_BYTES, 8192UL,
+      &final_config.metadata, ConfigName::TRACE_BAGGAGE_MAX_BYTES, 8192UL,
       [](const size_t &i) { return std::to_string(i); });
 
   if (final_config.baggage_opts.max_items <= 0 ||
@@ -422,17 +416,23 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   }
 
   if (auto trace_sampler_config = finalize_config(user_config.trace_sampler)) {
-    final_config.metadata.merge(trace_sampler_config->metadata);
-    all_sources_configs.merge(trace_sampler_config->telemetry_configs);
+    // Merge metadata vectors
+    for (auto &[key, values] : trace_sampler_config->metadata) {
+      auto &dest = final_config.metadata[key];
+      dest.insert(dest.end(), values.begin(), values.end());
+    }
     final_config.trace_sampler = std::move(*trace_sampler_config);
   } else {
     return std::move(trace_sampler_config.error());
   }
 
   if (auto span_sampler_config =
           finalize_config(user_config.span_sampler, *logger)) {
-    final_config.metadata.merge(span_sampler_config->metadata);
-    all_sources_configs.merge(span_sampler_config->telemetry_configs);
+    // Merge metadata vectors
+    for (auto &[key, values] : span_sampler_config->metadata) {
+      auto &dest = final_config.metadata[key];
+      dest.insert(dest.end(), values.begin(), values.end());
+    }
     final_config.span_sampler = std::move(*span_sampler_config);
   } else {
     return std::move(span_sampler_config.error());
@@ -455,32 +455,31 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
     final_config.telemetry = std::move(*telemetry_final_config);
     final_config.telemetry.products.emplace_back(telemetry::Product{
         telemetry::Product::Name::tracing, true, tracer_version, nullopt,
-        nullopt, all_sources_configs});
+        nullopt, final_config.metadata});
   } else {
     return std::move(telemetry_final_config.error());
   }
 
   // APM Tracing Enabled
   final_config.tracing_enabled = resolve_and_record_config(
       env_config->tracing_enabled, user_config.tracing_enabled,
-      &all_sources_configs, &final_config.metadata,
-      ConfigName::APM_TRACING_ENABLED, true,
+      &final_config.metadata, ConfigName::APM_TRACING_ENABLED, true,
       [](const bool &b) { return to_string(b); });
 
   {
     // Resource Renaming Enabled
     const bool resource_renaming_enabled = resolve_and_record_config(
         env_config->resource_renaming_enabled,
-        user_config.resource_renaming_enabled, &all_sources_configs,
-        &final_config.metadata, ConfigName::TRACE_RESOURCE_RENAMING_ENABLED,
-        false, [](const bool &b) { return to_string(b); });
+        user_config.resource_renaming_enabled, &final_config.metadata,
+        ConfigName::TRACE_RESOURCE_RENAMING_ENABLED, false,
+        [](const bool &b) { return to_string(b); });
 
     // Resource Renaming Always Simplified Endpoint
     const bool resource_renaming_always_simplified_endpoint =
         resolve_and_record_config(
             env_config->resource_renaming_always_simplified_endpoint,
             user_config.resource_renaming_always_simplified_endpoint,
-            &all_sources_configs, &final_config.metadata,
+            &final_config.metadata,
             ConfigName::TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT,
             false, [](const bool &b) { return to_string(b); });
 
@@ -511,7 +510,11 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
 
   if (!user_config.collector) {
     final_config.collector = *agent_finalized;
-    final_config.metadata.merge(agent_finalized->metadata);
+    // Merge metadata vectors
+    for (auto &[key, values] : agent_finalized->metadata) {
+      auto &dest = final_config.metadata[key];
+      dest.insert(dest.end(), values.begin(), values.end());
+    }
   } else {
     final_config.collector = user_config.collector;
   }