fix(config visibility): fix system test related to reporting of trace sampler and span sampler

include/datadog/span_sampler_config.h

@@ -50,6 +50,7 @@ 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&,

include/datadog/trace_sampler_config.h

@@ -51,6 +51,7 @@ 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.

src/datadog/span_sampler_config.cpp

@@ -228,20 +228,22 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
   }
 
   FinalizedSpanSamplerConfig result;
-
-  std::vector<SpanSamplerConfig::Rule> rules;
+  Optional<std::vector<SpanSamplerConfig::Rule>> env_rules;
+  Optional<std::vector<SpanSamplerConfig::Rule>> user_rules;
   if (!env_config->rules.empty()) {
-    rules = env_config->rules;
-    result.metadata[ConfigName::SPAN_SAMPLING_RULES] =
-        ConfigMetadata(ConfigName::SPAN_SAMPLING_RULES, to_string(rules),
-                       ConfigMetadata::Origin::ENVIRONMENT_VARIABLE);
-  } else if (!user_config.rules.empty()) {
-    rules = user_config.rules;
-    result.metadata[ConfigName::SPAN_SAMPLING_RULES] =
-        ConfigMetadata(ConfigName::SPAN_SAMPLING_RULES, to_string(rules),
-                       ConfigMetadata::Origin::CODE);
+    env_rules = env_config->rules;
+  }
+  if (!user_config.rules.empty()) {
+    user_rules = user_config.rules;
   }
 
+  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) {
+        return to_string(r);
+      });
+
   for (const auto &rule : rules) {
     auto maybe_rate = Rate::from(rule.sample_rate);
     if (auto *error = maybe_rate.if_error()) {
@@ -276,7 +278,6 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
     finalized.max_per_second = rule.max_per_second;
     result.rules.push_back(std::move(finalized));
   }
-
   return result;
 }
 

src/datadog/trace_sampler_config.cpp

@@ -191,27 +191,16 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
     result.rules.emplace_back(std::move(finalized_rule));
   }
 
-  Optional<double> sample_rate;
-  if (env_config->sample_rate) {
-    sample_rate = env_config->sample_rate;
-    result.metadata[ConfigName::TRACE_SAMPLING_RATE] = ConfigMetadata(
-        ConfigName::TRACE_SAMPLING_RATE, to_string(*sample_rate, 1),
-        ConfigMetadata::Origin::ENVIRONMENT_VARIABLE);
-  } else if (config.sample_rate) {
-    sample_rate = config.sample_rate;
-    result.metadata[ConfigName::TRACE_SAMPLING_RATE] = ConfigMetadata(
-        ConfigName::TRACE_SAMPLING_RATE, to_string(*sample_rate, 1),
-        ConfigMetadata::Origin::CODE);
-  } else {
-    result.metadata[ConfigName::TRACE_SAMPLING_RATE] =
-        ConfigMetadata(ConfigName::TRACE_SAMPLING_RATE, "1.0",
-                       ConfigMetadata::Origin::DEFAULT);
-  }
+  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,
+      [](const double &d) { return to_string(d, 1); });
 
+  bool is_sample_rate_provided = env_config->sample_rate || config.sample_rate;
   // If `sample_rate` was specified, then it translates to a "catch-all" rule
   // appended to the end of `rules`. First, though, we have to make sure the
   // sample rate is valid.
-  if (sample_rate) {
+  if (sample_rate && is_sample_rate_provided) {
     auto maybe_rate = Rate::from(*sample_rate);
     if (auto *error = maybe_rate.if_error()) {
       return error->with_prefix(
@@ -225,11 +214,10 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
     result.rules.emplace_back(std::move(finalized_rule));
   }
 
-  std::unordered_map<ConfigName, std::vector<ConfigMetadata>>
-      telemetry_configs_tmp;
   double max_per_second = resolve_and_record_config(
-      env_config->max_per_second, config.max_per_second, &telemetry_configs_tmp,
-      &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

@@ -423,6 +423,7 @@ 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);
     final_config.trace_sampler = std::move(*trace_sampler_config);
   } else {
     return std::move(trace_sampler_config.error());
@@ -431,6 +432,7 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
   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());

test/test_span_sampler.cpp

@@ -271,6 +271,24 @@ TEST_CASE("span rule sample rate") {
   config.trace_sampler.sample_rate = 0.0;  // drop the trace
   auto finalized = finalize_config(config);
   REQUIRE(finalized);
+
+  // metadata should be populated right - check the full JSON representation
+  auto expected_rules = "[{\"name\":\"*\",\"resource\":\"*\",\"sample_rate\":" +
+                        to_string(test_case.span_rule_rate, 1) +
+                        ",\"service\":\"testsvc\",\"tags\":{}}]";
+  REQUIRE(finalized->metadata[ConfigName::SPAN_SAMPLING_RULES].value ==
+          expected_rules);
+
+  auto tracing_product = finalized->telemetry.products[0];
+
+  // Verify the tracing product has the span sampling rules in telemetry configs
+  const auto& span_rules_configs =
+      tracing_product.configurations.at(ConfigName::SPAN_SAMPLING_RULES);
+  REQUIRE(span_rules_configs.size() ==
+          1);  // Only CODE origin since rules were set in code
+  REQUIRE(span_rules_configs[0].value == expected_rules);
+  REQUIRE(span_rules_configs[0].origin == ConfigMetadata::Origin::CODE);
+
   Tracer tracer{*finalized};
   {
     auto span = tracer.create_span();

test/test_trace_sampler.cpp

@@ -73,6 +73,21 @@ TEST_CASE("trace sampling rule sample rate") {
 
   auto finalized = finalize_config(config);
   REQUIRE(finalized);
+
+  // metadata should be populated right
+  REQUIRE(finalized->metadata[ConfigName::TRACE_SAMPLING_RATE].value ==
+          to_string(test_case.sample_rate, 1));
+
+  auto tracing_product = finalized->telemetry.products[0];
+  // Verify the tracing product has the telemetry configs
+  const auto& rate_configs =
+      tracing_product.configurations.at(ConfigName::TRACE_SAMPLING_RATE);
+  REQUIRE(rate_configs.size() == 2);
+  REQUIRE(rate_configs[0].value == to_string(1, 1));
+  REQUIRE(rate_configs[0].origin == ConfigMetadata::Origin::DEFAULT);
+  REQUIRE(rate_configs[1].value == to_string(test_case.sample_rate, 1));
+  REQUIRE(rate_configs[1].origin == ConfigMetadata::Origin::CODE);
+
   Tracer tracer{*finalized};
 
   for (std::size_t i = 0; i < num_iterations; ++i) {