--- /dev/null
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <thread>
+
+#ifndef BOOST_LOG_DYN_LINK
+#define BOOST_LOG_DYN_LINK
+#endif
+#include <boost/date_time.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/log/expressions.hpp>
+#include <boost/log/support/date_time.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/log/utility/manipulators.hpp>
+#include <boost/log/utility/setup.hpp>
+#define BOOST_LOG_USE_NATIVE_SYSLOG
+#include <boost/log/sinks/syslog_backend.hpp>
+
+#include "anbox/logger.h"
+
+namespace {
+namespace attrs {
+BOOST_LOG_ATTRIBUTE_KEYWORD(Severity, "Severity", anbox::Logger::Severity)
+BOOST_LOG_ATTRIBUTE_KEYWORD(Location, "Location", anbox::Logger::Location)
+BOOST_LOG_ATTRIBUTE_KEYWORD(Timestamp, "Timestamp", boost::posix_time::ptime)
+}
+
+struct BoostLogLogger : public anbox::Logger {
+ BoostLogLogger() : initialized_(false) {}
+
+ void Init(const anbox::Logger::Severity& severity = anbox::Logger::Severity::kWarning) override {
+ if (initialized_)
+ return;
+
+ boost::log::formatter formatter =
+ boost::log::expressions::stream
+ << "[" << attrs::Severity << " "
+ << boost::log::expressions::format_date_time<boost::posix_time::ptime>(
+ "Timestamp", "%Y-%m-%d %H:%M:%S")
+ << "] "
+ << boost::log::expressions::if_(boost::log::expressions::has_attr(
+ attrs::Location))[boost::log::expressions::stream
+ << "[" << attrs::Location << "] "]
+ << boost::log::expressions::smessage;
+
+ boost::log::core::get()->remove_all_sinks();
+
+ // If we have a controlling tty then we use the console for log outpu
+ // and otherwise we move everything into the system syslog.
+ if (isatty(0)) {
+ auto logger = boost::log::add_console_log(std::cout);
+ logger->set_formatter(formatter);
+ } else {
+ boost::shared_ptr<boost::log::sinks::syslog_backend> backend(
+ new boost::log::sinks::syslog_backend(
+ boost::log::keywords::facility = boost::log::sinks::syslog::user,
+ boost::log::keywords::use_impl = boost::log::sinks::syslog::native));
+ backend->set_severity_mapper(boost::log::sinks::syslog::direct_severity_mapping<int>("Severity"));
+ boost::log::core::get()->add_sink(boost::make_shared<boost::log::sinks::synchronous_sink<
+ boost::log::sinks::syslog_backend>>(backend));
+ }
+
+ severity_ = severity;
+ initialized_ = true;
+ }
+
+ void SetSeverity(const Severity& severity) override {
+ severity_ = severity;
+ }
+
+ Severity GetSeverity() override {
+ return severity_;
+ }
+
+ void Log(Severity severity, const std::string& message, const boost::optional<Location>& loc) override {
+ if (!initialized_) Init();
+
+ // FIXME somehow set_filter doesn't work with the trivial logger. If
+ // we set a filter based on the severity attribute open_record will
+ // not return a new record. Because of that we do a poor man filtering
+ // here until we have a proper way to do this via boost.
+ if (severity < severity_)
+ return;
+
+ if (auto rec = boost::log::trivial::logger::get().open_record()) {
+ boost::log::record_ostream out{rec};
+ out << boost::log::add_value(attrs::Severity, severity)
+ << boost::log::add_value(attrs::Timestamp, boost::posix_time::microsec_clock::universal_time())
+ << message;
+
+ if (loc) {
+ // We have to pass in a temporary as boost::log (<= 1.55) expects a
+ // mutable reference to be passed to boost::log::add_value(...).
+ auto tmp = *loc;
+ out << boost::log::add_value(attrs::Location, tmp);
+ }
+
+ boost::log::trivial::logger::get().push_record(std::move(rec));
+ }
+ }
+
+ private:
+ Severity severity_;
+ bool initialized_;
+};
+
+std::shared_ptr<anbox::Logger>& MutableInstance() {
+ static std::shared_ptr<anbox::Logger> instance{new BoostLogLogger()};
+ return instance;
+}
+
+void SetInstance(const std::shared_ptr<anbox::Logger>& logger) {
+ MutableInstance() = logger;
+}
+}
+namespace anbox {
+
+bool Logger::SetSeverityFromString(const std::string& severity) {
+ if (severity == "trace")
+ SetSeverity(Severity::kTrace);
+ else if (severity == "debug")
+ SetSeverity(Severity::kDebug);
+ else if (severity == "info")
+ SetSeverity(Severity::kInfo);
+ else if (severity == "warning")
+ SetSeverity(Severity::kWarning);
+ else if (severity == "error")
+ SetSeverity(Severity::kError);
+ else if (severity == "fatal")
+ SetSeverity(Severity::kFatal);
+ else
+ return false;
+ return true;
+}
+
+void Logger::Trace(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kTrace, message, location);
+}
+
+void Logger::Debug(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kDebug, message, location);
+}
+
+void Logger::Info(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kInfo, message, location);
+}
+
+void Logger::Warning(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kWarning, message, location);
+}
+
+void Logger::Error(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kError, message, location);
+}
+
+void Logger::Fatal(const std::string& message,
+ const boost::optional<Location>& location) {
+ Log(Severity::kFatal, message, location);
+}
+
+std::ostream& operator<<(std::ostream& strm, anbox::Logger::Severity severity) {
+ switch (severity) {
+ case anbox::Logger::Severity::kTrace:
+ return strm << "TT";
+ case anbox::Logger::Severity::kDebug:
+ return strm << "DD";
+ case anbox::Logger::Severity::kInfo:
+ return strm << "II";
+ case anbox::Logger::Severity::kWarning:
+ return strm << "WW";
+ case anbox::Logger::Severity::kError:
+ return strm << "EE";
+ case anbox::Logger::Severity::kFatal:
+ return strm << "FF";
+ default:
+ return strm << static_cast<unsigned int>(severity);
+ }
+}
+
+std::ostream& operator<<(std::ostream& out, const Logger::Location& location) {
+ return out << utils::string_format(
+ "%s:%d@%s",
+ boost::filesystem::path(location.file).filename().string(),
+ location.line, location.function);
+}
+
+Logger& Log() { return *MutableInstance(); }
+
+void SetLogger(const std::shared_ptr<Logger>& logger) { SetInstance(logger); }
+
+} // namespace anbox
Code Review / iec.git / blobdiff