wip

Author: Damien MEHALA

examples/baggage/main.cpp

@@ -14,7 +14,7 @@ struct CinReader : public dd::DictReader {
 
   void visit(
       const std::function<void(dd::StringView key, dd::StringView value)>&
-          visitor) const override{};
+          visitor) const override {};
 };
 
 std::istream& operator>>(std::istream& is, CinReader& reader) {
@@ -24,7 +24,7 @@ std::istream& operator>>(std::istream& is, CinReader& reader) {
 
 std::ostream& operator<<(std::ostream& os, dd::Baggage::Error error) {
   using dd::Baggage;
-  switch (error) {
+  switch (error.code) {
     case Baggage::Error::MISSING_HEADER:
       os << "missing `baggage` header";
       break;
@@ -47,7 +47,14 @@ std::ostream& operator<<(std::ostream& os, dd::Baggage::Error error) {
 int main() {
   dd::TracerConfig cfg;
   cfg.log_on_startup = false;
+  cfg.telemetry.enabled = false;
+  cfg.agent.remote_configuration_enabled = false;
   const auto finalized_cfg = datadog::tracing::finalize_config(cfg);
+  if (auto error = finalized_cfg.if_error()) {
+    std::cerr << "Failed to initialize the tracer: " << error->message
+              << std::endl;
+    return error->code;
+  }
 
   dd::Tracer tracer(*finalized_cfg);
 

include/datadog/baggage.h

@@ -1,10 +1,11 @@
+#pragma once
+
 #include <datadog/dict_reader.h>
 #include <datadog/dict_writer.h>
 #include <datadog/expected.h>
 #include <datadog/optional.h>
 #include <datadog/string_view.h>
 
-#include <initializer_list>
 #include <string>
 #include <unordered_map>
 
@@ -22,31 +23,42 @@ namespace tracing {
 /// interface using the `inject` method.
 class Baggage {
  public:
-  enum class Error : char {
-    /// Baggage propagation is disabled. This may be due to one of the following
-    /// reasons:
-    /// - `baggage` is not set as an extraction or injection propagation style.
-    /// - The maximum number of items is less than 0.
-    /// - The number of bytes is less than 3.
-    DISABLED,
-    MISSING_HEADER,
-    MALFORMED_BAGGAGE_HEADER,
-    MAXIMUM_CAPACITY_REACHED,
-    MAXIMUM_BYTES_REACHED,
+  struct Error final {
+    enum Code : char {
+      /// Baggage propagation is disabled. This may be due to one of the
+      /// following
+      /// reasons:
+      /// - `baggage` is not set as an extraction or injection propagation
+      /// style.
+      /// - The maximum number of items is less than 0.
+      /// - The number of bytes is less than 3.
+      DISABLED,
+      MISSING_HEADER,
+      MALFORMED_BAGGAGE_HEADER,
+      MAXIMUM_CAPACITY_REACHED,
+      MAXIMUM_BYTES_REACHED,
+    };
+    Code code;
+    Optional<size_t> pos;
+
+    Error(Code in_code) : code(in_code), pos(nullopt) {}
+    Error(Code in_code, size_t position) : code(in_code), pos(position) {}
+  };
+
+  struct Options final {
+    size_t max_bytes;
+    size_t max_items;
   };
 
   static constexpr size_t default_max_capacity = 64;
+  static constexpr Options default_options{2048, default_max_capacity};
 
   /// Extracts a Baggage instance from a `DictReader` and creates a Baggage
   /// instance if no errors are encounters .
   ///
   /// @param `reader` The input `DictReader` from which to extract the data.
-  /// @param `max_capacity` The maximum number of Baggage items allowd to
-  /// parse. An error is returned when the number of element parsed exceed this
-  /// value. If not specified, a default capacity is used.
   /// @return A `Baggage` instance or an `Error`.
-  static Expected<Baggage, Error> extract(
-      const DictReader& reader, size_t max_capacity = default_max_capacity);
+  static Expected<Baggage, Error> extract(const DictReader& reader);
 
   /// Initializes an empty Baggage with the default maximum capacity.
   Baggage() = default;
@@ -65,14 +77,6 @@ class Baggage {
   Baggage(std::unordered_map<std::string, std::string>,
           size_t max_capacity = default_max_capacity);
 
-  /// Initializes a Baggage instance using the provided initializer list of
-  /// key-value pairs. The maximum capacity can also be specified.
-  ///
-  /// @param `init_list` An initializer list containing key-value pairs.
-  /// @param `max_capacity` The maximum capacity for this Baggage instance.
-  Baggage(std::initializer_list<std::pair<const std::string, std::string>>,
-          size_t max_capacity = default_max_capacity);
-
   /// Checks if the Baggage contains a specified key.
   ///
   /// @param `key` The key to check.
@@ -124,10 +128,11 @@ class Baggage {
   /// limit.
   ///
   /// @param `writer` The DictWriter to inject the data into.
-  /// @param `max_bytes` The maximum number of bytes to write.
+  /// @param `opts` Injection options.
   /// @return An `Expected<void>`, which may either succeed or contain an
   /// error.
-  Expected<void> inject(DictWriter& writer, size_t max_bytes) const;
+  Expected<void> inject(DictWriter& writer,
+                        const Options& opts = default_options) const;
 
   /// Equality operator for comparing two Baggage instances.
   inline bool operator==(const Baggage& rhs) const {

include/datadog/propagation_style.h

@@ -22,7 +22,7 @@ enum class PropagationStyle {
   // propagation is disabled in the relevant direction (extraction or
   // injection).
   NONE,
-  // TBD
+  // Baggage header
   BAGGAGE,
 };
 

include/datadog/tracer.h

@@ -54,8 +54,7 @@ class Tracer {
   // read to determine if the process is instrumented with a tracer and to
   // retrieve relevant tracing information.
   std::shared_ptr<InMemoryFile> metadata_file_;
-  std::size_t baggage_max_items_;
-  std::size_t baggage_max_bytes_;
+  Baggage::Options baggage_opts_;
   bool baggage_injection_enabled_;
   bool baggage_extraction_enabled_;
 

include/datadog/tracer_config.h

@@ -11,6 +11,7 @@
 #include <variant>
 #include <vector>
 
+#include "baggage.h"
 #include "clock.h"
 #include "datadog_agent_config.h"
 #include "expected.h"
@@ -201,8 +202,7 @@ class FinalizedTracerConfig final {
   bool delegate_trace_sampling;
   bool report_traces;
   std::unordered_map<ConfigName, ConfigMetadata> metadata;
-  std::size_t baggage_max_items;
-  std::size_t baggage_max_bytes;
+  Baggage::Options baggage_opts;
 };
 
 // Return a `FinalizedTracerConfig` from the specified `config` and from any

src/datadog/baggage.cpp

@@ -6,7 +6,7 @@ namespace tracing {
 namespace {
 
 Expected<std::unordered_map<std::string, std::string>, Baggage::Error>
-parse_baggage(StringView input, size_t max_capacity) {
+parse_baggage(StringView input) {
   std::unordered_map<std::string, std::string> result;
   if (input.empty()) return result;
 
@@ -29,9 +29,6 @@ parse_baggage(StringView input, size_t max_capacity) {
     switch (internal_state) {
       case state::leading_spaces_key: {
         if (input[i] != ' ') {
-          if (result.size() == max_capacity)
-            return Baggage::Error::MAXIMUM_CAPACITY_REACHED;
-
           beg = i;
           tmp_end = i;
           internal_state = state::key;
@@ -40,7 +37,7 @@ parse_baggage(StringView input, size_t max_capacity) {
 
       case state::key: {
         if (input[i] == ',') {
-          return Baggage::Error::MALFORMED_BAGGAGE_HEADER;
+          return Baggage::Error{Baggage::Error::MALFORMED_BAGGAGE_HEADER, i};
         } else if (input[i] == '=') {
           key = StringView{input.data() + beg, tmp_end - beg + 1};
           internal_state = state::leading_spaces_value;
@@ -72,7 +69,7 @@ parse_baggage(StringView input, size_t max_capacity) {
   }
 
   if (internal_state != state::value) {
-    return Baggage::Error::MALFORMED_BAGGAGE_HEADER;
+    return {Baggage::Error::MALFORMED_BAGGAGE_HEADER};
   }
 
   value = StringView{input.data() + beg, tmp_end - beg + 1};
@@ -85,11 +82,6 @@ parse_baggage(StringView input, size_t max_capacity) {
 
 Baggage::Baggage(size_t max_capacity) : max_capacity_(max_capacity) {}
 
-Baggage::Baggage(
-    std::initializer_list<std::pair<const std::string, std::string>> baggage,
-    size_t max_capacity)
-    : max_capacity_(max_capacity), baggage_(baggage) {}
-
 Baggage::Baggage(std::unordered_map<std::string, std::string> baggage,
                  size_t max_capacity)
     : max_capacity_(max_capacity), baggage_(std::move(baggage)) {}
@@ -127,12 +119,15 @@ void Baggage::visit(std::function<void(StringView, StringView)>&& visitor) {
   }
 }
 
-Expected<void> Baggage::inject(DictWriter& writer, size_t max_bytes) const {
+Expected<void> Baggage::inject(DictWriter& writer, const Options& opts) const {
   if (baggage_.empty()) return {};
+  if (baggage_.size() > opts.max_items)
+    return datadog::tracing::Error{
+        datadog::tracing::Error::Code::BAGGAGE_MAXIMUM_BYTES_REACHED, ""};
 
   // TODO(@dmehala): Memory alloc optimization, (re)use fixed size buffer.
   std::string res;
-  res.reserve(max_bytes);
+  res.reserve(opts.max_bytes);
 
   auto it = baggage_.cbegin();
   res += it->first;
@@ -146,7 +141,7 @@ Expected<void> Baggage::inject(DictWriter& writer, size_t max_bytes) const {
     res += it->second;
   }
 
-  if (res.size() >= max_bytes)
+  if (res.size() >= opts.max_bytes)
     return datadog::tracing::Error{
         datadog::tracing::Error::Code::BAGGAGE_MAXIMUM_BYTES_REACHED, ""};
 
@@ -156,20 +151,19 @@ Expected<void> Baggage::inject(DictWriter& writer, size_t max_bytes) const {
   return {};
 }
 
-Expected<Baggage, Baggage::Error> Baggage::extract(const DictReader& headers,
-                                                   size_t max_capacity) {
+Expected<Baggage, Baggage::Error> Baggage::extract(const DictReader& headers) {
   auto found = headers.lookup("baggage");
   if (!found) {
-    return Error::MISSING_HEADER;
+    return Baggage::Error{Error::MISSING_HEADER};
   }
 
   // TODO(@dmehala): Avoid allocation
-  auto bv = parse_baggage(*found, max_capacity);
+  auto bv = parse_baggage(*found);
   if (auto error = bv.if_error()) {
     return *error;
   }
 
-  Baggage result(*bv, max_capacity);
+  Baggage result(*bv);
   return result;
 }
 

src/datadog/tracer.cpp

@@ -60,8 +60,7 @@ Tracer::Tracer(const FinalizedTracerConfig& config,
       extraction_styles_(config.extraction_styles),
       tags_header_max_size_(config.tags_header_size),
       sampling_delegation_enabled_(config.delegate_trace_sampling),
-      baggage_max_items_(config.baggage_max_items),
-      baggage_max_bytes_(config.baggage_max_bytes),
+      baggage_opts_(config.baggage_opts),
       baggage_injection_enabled_(false),
       baggage_extraction_enabled_(false) {
   if (config.report_hostname) {
@@ -120,6 +119,10 @@ std::string Tracer::config() const {
     {"extraction_styles", extraction_styles_},
     {"tags_header_size", tags_header_max_size_},
     {"environment_variables", nlohmann::json::parse(environment::to_json())},
+    {"baggage", nlohmann::json{
+      {"max_bytes", baggage_opts_.max_bytes},
+      {"max_items", baggage_opts_.max_items},
+    }},
   });
   // clang-format on
 
@@ -420,15 +423,15 @@ Span Tracer::extract_or_create_span(const DictReader& reader,
   return create_span(config);
 }
 
-Baggage Tracer::create_baggage() { return Baggage(baggage_max_items_); }
+Baggage Tracer::create_baggage() { return Baggage(baggage_opts_.max_items); }
 
 Expected<Baggage, Baggage::Error> Tracer::extract_baggage(
     const DictReader& reader) {
   if (!baggage_extraction_enabled_) {
-    return Baggage::Error::DISABLED;
+    return Baggage::Error{Baggage::Error::DISABLED};
   }
 
-  return Baggage::extract(reader, baggage_max_items_);
+  return Baggage::extract(reader);
 }
 
 Baggage Tracer::extract_or_create_baggage(const DictReader& reader) {
@@ -446,7 +449,7 @@ Expected<void> Tracer::inject(const Baggage& baggage, DictWriter& writer) {
     return Error{Error::Code::OTHER, "Baggage propagation is disabled"};
   }
 
-  return baggage.inject(writer, baggage_max_bytes_);
+  return baggage.inject(writer, baggage_opts_);
 }
 
 }  // namespace tracing

src/datadog/tracer_config.cpp

@@ -380,20 +380,20 @@ Expected<FinalizedTracerConfig> finalize_config(const TracerConfig &user_config,
                tracer_version);
 
   // Baggage
-  std::tie(origin, final_config.baggage_max_items) =
+  std::tie(origin, final_config.baggage_opts.max_items) =
       pick(env_config->baggage_max_items, user_config.baggage_max_items, 64);
   final_config.metadata[ConfigName::TRACE_BAGGAGE_MAX_ITEMS] =
       ConfigMetadata(ConfigName::TRACE_BAGGAGE_MAX_ITEMS,
-                     to_string(final_config.baggage_max_items), origin);
+                     to_string(final_config.baggage_opts.max_items), origin);
 
-  std::tie(origin, final_config.baggage_max_bytes) =
+  std::tie(origin, final_config.baggage_opts.max_bytes) =
       pick(env_config->baggage_max_bytes, user_config.baggage_max_bytes, 8192);
   final_config.metadata[ConfigName::TRACE_BAGGAGE_MAX_BYTES] =
       ConfigMetadata(ConfigName::TRACE_BAGGAGE_MAX_BYTES,
-                     to_string(final_config.baggage_max_bytes), origin);
+                     to_string(final_config.baggage_opts.max_bytes), origin);
 
-  if (final_config.baggage_max_items <= 0 ||
-      final_config.baggage_max_bytes < 3) {
+  if (final_config.baggage_opts.max_items <= 0 ||
+      final_config.baggage_opts.max_bytes < 3) {
     auto it = std::remove(final_config.extraction_styles.begin(),
                           final_config.extraction_styles.end(),
                           PropagationStyle::BAGGAGE);