overall improvements

Author: dmehala

CMakeLists.txt

@@ -150,6 +150,7 @@ target_sources(dd_trace_cpp-objects
     src/datadog/trace_sampler_config.cpp
     src/datadog/trace_sampler.cpp
     src/datadog/trace_segment.cpp
+    src/datadog/trace_source.cpp
     src/datadog/telemetry_metrics.cpp
     src/datadog/version.cpp
     src/datadog/w3c_propagation.cpp

include/datadog/datadog_agent_config.h

@@ -22,7 +22,6 @@
 #include "expected.h"
 #include "http_client.h"
 #include "remote_config/listener.h"
-#include "string_view.h"
 
 namespace datadog {
 namespace tracing {
@@ -90,6 +89,11 @@ class FinalizedDatadogAgentConfig {
 
   // Origin detection
   Optional<std::string> admission_controller_uid;
+
+  // Indicate if stats computation should be delegated to the Agent.
+  // This feature is not supported yet, however, we need to inform the Agent to
+  // not compute stats when APM Tracing `DD_APM_TRACING_ENABLED` is disabled.
+  bool stats_computation_enabled;
 };
 
 Expected<FinalizedDatadogAgentConfig> finalize_config(

include/datadog/injection_options.h

@@ -4,19 +4,10 @@
 // parameters to `Span::inject` that alter the behavior of trace context
 // propagation.
 
-#include <array>
-
-#include "optional.h"
-
 namespace datadog {
 namespace tracing {
 
-struct InjectionOptions {
-  // If DD_APM_TRACING_ENABLED=false and what we're injecting is not an APM
-  // trace, then the code for the trace source (e.g. 02 for Appsec) can be
-  // set here.
-  Optional<std::array<char, 2>> trace_source{};
-};
+struct InjectionOptions {};
 
 }  // namespace tracing
 }  // namespace datadog

include/datadog/span.h

@@ -49,6 +49,7 @@
 #include "optional.h"
 #include "string_view.h"
 #include "trace_id.h"
+#include "trace_source.h"
 
 namespace datadog {
 namespace tracing {
@@ -162,6 +163,8 @@ class Span {
   // Set end time of this span.  Doing so will override the default behavior of
   // using the current time in the destructor.
   void set_end_time(std::chrono::steady_clock::time_point);
+  // Specifies the product (AppSec, DBM) that created this span.
+  void set_source(Source);
 
   // Write information about this span and its trace into the specified `writer`
   // using all of the configured injection propagation styles.

include/datadog/trace_sampler_config.h

@@ -24,6 +24,7 @@ struct TraceSamplerRule final {
   Rate rate;
   SpanMatcher matcher;
   SamplingMechanism mechanism;
+  bool bypass_limiter = false;
 };
 
 struct TraceSamplerConfig {
@@ -50,6 +51,10 @@ class FinalizedTraceSamplerConfig {
   double max_per_second;
   std::vector<TraceSamplerRule> rules;
   std::unordered_map<ConfigName, ConfigMetadata> metadata;
+
+ public:
+  /// Returns the trace sampler configuration when APM Tracing is disabled.
+  static FinalizedTraceSamplerConfig apm_tracing_disabled_config();
 };
 
 Expected<FinalizedTraceSamplerConfig> finalize_config(

include/datadog/trace_segment.h

@@ -32,7 +32,6 @@
 #include <utility>
 #include <vector>
 
-#include "expected.h"
 #include "optional.h"
 #include "propagation_style.h"
 #include "runtime_id.h"
@@ -80,6 +79,8 @@ class TraceSegment {
 
   std::shared_ptr<ConfigManager> config_manager_;
 
+  bool tracing_enabled_;
+
  public:
   TraceSegment(const std::shared_ptr<Logger>& logger,
                const std::shared_ptr<Collector>& collector,
@@ -95,7 +96,8 @@ class TraceSegment {
                Optional<SamplingDecision> sampling_decision,
                Optional<std::string> additional_w3c_tracestate,
                Optional<std::string> additional_datadog_w3c_tracestate,
-               std::unique_ptr<SpanData> local_root);
+               std::unique_ptr<SpanData> local_root,
+               bool tracing_enabled = true);
 
   const SpanDefaults& defaults() const;
   const Optional<std::string>& hostname() const;
@@ -118,10 +120,13 @@ class TraceSegment {
   void span_finished();
 
   // Set the sampling decision to be a local, manual decision with the specified
-  // sampling `priority`.  Overwrite any previous sampling decision.
+  // sampling `priority`. Overwrite any previous sampling decision.
   void override_sampling_priority(int priority);
   void override_sampling_priority(SamplingPriority priority);
 
+  // Retrieves the local root span.
+  SpanData& local_root() const;
+
  private:
   // If `sampling_decision_` is null, use `trace_sampler_` to make a
   // sampling decision and assign it to `sampling_decision_`.

include/datadog/trace_source.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <datadog/string_view.h>
+
+namespace datadog {
+namespace tracing {
+
+/// Enumerates the possible trace sources that can generate a span.
+///
+/// This enum class identifies the different products that can create a span.
+/// Each source is represented by a distinct bit flag, allowing for bitwise
+/// operations.
+enum class Source : char {
+  apm = 0x01,
+  appsec = 0x02,
+  datastream_monitoring = 0x04,
+  datajob_monitoring = 0x08,
+  database_monitoring = 0x10,
+};
+
+/// Validates if a given string corresponds to a valid trace source.
+///
+/// This function checks whether the provided string matches any of the
+/// predefined trace sources specified in the Source enum. It is useful for
+/// ensuring that a source string obtained from an external input is valid
+/// before further processing.
+///
+/// @param source_str A string view representing the trace source to validate.
+///
+/// @return true if the source string is valid and corresponds to a known trace
+/// source, false otherwise.
+bool validate_trace_source(StringView source_str);
+
+/// Converts a Source enum value to its corresponding string representation
+inline constexpr StringView to_tag(Source source) {
+  switch (source) {
+    case Source::apm:
+      return "01";
+    case Source::appsec:
+      return "02";
+    case Source::database_monitoring:
+      return "04";
+    case Source::datajob_monitoring:
+      return "08";
+    case Source::datastream_monitoring:
+      return "10";
+  }
+
+  return "";
+}
+
+}  // namespace tracing
+}  // namespace datadog

include/datadog/tracer.h

@@ -54,6 +54,7 @@ class Tracer {
   Baggage::Options baggage_opts_;
   bool baggage_injection_enabled_;
   bool baggage_extraction_enabled_;
+  bool tracing_enabled_;
 
  public:
   // Create a tracer configured using the specified `config`, and optionally:

include/datadog/tracer_config.h

@@ -169,8 +169,15 @@ struct TracerConfig {
   /// separate thread.
   std::shared_ptr<EventScheduler> event_scheduler;
 
-  /// TBD
-  Optional<bool> apm_tracing_enabled;
+  /// `tracing_enabled` indicates whether APM traces and APM trace metrics
+  /// are enabled. If `false`, APM-specific traces are and metrics are dropped
+  /// This allows other products to operate independently (for example, AppSec).
+  /// This is distinct from `report_traces`, which controls whether any traces
+  /// are sent at all.
+  ///
+  /// Overridden by the `DD_APM_TRACING_ENABLED` environment variable. Defaults
+  /// to `true`.
+  Optional<bool> tracing_enabled;
 };
 
 // `FinalizedTracerConfig` contains `Tracer` implementation details derived from
@@ -210,7 +217,7 @@ class FinalizedTracerConfig final {
   HTTPClient::URL agent_url;
   std::shared_ptr<EventScheduler> event_scheduler;
   std::shared_ptr<HTTPClient> http_client;
-  bool apm_tracing_enabled;
+  bool tracing_enabled;
 };
 
 // Return a `FinalizedTracerConfig` from the specified `config` and from any

src/datadog/datadog_agent.cpp

@@ -167,6 +167,9 @@ DatadogAgent::DatadogAgent(
                    tracer_signature.library_language_version);
   headers_.emplace("Datadog-Meta-Tracer-Version",
                    tracer_signature.library_version);
+  if (config.stats_computation_enabled) {
+    headers_.emplace("Datadog-Client-Computed-Stats", "yes");
+  }
 
   // Origin Detection headers are not necessary when Unix Domain Socket (UDS)
   // is used to communicate with the Datadog Agent.