void flush(const std::string &buffer);
};
-
-#ifdef __ANDROID__
-static unsigned int level_to_android[] = {
- ANDROID_LOG_INFO, // LL_NONE
- //ANDROID_LOG_FATAL,
- ANDROID_LOG_ERROR, // LL_ERROR
- ANDROID_LOG_WARN, // LL_WARNING
- ANDROID_LOG_WARN, // LL_ACTION
- //ANDROID_LOG_INFO,
- ANDROID_LOG_DEBUG, // LL_INFO
- ANDROID_LOG_VERBOSE, // LL_VERBOSE
-
-};
-#endif
-
////
//// Globals
////
std::ostream infostream(&info_buf);
std::ostream verbosestream(&verbose_buf);
+// Android
+#ifdef __ANDROID__
+
+static unsigned int g_level_to_android[] = {
+ ANDROID_LOG_INFO, // LL_NONE
+ //ANDROID_LOG_FATAL,
+ ANDROID_LOG_ERROR, // LL_ERROR
+ ANDROID_LOG_WARN, // LL_WARNING
+ ANDROID_LOG_WARN, // LL_ACTION
+ //ANDROID_LOG_INFO,
+ ANDROID_LOG_DEBUG, // LL_INFO
+ ANDROID_LOG_VERBOSE, // LL_VERBOSE
+};
+
+class AndroidSystemLogOutput : public ICombinedLogOutput {
+ public:
+ AndroidSystemLogOutput()
+ {
+ g_logger.addOutput(this);
+ }
+ ~AndroidSystemLogOutput()
+ {
+ g_logger.removeOutput(this);
+ }
+ void logRaw(LogLevel lev, const std::string &line)
+ {
+ STATIC_ASSERT(ARRLEN(g_level_to_android) == LL_MAX,
+ mismatch_between_android_and_internal_loglevels);
+ __android_log_print(g_level_to_android[lev],
+ PROJECT_NAME_C, "%s", line.c_str());
+ }
+};
+
+AndroidSystemLogOutput g_android_log_output;
+
+#endif
///////////////////////////////////////////////////////////////////////////////
void Logger::addOutput(ILogOutput *out)
{
- addOutputMaxLevel(out, LL_MAX);
+ addOutputMaxLevel(out, (LogLevel)(LL_MAX - 1));
}
void Logger::addOutput(ILogOutput *out, LogLevel lev)
m_outputs[lev].push_back(out);
}
+void Logger::addOutputMasked(ILogOutput *out, LogLevelMask mask)
+{
+ for (size_t i = 0; i < LL_MAX; i++) {
+ if (mask & LOGLEVEL_TO_MASKLEVEL(i))
+ m_outputs[i].push_back(out);
+ }
+}
+
void Logger::addOutputMaxLevel(ILogOutput *out, LogLevel lev)
{
+ assert(lev < LL_MAX);
for (size_t i = 0; i <= lev; i++)
m_outputs[i].push_back(out);
}
-void Logger::removeOutput(ILogOutput *out)
+LogLevelMask Logger::removeOutput(ILogOutput *out)
{
+ LogLevelMask ret_mask = 0;
for (size_t i = 0; i < LL_MAX; i++) {
std::vector<ILogOutput *>::iterator it;
it = std::find(m_outputs[i].begin(), m_outputs[i].end(), out);
- if (it != m_outputs[i].end())
+ if (it != m_outputs[i].end()) {
+ ret_mask |= LOGLEVEL_TO_MASKLEVEL(i);
m_outputs[i].erase(it);
+ }
}
+ return ret_mask;
}
void Logger::setLevelSilenced(LogLevel lev, bool silenced)
void Logger::registerThread(const std::string &name)
{
- threadid_t id = get_current_thread_id();
+ threadid_t id = thr_get_current_thread_id();
MutexAutoLock lock(m_mutex);
m_thread_names[id] = name;
}
void Logger::deregisterThread()
{
- threadid_t id = get_current_thread_id();
+ threadid_t id = thr_get_current_thread_id();
MutexAutoLock lock(m_mutex);
m_thread_names.erase(id);
}
"VERBOSE",
};
assert(lev < LL_MAX && lev >= 0);
- assert(ARRLEN(names) == LL_MAX);
+ STATIC_ASSERT(ARRLEN(names) == LL_MAX,
+ mismatch_between_loglevel_names_and_enum);
return names[lev];
}
{
std::map<threadid_t, std::string>::const_iterator it;
- threadid_t id = get_current_thread_id();
+ threadid_t id = thr_get_current_thread_id();
it = m_thread_names.find(id);
if (it != m_thread_names.end())
return it->second;
const std::string thread_name = getThreadName();
const std::string label = getLevelLabel(lev);
+ const std::string timestamp = getTimestamp();
std::ostringstream os(std::ios_base::binary);
- os << getTimestamp() << ": " << label << "[" << thread_name << "]: " << text;
+ os << timestamp << ": " << label << "[" << thread_name << "]: " << text;
- logToSystem(lev, text);
- logToOutputs(lev, os.str());
+ logToOutputs(lev, os.str(), timestamp, thread_name, text);
}
void Logger::logRaw(LogLevel lev, const std::string &text)
if (m_silenced_levels[lev])
return;
- logToSystem(lev, text);
- logToOutputs(lev, text);
+ logToOutputsRaw(lev, text);
}
-void Logger::logToSystem(LogLevel lev, const std::string &text)
+void Logger::logToOutputsRaw(LogLevel lev, const std::string &line)
{
-#ifdef __ANDROID__
- assert(ARRLEN(level_to_android) == LL_MAX);
- __android_log_print(level_to_android[lev],
- PROJECT_NAME_C, "%s", text.c_str());
-#endif
+ MutexAutoLock lock(m_mutex);
+ for (size_t i = 0; i != m_outputs[lev].size(); i++)
+ m_outputs[lev][i]->logRaw(lev, line);
}
-void Logger::logToOutputs(LogLevel lev, const std::string &text)
+void Logger::logToOutputs(LogLevel lev, const std::string &combined,
+ const std::string &time, const std::string &thread_name,
+ const std::string &payload_text)
{
MutexAutoLock lock(m_mutex);
for (size_t i = 0; i != m_outputs[lev].size(); i++)
- m_outputs[lev][i]->log(text);
+ m_outputs[lev][i]->log(lev, combined, time, thread_name, payload_text);
}
void FileLogOutput::open(const std::string &filename)
{
- stream.open(filename.c_str(), std::ios::app | std::ios::ate);
- if (!stream.good())
+ m_stream.open(filename.c_str(), std::ios::app | std::ios::ate);
+ if (!m_stream.good())
throw FileNotGoodException("Failed to open log file " +
filename + ": " + strerror(errno));
- stream << "\n\n"
+ m_stream << "\n\n"
"-------------" << std::endl
<< " Separator" << std::endl
<< "-------------\n" << std::endl;
}
-
-
void LogBuffer::flush(const std::string &buffer)
{
logger.log(level, buffer);