DataDog · dmehala · Mar 13, 2024 · Feb 2, 2024 · Feb 15, 2024 · Feb 15, 2024
@@ -15,6 +15,7 @@ cc_library(
     "src/datadog/error.cpp",
     "src/datadog/extraction_util.cpp",
     "src/datadog/glob.cpp",
+    "src/datadog/http_client.cpp",
     "src/datadog/id_generator.cpp",
     "src/datadog/limiter.cpp",
     "src/datadog/logger.cpp",
@@ -34,6 +35,7 @@ cc_library(
     "src/datadog/span_matcher.cpp",
     "src/datadog/span_sampler_config.cpp",
     "src/datadog/span_sampler.cpp",
+    "src/datadog/string_util.cpp",
     "src/datadog/tag_propagation.cpp",
     "src/datadog/tags.cpp",
     "src/datadog/threaded_event_scheduler.cpp",
@@ -50,6 +52,7 @@ cc_library(
     hdrs = [
     "src/datadog/base64.h",
     "src/datadog/cerr_logger.h",
+    "src/datadog/config.h",
     "src/datadog/clock.h",
     "src/datadog/config_manager.h",
     "src/datadog/config_update.h",
@@ -98,6 +101,7 @@ cc_library(
     "src/datadog/span_matcher.h",
     "src/datadog/span_sampler_config.h",
     "src/datadog/span_sampler.h",
+    "src/datadog/string_util.h",
     "src/datadog/string_view.h",
     "src/datadog/tag_propagation.h",
     "src/datadog/tags.h",

@@ -101,6 +101,7 @@ target_sources(dd_trace_cpp-objects PRIVATE
     src/datadog/error.cpp
     src/datadog/extraction_util.cpp
     src/datadog/glob.cpp
+    src/datadog/http_client.cpp
     src/datadog/id_generator.cpp
     src/datadog/limiter.cpp
     src/datadog/logger.cpp
@@ -120,6 +121,7 @@ target_sources(dd_trace_cpp-objects PRIVATE
     src/datadog/span_matcher.cpp
     src/datadog/span_sampler_config.cpp
     src/datadog/span_sampler.cpp
+    src/datadog/string_util.cpp
     src/datadog/tags.cpp
     src/datadog/tag_propagation.cpp
     src/datadog/threaded_event_scheduler.cpp
@@ -141,6 +143,7 @@ target_sources(dd_trace_cpp-objects PUBLIC
   BASE_DIRS src/
   FILES
   src/datadog/base64.h
+  src/datadog/config.h
   src/datadog/cerr_logger.h
   src/datadog/clock.h
   src/datadog/config_manager.h
@@ -190,6 +193,7 @@ target_sources(dd_trace_cpp-objects PUBLIC
   src/datadog/span_matcher.h
   src/datadog/span_sampler_config.h
   src/datadog/span_sampler.h
+  src/datadog/string_util.h
   src/datadog/string_view.h
   src/datadog/tag_propagation.h
   src/datadog/tags.h

@@ -13,7 +13,7 @@ int main() {
     namespace dd = datadog::tracing;
 
     dd::TracerConfig config;
-    config.defaults.service = "my-service";
+    config.service = "my-service";
 
     const auto validated_config = dd::finalize_config(config);
     if (!validated_config) {

@@ -1,12 +1,11 @@
 #include <benchmark/benchmark.h>
-
 #include <datadog/collector.h>
-#include <datadog/json.hpp>
 #include <datadog/logger.h>
 #include <datadog/span_data.h>
 #include <datadog/tracer.h>
 #include <datadog/tracer_config.h>
 
+#include <datadog/json.hpp>
 #include <memory>
 
 #include "hasher.h"
@@ -35,9 +34,7 @@ struct SerializingCollector : public dd::Collector {
   }
 
   nlohmann::json config_json() const override {
-    return nlohmann::json::object({
-        {"type", "SerializingCollector"}
-    });
+    return nlohmann::json::object({{"type", "SerializingCollector"}});
   }
 };
 
@@ -47,7 +44,7 @@ struct SerializingCollector : public dd::Collector {
 void BM_TraceTinyCCSource(benchmark::State& state) {
   for (auto _ : state) {
     dd::TracerConfig config;
-    config.defaults.service = "benchmark";
+    config.service = "benchmark";
     config.logger = std::make_shared<NullLogger>();
     config.collector = std::make_shared<SerializingCollector>();
     const auto valid_config = dd::finalize_config(config);
@@ -58,6 +55,6 @@ void BM_TraceTinyCCSource(benchmark::State& state) {
 }
 BENCHMARK(BM_TraceTinyCCSource);
 
-} // namespace
+}  // namespace
 
 BENCHMARK_MAIN();
@@ -132,8 +132,8 @@ int sha256_traced(Digest &digest, const fs::path &path,
 
 int main() {
   dd::TracerConfig config;
-  config.defaults.service = "dd-trace-cpp-example";
-  config.defaults.environment = "dev";
+  config.service = "dd-trace-cpp-example";
+  config.environment = "dev";
 
   auto validated = dd::finalize_config(config);
   if (auto *error = validated.if_error()) {

@@ -25,8 +25,8 @@ void hard_stop(int /*signal*/) { std::exit(0); }
 int main() {
   // Set up the Datadog tracer.  See `src/datadog/tracer_config.h`.
   dd::TracerConfig config;
-  config.defaults.service = "dd-trace-cpp-http-server-example-proxy";
-  config.defaults.service_type = "proxy";
+  config.service = "dd-trace-cpp-http-server-example-proxy";
+  config.service_type = "proxy";
 
   // `finalize_config` validates `config` and applies any settings from
   // environment variables, such as `DD_AGENT_HOST`.

@@ -109,8 +109,8 @@ void on_post_notes(const httplib::Request& request, httplib::Response& response)
 int main() {
   // Set up the Datadog tracer.  See `src/datadog/tracer_config.h`.
   dd::TracerConfig config;
-  config.defaults.service = "dd-trace-cpp-http-server-example-server";
-  config.defaults.service_type = "server";
+  config.service = "dd-trace-cpp-http-server-example-server";
+  config.service_type = "server";
 
   // `finalize_config` validates `config` and applies any settings from
   // environment variables, such as `DD_AGENT_HOST`.

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "error.h"
+#include "optional.h"
+
+namespace datadog {
+namespace tracing {
+
+// Enumerates available configuration names for the tracing library
+enum class ConfigName : char {
+  SERVICE_NAME,
+  SERVICE_ENV,
+  SERVICE_VERSION,
+  REPORT_TRACES,
+  TAGS,
+  EXTRACTION_STYLES,
+  INJECTION_STYLES,
+  STARTUP_LOGS,
+  REPORT_TELEMETRY,
+  DELEGATE_SAMPLING,
+  GENEREATE_128BIT_TRACE_IDS,
+  AGENT_URL,
+  RC_POLL_INTERVAL,
+  TRACE_SAMPLING_RATE,
+  TRACE_SAMPLING_LIMIT,
+  TRACE_SAMPLING_RULES,
+  SPAN_SAMPLING_RULES,
+};
+
+// Represents metadata for configuration parameters
+struct ConfigMetadata {
+  enum class Origin : char {
+    ENVIRONMENT_VARIABLE,  // Originating from environment variables
+    CODE,                  // Defined in code
+    REMOTE_CONFIG,         // Retrieved from remote configuration
+    DEFAULT                // Default value
+  };
+
+  // Name of the configuration parameter
+  ConfigName name;
+  // Value of the configuration parameter
+  std::string value;
+  // Origin of the configuration parameter
+  Origin origin;
+  // Optional error associated with the configuration parameter
+  Optional<Error> error;
+
+  ConfigMetadata() = default;
+  ConfigMetadata(ConfigName n, std::string v, Origin orig,
+                 Optional<Error> err = nullopt)
+      : name(n), value(std::move(v)), origin(orig), error(std::move(err)) {}
+};
+
+// 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
@@ -1,80 +1,118 @@
 #include "config_manager.h"
 
+#include "parse_util.h"
+#include "string_util.h"
 #include "trace_sampler.h"
 
 namespace datadog {
 namespace tracing {
 
 ConfigManager::ConfigManager(const FinalizedTracerConfig& config)
     : clock_(config.clock),
-      default_trace_sampler_(
+      default_metadata_(config.metadata),
+      trace_sampler_(
           std::make_shared<TraceSampler>(config.trace_sampler, clock_)),
-      current_trace_sampler_(default_trace_sampler_),
-      default_span_defaults_(std::make_shared<SpanDefaults>(config.defaults)),
-      current_span_defaults_(default_span_defaults_),
-      default_report_traces_(config.report_traces),
-      current_report_traces_(default_report_traces_) {}
+      span_defaults_(std::make_shared<SpanDefaults>(config.defaults)),
+      report_traces_(config.report_traces) {}
 
 std::shared_ptr<TraceSampler> ConfigManager::trace_sampler() {
   std::lock_guard<std::mutex> lock(mutex_);
-  return current_trace_sampler_;
+  return trace_sampler_.value();
 }
 
 std::shared_ptr<const SpanDefaults> ConfigManager::span_defaults() {
   std::lock_guard<std::mutex> lock(mutex_);
-  return current_span_defaults_;
+  return span_defaults_.value();
 }
 
 bool ConfigManager::report_traces() {
   std::lock_guard<std::mutex> lock(mutex_);
-  return current_report_traces_;
+  return report_traces_.value();
 }
 
-void ConfigManager::update(const ConfigUpdate& conf) {
+std::vector<ConfigMetadata> ConfigManager::update(const ConfigUpdate& conf) {
+  std::vector<ConfigMetadata> metadata;
+
   std::lock_guard<std::mutex> lock(mutex_);
 
-  if (conf.trace_sampler) {
-    if (auto finalized_trace_sampler_cfg =
-            finalize_config(*conf.trace_sampler)) {
-      current_trace_sampler_ =
-          std::make_shared<TraceSampler>(*finalized_trace_sampler_cfg, clock_);
-    } else {
-      // TODO: report error
-    }
+  if (!conf.trace_sampling_rate) {
+    reset_config(ConfigName::TRACE_SAMPLING_RATE, trace_sampler_, metadata);
   } else {
-    current_trace_sampler_ = default_trace_sampler_;
-  }
+    ConfigMetadata trace_sampling_metadata(
+        ConfigName::TRACE_SAMPLING_RATE,
+        to_string(*conf.trace_sampling_rate, 1),
+        ConfigMetadata::Origin::REMOTE_CONFIG);
 
-  if (conf.tags) {
-    auto new_span_defaults =
-        std::make_shared<SpanDefaults>(*current_span_defaults_);
-    new_span_defaults->tags = std::move(*conf.tags);
+    TraceSamplerConfig trace_sampler_cfg;
+    trace_sampler_cfg.sample_rate = *conf.trace_sampling_rate;
+
+    auto finalized_trace_sampler_cfg = finalize_config(trace_sampler_cfg);
+    if (auto error = finalized_trace_sampler_cfg.if_error()) {
+      trace_sampling_metadata.error = *error;
+    }
 
-    current_span_defaults_ = new_span_defaults;
+    auto trace_sampler =
+        std::make_shared<TraceSampler>(*finalized_trace_sampler_cfg, clock_);
+
+    // This reset rate limiting and `TraceSampler` has no `operator==`.
+    // TODO: Instead of creating another `TraceSampler`, we should
+    // update the default sampling rate.
+    trace_sampler_ = std::move(trace_sampler);
+    metadata.emplace_back(std::move(trace_sampling_metadata));
+  }
+
+  if (!conf.tags) {
+    reset_config(ConfigName::TAGS, span_defaults_, metadata);
   } else {
-    current_span_defaults_ = default_span_defaults_;
+    ConfigMetadata tags_metadata(ConfigName::TAGS, join(*conf.tags, ","),
+                                 ConfigMetadata::Origin::REMOTE_CONFIG);
+
+    auto parsed_tags = parse_tags(*conf.tags);
+    if (auto error = parsed_tags.if_error()) {
+      tags_metadata.error = *error;
+    }
+
+    if (*parsed_tags != span_defaults_.value()->tags) {
+      auto new_span_defaults =
+          std::make_shared<SpanDefaults>(*span_defaults_.value());
+      new_span_defaults->tags = std::move(*parsed_tags);
+
+      span_defaults_ = new_span_defaults;
+      metadata.emplace_back(std::move(tags_metadata));
+    }
   }
 
-  if (conf.report_traces) {
-    current_report_traces_ = *conf.report_traces;
+  if (!conf.report_traces) {
+    reset_config(ConfigName::REPORT_TRACES, report_traces_, metadata);
   } else {
-    current_report_traces_ = default_report_traces_;
+    if (conf.report_traces != report_traces_.value()) {
+      report_traces_ = *conf.report_traces;
+      metadata.emplace_back(ConfigName::REPORT_TRACES,
+                            to_string(*conf.report_traces),
+                            ConfigMetadata::Origin::REMOTE_CONFIG);
+    }
   }
+
+  return metadata;
 }
 
-void ConfigManager::reset() {
-  std::lock_guard<std::mutex> lock(mutex_);
-  current_trace_sampler_ = default_trace_sampler_;
-  current_span_defaults_ = default_span_defaults_;
-  current_report_traces_ = default_report_traces_;
+template <typename T>
+void ConfigManager::reset_config(ConfigName name, T& conf,
+                                 std::vector<ConfigMetadata>& metadata) {
+  if (conf.is_original_value()) return;
+
+  conf.reset();
+  metadata.emplace_back(default_metadata_[name]);
 }
 
+std::vector<ConfigMetadata> ConfigManager::reset() { return update({}); }
+
 nlohmann::json ConfigManager::config_json() const {
   std::lock_guard<std::mutex> lock(mutex_);
   return nlohmann::json{
-      {"defaults", to_json(*current_span_defaults_)},
-      {"trace_sampler", current_trace_sampler_->config_json()},
-      {"report_traces", current_report_traces_}};
+      {"defaults", to_json(*span_defaults_.value())},
+      {"trace_sampler", trace_sampler_.value()->config_json()},
+      {"report_traces", report_traces_.value()}};
 }
 
 }  // namespace tracing