StructuredLogger.cpp

#include "StructuredLogger.h"
#include "LogManager.h"
 
#include <cstdio>
#include <cstring>
#include <chrono>
 
namespace
{
  void writeStrWithoutNewlines(const char* str, FILE* stream) {
    const char* start = str;
    const char* end = str;
 
    while (*end) {
      if (*end == '\n' || *end == '\r') {
        if (end > start) {
            std::fwrite(start, 1, end - start, stream);
        }
        std::fputc(' ', stream);
        start = end + 1;
      }
      end++;
    }
 
    if (end > start) {
      std::fwrite(start, 1, end - start, stream);
    }
  }
}
Cogs::Logging::StructuredLogger& Cogs::Logging::StructuredLogger::instance()
{
  static StructuredLogger i;
 
  return i;
}
 
void Cogs::Logging::StructuredLogger::consumeMessage(const char* source, Category category, uint32_t /*errorNumber*/, const char* message, const char* filename, int lineNumber)
{
  thread_local static char buffer[500] = {};
  constexpr const char categoryNames[] = { 'T', 'D', 'I', 'W', 'E', 'F' };
 
  const char level = categoryNames[static_cast<int>(category)];
 
  // Get current timestamp in ISO 8601 format with milliseconds
  auto now = std::chrono::system_clock::now();
  auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
  auto now_c = std::chrono::system_clock::to_time_t(now);
  std::tm now_tm = *std::gmtime(&now_c);
 
  char timestamp[25];
  std::strftime(timestamp, sizeof(timestamp), "%Y-%m-%dT%H:%M:%S", &now_tm);
  std::snprintf(timestamp + 19, 6, ".%03dZ", static_cast<int>(now_ms.count()));
 
  int n = 0;
  if(outputFilenames && filename && filename[0] != '\0') {
    n = std::snprintf(buffer, sizeof(buffer) - 1, "%c %s (%s:%d) [%s] ", level, timestamp, filename, lineNumber, source);
  }
  else {
    n = std::snprintf(buffer, sizeof(buffer) - 1, "%c %s [%s] ", level, timestamp, source);
  }
 
  // Guard against overflow if very long prefix generated. Format error < 0 not probable.
  n = std::max(n, 0);
  n = std::min(n, int(sizeof(buffer)));
 
  LockGuard lock(mutex);
 
  std::fwrite(buffer, 1, n, stderr);
  writeStrWithoutNewlines(message, stderr);
  std::fputc('\n', stderr);
 
  if(category >= Category::Error) {
    std::fflush(stderr);
  }
}