From patchwork Fri Jul 12 20:16:17 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 1675 Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 2622861607 for ; Fri, 12 Jul 2019 22:16:30 +0200 (CEST) Received: from neptunite.amanokami.net (softbank126209254147.bbtec.net [126.209.254.147]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 05E9D2B2; Fri, 12 Jul 2019 22:16:27 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1562962589; bh=gx/DccBevK4La2pqBOrMLHG9t5pn8PfGRm3BvQulAQg=; h=From:To:Cc:Subject:Date:From; b=MO6PbkduJj/mjjcHDhX2SJ2vDRdywU0C1rCz+9tUByPwZ9Y7PnteE/H6W/SVjfYNZ XUKpDw/OIKPOM4sAb42YQmMSQw0xc0FKBy7dCEAAocxj022PnrkEZISfsHvPVNV23y VypkTsmfX6YMUWw+XA9EzjaTUlK4Y/61XVTNChSs= From: Paul Elder To: libcamera-devel@lists.libcamera.org Date: Sat, 13 Jul 2019 05:16:17 +0900 Message-Id: <20190712201620.30457-1-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 1/4] libcamera: logging: add syslog, stream, and nowhere logging targets X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 12 Jul 2019 20:16:30 -0000 Allow logging to syslog, or any given ostream, or to nowhere. The logging API is updated to accomodate these new logging destinations. LogMessage is modified to allow this. Signed-off-by: Paul Elder --- include/libcamera/logging.h | 13 +- src/libcamera/include/log.h | 11 ++ src/libcamera/log.cpp | 345 +++++++++++++++++++++++++++++------- 3 files changed, 306 insertions(+), 63 deletions(-) diff --git a/include/libcamera/logging.h b/include/libcamera/logging.h index a8495cf..a6fa8dc 100644 --- a/include/libcamera/logging.h +++ b/include/libcamera/logging.h @@ -9,8 +9,17 @@ namespace libcamera { -void logSetFile(const char *file); -int logSetLevel(const char *category, const char *level); +enum LoggingTarget { + LoggingTargetNone, + LoggingTargetSyslog, + LoggingTargetFile, + LoggingTargetStream, +}; + +int logSetFile(const char *path); +int logSetStream(std::ostream &stream); +int logSetTarget(LoggingTarget target); +void logSetLevel(const char *category, const char *level); } /* namespace libcamera */ diff --git a/src/libcamera/include/log.h b/src/libcamera/include/log.h index 802836d..394db83 100644 --- a/src/libcamera/include/log.h +++ b/src/libcamera/include/log.h @@ -60,12 +60,23 @@ public: std::ostream &stream() { return msgStream_; } + std::string ×tamp() { return logTimestamp_; } + LogSeverity severity() { return severity_; } + std::string &category() { return logCategory_; } + std::string &fileInfo() { return logFileInfo_; } + std::string &msg() { return msg_; } + private: void init(const char *fileName, unsigned int line); std::ostringstream msgStream_; const LogCategory &category_; LogSeverity severity_; + + std::string logTimestamp_; + std::string logCategory_; + std::string logFileInfo_; + std::string msg_; }; class Loggable diff --git a/src/libcamera/log.cpp b/src/libcamera/log.cpp index 709c669..df63e81 100644 --- a/src/libcamera/log.cpp +++ b/src/libcamera/log.cpp @@ -15,8 +15,11 @@ #include #include #include +#include #include +#include + #include "utils.h" /** @@ -60,7 +63,12 @@ class Logger public: static Logger *instance(); - void write(const std::string &msg); + void write(LogMessage *msg); + + int logSetFile(const char *path); + int logSetStream(std::ostream &stream); + int logSetTarget(LoggingTarget target); + void logSetLevel(const char *category, const char *level); private: Logger(); @@ -68,9 +76,7 @@ private: void parseLogFile(); void parseLogLevels(); static LogSeverity parseLogLevel(const std::string &level); - - friend int logSetFile(const char *file); - friend void logSetLevel(const char *category, const char *level); + void closeLog(); friend LogCategory; void registerCategory(LogCategory *category); @@ -81,40 +87,83 @@ private: std::ofstream file_; std::ostream *output_; + + enum LoggingTarget target_; }; +/** + * \enum LoggingTarget + * \brief Log destination type + * \var LoggingTargetNone + * \brief No logging destination + * \sa logSetTarget + * \var LoggingTargetSyslog + * \brief Log to syslog + * \sa logSetTarget + * \var LoggingTargetFile + * \brief Log to file + * \sa logSetFile + * \var LoggingTargetStream + * \brief Log to stream + * \sa logSetStream + */ + /** * \brief Set the log file - * \param[in] file Full path to the log file + * \param[in] path Full path to the log file * - * This function sets the logging output file to \a file. The previous log file, + * This function sets the logging output file to \a path. The previous log file, * if any, is closed, and all new log messages will be written to the new log * file. * - * If \a file is a null pointer, the log is directed to stderr. If the - * function returns an error, the log file is not changed. + * If the function returns an error, the log file is not changed. * * \return Zero on success, or a negative error code otherwise. */ -int logSetFile(const char *file) +int logSetFile(const char *path) { - Logger *logger = Logger::instance(); - - if (!file) { - logger->output_ = &std::cerr; - logger->file_.close(); - return 0; - } + return Logger::instance()->logSetFile(path); +} - std::ofstream logFile(file); - if (!logFile.good()) - return -EINVAL; +/** + * \brief Set the log stream + * \param[in] stream Stream to send log output to + * + * This function sets the logging output stream to \a stream. The previous log file, + * if any, is closed, and all new log messages will be written to the new log + * stream. + * + * If the function returns an error, the log file is not changed. + * + * \return Zero on success, or a negative error code otherwise. + */ +int logSetStream(std::ostream &stream) +{ + return Logger::instance()->logSetStream(stream); +} - if (logger->output_ != &std::cerr) - logger->file_.close(); - logger->file_ = std::move(logFile); - logger->output_ = &logger->file_; - return 0; +/** + * \brief Set the log target + * \param[in] target Log destination + * + * This function sets the logging output to the target specified by \a target. + * The allowed values of \a target are LoggingTargetNone and LoggingTargetSyslog. + * LoggingTargetNone will send the log output to nowhere, and LoggingTargetSyslog + * will send the log output to syslog. The previous log file, if any, is closed, + * and all new log messages will be written to the new log destination. + * + * LoggingTargetFile and LoggingTargetStream are not valid values for \a target. + * Use logSetFile() and logSetStream() instead, respectively. + * + * \sa LoggingTarget + * + * If the function returns an error, the log file is not changed. + * + * \return Zero on success, or a negative error code otherwise. + */ +int logSetTarget(LoggingTarget target) +{ + return Logger::instance()->logSetTarget(target); } /** @@ -134,15 +183,41 @@ int logSetFile(const char *file) */ void logSetLevel(const char *category, const char *level) { - Logger *logger = Logger::instance(); + Logger::instance()->logSetLevel(category, level); +} - LogSeverity severity = Logger::parseLogLevel(level); - if (severity == LogInvalid) - return; +static int log_severity_to_syslog(LogSeverity severity) +{ + switch (severity) { + case LogDebug: + return LOG_DEBUG; + case LogInfo: + return LOG_INFO; + case LogWarning: + return LOG_WARNING; + case LogError: + return LOG_ERR; + case LogFatal: + return LOG_ALERT; + default: + return LOG_NOTICE; + } +} - for (LogCategory *c : logger->categories_) - if (!strcmp(c->name(), category)) - c->setSeverity(severity); +static const char *log_severity_name(LogSeverity severity) +{ + static const char *const names[] = { + " DBG", + " INFO", + " WARN", + " ERR", + "FATAL", + }; + + if (static_cast(severity) < ARRAY_SIZE(names)) + return names[severity]; + else + return "UNKWN"; } /** @@ -163,17 +238,119 @@ Logger *Logger::instance() * \brief Write a message to the configured logger output * \param[in] msg The message string */ -void Logger::write(const std::string &msg) +void Logger::write(LogMessage *msg) +{ + std::string str; + + switch (target_) { + case LoggingTargetNone: + break; + case LoggingTargetSyslog: + str = std::string(log_severity_name(msg->severity())) + " " + + msg->category() + " " + msg->fileInfo() + " " + msg->msg(); + syslog(log_severity_to_syslog(msg->severity()), "%s", str.c_str()); + break; + case LoggingTargetFile: + case LoggingTargetStream: + str = msg->timestamp() + log_severity_name(msg->severity()) + + " " + msg->category() + " " + msg->fileInfo() + " " + + msg->msg(); + output_->write(str.c_str(), str.size()); + output_->flush(); + break; + } +} + +/** + * \brief Set the log file + * \param[in] path Full path to the log file + * + * \sa logSetFile + * + * \return Zero on success, or a negative error code otherwise. + */ +int Logger::logSetFile(const char *path) +{ + std::ofstream logFile(path); + if (!logFile.good()) + return -EINVAL; + + closeLog(); + file_ = std::move(logFile); + output_ = &file_; + target_ = LoggingTargetFile; + + return 0; +} + +/** + * \brief Set the log stream + * \param[in] stream Stream to send log output to + * + * \sa logSetStream + * + * \return Zero on success, or a negative error code otherwise. + */ +int Logger::logSetStream(std::ostream &stream) { - output_->write(msg.c_str(), msg.size()); - output_->flush(); + closeLog(); + output_ = &stream; + target_ = LoggingTargetStream; + return 0; +} + +/** + * \brief Set the log target + * \param[in] target Log destination + * + * \sa logSetTarget + * + * \return Zero on success, or a negative error code otherwise. + */ +int Logger::logSetTarget(enum LoggingTarget target) +{ + switch (target) { + case LoggingTargetNone: + closeLog(); + output_ = nullptr; + target_ = LoggingTargetNone; + break; + case LoggingTargetSyslog: + openlog("libcamera", LOG_PID, 0); + closeLog(); + output_ = nullptr; + target_ = LoggingTargetSyslog; + break; + default: + return -EINVAL; + } + + return 0; +} + +/** + * \brief Set the log level + * \param[in] category Logging category + * \param[in] level Log level + * + * \sa logSetLevel + */ +void Logger::logSetLevel(const char *category, const char *level) +{ + LogSeverity severity = Logger::parseLogLevel(level); + if (severity == LogInvalid) + return; + + for (LogCategory *c : categories_) + if (!strcmp(c->name(), category)) + c->setSeverity(severity); } /** * \brief Construct a logger */ Logger::Logger() - : output_(&std::cerr) + : output_(&std::cerr), target_(LoggingTargetStream) { parseLogFile(); parseLogLevels(); @@ -184,6 +361,7 @@ Logger::Logger() * * If the LIBCAMERA_LOG_FILE environment variable is set, open the file it * points to and redirect the logger output to it. Errors are silently ignored + * * and don't affect the logger output (set to stderr). */ void Logger::parseLogFile() @@ -192,9 +370,16 @@ void Logger::parseLogFile() if (!file) return; + if (!strcmp(file, "syslog")) { + openlog("libcamera", LOG_PID, 0); + target_ = LoggingTargetSyslog; + return; + } + file_.open(file); if (file_.good()) output_ = &file_; + target_ = LoggingTargetFile; } /** @@ -286,6 +471,25 @@ LogSeverity Logger::parseLogLevel(const std::string &level) return static_cast(severity); } +/** + * \brief Close the current log file + */ +void Logger::closeLog() +{ + switch (target_) { + case LoggingTargetNone: + break; + case LoggingTargetSyslog: + closelog(); + break; + case LoggingTargetFile: + file_.close(); + break; + case LoggingTargetStream: + break; + } +} + /** * \brief Register a log category with the logger * \param[in] category The log category @@ -408,22 +612,6 @@ const LogCategory &LogCategory::defaultCategory() return category; } -static const char *log_severity_name(LogSeverity severity) -{ - static const char *const names[] = { - " DBG", - " INFO", - " WARN", - " ERR", - "FATAL", - }; - - if (static_cast(severity) < ARRAY_SIZE(names)) - return names[severity]; - else - return "UNKWN"; -} - /** * \class LogMessage * \brief Internal log message representation. @@ -495,16 +683,22 @@ void LogMessage::init(const char *fileName, unsigned int line) /* Log the timestamp, severity and file information. */ struct timespec timestamp; clock_gettime(CLOCK_MONOTONIC, ×tamp); - msgStream_.fill('0'); - msgStream_ << "[" << timestamp.tv_sec / (60 * 60) << ":" + std::ostringstream ossTimestamp; + ossTimestamp.fill('0'); + ossTimestamp << "[" << timestamp.tv_sec / (60 * 60) << ":" << std::setw(2) << (timestamp.tv_sec / 60) % 60 << ":" << std::setw(2) << timestamp.tv_sec % 60 << "." << std::setw(9) << timestamp.tv_nsec << "]"; - msgStream_.fill(' '); + ossTimestamp.fill(' '); + logTimestamp_ = ossTimestamp.str(); + + std::ostringstream ossCategory; + ossCategory << category_.name(); + logCategory_ = ossCategory.str(); - msgStream_ << " " << log_severity_name(severity_); - msgStream_ << " " << category_.name(); - msgStream_ << " " << utils::basename(fileName) << ":" << line << " "; + std::ostringstream ossFileInfo; + ossFileInfo << utils::basename(fileName) << ":" << line; + logFileInfo_ = ossFileInfo.str(); } LogMessage::~LogMessage() @@ -514,11 +708,10 @@ LogMessage::~LogMessage() return; msgStream_ << std::endl; + msg_ = msgStream_.str(); - if (severity_ >= category_.severity()) { - std::string msg(msgStream_.str()); - Logger::instance()->write(msg); - } + if (severity_ >= category_.severity()) + Logger::instance()->write(this); if (severity_ == LogSeverity::LogFatal) std::abort(); @@ -534,6 +727,36 @@ LogMessage::~LogMessage() * \return A reference to the log message stream */ +/** + * \fn LogMessage::timestamp() + * \brief Getter for the timestamp of the log message + * \return The timestamp of the message, as a string + */ + +/** + * \fn LogMessage::severity() + * \brief Getter for the severity of the log message + * \return The severity of the message + */ + +/** + * \fn LogMessage::category() + * \brief Getter for the category of the log message + * \return The category of the message, as a string + */ + +/** + * \fn LogMessage::fileInfo() + * \brief Getter for the file info of the log message + * \return The file info of the message, as a string + */ + +/** + * \fn LogMessage::msg() + * \brief Getter for the message text of the log message + * \return The message text of the message, as a string + */ + /** * \class Loggable * \brief Base class to support log message extensions