LogManager.cpp

#include "LogManager.h"
 
#include "Consumer.h"
#include "Logger.h"
 
#include "../HashFunctions.h"
#include "../Platform/Atomic.h"
 
#include <cstdio>
#include <set>
 
#if defined( _WIN32 )
  #include <Windows.h>
  #include <dbghelp.h>
#elif !defined( EMSCRIPTEN )
  #include <cxxabi.h>   // Needs libc++-dev on Ubuntu.
  #include <dlfcn.h>
  #include <errno.h>
  #include <pthread.h>
  #include <signal.h>
  #include <stdint.h>
  #include <unistd.h>
  #include <unwind.h>
#endif // _WIN32
 
namespace {
  Cogs::Atomic<Cogs::Logging::Category> minimumCategory(Cogs::Logging::Category::Trace);
 
#if defined( _WIN32 )
  LPTOP_LEVEL_EXCEPTION_FILTER previousFilter = nullptr;
#endif
 
  Cogs::Mutex& getConsumersMutex() {
    static Cogs::Mutex mutex;
    return mutex;
  }
 
  std::set<Cogs::Logging::Consumer*>& getConsumers() {
    static std::set<Cogs::Logging::Consumer*> consumers;
    return consumers;
  }
}
 
namespace Cogs::Logging {
 
  void consumeMessage(const char* source, Category category, uint32_t errorNumber, const char* filename, int lineNumber, _Printf_format_string_ const char* fmt, va_list argptr) {
    if (category >= minimumCategory.load()) {
      LockGuard   lock(getConsumersMutex());
 
      // Buffer for encoded log. Individual logs longer is truncated.
      static char buffer[16000]{};
 
      if (!filename) {
        filename = "";
      }
 
      int rv = std::vsnprintf(buffer, sizeof(buffer), fmt, argptr);
      if (0 <= rv) {
        // Output to buffer follows C++11 spec and is null terminated (possibly truncated).
        for (Consumer* consumer : getConsumers()) {
          if (category >= consumer->getMinimumCategory()) {
            consumer->consumeMessage(source, category, errorNumber, buffer, filename, lineNumber);
          }
        }
      }
      else {
        // Format error: Log format given. Output to buffer follows C++11 spec and is null terminated (possibly truncated).
        std::snprintf(buffer, sizeof(buffer), "Invalid log format: %s", fmt);
        for (Consumer* consumer : getConsumers()) {
          if (category >= consumer->getMinimumCategory()) {
            // Just passing buffer. std::snprintf returns null terminated. Seldom called.
            consumer->consumeMessage(source, category, errorNumber, buffer, filename, lineNumber);
          }
        }
      }
    }
  }
 
#if defined( _WIN32 )
  LONG WINAPI   exceptionHandler(EXCEPTION_POINTERS* ep) {
    void* addresses[200];
    int   noofaddresses = CaptureStackBackTrace(0, 199, addresses, nullptr);
 
    const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Crash");
    LOG_FATAL(logger, "Caught unhandled exception.");
 
    for(int idx = 0; idx < noofaddresses; ++idx) {
      char               local[sizeof(IMAGEHLP_SYMBOL64) + 992];
      IMAGEHLP_SYMBOL64* symbol = reinterpret_cast<IMAGEHLP_SYMBOL64*>(local);
      DWORD64            realaddr = reinterpret_cast<DWORD64>(addresses[idx]) - 1;
      DWORD64            symdisp;
 
      memset(local, 0, sizeof(local));
 
      symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
      symbol->MaxNameLength = sizeof(local) - sizeof(IMAGEHLP_SYMBOL64);
 
      if(SymGetSymFromAddr64(GetCurrentProcess(), realaddr, &symdisp, symbol) || (!GetLastError() && symbol->Name[0])) {
        char            symname[4096];
        DWORD           linedisp;
        IMAGEHLP_LINE64 line;
 
        UnDecorateSymbolName(symbol->Name, symname, sizeof(symname), UNDNAME_COMPLETE);
 
        memset(&line, 0, sizeof(line));
        line.SizeOfStruct = sizeof(line);
 
        if(SymGetLineFromAddr64(GetCurrentProcess(), realaddr, &linedisp, &line)) {
          LOG_FATAL(logger, "%p - %s (%s:%d)", reinterpret_cast<void*>(realaddr), symname, line.FileName, line.LineNumber);
        }
        else {
          LOG_FATAL(logger, "%p - %s", reinterpret_cast<void*>(realaddr), symname);
        }
      }
      else {
        LOG_FATAL(logger, "%p - (Unknown)", reinterpret_cast<void*>(realaddr));
      }
    }
    return previousFilter ? previousFilter(ep) : EXCEPTION_CONTINUE_SEARCH;
  }
#elif !defined( EMSCRIPTEN )
  struct BacktraceState {
    void**  current;
    void**  end;
  };
 
