ThrottledConsumer.cpp

#include "ThrottledConsumer.h"
 
#include "../HashSequence.h"
#include "../Platform/Timer.h"
#include "../Platform/Timer.h"
 
namespace {
  bool  enabled = false;   // Call setEnabled to control whether throttling is enabled or not.
}
 
void Cogs::Logging::ThrottledConsumer::setEnabled(bool enable) {
  enabled = enable;
}
 
void Cogs::Logging::ThrottledConsumer::consumeMessage(const char* source, Category category, uint32_t /*errorNumber*/, const char* message, const char* filename, int lineNumber) {
  assert(filename);
 
  messagesMutex.lock();
  Message&  msg = messages[hashSequence(source, message, filename, lineNumber)];
 
  if (!msg.outputTime) {
    msg.message = message;
    msg.source = source;
    msg.file = filename;
    msg.line = lineNumber;
    msg.category = category;
  }
  msg.count++;
  messagesMutex.unlock();
 
  flush(!enabled);
}
 
void Cogs::Logging::ThrottledConsumer::flush(bool flushAll) {
  int64_t     now = Cogs::Timer::currentTimeMilliseconds();
  char        buffer[64];
  std::string prefix;
  time_t      seconds = now / 1000;
  char        milliseconds[64];
 
  strftime(buffer, sizeof(buffer), "%H:%M:%S", localtime(&seconds));
  snprintf(milliseconds, sizeof(milliseconds), ":%03d", static_cast<int>(now % 1000));
  strcat(buffer, milliseconds);
 
  LockGuard lock(messagesMutex);
 
  for (auto i = messages.begin(), e = messages.end(); i != e; ) {
    Message&  message = i->second;
 
    if (flushAll || (message.outputTime < now)) {
      if (message.count) {
        prefix = "[";
        prefix += buffer;
 
        if (message.count > 1) {
          prefix += " *";
          prefix += std::to_string(message.count);
        }
        prefix += "]";
 
        outputMessage(prefix, message);
 
        message.outputTime = flushAll ? 0 : now + (message.count * 100);
        message.count = 0;
      }
      else {
        i = messages.erase(i);
        continue;
      }
    }
    ++i;
  }
}