chore(deps): update spdlog to v1.16.0 (#402)

With move to debian:trixie, gcc -Werror complains about spdlog.

Update spdlog. This also updates fmt which is now stricter. Add newly required formatters and fix logs.

Author: yonch

build-tools/cpp_misc/spdlog

@@ -53,15 +53,15 @@ ConnectionCaretaker::ConnectionCaretaker(
     aws_metadata_->print_instance_metadata();
     aws_metadata_->print_interfaces();
   } else {
-    LOG::warn("Unable to fetch AWS metadata: {}", aws_metadata.error());
+    LOG::warn("Unable to fetch AWS metadata: {}", aws_metadata.error().what());
   }
 
   LOG::trace_in(CloudPlatform::gcp, "--- resolving GCP metadata ---");
   if (auto gcp_metadata = GcpInstanceMetadata::fetch(metadata_timeout)) {
     gcp_metadata_.emplace(std::move(gcp_metadata.value()));
     gcp_metadata_->print();
   } else {
-    LOG::warn("Unable to fetch GCP metadata: {}", gcp_metadata.error());
+    LOG::warn("Unable to fetch GCP metadata: {}", gcp_metadata.error().what());
   }
 
   int res = uv_timer_init(loop_, &heartbeat_timer_);

channel/connection_caretaker.cc

@@ -19,7 +19,8 @@ std::error_code FileChannel::send(const u8 *data, int size)
   std::string_view const buffer{reinterpret_cast<char const *>(data), static_cast<std::string_view::size_type>(size)};
 
   if (auto const error = fd_.write_all(buffer)) {
-    LOG::error("error while writing {} bytes into file channel: {}", size, error);
+    const std::string error_message = error.message();
+    LOG::error("error while writing {} bytes into file channel: {} ({})", size, error_message, error.value());
     return error;
   }
 
@@ -35,7 +36,8 @@ std::error_code FileChannel::flush()
 {
   auto const error = fd_.flush_data();
   if (error) {
-    LOG::error("error while flushing data for file channel: {}", error);
+    const std::string error_message = error.message();
+    LOG::error("error while flushing data for file channel: {} ({})", error_message, error.value());
   }
   return error;
 }

channel/file_channel.cc

@@ -5,6 +5,7 @@
 #include <channel/reconnecting_channel.h>
 
 #include <util/log.h>
+#include <util/log_formatters.h>
 
 #include <stdexcept>
 

channel/reconnecting_channel.cc

@@ -117,7 +117,7 @@ void TCPChannel::conn_connect_cb(uv_connect_t *req, int status)
   auto tcp = (TCPChannel *)req->handle->data;
 
   if (status < 0) {
-    LOG::trace_in(channel::Component::tcp, "TCPChannel::{}(): error {}", __func__, static_cast<std::errc>(-status));
+    LOG::trace_in(channel::Component::tcp, "TCPChannel::{}(): error {}", __func__, uv_error_t{status});
     /* error occurred */
     tcp->connected_ = false;
     tcp->callbacks_->on_error(status);
@@ -182,7 +182,8 @@ void TCPChannel::connect(Callbacks &callbacks)
   int status = getaddrinfo(addr_.c_str(), port_.c_str(), &hints, &res);
 
   if (status != 0) {
-    LOG::critical("getaddrinfo failed: {} - calling abort", static_cast<std::errc>(status));
+    const char *error_text = gai_strerror(status);
+    LOG::critical("getaddrinfo failed: {} - calling abort", error_text ? error_text : "unknown error");
     // TODO: gracefully handle getaddrinfo errors
     std::abort();
   }

channel/tcp_channel.cc

@@ -132,26 +132,29 @@ void NetworkInterfacesEnumerator::handle_ec2_error(
     CollectorStatus status, Aws::Client::AWSError<Aws::EC2::EC2Errors> const &error)
 {
   if (error.GetErrorType() == Aws::EC2::EC2Errors::THROTTLING) {
-    log_.error("{} - AWS API call throttled: {}", status, error.GetMessage());
+    log_.error("{} - AWS API call throttled: {}", to_string(status), error.GetMessage());
     return;
   }
 
   auto const http_status = static_cast<std::underlying_type_t<Aws::Http::HttpResponseCode>>(error.GetResponseCode());
 
-  LOG::trace("reporting cloud collector as unhealthy (status={} detail={})", status, http_status);
+  LOG::trace("reporting cloud collector as unhealthy (status={} detail={})", to_string(status), http_status);
   writer_.collector_health(integer_value(status), http_status);
 
   if (http_status >= 400 && http_status < 500) {
     log_.error(
         "{} -  API call failed with http status {}. Double check that AWS credentials are"
         " properly set up for this pod. Check setup instructions for more information."
         " Error message from AWS: {}",
-        status,
+        to_string(status),
         http_status,
         error.GetMessage());
   } else {
     log_.error(
-        "{} -  API call failed with http status {}. Error message from AWS: {}", status, http_status, error.GetMessage());
+        "{} -  API call failed with http status {}. Error message from AWS: {}",
+        to_string(status),
+        http_status,
+        error.GetMessage());
   }
 }
 

collector/cloud/enumerator.cc

@@ -80,7 +80,7 @@ int main(int argc, char *argv[])
 
   // resolve hostname
   std::string const hostname = get_host_name(MAX_HOSTNAME_LENGTH).recover([](auto &error) {
-    LOG::error("Unable to retrieve host information from uname: {}", error);
+    LOG::error("Unable to retrieve host information from uname: {}", log_waive(error.message()));
     return "(unknown)";
   });
 

collector/cloud/main.cc

@@ -85,7 +85,7 @@ int main(int argc, char *argv[])
 
   // resolve hostname
   std::string const hostname = get_host_name(MAX_HOSTNAME_LENGTH).recover([](auto &error) {
-    LOG::error("Unable to retrieve host information from uname: {}", error);
+    LOG::error("Unable to retrieve host information from uname: {}", log_waive(error.message()));
     return "(unknown)";
   });
   LOG::info("Kubernetes Collector version {} ({}) started on host {}", versions::release, release_mode_string, hostname);

collector/k8s/main.cc

@@ -23,8 +23,10 @@
 #include <spdlog/fmt/bin_to_hex.h>
 
 #include <chrono>
+#include <cstring>
 #include <iostream>
 #include <stdexcept>
+#include <string_view>
 
 constexpr u16 DNS_MAX_PACKET_LEN = 512;
 
@@ -34,6 +36,16 @@ static BufferedPoller *singleton_ = nullptr;
 
 static constexpr u64 DNS_TIMEOUT_TIME_NS = 10'000'000'000ull;
 
+namespace {
+
+std::string_view comm_to_string(std::uint8_t const (&comm)[16])
+{
+  auto const length = strnlen(reinterpret_cast<char const *>(comm), sizeof(comm));
+  return std::string_view(reinterpret_cast<char const *>(comm), length);
+}
+
+} // namespace
+
 BufferedPoller::BufferedPoller(
     uv_loop_t &loop,
     PerfContainer &container,
@@ -1034,7 +1046,16 @@ void BufferedPoller::handle_pid_info(message_metadata const &metadata, jb_agent_
 {
   pid_count_++;
 
-  LOG::debug_in(AgentLogKind::PID, "{}: msg={} pid_count_={}", __func__, msg, pid_count_);
+  const std::string_view comm = comm_to_string(msg.comm);
+  LOG::debug_in(
+      AgentLogKind::PID,
+      "{}: pid={} parent={} cgroup=0x{:x} comm='{}' pid_count_={}",
+      __func__,
+      msg.pid,
+      msg.parent_pid,
+      msg.cgroup,
+      comm,
+      pid_count_);
 
   cgroup_handler_.handle_pid_info(msg.pid, msg.cgroup, msg.comm);
   process_handler_.on_new_process(std::chrono::nanoseconds{metadata.timestamp}, msg);
@@ -1057,23 +1078,25 @@ void BufferedPoller::handle_pid_close(message_metadata const &metadata, jb_agent
 {
   pid_count_--;
 
-  LOG::debug_in(AgentLogKind::PID, "{}: msg={} pid_count_={}", __func__, msg, pid_count_);
+  const std::string_view comm = comm_to_string(msg.comm);
+  LOG::debug_in(AgentLogKind::PID, "{}: pid={} comm='{}' pid_count_={}", __func__, msg.pid, comm, pid_count_);
 
   process_handler_.on_process_end(std::chrono::nanoseconds{metadata.timestamp}, msg);
   writer_.pid_close_info_tstamp(metadata.timestamp, msg.pid, msg.comm);
 }
 
 void BufferedPoller::handle_pid_set_comm(message_metadata const &metadata, jb_agent_internal__pid_set_comm &msg)
 {
-  LOG::debug_in(AgentLogKind::PID, "{}: msg={}", __func__, msg);
+  const std::string_view comm = comm_to_string(msg.comm);
+  LOG::debug_in(AgentLogKind::PID, "{}: pid={} comm='{}'", __func__, msg.pid, comm);
 
   process_handler_.set_process_command(std::chrono::nanoseconds{metadata.timestamp}, msg);
   writer_.pid_set_comm_tstamp(metadata.timestamp, msg.pid, msg.comm);
 }
 
 void BufferedPoller::handle_pid_exit(message_metadata const &metadata, jb_agent_internal__pid_exit &msg)
 {
-  LOG::debug_in(AgentLogKind::PID, "{}: msg={}", __func__, msg);
+  LOG::debug_in(AgentLogKind::PID, "{}: tgid={} pid={} exit_code={}", __func__, msg.tgid, msg.pid, msg.exit_code);
 
   process_handler_.pid_exit(std::chrono::nanoseconds{metadata.timestamp}, msg);
 }

collector/kernel/buffered_poller.cc

@@ -11,6 +11,7 @@
 #include <util/file_ops.h>
 #include <util/k8s_metadata.h>
 #include <util/log.h>
+#include <util/log_formatters.h>
 #include <util/nomad_metadata.h>
 
 #include <generated/ebpf_net/agent_internal/wire_message.h>
@@ -299,7 +300,8 @@ void CgroupHandler::fetch_done_cb(CurlEngineStatus status, long responseCode, st
   queries_.erase(pos);
 
   if (!success) {
-    log_.error("docker fetch failed [{}:{}]: {}", status, responseCode, curlError);
+    const std::string_view status_text = to_string(status);
+    log_.error("docker fetch failed [{}:{}]: {}", status_text, responseCode, curlError);
     return;
   }
 
@@ -433,7 +435,7 @@ void CgroupHandler::handle_docker_response(u64 cgroup, std::string const &respon
   }
 
   if (docker_host_config.has_value()) {
-    LOG::debug_in(AgentLogKind::DOCKER, "container resource limits: {}", *docker_host_config);
+    LOG::debug_in(AgentLogKind::DOCKER, "container resource limits: {}", fmt::streamed(*docker_host_config));
 
     auto const cpu_period = docker_host_config->cpu_period();
     auto const cpu_quota = docker_host_config->cpu_quota();