  _Unwind_Reason_Code unwindCallback(struct _Unwind_Context* context, void* arg)
  {
    BacktraceState* state = static_cast<BacktraceState*>(arg);
    uintptr_t       pc = _Unwind_GetIP(context);
 
    if (pc) {
      if (state->current == state->end) {
        return _URC_END_OF_STACK;
      }
      *state->current++ = reinterpret_cast<void*>(pc);
    }
    return _URC_NO_REASON;
  }
 
  void printFrame(void* address) {
    Dl_info   info;
    char      hexAddr[20] = { '0', 'x', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', ':', ' ' };
    uint64_t  addrValue = reinterpret_cast<uint64_t>(address);
    int       file = fileno(stderr);
 
    for (int idx = 18; addrValue; addrValue >>= 4) {
      hexAddr[--idx] = "0123456789ABCDEF"[addrValue & 0x0F];
    }
 
    write(file, hexAddr, 20);
 
    if (dladdr(address, &info)) {
      if (info.dli_sname) {
        int   status;
        char* demangled = abi::__cxa_demangle(info.dli_sname, nullptr, nullptr, &status);
 
        if (demangled) {
          if (status == 0) {
            write(file, demangled, strlen(demangled));
          }
          free(demangled);
        }
        else {
          write(file, info.dli_sname, strlen(info.dli_sname));
        }
      }
      else if (info.dli_fname) {
        write(file, info.dli_fname, strlen(info.dli_fname));
      }
    }
    write(file, "\n", 1);
  }
 
  void signalHandler(int sig) {
    static volatile sig_atomic_t  inProgress = 0;
    void*                         addresses[200];
    BacktraceState                state = { addresses, addresses + 200 };
    struct sigaction              sigact = {};
 
    if (!inProgress) {
      inProgress = 1;
 
      sigact.sa_handler = SIG_DFL;
      sigaction(sig, &sigact, nullptr);
      sigaction(SIGABRT, &sigact, nullptr);
 
      _Unwind_Backtrace(&unwindCallback, &state);
 
      switch (sig) {
        case SIGILL:  write(fileno(stderr), "Caught SIGILL.\n", 15);  break;
        case SIGABRT: write(fileno(stderr), "Caught SIGABRT.\n", 16); break;
        case SIGFPE:  write(fileno(stderr), "Caught SIGFPE.\n", 15);  break;
        case SIGSEGV: write(fileno(stderr), "Caught SIGSEGV.\n", 16); break;
        case SIGBUS:  write(fileno(stderr), "Caught SIGBUS.\n", 15);  break;
      }
 
      for (int idx = 0, addrCount = static_cast<int>(state.current - addresses); idx < addrCount; ++idx) {
        printFrame(addresses[idx]);
      }
      fsync(fileno(stderr));
    }
    raise(sig);
  }
#endif
}
 
void Cogs::Logging::setLoggerCategory(Category category) {
  Consumer::setDefaultMinimumCategory(category);
}
 
void Cogs::Logging::updateLoggerCategory(Category category) {
  // Cannot lock mutex as setMinimumCategory also locks same mutex calling Logging::updateMinimumCategory.
  // Only a problem of list of consumers changed.
  for (Consumer* consumer : getConsumers()) {
    consumer->setMinimumCategory(category);
  }
}
 
void Cogs::Logging::updateMinimumCategory() {
  LockGuard lock(getConsumersMutex());
  Category  category = Category::Fatal;
 
  for (Consumer* consumer : getConsumers()) {
    category = std::min(category, consumer->getMinimumCategory());
  }
  minimumCategory = category;
}
 
void Cogs::Logging::enableUnhandledExceptionLogging() {
#if defined( _WIN32 )
  SymSetOptions(SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_ALLOW_ABSOLUTE_SYMBOLS | SYMOPT_INCLUDE_32BIT_MODULES);
  SymInitialize(GetCurrentProcess(), nullptr, 1);
  SetUnhandledExceptionFilter(&exceptionHandler);
#elif !defined( EMSCRIPTEN )
  struct sigaction sigact = {};
 
  sigact.sa_handler = &signalHandler;
  sigemptyset(&sigact.sa_mask);
 
  sigaddset(&sigact.sa_mask, SIGILL);
  sigaddset(&sigact.sa_mask, SIGABRT);
  sigaddset(&sigact.sa_mask, SIGFPE);
  sigaddset(&sigact.sa_mask, SIGSEGV);
  sigaddset(&sigact.sa_mask, SIGBUS);
 
  sigaction(SIGILL, &sigact, nullptr);
  sigaction(SIGABRT, &sigact, nullptr);
  sigaction(SIGFPE, &sigact, nullptr);
  sigaction(SIGSEGV, &sigact, nullptr);
  sigaction(SIGBUS, &sigact, nullptr);
#endif // _WIN32
}
 
 
void Cogs::Logging::registerConsumer(Consumer* consumer) {
  LockGuard lock(getConsumersMutex());
 
  getConsumers().insert(consumer);
}
 
void Cogs::Logging::unregisterConsumer(Consumer* consumer) {
  LockGuard             lock(getConsumersMutex());
  std::set<Consumer*>&  consumers = getConsumers();
  auto                  i = consumers.find(consumer);
 
  if (i != consumers.end()) {
    consumers.erase(i);
  }
}
 
Cogs::Logging::Category Cogs::Logging::parseCategoryString(const StringView category) {
  switch (Cogs::hashLowercase(category)) {
    case Cogs::hash("trace"):   return Logging::Category::Trace;
    case Cogs::hash("debug"):   return Logging::Category::Debug;
    case Cogs::hash("info"):    return Logging::Category::Info;
    case Cogs::hash("warning"): return Logging::Category::Warning;
    case Cogs::hash("error"):   return Logging::Category::Error;
    case Cogs::hash("fatal"):   return Logging::Category::Fatal;
    default:              return Logging::Category::Debug;
  }
}
 
bool Cogs::Logging::isErrorGroup(uint32_t errorNumber, ErrorGroup group) {
  return (errorNumber & group) == group;
}
 
void Cogs::Logging::log(const char* message, const char* source, const Category category, uint32_t errorNumber) {
  consumeMessage(source, category, errorNumber, "", 0, message, nullptr);
}
 
void Cogs::Logging::log(const char* source, const Category category, uint32_t errorNumber, _Printf_format_string_ const char * fmt, ...) {
  va_list argptr;
 
  va_start(argptr, fmt);
  consumeMessage(source, category, errorNumber, "", 0, fmt, argptr);
  va_end(argptr);
}
 
void Cogs::Logging::logArgs(const char* source, const Category category, uint32_t errorNumber, const char * fmt, va_list argptr) {
  consumeMessage(source, category, errorNumber, "", 0, fmt, argptr);
}
 
void Cogs::Logging::logFileLine(const char* filename, const int lineNumber, const char * source, const Category category, uint32_t errorNumber, _Printf_format_string_ const char * fmt, ...) {
  va_list argptr;
 
  va_start(argptr, fmt);
  consumeMessage(source, category, errorNumber, filename, lineNumber, fmt, argptr);
  va_end(argptr);
}
 
void Cogs::Logging::logFileLineArgs(const char* filename, const int lineNumber, const char * source, const Category category, uint32_t errorNumber, const char* fmt, va_list argptr) {
  consumeMessage(source, category, errorNumber, filename, lineNumber, fmt, argptr);
}