src/common/logger.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2018 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   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 General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include <iostream>
  22
  23 #ifdef HAVE_SYSLOG
  24 #  include <syslog.h>
  25 #endif
  26
  27 #include <QByteArray>
  28 #include <QDateTime>
  29 #include <QDebug>
  30 #include <QFile>
  31
  32 #include "logger.h"
  33 #include "quassel.h"
  34
  35 namespace {
  36
  37 QByteArray msgWithTime(const Logger::LogEntry &msg)
  38 {
  39     return (msg.timeStamp.toString("yyyy-MM-dd hh:mm:ss ") + msg.message + "\n").toUtf8();
  40 };
  41
  42 }
  43
  44
  45 Logger::Logger(QObject *parent)
  46     : QObject(parent)
  47 {
  48     static bool registered = []() {
  49         qRegisterMetaType<LogEntry>();
  50         return true;
  51     }();
  52     Q_UNUSED(registered)
  53
  54     connect(this, SIGNAL(messageLogged(Logger::LogEntry)), this, SLOT(onMessageLogged(Logger::LogEntry)));
  55
  56     qInstallMessageHandler(Logger::messageHandler);
  57 }
  58
  59
  60 Logger::~Logger()
  61 {
  62     // If we're not initialized yet, output pending messages so they don't get lost
  63     if (!_initialized) {
  64         for (auto &&message : _messages) {
  65             std::cerr << msgWithTime(message).constData();
  66         }
  67     }
  68 }
  69
  70
  71 std::vector<Logger::LogEntry> Logger::messages() const
  72 {
  73     return _messages;
  74 }
  75
  76
  77 bool Logger::setup(bool keepMessages)
  78 {
  79     _keepMessages = keepMessages;
  80
  81     // Set maximum level for output (we still store/announce all messages for client-side filtering)
  82     if (Quassel::isOptionSet("loglevel")) {
  83         QString level = Quassel::optionValue("loglevel").toLower();
  84         if (level == "debug")
  85             _outputLevel = LogLevel::Debug;
  86         else if (level == "info")
  87             _outputLevel = LogLevel::Info;
  88         else if (level == "warning")
  89             _outputLevel = LogLevel::Warning;
  90         else if (level == "error")
  91             _outputLevel = LogLevel::Error;
  92         else {
  93             qCritical() << qPrintable(tr("Invalid log level %1; supported are Debug|Info|Warning|Error").arg(level));
  94             return false;
  95         }
  96     }
  97
  98     QString logfilename = Quassel::optionValue("logfile");
  99     if (!logfilename.isEmpty()) {
 100         _logFile.setFileName(logfilename);
 101         if (!_logFile.open(QFile::Append|QFile::Unbuffered|QFile::Text)) {
 102             qCritical() << qPrintable(tr("Could not open log file \"%1\": %2").arg(logfilename, _logFile.errorString()));
 103         }
 104     }
 105     if (!_logFile.isOpen()) {
 106         if (!_logFile.open(stderr, QFile::WriteOnly|QFile::Unbuffered|QFile::Text)) {
 107             qCritical() << qPrintable(tr("Cannot write to stderr: %1").arg(_logFile.errorString()));
 108         }
 109     }
 110
 111 #ifdef HAVE_SYSLOG
 112     _syslogEnabled = Quassel::isOptionSet("syslog");
 113 #endif
 114
 115     _initialized = true;
 116
 117     // Now that we've setup our logging backends, output pending messages
 118     for (auto &&message : _messages) {
 119         outputMessage(message);
 120     }
 121     if (!_keepMessages) {
 122         _messages.clear();
 123     }
 124
 125     return true;
 126 }
 127
 128
 129 void Logger::messageHandler(QtMsgType type, const QMessageLogContext &, const QString &message)
 130 {
 131     Quassel::instance()->logger()->handleMessage(type, message);
 132 }
 133
 134
 135 void Logger::handleMessage(QtMsgType type, const QString &msg)
 136 {
 137     switch (type) {
 138     case QtDebugMsg:
 139         handleMessage(LogLevel::Debug, msg);
 140         break;
 141     case QtInfoMsg:
 142         handleMessage(LogLevel::Info, msg);
 143         break;
 144     case QtWarningMsg:
 145         handleMessage(LogLevel::Warning, msg);
 146         break;
 147     case QtCriticalMsg:
 148         handleMessage(LogLevel::Error, msg);
 149         break;
 150     case QtFatalMsg:
 151         handleMessage(LogLevel::Fatal, msg);
 152         break;
 153     }
 154 }
 155
 156
 157 void Logger::handleMessage(LogLevel level, const QString &msg)
 158 {
 159     QString logString;
 160
 161     switch (level) {
 162     case LogLevel::Debug:
 163         logString = "[Debug] ";
 164         break;
 165     case LogLevel::Info:
 166         logString = "[Info ] ";
 167         break;
 168     case LogLevel::Warning:
 169         logString = "[Warn ] ";
 170         break;
 171     case LogLevel::Error:
 172         logString = "[Error] ";
 173         break;
 174     case LogLevel::Fatal:
 175         logString = "[FATAL] ";
 176         break;
 177     }
 178
 179     // Use signal connection to make this method thread-safe
 180     emit messageLogged({QDateTime::currentDateTime(), level, logString += msg});
 181 }
 182
 183
 184 void Logger::onMessageLogged(const LogEntry &message)
 185 {
 186     if (_keepMessages) {
 187         _messages.push_back(message);
 188     }
 189
 190     // If setup() wasn't called yet, just store the message - will be output later
 191     if (_initialized) {
 192         outputMessage(message);
 193     }
 194 }
 195
 196
 197 void Logger::outputMessage(const LogEntry &message)
 198 {
 199     if (message.logLevel < _outputLevel) {
 200         return;
 201     }
 202
 203 #ifdef HAVE_SYSLOG
 204     if (_syslogEnabled) {
 205         int prio{LOG_INFO};
 206         switch (message.logLevel) {
 207         case LogLevel::Debug:
 208             prio = LOG_DEBUG;
 209             break;
 210         case LogLevel::Info:
 211             prio = LOG_INFO;
 212             break;
 213         case LogLevel::Warning:
 214             prio = LOG_WARNING;
 215             break;
 216         case LogLevel::Error:
 217             prio = LOG_ERR;
 218             break;
 219         case LogLevel::Fatal:
 220             prio = LOG_CRIT;
 221         }
 222         syslog(prio|LOG_USER, "%s", qPrintable(message.message));
 223     }
 224 #endif
 225
 226     if (!_logFile.fileName().isEmpty() || !_syslogEnabled) {
 227         _logFile.write(msgWithTime(message));
 228     }
 229
 230 #ifndef Q_OS_MAC
 231     // For fatal messages, write log to dump file
 232     if (message.logLevel == LogLevel::Fatal) {
 233         QFile dumpFile{Quassel::instance()->coreDumpFileName()};
 234         if (dumpFile.open(QIODevice::Append)) {
 235             dumpFile.write(msgWithTime(message));
 236             dumpFile.close();
 237         }
 238     }
 239 #endif
 240
 241 }