3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include "threading/mutex_auto_lock.h"
27 #include "exceptions.h"
28 #include "util/numeric.h"
37 const int BUFFER_LENGTH = 256;
39 class StringBuffer : public std::streambuf {
46 virtual void flush(const std::string &buf) = 0;
47 std::streamsize xsputn(const char *s, std::streamsize n);
48 void push_back(char c);
51 char buffer[BUFFER_LENGTH];
56 class LogBuffer : public StringBuffer {
58 LogBuffer(Logger &logger, LogLevel lev) :
63 void flush(const std::string &buffer);
71 class RawLogBuffer : public StringBuffer {
73 void flush(const std::string &buffer);
82 StreamLogOutput stdout_output(std::cout);
83 StreamLogOutput stderr_output(std::cerr);
84 std::ostream null_stream(NULL);
88 LogBuffer none_buf(g_logger, LL_NONE);
89 LogBuffer error_buf(g_logger, LL_ERROR);
90 LogBuffer warning_buf(g_logger, LL_WARNING);
91 LogBuffer action_buf(g_logger, LL_ACTION);
92 LogBuffer info_buf(g_logger, LL_INFO);
93 LogBuffer verbose_buf(g_logger, LL_VERBOSE);
96 std::ostream *dout_con_ptr = &null_stream;
97 std::ostream *derr_con_ptr = &verbosestream;
100 std::ostream *dout_server_ptr = &infostream;
101 std::ostream *derr_server_ptr = &errorstream;
105 std::ostream *dout_client_ptr = &infostream;
106 std::ostream *derr_client_ptr = &errorstream;
109 std::ostream rawstream(&raw_buf);
110 std::ostream dstream(&none_buf);
111 std::ostream errorstream(&error_buf);
112 std::ostream warningstream(&warning_buf);
113 std::ostream actionstream(&action_buf);
114 std::ostream infostream(&info_buf);
115 std::ostream verbosestream(&verbose_buf);
120 static unsigned int g_level_to_android[] = {
121 ANDROID_LOG_INFO, // LL_NONE
123 ANDROID_LOG_ERROR, // LL_ERROR
124 ANDROID_LOG_WARN, // LL_WARNING
125 ANDROID_LOG_WARN, // LL_ACTION
127 ANDROID_LOG_DEBUG, // LL_INFO
128 ANDROID_LOG_VERBOSE, // LL_VERBOSE
131 class AndroidSystemLogOutput : public ICombinedLogOutput {
133 AndroidSystemLogOutput()
135 g_logger.addOutput(this);
137 ~AndroidSystemLogOutput()
139 g_logger.removeOutput(this);
141 void logRaw(LogLevel lev, const std::string &line)
143 STATIC_ASSERT(ARRLEN(g_level_to_android) == LL_MAX,
144 mismatch_between_android_and_internal_loglevels);
145 __android_log_print(g_level_to_android[lev],
146 PROJECT_NAME_C, "%s", line.c_str());
150 AndroidSystemLogOutput g_android_log_output;
154 ///////////////////////////////////////////////////////////////////////////////
161 LogLevel Logger::stringToLevel(const std::string &name)
165 else if (name == "error")
167 else if (name == "warning")
169 else if (name == "action")
171 else if (name == "info")
173 else if (name == "verbose")
179 void Logger::addOutput(ILogOutput *out)
181 addOutputMaxLevel(out, (LogLevel)(LL_MAX - 1));
184 void Logger::addOutput(ILogOutput *out, LogLevel lev)
186 m_outputs[lev].push_back(out);
189 void Logger::addOutputMasked(ILogOutput *out, LogLevelMask mask)
191 for (size_t i = 0; i < LL_MAX; i++) {
192 if (mask & LOGLEVEL_TO_MASKLEVEL(i))
193 m_outputs[i].push_back(out);
197 void Logger::addOutputMaxLevel(ILogOutput *out, LogLevel lev)
199 assert(lev < LL_MAX);
200 for (size_t i = 0; i <= lev; i++)
201 m_outputs[i].push_back(out);
204 LogLevelMask Logger::removeOutput(ILogOutput *out)
206 LogLevelMask ret_mask = 0;
207 for (size_t i = 0; i < LL_MAX; i++) {
208 std::vector<ILogOutput *>::iterator it;
210 it = std::find(m_outputs[i].begin(), m_outputs[i].end(), out);
211 if (it != m_outputs[i].end()) {
212 ret_mask |= LOGLEVEL_TO_MASKLEVEL(i);
213 m_outputs[i].erase(it);
219 void Logger::setLevelSilenced(LogLevel lev, bool silenced)
221 m_silenced_levels[lev] = silenced;
224 void Logger::registerThread(const std::string &name)
226 std::thread::id id = std::this_thread::get_id();
227 MutexAutoLock lock(m_mutex);
228 m_thread_names[id] = name;
231 void Logger::deregisterThread()
233 std::thread::id id = std::this_thread::get_id();
234 MutexAutoLock lock(m_mutex);
235 m_thread_names.erase(id);
238 const std::string Logger::getLevelLabel(LogLevel lev)
240 static const std::string names[] = {
248 assert(lev < LL_MAX && lev >= 0);
249 STATIC_ASSERT(ARRLEN(names) == LL_MAX,
250 mismatch_between_loglevel_names_and_enum);
254 LogColor Logger::color_mode = LOG_COLOR_AUTO;
256 const std::string Logger::getThreadName()
258 std::map<std::thread::id, std::string>::const_iterator it;
260 std::thread::id id = std::this_thread::get_id();
261 it = m_thread_names.find(id);
262 if (it != m_thread_names.end())
265 std::ostringstream os;
266 os << "#0x" << std::hex << id;
270 void Logger::log(LogLevel lev, const std::string &text)
272 if (m_silenced_levels[lev])
275 const std::string thread_name = getThreadName();
276 const std::string label = getLevelLabel(lev);
277 const std::string timestamp = getTimestamp();
278 std::ostringstream os(std::ios_base::binary);
279 os << timestamp << ": " << label << "[" << thread_name << "]: " << text;
281 logToOutputs(lev, os.str(), timestamp, thread_name, text);
284 void Logger::logRaw(LogLevel lev, const std::string &text)
286 if (m_silenced_levels[lev])
289 logToOutputsRaw(lev, text);
292 void Logger::logToOutputsRaw(LogLevel lev, const std::string &line)
294 MutexAutoLock lock(m_mutex);
295 for (size_t i = 0; i != m_outputs[lev].size(); i++)
296 m_outputs[lev][i]->logRaw(lev, line);
299 void Logger::logToOutputs(LogLevel lev, const std::string &combined,
300 const std::string &time, const std::string &thread_name,
301 const std::string &payload_text)
303 MutexAutoLock lock(m_mutex);
304 for (size_t i = 0; i != m_outputs[lev].size(); i++)
305 m_outputs[lev][i]->log(lev, combined, time, thread_name, payload_text);
310 //// *LogOutput methods
313 void FileLogOutput::open(const std::string &filename)
315 m_stream.open(filename.c_str(), std::ios::app | std::ios::ate);
316 if (!m_stream.good())
317 throw FileNotGoodException("Failed to open log file " +
318 filename + ": " + strerror(errno));
320 "-------------" << std::endl
321 << " Separator" << std::endl
322 << "-------------\n" << std::endl;
331 int StringBuffer::overflow(int c)
338 std::streamsize StringBuffer::xsputn(const char *s, std::streamsize n)
340 for (int i = 0; i < n; ++i)
345 void StringBuffer::push_back(char c)
347 if (c == '\n' || c == '\r') {
349 flush(std::string(buffer, buffer_index));
352 buffer[buffer_index++] = c;
353 if (buffer_index >= BUFFER_LENGTH) {
354 flush(std::string(buffer, buffer_index));
361 void LogBuffer::flush(const std::string &buffer)
363 logger.log(level, buffer);
366 void RawLogBuffer::flush(const std::string &buffer)
368 g_logger.logRaw(LL_NONE, buffer);