print config as JSON on Tracer startup

Author: dgoffredo

doc/README.md

@@ -14,10 +14,6 @@ Code Component Relationships
 ----------------------------
 ![another diagram](includes.svg)
 
-Example Usage
--------------
-TODO
-
 Objects
 -------
 - _Span_ has a beginning, end, and tags.  It is associated with a _TraceSegment_.

src/datadog/collector.h

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "expected.h"
+#include "json_fwd.hpp"
 
 namespace datadog {
 namespace tracing {
@@ -32,6 +33,16 @@ class Collector {
       std::vector<std::unique_ptr<SpanData>>&& spans,
       const std::shared_ptr<TraceSampler>& response_handler) = 0;
 
+  // Assign to the specified `destination` a JSON representation of this
+  // object's configuration. The JSON representation is an object with
+  // the following properties:
+  //
+  // - "type" is the unmangled, unqualified name of the most-derived class, e.g.
+  //   "DatadogAgent".
+  // - "config" is an object containing this object's configuration. "config"
+  //   may be omitted if the derived class has no configuration.
+  virtual void config_json(nlohmann::json& destination) const = 0;
+
   virtual ~Collector() {}
 };
 

src/datadog/datadog_agent.cpp

@@ -3,6 +3,7 @@
 #include <cassert>
 #include <chrono>
 #include <string>
+#include <typeinfo>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -142,7 +143,8 @@ DatadogAgent::DatadogAgent(const FinalizedDatadogAgentConfig& config,
       http_client_(config.http_client),
       event_scheduler_(config.event_scheduler),
       cancel_scheduled_flush_(event_scheduler_->schedule_recurring_event(
-          config.flush_interval, [this]() { flush(); })) {
+          config.flush_interval, [this]() { flush(); })),
+      flush_interval_(config.flush_interval) {
   assert(logger_);
 }
 
@@ -162,6 +164,25 @@ Expected<void> DatadogAgent::send(
   return std::nullopt;
 }
 
+void DatadogAgent::config_json(nlohmann::json& destination) const {
+  const auto& url = traces_endpoint_;  // brevity
+  const auto flush_interval_milliseconds =
+      std::chrono::duration_cast<std::chrono::milliseconds>(flush_interval_)
+          .count();
+
+  // clang-format off
+  destination = nlohmann::json::object({
+    {"type", "DatadogAgent"},
+    {"config", nlohmann::json::object({
+      {"url", (url.scheme + "://" + url.authority + url.path)},
+      {"flush_interval_milliseconds", flush_interval_milliseconds},
+      {"http_client_typeid", typeid(*http_client_).name()},
+      {"event_scheduler_typeid", typeid(*event_scheduler_).name()},
+    })},
+  });
+  // clang-format on
+}
+
 void DatadogAgent::flush() {
   outgoing_trace_chunks_.clear();
   {

src/datadog/datadog_agent.h

@@ -42,6 +42,7 @@ class DatadogAgent : public Collector {
   std::shared_ptr<HTTPClient> http_client_;
   std::shared_ptr<EventScheduler> event_scheduler_;
   EventScheduler::Cancel cancel_scheduled_flush_;
+  std::chrono::steady_clock::duration flush_interval_;
 
   void flush();
 
@@ -50,9 +51,11 @@ class DatadogAgent : public Collector {
                const std::shared_ptr<Logger>&);
   ~DatadogAgent();
 
-  virtual Expected<void> send(
+  Expected<void> send(
       std::vector<std::unique_ptr<SpanData>>&& spans,
       const std::shared_ptr<TraceSampler>& response_handler) override;
+
+  void config_json(nlohmann::json& destination) const override;
 };
 
 }  // namespace tracing

src/datadog/environment.cpp

@@ -2,6 +2,8 @@
 
 #include <cstdlib>
 
+#include "json.hpp"
+
 namespace datadog {
 namespace tracing {
 namespace environment {
@@ -17,6 +19,15 @@ std::optional<std::string_view> lookup(Variable variable) {
   return std::string_view{value};
 }
 
+void environment_to_json(nlohmann::json &destination) {
+  destination = nlohmann::json::object({});
+  for (const char *name : variable_names) {
+    if (const char *value = std::getenv(name)) {
+      destination[name] = value;
+    }
+  }
+}
+
 }  // namespace environment
 }  // namespace tracing
 }  // namespace datadog

src/datadog/environment.h

@@ -17,6 +17,8 @@
 #include <optional>
 #include <string_view>
 
+#include "json_fwd.hpp"
+
 namespace datadog {
 namespace tracing {
 namespace environment {
@@ -54,7 +56,7 @@ enum Variable { LIST_ENVIRONMENT_VARIABLES(WITH_COMMA) };
 
 #define QUOTED_WITH_COMMA(ARG) WITH_COMMA(QUOTED(ARG))
 
-inline const char *const variable_names[] = {
+inline const char* const variable_names[] = {
     LIST_ENVIRONMENT_VARIABLES(QUOTED_WITH_COMMA)};
 
 #undef QUOTED_WITH_COMMA
@@ -70,6 +72,8 @@ std::string_view name(Variable variable);
 // `std::nullptr` if that variable is not set in the environment.
 std::optional<std::string_view> lookup(Variable variable);
 
+void environment_to_json(nlohmann::json& destination);
+
 }  // namespace environment
 }  // namespace tracing
 }  // namespace datadog

src/datadog/logger.h

@@ -5,7 +5,7 @@
 //
 // Errors, when they occur, are typically returned as `Error` values (often as
 // part of an `Expected` value). However, in "async" contexts where there is
-// nowhere to return a value, the logger is used instead. 
+// nowhere to return a value, the logger is used instead.
 //
 // `Logger`'s pure virtual member functions accept a callback function that is
 // either invoked immediately or not invoked at all, depending on the

src/datadog/null_collector.cpp

@@ -1 +1,18 @@
 #include "null_collector.h"
+
+#include "json.hpp"
+
+namespace datadog {
+namespace tracing {
+
+void NullCollector::config_json(nlohmann::json& destination) const {
+  // clang-format off
+    destination = nlohmann::json::object({
+        {"type", "NullCollector"},
+        {"config", nlohmann::json::object({})},
+    });
+  // clang-format on
+}
+
+}  // namespace tracing
+}  // namespace datadog

src/datadog/null_collector.h

@@ -15,6 +15,8 @@ class NullCollector : public Collector {
                       const std::shared_ptr<TraceSampler>&) override {
     return {};
   }
+
+  void config_json(nlohmann::json& destination) const override;
 };
 
 }  // namespace tracing

src/datadog/parse_util.h

@@ -27,8 +27,8 @@ std::string_view strip(std::string_view input);
 Expected<std::uint64_t> parse_uint64(std::string_view input, int base);
 Expected<int> parse_int(std::string_view input, int base);
 
-// Return a floating point number parsed from the specified `input`, or return an
-// `Error` if not such number can be parsed. It is an error unless all of
+// Return a floating point number parsed from the specified `input`, or return
+// an `Error` if not such number can be parsed. It is an error unless all of
 // `input` is consumed by the parse. Leading and trailing whitespace are not
 // ignored.
 Expected<double> parse_double(std::string_view input);