Logging

Author: pablomartinezbernardo

src/datadog/telemetry/telemetry.cpp

@@ -105,18 +105,19 @@ void error(std::string message, std::string stacktrace) {
 
 namespace counter {
 void increment(const Counter& counter) {
-  std::visit(
-      details::Overload{
-          [&](Telemetry& telemetry) { telemetry.increment_counter(counter); },
-          [](auto&&) {},
-      },
-      instance());
+  std::visit(details::Overload{
+                 [&](Telemetry& telemetry) {
+                   telemetry.increment_counter(counter, nullptr);
+                 },
+                 [](auto&&) {},
+             },
+             instance());
 }
 
 void increment(const Counter& counter, const std::vector<std::string>& tags) {
   std::visit(details::Overload{
                  [&](Telemetry& telemetry) {
-                   telemetry.increment_counter(counter, tags);
+                   telemetry.increment_counter(counter, tags, nullptr);
                  },
                  [](auto&&) {},
              },

src/datadog/telemetry/telemetry_impl.cpp

@@ -208,9 +208,13 @@ Telemetry::Telemetry(FinalizedConfiguration config,
       host_info_(get_host_info()) {
   // Callback for successful telemetry HTTP requests, to examine HTTP
   // status.
+  logger_->log_error("Constructing telemetry object");
   send_telemetry("app-started", app_started());
+  logger_->log_error("Draining from constructor");
   http_client_->drain(clock_().tick + 2s);
+  logger_->log_error("Drain called");
   schedule_tasks();
+  logger_->log_error("Finished constructor");
 }
 
 void Telemetry::schedule_tasks() {
@@ -226,16 +230,21 @@ void Telemetry::schedule_tasks() {
 }
 
 Telemetry::~Telemetry() {
+  logger_->log_error("Destructor called");
   shutting_down_.store(true, std::memory_order_release);
   if (!tasks_.empty()) {
+    logger_->log_error("Tasks wasnt empty");
     cancel_tasks(tasks_);
     capture_metrics();
     // The app-closing message is bundled with a message containing the
     // final metric values.
+    logger_->log_error("Sending closing telemetry");
     send_telemetry("app-closing", app_closing());
+    logger_->log_error("Draining closing telemetry");
     http_client_->drain(clock_().tick + 2s);
   }
   http_client_.reset();
+  logger_->log_error("Exiting destructor");
 }
 
 Telemetry::Telemetry(Telemetry&& rhs)
@@ -284,23 +293,24 @@ Telemetry& Telemetry::operator=(Telemetry&& rhs) {
 
 void Telemetry::log_error(std::string message) {
   if (!config_.report_logs) return;
-  increment_counter(internal_metrics::logs_created, {"level:error"});
+  increment_counter(internal_metrics::logs_created, {"level:error"}, nullptr);
   log(std::move(message), LogLevel::ERROR);
 }
 
 void Telemetry::log_error(std::string message, std::string stacktrace) {
   if (!config_.report_logs) return;
-  increment_counter(internal_metrics::logs_created, {"level:error"});
+  increment_counter(internal_metrics::logs_created, {"level:error"}, nullptr);
   log(std::move(message), LogLevel::ERROR, stacktrace);
 }
 
 void Telemetry::log_warning(std::string message) {
   if (!config_.report_logs) return;
-  increment_counter(internal_metrics::logs_created, {"level:warning"});
+  increment_counter(internal_metrics::logs_created, {"level:warning"}, nullptr);
   log(std::move(message), LogLevel::WARNING);
 }
 
 void Telemetry::send_telemetry(StringView request_type, std::string payload) {
+  logger_->log_error("Sending telemetry");
   auto set_telemetry_headers = [request_type, payload_size = payload.size(),
                                 debug_enabled = config_.debug,
                                 tracer_signature =
@@ -327,19 +337,19 @@ void Telemetry::send_telemetry(StringView request_type, std::string payload) {
                                    std::string response_body) {
     if (response_status >= 500) {
       increment_counter(internal_metrics::responses,
-                        {"status_code:5xx", "endpoint:agent"});
+                        {"status_code:5xx", "endpoint:agent"}, logger_);
     } else if (response_status >= 400) {
       increment_counter(internal_metrics::responses,
-                        {"status_code:4xx", "endpoint:agent"});
+                        {"status_code:4xx", "endpoint:agent"}, logger_);
     } else if (response_status >= 300) {
       increment_counter(internal_metrics::responses,
-                        {"status_code:3xx", "endpoint:agent"});
+                        {"status_code:3xx", "endpoint:agent"}, logger_);
     } else if (response_status >= 200) {
       increment_counter(internal_metrics::responses,
-                        {"status_code:2xx", "endpoint:agent"});
+                        {"status_code:2xx", "endpoint:agent"}, logger_);
     } else if (response_status >= 100) {
       increment_counter(internal_metrics::responses,
-                        {"status_code:1xx", "endpoint:agent"});
+                        {"status_code:1xx", "endpoint:agent"}, logger_);
     }
 
     if (response_status < 200 || response_status >= 300) {
@@ -353,13 +363,14 @@ void Telemetry::send_telemetry(StringView request_type, std::string payload) {
 
   // Callback for unsuccessful telemetry HTTP requests.
   auto telemetry_on_error = [this, logger = logger_](Error error) {
+    logger->log_error("Telemetry on error called");
     increment_counter(internal_metrics::errors,
-                      {"type:network", "endpoint:agent"});
+                      {"type:network", "endpoint:agent"}, logger);
     logger->log_error(error.with_prefix(
         "Error occurred during HTTP request for telemetry: "));
   };
 
-  increment_counter(internal_metrics::requests, {"endpoint:agent"});
+  increment_counter(internal_metrics::requests, {"endpoint:agent"}, logger_);
   add_datapoint(internal_metrics::bytes_sent, {"endpoint:agent"},
                 payload.size());
 
@@ -368,8 +379,9 @@ void Telemetry::send_telemetry(StringView request_type, std::string payload) {
                          std::move(payload), std::move(telemetry_on_response),
                          std::move(telemetry_on_error), clock_().tick + 5s);
   if (auto* error = post_result.if_error()) {
+    logger_->log_error("Error posting");
     increment_counter(internal_metrics::errors,
-                      {"type:network", "endpoint:agent"});
+                      {"type:network", "endpoint:agent"}, logger_);
     logger_->log_error(
         error->with_prefix("Unexpected error submitting telemetry event: "));
   }
@@ -749,16 +761,27 @@ void Telemetry::log(std::string message, telemetry::LogLevel level,
       telemetry::LogMessage{std::move(message), level, stacktrace, timestamp});
 }
 
-void Telemetry::increment_counter(const Counter& id) {
-  increment_counter(id, {});
+void Telemetry::increment_counter(const Counter& id,
+                                  std::shared_ptr<tracing::Logger> logger) {
+  increment_counter(id, {}, logger);
 }
 
 void Telemetry::increment_counter(const Counter& id,
-                                  const std::vector<std::string>& tags) {
+                                  const std::vector<std::string>& tags,
+                                  std::shared_ptr<tracing::Logger> logger) {
+  if (logger != nullptr) {
+    logger->log_error("increment_counter called");
+  }
   std::lock_guard l{counter_mutex_};
   if (shutting_down_.load(std::memory_order_acquire)) {
+    if (logger != nullptr) {
+      logger->log_error("was derstroying, returning");
+    }
     return;
   }
+  if (logger != nullptr) {
+    logger->log_error("was not destroying, changing variable");
+  }
   counters_[{id, tags}] += 1;
 }
 

src/datadog/telemetry/telemetry_impl.h

@@ -110,9 +110,11 @@ class Telemetry final {
       const std::vector<tracing::ConfigMetadata>& new_configuration);
 
   /// Counter
-  void increment_counter(const Counter& counter);
   void increment_counter(const Counter& counter,
-                         const std::vector<std::string>& tags);
+                         std::shared_ptr<tracing::Logger> logger);
+  void increment_counter(const Counter& counter,
+                         const std::vector<std::string>& tags,
+                         std::shared_ptr<tracing::Logger> logger);
   void decrement_counter(const Counter& counter);
   void decrement_counter(const Counter& counter,
                          const std::vector<std::string>& tags);

test/telemetry/test_telemetry.cpp

@@ -344,13 +344,13 @@ TELEMETRY_IMPLEMENTATION_TEST("Tracer telemetry API") {
       /// - can't decrement below zero. -> is that a telemetry requirements?
       /// - rates or counter reset to zero after capture.
       const Counter my_counter{"my_counter", "counter-test", true};
-      telemetry.increment_counter(my_counter);  // = 1
-      telemetry.increment_counter(my_counter);  // = 2
-      telemetry.increment_counter(my_counter);  // = 3
-      telemetry.decrement_counter(my_counter);  // = 2
+      telemetry.increment_counter(my_counter, nullptr);  // = 1
+      telemetry.increment_counter(my_counter, nullptr);  // = 2
+      telemetry.increment_counter(my_counter, nullptr);  // = 3
+      telemetry.decrement_counter(my_counter);           // = 2
       scheduler->trigger_metrics_capture();
 
-      telemetry.increment_counter(my_counter);  // = 1
+      telemetry.increment_counter(my_counter, nullptr);  // = 1
       scheduler->trigger_metrics_capture();
 
       telemetry.set_counter(my_counter, 42);
@@ -626,7 +626,7 @@ TELEMETRY_IMPLEMENTATION_TEST("Tracer telemetry API") {
       {
         Telemetry tmp_telemetry{*finalize_config(), logger, client,
                                 scheduler,          *url,   clock};
-        tmp_telemetry.increment_counter(my_counter);  // = 1
+        tmp_telemetry.increment_counter(my_counter, nullptr);  // = 1
         tmp_telemetry.add_datapoint(response_time, 128);
         tmp_telemetry.set_rate(rps, 1000);
         client->clear();