feat: introduce the option to disable Remote Configuration (#106)

Disable Remote Configuration programmatically or using
`DD_REMOTE_CONFIGURATION_ENABLED=0`.

- Add support for `DD_REMOTE_CONFIGURATION_ENABLED` environment variable
- Cease periodic request for Remote Configuration when the feature
  is disabled.
- Store and cancel scheduled tasks all at once.
- chore: Relocate string utility functions from `parse_util` to
  `string_util`.

Author: dmehala

src/datadog/curl.cpp

@@ -19,7 +19,7 @@
 #include "http_client.h"
 #include "json.hpp"
 #include "logger.h"
-#include "parse_util.h"
+#include "string_util.h"
 #include "string_view.h"
 
 namespace datadog {
@@ -438,8 +438,8 @@ std::size_t CurlImpl::on_read_header(char *data, std::size_t,
     return length;
   }
 
-  const auto key = strip(range(begin, colon));
-  const auto value = strip(range(colon + 1, end));
+  const auto key = trim(range(begin, colon));
+  const auto value = trim(range(colon + 1, end));
 
   std::string key_lower;
   key_lower.reserve(key.size());

src/datadog/datadog_agent.cpp

@@ -160,14 +160,16 @@ DatadogAgent::DatadogAgent(
       remote_configuration_endpoint_(remote_configuration_endpoint(config.url)),
       http_client_(config.http_client),
       event_scheduler_(config.event_scheduler),
-      cancel_scheduled_flush_(event_scheduler_->schedule_recurring_event(
-          config.flush_interval, [this]() { flush(); })),
       flush_interval_(config.flush_interval),
       request_timeout_(config.request_timeout),
       shutdown_timeout_(config.shutdown_timeout),
       remote_config_(tracer_signature, config_manager) {
   assert(logger_);
   assert(tracer_telemetry_);
+
+  tasks_.emplace_back(event_scheduler_->schedule_recurring_event(
+      config.flush_interval, [this]() { flush(); }));
+
   if (tracer_telemetry_->enabled()) {
     // Callback for successful telemetry HTTP requests, to examine HTTP
     // status.
@@ -194,35 +196,39 @@ DatadogAgent::DatadogAgent(
     // Every 10 seconds, have the tracer telemetry capture the metrics
     // values. Every 60 seconds, also report those values to the datadog
     // agent.
-    cancel_telemetry_timer_ = event_scheduler_->schedule_recurring_event(
+    tasks_.emplace_back(event_scheduler_->schedule_recurring_event(
         std::chrono::seconds(10), [this, n = 0]() mutable {
           n++;
           tracer_telemetry_->capture_metrics();
           if (n % 6 == 0) {
             send_heartbeat_and_telemetry();
           }
-        });
+        }));
   }
 
-  cancel_remote_configuration_task_ =
-      event_scheduler_->schedule_recurring_event(
-          config.remote_configuration_poll_interval,
-          [this] { get_and_apply_remote_configuration_updates(); });
+  if (config.remote_configuration_enabled) {
+    tasks_.emplace_back(event_scheduler_->schedule_recurring_event(
+        config.remote_configuration_poll_interval,
+        [this] { get_and_apply_remote_configuration_updates(); }));
+  }
 }
 
 DatadogAgent::~DatadogAgent() {
   const auto deadline = clock_().tick + shutdown_timeout_;
-  cancel_scheduled_flush_();
+
+  for (auto&& cancel_task : tasks_) {
+    cancel_task();
+  }
+
   flush();
-  cancel_remote_configuration_task_();
+
   if (tracer_telemetry_->enabled()) {
-    // This action only needs to occur if tracer telemetry is enabled.
-    cancel_telemetry_timer_();
     tracer_telemetry_->capture_metrics();
     // The app-closing message is bundled with a message containing the
     // final metric values.
     send_app_closing();
   }
+
   http_client_->drain(deadline);
 }
 

src/datadog/datadog_agent.h

@@ -46,9 +46,7 @@ class DatadogAgent : public Collector {
   HTTPClient::URL remote_configuration_endpoint_;
   std::shared_ptr<HTTPClient> http_client_;
   std::shared_ptr<EventScheduler> event_scheduler_;
-  EventScheduler::Cancel cancel_scheduled_flush_;
-  EventScheduler::Cancel cancel_telemetry_timer_;
-  EventScheduler::Cancel cancel_remote_configuration_task_;
+  std::vector<EventScheduler::Cancel> tasks_;
   std::chrono::steady_clock::duration flush_interval_;
   // Callbacks for submitting telemetry data
   HTTPClient::ResponseHandler telemetry_on_response_;

src/datadog/datadog_agent_config.cpp

@@ -15,6 +15,10 @@ namespace tracing {
 Expected<DatadogAgentConfig> load_datadog_agent_env_config() {
   DatadogAgentConfig env_config;
 
+  if (auto rc_enabled = lookup(environment::DD_REMOTE_CONFIGURATION_ENABLED)) {
+    env_config.remote_configuration_enabled = !falsy(*rc_enabled);
+  }
+
   if (auto raw_rc_poll_interval_value =
           lookup(environment::DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS)) {
     auto res = parse_int(*raw_rc_poll_interval_value, 10);
@@ -122,6 +126,10 @@ Expected<FinalizedDatadogAgentConfig> finalize_config(
                  "positive number of seconds."};
   }
 
+  result.remote_configuration_enabled =
+      value_or(env_config->remote_configuration_enabled,
+               user_config.remote_configuration_enabled, true);
+
   const auto [origin, url] =
       pick(env_config->url, user_config.url, "http://localhost:8126");
   auto parsed_url = HTTPClient::URL::parse(url);

src/datadog/datadog_agent_config.h

@@ -56,6 +56,9 @@ struct DatadogAgentConfig {
   Optional<int> request_timeout_milliseconds;
   // Maximum amount of time the process is allowed to wait before shutting down.
   Optional<int> shutdown_timeout_milliseconds;
+  // Enable the capability that allows to remotely configure and change the
+  // behavior of the tracer.
+  Optional<bool> remote_configuration_enabled;
   // How often, in seconds, to query the Datadog Agent for remote configuration
   // updates.
   Optional<int> remote_configuration_poll_interval_seconds;
@@ -71,6 +74,7 @@ class FinalizedDatadogAgentConfig {
 
  public:
   Clock clock;
+  bool remote_configuration_enabled;
   std::shared_ptr<HTTPClient> http_client;
   std::shared_ptr<EventScheduler> event_scheduler;
   HTTPClient::URL url;

src/datadog/environment.h

@@ -30,6 +30,7 @@ namespace environment {
   MACRO(DD_INSTRUMENTATION_TELEMETRY_ENABLED)   \
   MACRO(DD_PROPAGATION_STYLE_EXTRACT)           \
   MACRO(DD_PROPAGATION_STYLE_INJECT)            \
+  MACRO(DD_REMOTE_CONFIGURATION_ENABLED)        \
   MACRO(DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS) \
   MACRO(DD_SERVICE)                             \
   MACRO(DD_SPAN_SAMPLING_RULES)                 \

src/datadog/extraction_util.cpp

@@ -10,6 +10,7 @@
 #include "json.hpp"
 #include "logger.h"
 #include "parse_util.h"
+#include "string_util.h"
 #include "tag_propagation.h"
 #include "tags.h"
 

src/datadog/http_client.cpp

@@ -1,6 +1,6 @@
 #include "http_client.h"
 
-#include "parse_util.h"
+#include "string_util.h"
 
 namespace datadog {
 namespace tracing {

src/datadog/parse_util.cpp

@@ -1,10 +1,10 @@
 #include "parse_util.h"
 
 #include <algorithm>
-#include <cassert>
 #include <cctype>
 #include <charconv>
-#include <iterator>
+#include <cstddef>
+#include <cstdint>
 #include <sstream>
 #include <string>
 
@@ -44,20 +44,10 @@ Expected<Integer> parse_integer(StringView input, int base, StringView kind) {
 
 }  // namespace
 
-StringView strip(StringView input) {
-  const auto not_whitespace = [](unsigned char ch) {
-    return !std::isspace(ch);
-  };
-  const char *const begin =
-      std::find_if(input.begin(), input.end(), not_whitespace);
-  const char *const end =
-      std::find_if(input.rbegin(), std::make_reverse_iterator(begin),
-                   not_whitespace)
-          .base();
-
-  assert(begin <= end);
-
-  return StringView{begin, std::size_t(end - begin)};
+bool falsy(StringView input) {
+  auto lower = std::string{input};
+  to_lower(lower);
+  return lower == "0" || lower == "false" || lower == "no";
 }
 
 Expected<std::uint64_t> parse_uint64(StringView input, int base) {
@@ -99,27 +89,13 @@ Expected<double> parse_double(StringView input) {
   return value;
 }
 
-bool starts_with(StringView subject, StringView prefix) {
-  if (prefix.size() > subject.size()) {
-    return false;
-  }
-
-  return std::mismatch(subject.begin(), subject.end(), prefix.begin()).second ==
-         prefix.end();
-}
-
-void to_lower(std::string &text) {
-  std::transform(text.begin(), text.end(), text.begin(),
-                 [](unsigned char ch) { return std::tolower(ch); });
-}
-
 // List items are separated by an optional comma (",") and any amount of
 // whitespace.
 // Leading and trailing whitespace is ignored.
 std::vector<StringView> parse_list(StringView input) {
   using uchar = unsigned char;
 
-  input = strip(input);
+  input = trim(input);
   std::vector<StringView> items;
   if (input.empty()) {
     return items;

src/datadog/parse_util.h

@@ -2,8 +2,7 @@
 
 // This component provides parsing-related miscellanea.
 
-#include <cstddef>
-#include <cstdint>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
@@ -13,20 +12,16 @@
 namespace datadog {
 namespace tracing {
 
-// Return a `string_view` over the specified range of characters `[begin, end)`.
-inline StringView range(const char* begin, const char* end) {
-  return StringView{begin, std::size_t(end - begin)};
-}
-
-// Remove leading and trailing whitespace (as determined by `std::isspace`) from
-// the specified `input`.
-StringView strip(StringView input);
+bool falsy(StringView input);
 
 // Return a non-negative integer parsed from the specified `input` with respect
 // to the specified `base`, or return an `Error` if no such integer can be
 // parsed. It is an error unless all of `input` is consumed by the parse.
 // Leading and trailing whitespace are not ignored.
 Expected<std::uint64_t> parse_uint64(StringView input, int base);
+
+// Return an integer parsed from the specified `input` with respect to the
+// specified `base`, or return an `Error` if no such integer can be parsed.
 Expected<int> parse_int(StringView input, int base);
 
 // Return a floating point number parsed from the specified `input`, or return
@@ -35,12 +30,6 @@ Expected<int> parse_int(StringView input, int base);
 // ignored.
 Expected<double> parse_double(StringView input);
 
-// Return whether the specified `prefix` is a prefix of the specified `subject`.
-bool starts_with(StringView subject, StringView prefix);
-
-// Convert the specified `text` to lower case in-place.
-void to_lower(std::string& text);
-
 // List items are separated by an optional comma (",") and any amount of
 // whitespace.
 // Leading and trailing whitespace are ignored.