[skip ci] remove unecessary changes

dmehala · dmehala · commit 7a3a6c511c84 · 2025-06-19T20:15:54.000+02:00
diff --git a/include/datadog/collector.h b/include/datadog/collector.h
@@ -19,7 +19,7 @@ namespace datadog {
 namespace tracing {
 
 struct SpanData;
-class ErasedTraceSampler;
+class TraceSampler;
 
 class Collector {
  public:
@@ -29,7 +29,7 @@ class Collector {
   // occurs.
   virtual Expected<void> send(
       std::vector<std::unique_ptr<SpanData>>&& spans,
-      const std::shared_ptr<ErasedTraceSampler>& response_handler) = 0;
+      const std::shared_ptr<TraceSampler>& response_handler) = 0;
 
   // Return a JSON representation of this object's configuration. The JSON
   // representation is an object with the following properties:
diff --git a/include/datadog/datadog_agent_config.h b/include/datadog/datadog_agent_config.h
@@ -66,9 +66,6 @@ struct DatadogAgentConfig {
   // How often, in seconds, to query the Datadog Agent for remote configuration
   // updates.
   Optional<double> remote_configuration_poll_interval_seconds;
-  // Whether APM tracing is enabled. This affects whether the
-  // "Datadog-Client-Computed-Stats: yes" header is sent with trace requests.
-  Optional<bool> apm_tracing_enabled;
 };
 
 class FinalizedDatadogAgentConfig {
@@ -90,7 +87,6 @@ class FinalizedDatadogAgentConfig {
   std::chrono::steady_clock::duration shutdown_timeout;
   std::chrono::steady_clock::duration remote_configuration_poll_interval;
   std::unordered_map<ConfigName, ConfigMetadata> metadata;
-  bool apm_tracing_enabled;
 
   // Origin detection
   Optional<std::string> admission_controller_uid;
diff --git a/include/datadog/null_collector.h b/include/datadog/null_collector.h
@@ -11,7 +11,7 @@ namespace tracing {
 class NullCollector : public Collector {
  public:
   Expected<void> send(std::vector<std::unique_ptr<SpanData>>&&,
-                      const std::shared_ptr<ErasedTraceSampler>&) override {
+                      const std::shared_ptr<TraceSampler>&) override {
     return {};
   }
 
diff --git a/include/datadog/trace_segment.h b/include/datadog/trace_segment.h
@@ -53,16 +53,15 @@ class Logger;
 struct SpanData;
 struct SpanDefaults;
 class SpanSampler;
-class ErasedTraceSampler;
+class TraceSampler;
 class ConfigManager;
 
 class TraceSegment {
   mutable std::mutex mutex_;
 
   std::shared_ptr<Logger> logger_;
   std::shared_ptr<Collector> collector_;
-  std::shared_ptr<ErasedTraceSampler> trace_sampler_;
-  bool apm_tracing_enabled_;
+  std::shared_ptr<TraceSampler> trace_sampler_;
   std::shared_ptr<SpanSampler> span_sampler_;
 
   std::shared_ptr<const SpanDefaults> defaults_;
@@ -84,8 +83,7 @@ class TraceSegment {
  public:
   TraceSegment(const std::shared_ptr<Logger>& logger,
                const std::shared_ptr<Collector>& collector,
-               std::shared_ptr<ErasedTraceSampler> trace_sampler,
-               bool apm_tracing_enabled,
+               const std::shared_ptr<TraceSampler>& trace_sampler,
                const std::shared_ptr<SpanSampler>& span_sampler,
                const std::shared_ptr<const SpanDefaults>& defaults,
                const std::shared_ptr<ConfigManager>& config_manager,
diff --git a/include/datadog/tracer.h b/include/datadog/tracer.h
@@ -29,7 +29,7 @@ namespace tracing {
 class ConfigManager;
 class DictReader;
 struct SpanConfig;
-class ErasedTraceSampler;
+class TraceSampler;
 class SpanSampler;
 class IDGenerator;
 class InMemoryFile;
@@ -39,8 +39,6 @@ class Tracer {
   RuntimeID runtime_id_;
   TracerSignature signature_;
   std::shared_ptr<ConfigManager> config_manager_;
-  std::shared_ptr<ErasedTraceSampler>
-      apm_tracing_disabled_sampler_;  // empty if enabled
   std::shared_ptr<Collector> collector_;
   std::shared_ptr<SpanSampler> span_sampler_;
   std::shared_ptr<const IDGenerator> generator_;
@@ -106,10 +104,6 @@ class Tracer {
   // same JSON object that was logged when this Tracer was created.
   std::string config() const;
 
-  bool is_apm_tracing_enabled() const {
-    return apm_tracing_disabled_sampler_ == nullptr;
-  }
-
  private:
   void store_config();
 };
diff --git a/include/datadog/tracer_config.h b/include/datadog/tracer_config.h
@@ -28,7 +28,6 @@ class Collector;
 class Logger;
 class SpanSampler;
 class TraceSampler;
-class ErasedTraceSampler;
 
 struct TracerConfig {
   // Set the service name.
@@ -81,16 +80,6 @@ struct TracerConfig {
   // `telemetry/configuration.h` By default, the telemetry module is enabled.
   telemetry::Configuration telemetry;
 
-  // `apm_tracing_enabled` indicates whether APM traces and APM trace metrics
-  // are enabled. If `false`, APM-specific traces are dropped and APM trace
-  // metrics are not computed. This allows other products (e.g., AppSec) to
-  // operate independently.
-  // This is distinct from `report_traces`, which controls whether any traces
-  // are sent at all.
-  // `apm_tracing_enabled` is overridden by the `DD_APM_TRACING_ENABLED`
-  // environment variable. Defaults to `true`.
-  Optional<bool> apm_tracing_enabled;
-
   // `trace_sampler` configures trace sampling.  Trace sampling determines which
   // traces are sent to Datadog.  See `trace_sampler_config.h`.
   TraceSamplerConfig trace_sampler;
@@ -179,6 +168,9 @@ struct TracerConfig {
   /// By default, it uses `ThreadedEventScheduler`, which runs tasks on a
   /// separate thread.
   std::shared_ptr<EventScheduler> event_scheduler;
+
+  /// TBD
+  Optional<bool> apm_tracing_enabled;
 };
 
 // `FinalizedTracerConfig` contains `Tracer` implementation details derived from
@@ -208,7 +200,6 @@ class FinalizedTracerConfig final {
   std::shared_ptr<Logger> logger;
   bool log_on_startup;
   bool generate_128bit_trace_ids;
-  bool apm_tracing_enabled;
   Optional<RuntimeID> runtime_id;
   Clock clock;
   std::string integration_name;
@@ -219,6 +210,7 @@ class FinalizedTracerConfig final {
   HTTPClient::URL agent_url;
   std::shared_ptr<EventScheduler> event_scheduler;
   std::shared_ptr<HTTPClient> http_client;
+  bool apm_tracing_enabled;
 };
 
 // Return a `FinalizedTracerConfig` from the specified `config` and from any
diff --git a/src/datadog/config_manager.cpp b/src/datadog/config_manager.cpp
@@ -130,8 +130,6 @@ ConfigManager::ConfigManager(const FinalizedTracerConfig& config)
       default_metadata_(config.metadata),
       trace_sampler_(
           std::make_shared<TraceSampler>(config.trace_sampler, clock_)),
-      erased_trace_sampler_(
-          std::make_shared<ErasedTraceSampler>(trace_sampler_)),
       rules_(config.trace_sampler.rules),
       span_defaults_(std::make_shared<SpanDefaults>(config.defaults)),
       report_traces_(config.report_traces) {}
@@ -165,9 +163,9 @@ void ConfigManager::on_revert(const Configuration&) {
   telemetry::capture_configuration_change(config_metadata);
 }
 
-std::shared_ptr<ErasedTraceSampler> ConfigManager::trace_sampler() {
+std::shared_ptr<TraceSampler> ConfigManager::trace_sampler() {
   std::lock_guard<std::mutex> lock(mutex_);
-  return erased_trace_sampler_;
+  return trace_sampler_;
 }
 
 std::shared_ptr<const SpanDefaults> ConfigManager::span_defaults() {
diff --git a/src/datadog/config_manager.h b/src/datadog/config_manager.h
@@ -70,9 +70,6 @@ class ConfigManager : public remote_config::Listener {
   std::unordered_map<ConfigName, ConfigMetadata> default_metadata_;
 
   std::shared_ptr<TraceSampler> trace_sampler_;
-  // wraps trace_sampler_ and should be changed if trace_sampler_ is changed
-  // Could be created every time, but that would be a waste
-  std::shared_ptr<ErasedTraceSampler> erased_trace_sampler_;
   std::vector<TraceSamplerRule> rules_;
 
   DynamicConfig<std::shared_ptr<const SpanDefaults>> span_defaults_;
@@ -96,7 +93,7 @@ class ConfigManager : public remote_config::Listener {
   void on_post_process() override{};
 
   // Return the `TraceSampler` consistent with the most recent configuration.
-  std::shared_ptr<ErasedTraceSampler> trace_sampler();
+  std::shared_ptr<TraceSampler> trace_sampler();
 
   // Return the `SpanDefaults` consistent with the most recent configuration.
   std::shared_ptr<const SpanDefaults> span_defaults();
diff --git a/src/datadog/datadog_agent.cpp b/src/datadog/datadog_agent.cpp
@@ -157,8 +157,7 @@ DatadogAgent::DatadogAgent(
       flush_interval_(config.flush_interval),
       request_timeout_(config.request_timeout),
       shutdown_timeout_(config.shutdown_timeout),
-      remote_config_(tracer_signature, rc_listeners, logger),
-      apm_tracing_enabled_(config.apm_tracing_enabled) {
+      remote_config_(tracer_signature, rc_listeners, logger) {
   assert(logger_);
 
   // Set HTTP headers
@@ -212,7 +211,7 @@ DatadogAgent::~DatadogAgent() {
 
 Expected<void> DatadogAgent::send(
     std::vector<std::unique_ptr<SpanData>>&& spans,
-    const std::shared_ptr<ErasedTraceSampler>& response_handler) {
+    const std::shared_ptr<TraceSampler>& response_handler) {
   std::lock_guard<std::mutex> lock(mutex_);
   trace_chunks_.push_back(TraceChunk{std::move(spans), response_handler});
   return nullopt;
@@ -273,7 +272,7 @@ void DatadogAgent::flush() {
   // One HTTP request to the Agent could possibly involve trace chunks from
   // multiple tracers, and thus multiple trace samplers might need to have
   // their rates updated. Unlikely, but possible.
-  std::unordered_set<std::shared_ptr<ErasedTraceSampler>> response_handlers;
+  std::unordered_set<std::shared_ptr<TraceSampler>> response_handlers;
   for (auto& chunk : trace_chunks) {
     response_handlers.insert(std::move(chunk.response_handler));
   }
@@ -285,9 +284,6 @@ void DatadogAgent::flush() {
     for (const auto& [key, value] : headers_) {
       writer.set(key, value);
     }
-    if (!apm_tracing_enabled_) {
-      writer.set("Datadog-Client-Computed-Stats", "yes");
-    }
   };
 
   // This is the callback for the HTTP response.  It's invoked
diff --git a/src/datadog/datadog_agent.h b/src/datadog/datadog_agent.h
@@ -21,17 +21,17 @@
 namespace datadog {
 namespace tracing {
 
-class ErasedTraceSampler;
 class FinalizedDatadogAgentConfig;
 class Logger;
 struct SpanData;
+class TraceSampler;
 struct TracerSignature;
 
 class DatadogAgent : public Collector {
  public:
   struct TraceChunk {
     std::vector<std::unique_ptr<SpanData>> spans;
-    std::shared_ptr<ErasedTraceSampler> response_handler;
+    std::shared_ptr<TraceSampler> response_handler;
   };
 
  private:
@@ -51,7 +51,6 @@ class DatadogAgent : public Collector {
   remote_config::Manager remote_config_;
 
   std::unordered_map<std::string, std::string> headers_;
-  bool apm_tracing_enabled_;
 
   void flush();
 
@@ -64,7 +63,7 @@ class DatadogAgent : public Collector {
 
   Expected<void> send(
       std::vector<std::unique_ptr<SpanData>>&& spans,
-      const std::shared_ptr<ErasedTraceSampler>& response_handler) override;
+      const std::shared_ptr<TraceSampler>& response_handler) override;
 
   void get_and_apply_remote_configuration_updates();
 
diff --git a/src/datadog/datadog_agent_config.cpp b/src/datadog/datadog_agent_config.cpp
@@ -31,10 +31,6 @@ Expected<DatadogAgentConfig> load_datadog_agent_env_config() {
     env_config.remote_configuration_poll_interval_seconds = *res;
   }
 
-  if (auto apm_enabled_env = lookup(environment::DD_APM_TRACING_ENABLED)) {
-    env_config.apm_tracing_enabled = !falsy(*apm_enabled_env);
-  }
-
   auto env_host = lookup(environment::DD_AGENT_HOST);
   auto env_port = lookup(environment::DD_TRACE_AGENT_PORT);
 
@@ -139,9 +135,6 @@ Expected<FinalizedDatadogAgentConfig> finalize_config(
       value_or(env_config->remote_configuration_enabled,
                user_config.remote_configuration_enabled, true);
 
-  result.apm_tracing_enabled = value_or(env_config->apm_tracing_enabled,
-                                        user_config.apm_tracing_enabled, true);
-
   const auto [origin, url] =
       pick(env_config->url, user_config.url, "http://localhost:8126");
   auto parsed_url = HTTPClient::URL::parse(url);
diff --git a/src/datadog/trace_sampler.cpp b/src/datadog/trace_sampler.cpp
@@ -12,7 +12,6 @@
 #include "json_serializer.h"
 #include "sampling_util.h"
 #include "span_data.h"
-#include "tags.h"
 
 namespace datadog {
 namespace tracing {
@@ -125,97 +124,5 @@ nlohmann::json TraceSampler::config_json() const {
   });
 }
 
-SamplingDecision ApmDisabledTraceSampler::decide(const SpanData& span_data) {
-  SamplingDecision decision;
-  decision.origin = SamplingDecision::Origin::LOCAL;
-
-  auto now = clock_();
-  uint64_t num_allowed;
-  if (span_data.tags.find(tags::internal::trace_source) !=
-      span_data.tags.end()) {
-    decision.mechanism = static_cast<int>(SamplingMechanism::APP_SEC);
-    decision.priority = static_cast<int>(SamplingPriority::USER_KEEP);
-    last_kept_.store(now.wall, std::memory_order_relaxed);
-    num_allowed = num_allowed_.fetch_add(1, std::memory_order_relaxed) + 1;
-  } else {
-    auto last_kept = last_kept_.load(std::memory_order_relaxed);
-    if (now.wall - last_kept >= INTERVAL) {
-      if (last_kept_.compare_exchange_strong(last_kept, now.wall)) {
-        decision.priority = static_cast<int>(SamplingPriority::USER_KEEP);
-        num_allowed = num_allowed_.fetch_add(1, std::memory_order_relaxed) + 1;
-      } else {
-        // another thread got to it first
-        decision.priority = static_cast<int>(SamplingPriority::USER_DROP);
-        num_allowed = num_allowed_.load(std::memory_order_relaxed);
-      }
-    } else {
-      decision.priority = static_cast<int>(SamplingPriority::USER_DROP);
-      num_allowed = num_allowed_.load(std::memory_order_relaxed);
-    }
-  }
-
-  auto num_asked = num_asked_.fetch_add(1, std::memory_order_relaxed) + 1;
-  decision.limiter_max_per_second = ALLOWED_PER_SECOND;
-  double effective_rate = static_cast<double>(num_allowed) / num_asked;
-  if (effective_rate > 1.0) {
-    // can happen due to the relaxed atomic operations
-    effective_rate = 1.0;
-  }
-  decision.limiter_effective_rate = Rate::from(effective_rate).value();
-
-  return decision;
-}
-
-void ApmDisabledTraceSampler::handle_collector_response(
-    const CollectorResponse&) {
-  // do nothing
-}
-
-nlohmann::json ApmDisabledTraceSampler::config_json() const {
-  return nlohmann::json::object({
-      {"max_per_second", ALLOWED_PER_SECOND},
-  });
-}
-
-template <typename Ptr>
-struct ErasedTraceSampler::Model : Concept {
-  Model(Ptr&& samplerImpl) : impl_(std::move(samplerImpl)) {}
-
-  SamplingDecision decide(const SpanData& span_data) override {
-    return impl_->decide(span_data);
-  }
-
-  void handle_collector_response(const CollectorResponse& response) override {
-    impl_->handle_collector_response(response);
-  }
-
-  nlohmann::json config_json() const override { return impl_->config_json(); }
-
- private:
-  Ptr impl_;
-};
-
-template <typename Ptr>
-ErasedTraceSampler::ErasedTraceSampler(Ptr samplerImpl) {
-  impl_ = std::make_unique<Model<Ptr>>(std::move(samplerImpl));
-}
-
-template ErasedTraceSampler::ErasedTraceSampler(std::shared_ptr<TraceSampler>);
-template ErasedTraceSampler::ErasedTraceSampler(
-    std::unique_ptr<ApmDisabledTraceSampler>);
-
-SamplingDecision ErasedTraceSampler::decide(const SpanData& span_data) {
-  return impl_->decide(span_data);
-}
-
-void ErasedTraceSampler::handle_collector_response(
-    const CollectorResponse& response) {
-  impl_->handle_collector_response(response);
-}
-
-nlohmann::json ErasedTraceSampler::config_json() const {
-  return impl_->config_json();
-}
-
 }  // namespace tracing
 }  // namespace datadog
diff --git a/src/datadog/trace_sampler.h b/src/datadog/trace_sampler.h
diff --git a/src/datadog/trace_segment.cpp b/src/datadog/trace_segment.cpp
diff --git a/src/datadog/tracer.cpp b/src/datadog/tracer.cpp
diff --git a/test/mocks/collectors.h b/test/mocks/collectors.h
diff --git a/test/test_datadog_agent.cpp b/test/test_datadog_agent.cpp

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace tracing {`
`11`	`11`	`class NullCollector : public Collector {`
`12`	`12`	`public:`
`13`	`13`	`Expected<void> send(std::vector<std::unique_ptr<SpanData>>&&,`
`14`		`- const std::shared_ptr<ErasedTraceSampler>&) override {`
	`14`	`+ const std::shared_ptr<TraceSampler>&) override {`
`15`	`15`	`return {};`
`16`	`16`	`}`
`17`	`17`