src/log.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   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.
   9
  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.
  14
  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.
  18 */
  19
  20 #include "log.h"
  21
  22 #include "threading/mutex_auto_lock.h"
  23 #include "debug.h"
  24 #include "gettime.h"
  25 #include "porting.h"
  26 #include "config.h"
  27 #include "exceptions.h"
  28 #include "util/numeric.h"
  29 #include "log.h"
  30
  31 #include <sstream>
  32 #include <iostream>
  33 #include <algorithm>
  34 #include <cerrno>
  35 #include <cstring>
  36
  37 const int BUFFER_LENGTH = 256;
  38
  39 class StringBuffer : public std::streambuf {
  40 public:
  41         StringBuffer() {
  42                 buffer_index = 0;
  43         }
  44
  45         int overflow(int c);
  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);
  49
  50 private:
  51         char buffer[BUFFER_LENGTH];
  52         int buffer_index;
  53 };
  54
  55
  56 class LogBuffer : public StringBuffer {
  57 public:
  58         LogBuffer(Logger &logger, LogLevel lev) :
  59                 logger(logger),
  60                 level(lev)
  61         {}
  62
  63         void flush(const std::string &buffer);
  64
  65 private:
  66         Logger &logger;
  67         LogLevel level;
  68 };
  69
  70
  71 class RawLogBuffer : public StringBuffer {
  72 public:
  73         void flush(const std::string &buffer);
  74 };
  75
  76 ////
  77 //// Globals
  78 ////
  79
  80 Logger g_logger;
  81
  82 StreamLogOutput stdout_output(std::cout);
  83 StreamLogOutput stderr_output(std::cerr);
  84 std::ostream null_stream(NULL);
  85
  86 RawLogBuffer raw_buf;
  87
  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);
  94
  95 // Connection
  96 std::ostream *dout_con_ptr = &null_stream;
  97 std::ostream *derr_con_ptr = &verbosestream;
  98
  99 // Server
 100 std::ostream *dout_server_ptr = &infostream;
 101 std::ostream *derr_server_ptr = &errorstream;
 102
 103 #ifndef SERVER
 104 // Client
 105 std::ostream *dout_client_ptr = &infostream;
 106 std::ostream *derr_client_ptr = &errorstream;
 107 #endif
 108
 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);
 116
 117 // Android
 118 #ifdef __ANDROID__
 119
 120 static unsigned int g_level_to_android[] = {
 121         ANDROID_LOG_INFO,     // LL_NONE
 122         //ANDROID_LOG_FATAL,
 123         ANDROID_LOG_ERROR,    // LL_ERROR
 124         ANDROID_LOG_WARN,     // LL_WARNING
 125         ANDROID_LOG_WARN,     // LL_ACTION
 126         //ANDROID_LOG_INFO,
 127         ANDROID_LOG_DEBUG,    // LL_INFO
 128         ANDROID_LOG_VERBOSE,  // LL_VERBOSE
 129 };
 130
 131 class AndroidSystemLogOutput : public ICombinedLogOutput {
 132         public:
 133                 AndroidSystemLogOutput()
 134                 {
 135                         g_logger.addOutput(this);
 136                 }
 137                 ~AndroidSystemLogOutput()
 138                 {
 139                         g_logger.removeOutput(this);
 140                 }
 141                 void logRaw(LogLevel lev, const std::string &line)
 142                 {
 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());
 147                 }
 148 };
 149
 150 AndroidSystemLogOutput g_android_log_output;
 151
 152 #endif
 153
 154 ///////////////////////////////////////////////////////////////////////////////
 155
 156
 157 ////
 158 //// Logger
 159 ////
 160
 161 LogLevel Logger::stringToLevel(const std::string &name)
 162 {
 163         if (name == "none")
 164                 return LL_NONE;
 165         else if (name == "error")
 166                 return LL_ERROR;
 167         else if (name == "warning")
 168                 return LL_WARNING;
 169         else if (name == "action")
 170                 return LL_ACTION;
 171         else if (name == "info")
 172                 return LL_INFO;
 173         else if (name == "verbose")
 174                 return LL_VERBOSE;
 175         else
 176                 return LL_MAX;
 177 }
 178
 179 void Logger::addOutput(ILogOutput *out)
 180 {
 181         addOutputMaxLevel(out, (LogLevel)(LL_MAX - 1));
 182 }
 183
 184 void Logger::addOutput(ILogOutput *out, LogLevel lev)
 185 {
 186         m_outputs[lev].push_back(out);
 187 }
 188
 189 void Logger::addOutputMasked(ILogOutput *out, LogLevelMask mask)
 190 {
 191         for (size_t i = 0; i < LL_MAX; i++) {
 192                 if (mask & LOGLEVEL_TO_MASKLEVEL(i))
 193                         m_outputs[i].push_back(out);
 194         }
 195 }
 196
 197 void Logger::addOutputMaxLevel(ILogOutput *out, LogLevel lev)
 198 {
 199         assert(lev < LL_MAX);
 200         for (size_t i = 0; i <= lev; i++)
 201                 m_outputs[i].push_back(out);
 202 }
 203
 204 LogLevelMask Logger::removeOutput(ILogOutput *out)
 205 {
 206         LogLevelMask ret_mask = 0;
 207         for (size_t i = 0; i < LL_MAX; i++) {
 208                 std::vector<ILogOutput *>::iterator it;
 209
 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);
 214                 }
 215         }
 216         return ret_mask;
 217 }
 218
 219 void Logger::setLevelSilenced(LogLevel lev, bool silenced)
 220 {
 221         m_silenced_levels[lev] = silenced;
 222 }
 223
 224 void Logger::registerThread(const std::string &name)
 225 {
 226         threadid_t id = thr_get_current_thread_id();
 227         MutexAutoLock lock(m_mutex);
 228         m_thread_names[id] = name;
 229 }
 230
 231 void Logger::deregisterThread()
 232 {
 233         threadid_t id = thr_get_current_thread_id();
 234         MutexAutoLock lock(m_mutex);
 235         m_thread_names.erase(id);
 236 }
 237
 238 const std::string Logger::getLevelLabel(LogLevel lev)
 239 {
 240         static const std::string names[] = {
 241                 "",
 242                 "ERROR",
 243                 "WARNING",
 244                 "ACTION",
 245                 "INFO",
 246                 "VERBOSE",
 247         };
 248         assert(lev < LL_MAX && lev >= 0);
 249         STATIC_ASSERT(ARRLEN(names) == LL_MAX,
 250                 mismatch_between_loglevel_names_and_enum);
 251         return names[lev];
 252 }
 253
 254 const std::string Logger::getThreadName()
 255 {
 256         std::map<threadid_t, std::string>::const_iterator it;
 257
 258         threadid_t id = thr_get_current_thread_id();
 259         it = m_thread_names.find(id);
 260         if (it != m_thread_names.end())
 261                 return it->second;
 262
 263         std::ostringstream os;
 264         os << "#0x" << std::hex << id;
 265         return os.str();
 266 }
 267
 268 void Logger::log(LogLevel lev, const std::string &text)
 269 {
 270         if (m_silenced_levels[lev])
 271                 return;
 272
 273         const std::string thread_name = getThreadName();
 274         const std::string label = getLevelLabel(lev);
 275         const std::string timestamp = getTimestamp();
 276         std::ostringstream os(std::ios_base::binary);
 277         os << timestamp << ": " << label << "[" << thread_name << "]: " << text;
 278
 279         logToOutputs(lev, os.str(), timestamp, thread_name, text);
 280 }
 281
 282 void Logger::logRaw(LogLevel lev, const std::string &text)
 283 {
 284         if (m_silenced_levels[lev])
 285                 return;
 286
 287         logToOutputsRaw(lev, text);
 288 }
 289
 290 void Logger::logToOutputsRaw(LogLevel lev, const std::string &line)
 291 {
 292         MutexAutoLock lock(m_mutex);
 293         for (size_t i = 0; i != m_outputs[lev].size(); i++)
 294                 m_outputs[lev][i]->logRaw(lev, line);
 295 }
 296
 297 void Logger::logToOutputs(LogLevel lev, const std::string &combined,
 298         const std::string &time, const std::string &thread_name,
 299         const std::string &payload_text)
 300 {
 301         MutexAutoLock lock(m_mutex);
 302         for (size_t i = 0; i != m_outputs[lev].size(); i++)
 303                 m_outputs[lev][i]->log(lev, combined, time, thread_name, payload_text);
 304 }
 305
 306
 307 ////
 308 //// *LogOutput methods
 309 ////
 310
 311 void FileLogOutput::open(const std::string &filename)
 312 {
 313         m_stream.open(filename.c_str(), std::ios::app | std::ios::ate);
 314         if (!m_stream.good())
 315                 throw FileNotGoodException("Failed to open log file " +
 316                         filename + ": " + strerror(errno));
 317         m_stream << "\n\n"
 318                    "-------------" << std::endl
 319                 << "  Separator" << std::endl
 320                 << "-------------\n" << std::endl;
 321 }
 322
 323
 324
 325 ////
 326 //// *Buffer methods
 327 ////
 328
 329 int StringBuffer::overflow(int c)
 330 {
 331         push_back(c);
 332         return c;
 333 }
 334
 335
 336 std::streamsize StringBuffer::xsputn(const char *s, std::streamsize n)
 337 {
 338         for (int i = 0; i < n; ++i)
 339                 push_back(s[i]);
 340         return n;
 341 }
 342
 343 void StringBuffer::push_back(char c)
 344 {
 345         if (c == '\n' || c == '\r') {
 346                 if (buffer_index)
 347                         flush(std::string(buffer, buffer_index));
 348                 buffer_index = 0;
 349         } else {
 350                 int index = buffer_index;
 351                 buffer[index++] = c;
 352                 if (index >= BUFFER_LENGTH) {
 353                         flush(std::string(buffer, buffer_index));
 354                         buffer_index = 0;
 355                 } else {
 356                         buffer_index = index;
 357                 }
 358         }
 359 }
 360
 361
 362 void LogBuffer::flush(const std::string &buffer)
 363 {
 364         logger.log(level, buffer);
 365 }
 366
 367 void RawLogBuffer::flush(const std::string &buffer)
 368 {
 369         g_logger.logRaw(LL_NONE, buffer);
 370 }