code review suggestions:

src/datadog/curl.cpp

@@ -96,7 +96,7 @@ CURLcode CurlLibrary::easy_setopt_writefunction(CURL *handle,
   return curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, on_write);
 }
 
-CURLcode CurlLibrary::easy_setopt_timeout(CURL *handle, long timeout_ms) {
+CURLcode CurlLibrary::easy_setopt_timeout_ms(CURL *handle, long timeout_ms) {
   return curl_easy_setopt(handle, CURLOPT_TIMEOUT_MS, timeout_ms);
 }
 
@@ -167,14 +167,14 @@ class CurlImpl {
   std::mutex mutex_;
   CurlLibrary &curl_;
   const std::shared_ptr<Logger> logger_;
+  Clock clock_;
   CURLM *multi_handle_;
   std::unordered_set<CURL *> request_handles_;
   std::list<CURL *> new_handles_;
   bool shutting_down_;
   int num_active_handles_;
   std::condition_variable no_requests_;
   std::thread event_loop_;
-  Clock clock_;
 
   struct Request {
     CurlLibrary *curl = nullptr;
@@ -185,7 +185,7 @@ class CurlImpl {
     char error_buffer[CURL_ERROR_SIZE] = "";
     std::unordered_map<std::string, std::string> response_headers_lower;
     std::string response_body;
-    HTTPClient::Deadline deadline;
+    std::chrono::steady_clock::time_point deadline;
 
     ~Request();
   };
@@ -228,13 +228,14 @@ class CurlImpl {
   static StringView trim(StringView);
 
  public:
-  explicit CurlImpl(const std::shared_ptr<Logger> &, CurlLibrary &,
-                    const Curl::ThreadGenerator &);
+  explicit CurlImpl(const std::shared_ptr<Logger> &, const Clock &,
+                    CurlLibrary &, const Curl::ThreadGenerator &);
   ~CurlImpl();
 
   Expected<void> post(const URL &url, HeadersSetter set_headers,
                       std::string body, ResponseHandler on_response,
-                      ErrorHandler on_error, HTTPClient::Deadline deadline);
+                      ErrorHandler on_error,
+                      std::chrono::steady_clock::time_point deadline);
 
   void drain(std::chrono::steady_clock::time_point deadline);
 };
@@ -249,21 +250,24 @@ void throw_on_error(CURLcode result) {
 
 }  // namespace
 
-Curl::Curl(const std::shared_ptr<Logger> &logger) : Curl(logger, libcurl) {}
+Curl::Curl(const std::shared_ptr<Logger> &logger, const Clock &clock)
+    : Curl(logger, clock, libcurl) {}
 
-Curl::Curl(const std::shared_ptr<Logger> &logger, CurlLibrary &curl)
-    : Curl(logger, curl,
+Curl::Curl(const std::shared_ptr<Logger> &logger, const Clock &clock,
+           CurlLibrary &curl)
+    : Curl(logger, clock, curl,
            [](auto &&func) { return std::thread(std::move(func)); }) {}
 
-Curl::Curl(const std::shared_ptr<Logger> &logger, CurlLibrary &curl,
-           const Curl::ThreadGenerator &make_thread)
-    : impl_(new CurlImpl{logger, curl, make_thread}) {}
+Curl::Curl(const std::shared_ptr<Logger> &logger, const Clock &clock,
+           CurlLibrary &curl, const Curl::ThreadGenerator &make_thread)
+    : impl_(new CurlImpl{logger, clock, curl, make_thread}) {}
 
 Curl::~Curl() { delete impl_; }
 
 Expected<void> Curl::post(const URL &url, HeadersSetter set_headers,
                           std::string body, ResponseHandler on_response,
-                          ErrorHandler on_error, Deadline deadline) {
+                          ErrorHandler on_error,
+                          std::chrono::steady_clock::time_point deadline) {
   return impl_->post(url, set_headers, body, on_response, on_error, deadline);
 }
 
@@ -275,10 +279,11 @@ nlohmann::json Curl::config_json() const {
   return nlohmann::json::object({{"type", "datadog::tracing::Curl"}});
 }
 
-CurlImpl::CurlImpl(const std::shared_ptr<Logger> &logger, CurlLibrary &curl,
-                   const Curl::ThreadGenerator &make_thread)
+CurlImpl::CurlImpl(const std::shared_ptr<Logger> &logger, const Clock &clock,
+                   CurlLibrary &curl, const Curl::ThreadGenerator &make_thread)
     : curl_(curl),
       logger_(logger),
+      clock_(clock),
       shutting_down_(false),
       num_active_handles_(0) {
   curl_.global_init(CURL_GLOBAL_ALL);
@@ -323,11 +328,10 @@ CurlImpl::~CurlImpl() {
   curl_.global_cleanup();
 }
 
-Expected<void> CurlImpl::post(const HTTPClient::URL &url,
-                              HeadersSetter set_headers, std::string body,
-                              ResponseHandler on_response,
-                              ErrorHandler on_error,
-                              HTTPClient::Deadline deadline) try {
+Expected<void> CurlImpl::post(
+    const HTTPClient::URL &url, HeadersSetter set_headers, std::string body,
+    ResponseHandler on_response, ErrorHandler on_error,
+    std::chrono::steady_clock::time_point deadline) try {
   if (multi_handle_ == nullptr) {
     return Error{Error::CURL_HTTP_CLIENT_NOT_RUNNING,
                  "Unable to send request via libcurl because the HTTP client "
@@ -509,18 +513,27 @@ void CurlImpl::run() {
 
       auto *request = reinterpret_cast<Request *>(user_data);
       const auto timeout = request->deadline - clock_().tick;
-      if (timeout <= HTTPClient::Deadline::duration::zero()) {
+      if (timeout <= std::chrono::steady_clock::time_point::duration::zero()) {
+        std::string message;
+        message +=
+            "Request deadline exceeded before request was even added to "
+            "libcurl "
+            "event loop. Deadline was ";
+        message += std::to_string(
+            -std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
+                 .count());
+        message += " nanoseconds ago.";
         request->on_error(
-            Error{Error::CURL_REQUEST_FAILURE,
-                  "Request not processed as the deadline has been reached."});
+            Error{Error::CURL_DEADLINE_EXCEEDED_BEFORE_REQUEST_START,
+                  std::move(message)});
 
         curl_.easy_cleanup(handle);
         delete request;
 
         continue;
       }
 
-      throw_on_error(curl_.easy_setopt_timeout(
+      log_on_error(curl_.easy_setopt_timeout_ms(
           handle, std::chrono::duration_cast<std::chrono::milliseconds>(timeout)
                       .count()));
       log_on_error(curl_.multi_add_handle(multi_handle_, handle));

src/datadog/curl.h

@@ -17,6 +17,7 @@
 #include <string>
 #include <thread>
 
+#include "clock.h"
 #include "http_client.h"
 #include "json_fwd.hpp"
 
@@ -59,7 +60,7 @@ class CurlLibrary {
   virtual CURLcode easy_setopt_url(CURL *handle, const char *url);
   virtual CURLcode easy_setopt_writedata(CURL *handle, void *data);
   virtual CURLcode easy_setopt_writefunction(CURL *handle, WriteCallback);
-  virtual CURLcode easy_setopt_timeout(CURL *handle, long timeout_ms);
+  virtual CURLcode easy_setopt_timeout_ms(CURL *handle, long timeout_ms);
   virtual const char *easy_strerror(CURLcode error);
   virtual void global_cleanup();
   virtual CURLcode global_init(long flags);
@@ -87,16 +88,18 @@ class Curl : public HTTPClient {
  public:
   using ThreadGenerator = std::function<std::thread(std::function<void()> &&)>;
 
-  explicit Curl(const std::shared_ptr<Logger> &);
-  Curl(const std::shared_ptr<Logger> &, CurlLibrary &);
-  Curl(const std::shared_ptr<Logger> &, CurlLibrary &, const ThreadGenerator &);
+  explicit Curl(const std::shared_ptr<Logger> &, const Clock &);
+  Curl(const std::shared_ptr<Logger> &, const Clock &, CurlLibrary &);
+  Curl(const std::shared_ptr<Logger> &, const Clock &, CurlLibrary &,
+       const ThreadGenerator &);
   ~Curl();
 
   Curl(const Curl &) = delete;
 
   Expected<void> post(const URL &url, HeadersSetter set_headers,
                       std::string body, ResponseHandler on_response,
-                      ErrorHandler on_error, Deadline deadline) override;
+                      ErrorHandler on_error,
+                      std::chrono::steady_clock::time_point deadline) override;
 
   void drain(std::chrono::steady_clock::time_point deadline) override;
 

src/datadog/datadog_agent.cpp

@@ -125,9 +125,8 @@ std::variant<CollectorResponse, std::string> parse_agent_traces_response(
 }  // namespace
 
 DatadogAgent::DatadogAgent(const FinalizedDatadogAgentConfig& config,
-                           const Clock& clock,
                            const std::shared_ptr<Logger>& logger)
-    : clock_(clock),
+    : clock_(config.clock),
       logger_(logger),
       traces_endpoint_(traces_endpoint(config.url)),
       http_client_(config.http_client),

src/datadog/datadog_agent.h

@@ -46,7 +46,7 @@ class DatadogAgent : public Collector {
   void flush();
 
  public:
-  DatadogAgent(const FinalizedDatadogAgentConfig&, const Clock& clock,
+  DatadogAgent(const FinalizedDatadogAgentConfig&,
                const std::shared_ptr<Logger>&);
   ~DatadogAgent();
 

src/datadog/datadog_agent_config.cpp

@@ -84,11 +84,14 @@ Expected<HTTPClient::URL> DatadogAgentConfig::parse(StringView input) {
 }
 
 Expected<FinalizedDatadogAgentConfig> finalize_config(
-    const DatadogAgentConfig& config, const std::shared_ptr<Logger>& logger) {
+    const DatadogAgentConfig& config, const std::shared_ptr<Logger>& logger,
+    const Clock& clock) {
   FinalizedDatadogAgentConfig result;
 
+  result.clock = clock;
+
   if (!config.http_client) {
-    result.http_client = default_http_client(logger);
+    result.http_client = default_http_client(logger, clock);
     // `default_http_client` might return a `Curl` instance depending on how
     // this library was built.  If it returns `nullptr`, then there's no
     // built-in default, and so the user must provide a value.

src/datadog/datadog_agent_config.h

@@ -16,6 +16,7 @@
 #include <string>
 #include <variant>
 
+#include "clock.h"
 #include "expected.h"
 #include "http_client.h"
 #include "string_view.h"
@@ -59,7 +60,7 @@ struct DatadogAgentConfig {
 
 class FinalizedDatadogAgentConfig {
   friend Expected<FinalizedDatadogAgentConfig> finalize_config(
-      const DatadogAgentConfig& config, const std::shared_ptr<Logger>& logger);
+      const DatadogAgentConfig&, const std::shared_ptr<Logger>&, const Clock&);
 
   FinalizedDatadogAgentConfig() = default;
 
@@ -70,10 +71,12 @@ class FinalizedDatadogAgentConfig {
   std::chrono::steady_clock::duration flush_interval;
   std::chrono::steady_clock::duration request_timeout;
   std::chrono::steady_clock::duration shutdown_timeout;
+  Clock clock;
 };
 
 Expected<FinalizedDatadogAgentConfig> finalize_config(
-    const DatadogAgentConfig& config, const std::shared_ptr<Logger>& logger);
+    const DatadogAgentConfig& config, const std::shared_ptr<Logger>& logger,
+    const Clock& clock);
 
 }  // namespace tracing
 }  // namespace datadog

src/datadog/default_http_client.h

@@ -9,14 +9,16 @@
 
 #include <memory>
 
+#include "clock.h"
+
 namespace datadog {
 namespace tracing {
 
 class HTTPClient;
 class Logger;
 
 std::shared_ptr<HTTPClient> default_http_client(
-    const std::shared_ptr<Logger>& logger);
+    const std::shared_ptr<Logger>& logger, const Clock& clock);
 
 }  // namespace tracing
 }  // namespace datadog

src/datadog/default_http_client_curl.cpp

@@ -12,8 +12,8 @@ namespace datadog {
 namespace tracing {
 
 std::shared_ptr<HTTPClient> default_http_client(
-    const std::shared_ptr<Logger>& logger) {
-  return std::make_shared<Curl>(logger);
+    const std::shared_ptr<Logger>& logger, const Clock& clock) {
+  return std::make_shared<Curl>(logger, clock);
 }
 
 }  // namespace tracing

src/datadog/default_http_client_null.cpp

@@ -9,8 +9,8 @@
 namespace datadog {
 namespace tracing {
 
-std::shared_ptr<HTTPClient> default_http_client(
-    const std::shared_ptr<Logger>&) {
+std::shared_ptr<HTTPClient> default_http_client(const std::shared_ptr<Logger> &,
+                                                const Clock &) {
   return nullptr;
 }
 

src/datadog/error.h

@@ -70,6 +70,7 @@ struct Error {
     MULTIPLE_PROPAGATION_STYLE_ENVIRONMENT_VARIABLES = 45,
     DUPLICATE_PROPAGATION_STYLE = 46,
     ZERO_TRACE_ID = 47,
+    CURL_DEADLINE_EXCEEDED_BEFORE_REQUEST_START = 48,
   };
 
   Code code;

src/datadog/http_client.h

@@ -36,7 +36,6 @@ class HTTPClient {
   // `ErrorHandler` is for errors encountered by `HTTPClient`, not for
   // error-indicating HTTP responses.
   using ErrorHandler = std::function<void(Error)>;
-  using Deadline = std::chrono::steady_clock::time_point;
 
   // Send a POST request to the specified `url`.  Set request headers by calling
   // the specified `set_headers` callback.  Include the specified `body` at the
@@ -45,13 +44,14 @@ class HTTPClient {
   // response status).  Invoke the specified `on_error` if an error occurs
   // outside of HTTP, such as a connection failure.  If an error occurs while
   // preparing the request, return an `Error`.
-  virtual Expected<void> post(const URL& url, HeadersSetter set_headers,
-                              std::string body, ResponseHandler on_response,
-                              ErrorHandler on_error, Deadline deadline) = 0;
+  virtual Expected<void> post(
+      const URL& url, HeadersSetter set_headers, std::string body,
+      ResponseHandler on_response, ErrorHandler on_error,
+      std::chrono::steady_clock::time_point deadline) = 0;
 
   // Wait until there are no more outstanding requests, or until the specified
   // `deadline`.
-  virtual void drain(Deadline deadline) = 0;
+  virtual void drain(std::chrono::steady_clock::time_point deadline) = 0;
 
   // Return a JSON representation of this object's configuration. The JSON
   // representation is an object with the following properties:

src/datadog/tracer.cpp

@@ -200,26 +200,18 @@ Expected<ExtractedData> extract_b3(
 }  // namespace
 
 Tracer::Tracer(const FinalizedTracerConfig& config)
-    : Tracer(config, default_id_generator(config.trace_id_128_bit),
-             default_clock) {}
+    : Tracer(config, default_id_generator(config.trace_id_128_bit)) {}
 
 Tracer::Tracer(const FinalizedTracerConfig& config,
                const std::shared_ptr<const IDGenerator>& generator)
-    : Tracer(config, generator, default_clock) {}
-
-Tracer::Tracer(const FinalizedTracerConfig& config, const Clock& clock)
-    : Tracer(config, default_id_generator(config.trace_id_128_bit), clock) {}
-
-Tracer::Tracer(const FinalizedTracerConfig& config,
-               const std::shared_ptr<const IDGenerator>& generator,
-               const Clock& clock)
     : logger_(config.logger),
       collector_(/* see constructor body */),
       trace_sampler_(
-          std::make_shared<TraceSampler>(config.trace_sampler, clock)),
-      span_sampler_(std::make_shared<SpanSampler>(config.span_sampler, clock)),
+          std::make_shared<TraceSampler>(config.trace_sampler, config.clock)),
+      span_sampler_(
+          std::make_shared<SpanSampler>(config.span_sampler, config.clock)),
       generator_(generator),
-      clock_(clock),
+      clock_(config.clock),
       defaults_(std::make_shared<SpanDefaults>(config.defaults)),
       injection_styles_(config.injection_styles),
       extraction_styles_(config.extraction_styles),
@@ -231,8 +223,7 @@ Tracer::Tracer(const FinalizedTracerConfig& config,
   } else {
     auto& agent_config =
         std::get<FinalizedDatadogAgentConfig>(config.collector);
-    collector_ =
-        std::make_shared<DatadogAgent>(agent_config, clock, config.logger);
+    collector_ = std::make_shared<DatadogAgent>(agent_config, config.logger);
   }
 
   if (config.log_on_startup) {

src/datadog/tracer.h

@@ -47,10 +47,6 @@ class Tracer {
   explicit Tracer(const FinalizedTracerConfig& config);
   Tracer(const FinalizedTracerConfig& config,
          const std::shared_ptr<const IDGenerator>& generator);
-  Tracer(const FinalizedTracerConfig& config, const Clock& clock);
-  Tracer(const FinalizedTracerConfig& config,
-         const std::shared_ptr<const IDGenerator>& generator,
-         const Clock& clock);
 
   // Create a new trace and return the root span of the trace.  Optionally
   // specify a `config` indicating the attributes of the root span.