don't let DatadogAgent::flush run concurrently (#21)

* don't let DatadogAgent::flush run concurrently

* less optimal, more zen: now concurrent access is safe

Author: dgoffredo

src/datadog/datadog_agent.cpp

@@ -159,8 +159,7 @@ Expected<void> DatadogAgent::send(
     std::vector<std::unique_ptr<SpanData>>&& spans,
     const std::shared_ptr<TraceSampler>& response_handler) {
   std::lock_guard<std::mutex> lock(mutex_);
-  incoming_trace_chunks_.push_back(
-      TraceChunk{std::move(spans), response_handler});
+  trace_chunks_.push_back(TraceChunk{std::move(spans), response_handler});
   return nullopt;
 }
 
@@ -184,19 +183,19 @@ nlohmann::json DatadogAgent::config_json() const {
 }
 
 void DatadogAgent::flush() {
-  outgoing_trace_chunks_.clear();
+  std::vector<TraceChunk> trace_chunks;
   {
     std::lock_guard<std::mutex> lock(mutex_);
     using std::swap;
-    swap(incoming_trace_chunks_, outgoing_trace_chunks_);
+    swap(trace_chunks, trace_chunks_);
   }
 
-  if (outgoing_trace_chunks_.empty()) {
+  if (trace_chunks.empty()) {
     return;
   }
 
   std::string body;
-  auto encode_result = msgpack_encode(body, outgoing_trace_chunks_);
+  auto encode_result = msgpack_encode(body, trace_chunks);
   if (auto* error = encode_result.if_error()) {
     logger_->log_error(*error);
     return;
@@ -206,19 +205,18 @@ void DatadogAgent::flush() {
   // multiple tracers, and thus multiple trace samplers might need to have
   // their rates updated. Unlikely, but possible.
   std::unordered_set<std::shared_ptr<TraceSampler>> response_handlers;
-  for (auto& chunk : outgoing_trace_chunks_) {
+  for (auto& chunk : trace_chunks) {
     response_handlers.insert(std::move(chunk.response_handler));
   }
 
   // This is the callback for setting request headers.
   // It's invoked synchronously (before `post` returns).
-  auto set_request_headers = [this](DictWriter& headers) {
+  auto set_request_headers = [&](DictWriter& headers) {
     headers.set("Content-Type", "application/msgpack");
     headers.set("Datadog-Meta-Lang", "cpp");
     headers.set("Datadog-Meta-Lang-Version", std::to_string(__cplusplus));
     headers.set("Datadog-Meta-Tracer-Version", tracer_version);
-    headers.set("X-Datadog-Trace-Count",
-                std::to_string(outgoing_trace_chunks_.size()));
+    headers.set("X-Datadog-Trace-Count", std::to_string(trace_chunks.size()));
   };
 
   // This is the callback for the HTTP response.  It's invoked

src/datadog/datadog_agent.h

@@ -34,10 +34,7 @@ class DatadogAgent : public Collector {
   std::mutex mutex_;
   Clock clock_;
   std::shared_ptr<Logger> logger_;
-  // `incoming_trace_chunks_` are what `send` appends to.
-  std::vector<TraceChunk> incoming_trace_chunks_;
-  // `outgoing_trace_chunks_` are what `flush` consumes from.
-  std::vector<TraceChunk> outgoing_trace_chunks_;
+  std::vector<TraceChunk> trace_chunks_;
   HTTPClient::URL traces_endpoint_;
   std::shared_ptr<HTTPClient> http_client_;
   std::shared_ptr<EventScheduler> event_scheduler_;