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 class StringBuffer : public std::streambuf {
  38 public:
  39         StringBuffer() {}
  40
  41         int overflow(int c);
  42         virtual void flush(const std::string &buf) = 0;
  43         std::streamsize xsputn(const char *s, std::streamsize n);
  44         void push_back(char c);
  45
  46 private:
  47         std::string buffer;
  48 };
  49
  50
  51 class LogBuffer : public StringBuffer {
  52 public:
  53         LogBuffer(Logger &logger, LogLevel lev) :
  54                 logger(logger),
  55                 level(lev)
  56         {}
  57
  58         void flush(const std::string &buffer);
  59
  60 private:
  61         Logger &logger;
  62         LogLevel level;
  63 };
  64
  65
  66 class RawLogBuffer : public StringBuffer {
  67 public:
  68         void flush(const std::string &buffer);
  69 };
  70
  71 ////
  72 //// Globals
  73 ////
  74
  75 Logger g_logger;
  76
  77 StreamLogOutput stdout_output(std::cout);
  78 StreamLogOutput stderr_output(std::cerr);
  79 std::ostream null_stream(NULL);
  80
  81 RawLogBuffer raw_buf;
  82
  83 LogBuffer none_buf(g_logger, LL_NONE);
  84 LogBuffer error_buf(g_logger, LL_ERROR);
  85 LogBuffer warning_buf(g_logger, LL_WARNING);
  86 LogBuffer action_buf(g_logger, LL_ACTION);
  87 LogBuffer info_buf(g_logger, LL_INFO);
  88 LogBuffer verbose_buf(g_logger, LL_VERBOSE);
  89
  90 // Connection
  91 std::ostream *dout_con_ptr = &null_stream;
  92 std::ostream *derr_con_ptr = &verbosestream;
  93
  94 // Server
  95 std::ostream *dout_server_ptr = &infostream;
  96 std::ostream *derr_server_ptr = &errorstream;
  97
  98 #ifndef SERVER
  99 // Client
 100 std::ostream *dout_client_ptr = &infostream;
 101 std::ostream *derr_client_ptr = &errorstream;
 102 #endif
 103
 104 std::ostream rawstream(&raw_buf);
 105 std::ostream dstream(&none_buf);
 106 std::ostream errorstream(&error_buf);
 107 std::ostream warningstream(&warning_buf);
 108 std::ostream actionstream(&action_buf);
 109 std::ostream infostream(&info_buf);
 110 std::ostream verbosestream(&verbose_buf);
 111
 112 // Android
 113 #ifdef __ANDROID__
 114
 115 static unsigned int g_level_to_android[] = {
 116         ANDROID_LOG_INFO,     // LL_NONE
 117         //ANDROID_LOG_FATAL,
 118         ANDROID_LOG_ERROR,    // LL_ERROR
 119         ANDROID_LOG_WARN,     // LL_WARNING
 120         ANDROID_LOG_WARN,     // LL_ACTION
 121         //ANDROID_LOG_INFO,
 122         ANDROID_LOG_DEBUG,    // LL_INFO
 123         ANDROID_LOG_VERBOSE,  // LL_VERBOSE
 124 };
 125
 126 class AndroidSystemLogOutput : public ICombinedLogOutput {
 127         public:
 128                 AndroidSystemLogOutput()
 129                 {
 130                         g_logger.addOutput(this);
 131                 }
 132                 ~AndroidSystemLogOutput()
 133                 {
 134                         g_logger.removeOutput(this);
 135                 }
 136                 void logRaw(LogLevel lev, const std::string &line)
 137                 {
 138                         assert(ARRLEN(g_level_to_android) == LL_MAX);
 139                         __android_log_print(g_level_to_android[lev],
 140                                 PROJECT_NAME_C, "%s", line.c_str());
 141                 }
 142 };
 143
 144 AndroidSystemLogOutput g_android_log_output;
 145
 146 #endif
 147
 148 ///////////////////////////////////////////////////////////////////////////////
 149
 150
 151 ////
 152 //// Logger
 153 ////
 154
 155 LogLevel Logger::stringToLevel(const std::string &name)
 156 {
 157         if (name == "none")
 158                 return LL_NONE;
 159         else if (name == "error")
 160                 return LL_ERROR;
 161         else if (name == "warning")
 162                 return LL_WARNING;
 163         else if (name == "action")
 164                 return LL_ACTION;
 165         else if (name == "info")
 166                 return LL_INFO;
 167         else if (name == "verbose")
 168                 return LL_VERBOSE;
 169         else
 170                 return LL_MAX;
 171 }
 172
 173 void Logger::addOutput(ILogOutput *out)
 174 {
 175         addOutputMaxLevel(out, (LogLevel)(LL_MAX - 1));
 176 }
 177
 178 void Logger::addOutput(ILogOutput *out, LogLevel lev)
 179 {
 180         m_outputs[lev].push_back(out);
 181 }
 182
 183 void Logger::addOutputMaxLevel(ILogOutput *out, LogLevel lev)
 184 {
 185         assert(lev < LL_MAX);
 186         for (size_t i = 0; i <= lev; i++)
 187                 m_outputs[i].push_back(out);
 188 }
 189
 190 void Logger::removeOutput(ILogOutput *out)
 191 {
 192         for (size_t i = 0; i < LL_MAX; i++) {
 193                 std::vector<ILogOutput *>::iterator it;
 194
 195                 it = std::find(m_outputs[i].begin(), m_outputs[i].end(), out);
 196                 if (it != m_outputs[i].end())
 197                         m_outputs[i].erase(it);
 198         }
 199 }
 200
 201 void Logger::setLevelSilenced(LogLevel lev, bool silenced)
 202 {
 203         m_silenced_levels[lev] = silenced;
 204 }
 205
 206 void Logger::registerThread(const std::string &name)
 207 {
 208         threadid_t id = thr_get_current_thread_id();
 209         MutexAutoLock lock(m_mutex);
 210         m_thread_names[id] = name;
 211 }
 212
 213 void Logger::deregisterThread()
 214 {
 215         threadid_t id = thr_get_current_thread_id();
 216         MutexAutoLock lock(m_mutex);
 217         m_thread_names.erase(id);
 218 }
 219
 220 const std::string Logger::getLevelLabel(LogLevel lev)
 221 {
 222         static const std::string names[] = {
 223                 "",
 224                 "ERROR",
 225                 "WARNING",
 226                 "ACTION",
 227                 "INFO",
 228                 "VERBOSE",
 229         };
 230         assert(lev < LL_MAX && lev >= 0);
 231         assert(ARRLEN(names) == LL_MAX);
 232         return names[lev];
 233 }
 234
 235 const std::string Logger::getThreadName()
 236 {
 237         std::map<threadid_t, std::string>::const_iterator it;
 238
 239         threadid_t id = thr_get_current_thread_id();
 240         it = m_thread_names.find(id);
 241         if (it != m_thread_names.end())
 242                 return it->second;
 243
 244         std::ostringstream os;
 245         os << "#0x" << std::hex << id;
 246         return os.str();
 247 }
 248
 249 void Logger::log(LogLevel lev, const std::string &text)
 250 {
 251         if (m_silenced_levels[lev])
 252                 return;
 253
 254         const std::string thread_name = getThreadName();
 255         const std::string label = getLevelLabel(lev);
 256         const std::string timestamp = getTimestamp();
 257         std::ostringstream os(std::ios_base::binary);
 258         os << timestamp << ": " << label << "[" << thread_name << "]: " << text;
 259
 260         logToOutputs(lev, os.str(), timestamp, thread_name, text);
 261 }
 262
 263 void Logger::logRaw(LogLevel lev, const std::string &text)
 264 {
 265         if (m_silenced_levels[lev])
 266                 return;
 267
 268         logToOutputsRaw(lev, text);
 269 }
 270
 271 void Logger::logToOutputsRaw(LogLevel lev, const std::string &line)
 272 {
 273         MutexAutoLock lock(m_mutex);
 274         for (size_t i = 0; i != m_outputs[lev].size(); i++)
 275                 m_outputs[lev][i]->logRaw(lev, line);
 276 }
 277
 278 void Logger::logToOutputs(LogLevel lev, const std::string &combined,
 279         const std::string &time, const std::string &thread_name,
 280         const std::string &payload_text)
 281 {
 282         MutexAutoLock lock(m_mutex);
 283         for (size_t i = 0; i != m_outputs[lev].size(); i++)
 284                 m_outputs[lev][i]->log(lev, combined, time, thread_name, payload_text);
 285 }
 286
 287
 288 ////
 289 //// *LogOutput methods
 290 ////
 291
 292 void FileLogOutput::open(const std::string &filename)
 293 {
 294         m_stream.open(filename.c_str(), std::ios::app | std::ios::ate);
 295         if (!m_stream.good())
 296                 throw FileNotGoodException("Failed to open log file " +
 297                         filename + ": " + strerror(errno));
 298         m_stream << "\n\n"
 299                    "-------------" << std::endl
 300                 << "  Separator" << std::endl
 301                 << "-------------\n" << std::endl;
 302 }
 303
 304
 305
 306 ////
 307 //// *Buffer methods
 308 ////
 309
 310 int StringBuffer::overflow(int c)
 311 {
 312         push_back(c);
 313         return c;
 314 }
 315
 316
 317 std::streamsize StringBuffer::xsputn(const char *s, std::streamsize n)
 318 {
 319         for (int i = 0; i < n; ++i)
 320                 push_back(s[i]);
 321         return n;
 322 }
 323
 324 void StringBuffer::push_back(char c)
 325 {
 326         if (c == '\n' || c == '\r') {
 327                 if (!buffer.empty())
 328                         flush(buffer);
 329                 buffer.clear();
 330         } else {
 331                 buffer.push_back(c);
 332         }
 333 }
 334
 335
 336 void LogBuffer::flush(const std::string &buffer)
 337 {
 338         logger.log(level, buffer);
 339 }
 340
 341 void RawLogBuffer::flush(const std::string &buffer)
 342 {
 343         g_logger.logRaw(LL_NONE, buffer);
 344 }