Logger.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/Logger.h"
 
#include <Poco/Logger.h>
#include <Poco/NullStream.h>
 
#include <algorithm>
#include <exception>
#include <iostream>
#include <sstream>
 
namespace Mantid::Kernel {
namespace {
// We only need a single NullStream object
Poco::NullOutputStream NULL_STREAM;
} // namespace
 
static const std::string PriorityNames_data[] = {"NOT_USED",         "PRIO_FATAL",   "PRIO_CRITICAL",
                                                 "PRIO_ERROR",       "PRIO_WARNING", "PRIO_NOTICE",
                                                 "PRIO_INFORMATION", "PRIO_DEBUG",   "PRIO_TRACE"};
const std::string *Logger::PriorityNames = PriorityNames_data;
 
Logger::Logger(const std::string &name)
    : m_log(&Poco::Logger::get(name)), m_logStream(std::make_unique<ThreadSafeLogStream>(*m_log)), m_levelOffset(0),
      m_enabled(true) {}
 
void Logger::setName(const std::string &name) {
  auto *logger = &Poco::Logger::get(name);
  auto logStream = std::make_unique<ThreadSafeLogStream>(*logger); // don't swap if this throws
 
  using std::swap;
  swap(m_log, logger);
  swap(m_logStream, logStream);
}
 
bool Logger::getEnabled() const { return m_enabled; }
 
void Logger::setEnabled(const bool enabled) { m_enabled = enabled; }
 
void Logger::fatal(const std::string &msg) { log(msg, Poco::Message::PRIO_FATAL); }
 
void Logger::error(const std::string &msg) { log(msg, Poco::Message::PRIO_ERROR); }
 
void Logger::warning(const std::string &msg) { log(msg, Poco::Message::PRIO_WARNING); }
 
void Logger::notice(const std::string &msg) { log(msg, Poco::Message::PRIO_NOTICE); }
 
void Logger::information(const std::string &msg) { log(msg, Poco::Message::PRIO_INFORMATION); }
 
void Logger::debug(const std::string &msg) { log(msg, Poco::Message::PRIO_DEBUG); }
 
void Logger::dump(const std::string &msg, const void *buffer, std::size_t length) {
  if (m_enabled) {
    try {
      m_log->dump(msg, buffer, length);
    } catch (std::exception &e) {
      // failures in logging are not allowed to throw exceptions out of the
      // logging class
      std::cerr << e.what();
    }
  }
}
 
bool Logger::is(int level) const {
  bool retVal = false;
  try {
    retVal = m_log->is(level);
  } catch (std::exception &e) {
    // failures in logging are not allowed to throw exceptions out of the
    // logging class
    std::cerr << e.what();
  }
  return retVal;
}
 
void Logger::setLevel(int level) {
  try {
    m_log->setLevel(level);
  } catch (std::exception &e) {
    // failures in logging are not allowed to throw exceptions out of the
    // logging class
    std::cerr << e.what();
  }
}
 
void Logger::setLevel(const std::string &level) {
  try {
    m_log->setLevel(level);
  } catch (std::exception &e) {
    // failures in logging are not allowed to throw exceptions out of the
    // logging class
    std::cerr << e.what();
  }
}
 
int Logger::getLevel() const { return m_log->getLevel(); }
 
std::ostream &Logger::fatal() { return getLogStream(Priority::PRIO_FATAL); }
 
std::ostream &Logger::error() { return getLogStream(Priority::PRIO_ERROR); }
 
std::ostream &Logger::warning() { return getLogStream(Priority::PRIO_WARNING); }
 
std::ostream &Logger::notice() { return getLogStream(Priority::PRIO_NOTICE); }
 
std::ostream &Logger::information() { return getLogStream(Priority::PRIO_INFORMATION); }
 
std::ostream &Logger::debug() { return getLogStream(Priority::PRIO_DEBUG); }
 
void Logger::accumulate(const std::string &msg) { m_logStream->accumulate(msg); }
 
void Logger::flush() { log(m_logStream->flush(), Priority(getLevel())); }
 
void Logger::flush(Priority priority) { log(m_logStream->flush(), priority); }
 
void Logger::flushDebug() { flush(Poco::Message::PRIO_DEBUG); }
 
void Logger::flushInformation() { flush(Poco::Message::PRIO_INFORMATION); }
 
void Logger::flushNotice() { flush(Poco::Message::PRIO_NOTICE); }
 
void Logger::flushWarning() { flush(Poco::Message::PRIO_WARNING); }
 
void Logger::flushError() { flush(Poco::Message::PRIO_ERROR); }
 
void Logger::flushFatal() { flush(Poco::Message::PRIO_FATAL); }
 
void Logger::purge() { m_logStream->flush(); }
 
void Logger::shutdown() {
  try {
    // Release the POCO loggers
    Poco::Logger::shutdown();
  } catch (std::exception &e) {
    // failures in logging are not allowed to throw exceptions out of the
    // logging class
    std::cerr << e.what();
  }
}
 
void Logger::setLevelForAll(const int level) {
  // "" is the root logger
  Poco::Logger::setLevel("", level);
}
 
void Logger::log(const std::string &message, const Logger::Priority &priority) {
  if (!m_enabled)
    return;
 
  try {
    switch (applyLevelOffset(priority)) {
    case Poco::Message::PRIO_FATAL:
      m_log->fatal(message);
      break;
    case Poco::Message::PRIO_CRITICAL:
      m_log->critical(message);
      break;
    case Poco::Message::PRIO_ERROR:
      m_log->error(message);
      break;
    case Poco::Message::PRIO_WARNING:
      m_log->warning(message);
      break;
    case Poco::Message::PRIO_NOTICE:
      m_log->notice(message);
      break;
    case Poco::Message::PRIO_INFORMATION:
      m_log->information(message);
      break;
    case Poco::Message::PRIO_DEBUG:
      m_log->debug(message);
      break;
    case Poco::Message::PRIO_TRACE:
      m_log->trace(message);
      break;
    default:
      break;
    }
  } catch (std::exception &e) {
    // Failures in logging are not allowed to throw exceptions out of the
    // logging class
    std::cerr << "Error in logging framework: " << e.what();
  }
}
 
std::ostream &Logger::getLogStream(const Logger::Priority &priority) {
  if (!m_enabled)
    return NULL_STREAM;
 
  switch (applyLevelOffset(priority)) {
  case Poco::Message::PRIO_FATAL:
    return m_logStream->fatal();
    break;
  case Poco::Message::PRIO_CRITICAL:
    return m_logStream->critical();
    break;
  case Poco::Message::PRIO_ERROR:
    return m_logStream->error();
    break;
  case Poco::Message::PRIO_WARNING:
    return m_logStream->warning();
    break;
  case Poco::Message::PRIO_NOTICE:
    return m_logStream->notice();
    break;
  case Poco::Message::PRIO_INFORMATION:
    return m_logStream->information();
    break;
  case Poco::Message::PRIO_DEBUG:
    return m_logStream->debug();
    break;
  default:
    return NULL_STREAM;
  }
}
 
Logger::Priority Logger::applyLevelOffset(Logger::Priority proposedLevel) {
  int retVal = proposedLevel;
  // fast exit if offset is 0
  if (m_levelOffset == 0) {
    return proposedLevel;
  } else {
    retVal += m_levelOffset;
    if (retVal < static_cast<int>(Priority::PRIO_FATAL)) {
      retVal = Priority::PRIO_FATAL;
    } else if (retVal > static_cast<int>(Priority::PRIO_TRACE)) {
      retVal = Priority::PRIO_TRACE;
    }
  }
  // Logger::Priority p(retVal);
  return static_cast<Logger::Priority>(retVal);
}
 
void Logger::setLevelOffset(int level) { m_levelOffset = level; }
 
int Logger::getLevelOffset() const { return m_levelOffset; }
 
} // namespace Mantid::Kernel