answer to comment, merge instead of passing by ref

Author: anna-git

include/datadog/span_sampler_config.h

@@ -37,9 +37,7 @@ struct SpanSamplerConfig {
 
 class FinalizedSpanSamplerConfig {
   friend Expected<FinalizedSpanSamplerConfig> finalize_config(
-      const SpanSamplerConfig&, Logger&,
-      std::unordered_map<ConfigName, std::vector<ConfigMetadata>>*
-          telemetry_configs);
+      const SpanSamplerConfig&, Logger&);
   friend class FinalizedTracerConfig;
 
   FinalizedSpanSamplerConfig() = default;
@@ -52,12 +50,11 @@ class FinalizedSpanSamplerConfig {
 
   std::vector<Rule> rules;
   std::unordered_map<ConfigName, ConfigMetadata> metadata;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> telemetry_configs;
 };
 
-Expected<FinalizedSpanSamplerConfig> finalize_config(
-    const SpanSamplerConfig&, Logger&,
-    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>*
-        telemetry_configs);
+Expected<FinalizedSpanSamplerConfig> finalize_config(const SpanSamplerConfig&,
+                                                     Logger&);
 
 std::string to_string(const FinalizedSpanSamplerConfig::Rule&);
 

include/datadog/trace_sampler_config.h

@@ -42,9 +42,7 @@ struct TraceSamplerConfig {
 
 class FinalizedTraceSamplerConfig {
   friend Expected<FinalizedTraceSamplerConfig> finalize_config(
-      const TraceSamplerConfig& config,
-      std::unordered_map<ConfigName, std::vector<ConfigMetadata>>*
-          telemetry_configs);
+      const TraceSamplerConfig& config);
   friend class FinalizedTracerConfig;
 
   FinalizedTraceSamplerConfig() = default;
@@ -53,16 +51,15 @@ class FinalizedTraceSamplerConfig {
   double max_per_second;
   std::vector<TraceSamplerRule> rules;
   std::unordered_map<ConfigName, ConfigMetadata> metadata;
+  std::unordered_map<ConfigName, std::vector<ConfigMetadata>> telemetry_configs;
 
  public:
   /// Returns the trace sampler configuration when APM Tracing is disabled.
   static FinalizedTraceSamplerConfig apm_tracing_disabled_config();
 };
 
 Expected<FinalizedTraceSamplerConfig> finalize_config(
-    const TraceSamplerConfig& config,
-    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>*
-        telemetry_configs);
+    const TraceSamplerConfig& config);
 
 }  // namespace tracing
 }  // namespace datadog

src/datadog/span_sampler_config.cpp

@@ -221,9 +221,7 @@ Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger &logger) {
 SpanSamplerConfig::Rule::Rule(const SpanMatcher &base) : SpanMatcher(base) {}
 
 Expected<FinalizedSpanSamplerConfig> finalize_config(
-    const SpanSamplerConfig &user_config, Logger &logger,
-    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>
-        *telemetry_configs) {
+    const SpanSamplerConfig &user_config, Logger &logger) {
   Expected<SpanSamplerConfig> env_config = load_span_sampler_env_config(logger);
   if (auto error = env_config.if_error()) {
     return *error;
@@ -242,7 +240,7 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
   }
 
   std::vector<SpanSamplerConfig::Rule> rules = resolve_and_record_config(
-      env_rules, user_rules, telemetry_configs, &result.metadata,
+      env_rules, user_rules, &result.telemetry_configs, &result.metadata,
       ConfigName::SPAN_SAMPLING_RULES, std::vector<SpanSamplerConfig::Rule>{},
       [](const std::vector<SpanSamplerConfig::Rule> &r) {
         return to_string(r);

src/datadog/trace_sampler_config.cpp

@@ -150,9 +150,7 @@ std::string to_string(const std::vector<TraceSamplerConfig::Rule> &rules) {
 TraceSamplerConfig::Rule::Rule(const SpanMatcher &base) : SpanMatcher(base) {}
 
 Expected<FinalizedTraceSamplerConfig> finalize_config(
-    const TraceSamplerConfig &config,
-    std::unordered_map<ConfigName, std::vector<ConfigMetadata>>
-        *telemetry_configs) {
+    const TraceSamplerConfig &config) {
   Expected<TraceSamplerConfig> env_config = load_trace_sampler_env_config();
   if (auto error = env_config.if_error()) {
     return *error;
@@ -194,7 +192,7 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   }
 
   Optional<double> sample_rate = resolve_and_record_config(
-      env_config->sample_rate, config.sample_rate, telemetry_configs,
+      env_config->sample_rate, config.sample_rate, &result.telemetry_configs,
       &result.metadata, ConfigName::TRACE_SAMPLING_RATE, 1.0,
       [](const double &d) { return to_string(d, 1); });
 
@@ -216,8 +214,9 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   }
 
   double max_per_second = resolve_and_record_config(
-      env_config->max_per_second, config.max_per_second, telemetry_configs,
-      &result.metadata, ConfigName::TRACE_SAMPLING_LIMIT, 100.0,
+      env_config->max_per_second, config.max_per_second,
+      &result.telemetry_configs, &result.metadata,
+      ConfigName::TRACE_SAMPLING_LIMIT, 100.0,
       [](const double &d) { return std::to_string(d); });
 
   const auto allowed_types = {FP_NORMAL, FP_SUBNORMAL};

src/datadog/tracer_config.cpp

@@ -421,17 +421,18 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
     return std::move(*error);
   }
 
-  if (auto trace_sampler_config =
-          finalize_config(user_config.trace_sampler, &all_sources_configs)) {
+  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);
     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, &all_sources_configs)) {
+  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);
     final_config.span_sampler = std::move(*span_sampler_config);
   } else {
     return std::move(span_sampler_config.error());