log: add slf4j-compatible logger class

Supports variadic logging with placeholders, e.g.

  logger.error("what happened? x = {}, y = {}", x, y);

Instantiate loggers as static thread_local, e.g.

  class foo {
      static thread_local logging::logger logger;
  };

  thread_local logging::logger foo::logger{logging::logger_for<foo>};

configure.py

@@ -202,6 +202,7 @@ cassandra_interface = Thrift(source = 'interface/cassandra.thrift', service = 'C
 deps = {
     'seastar': (['main.cc',
                  'database.cc',
+                 'log.cc',
                  'cql3/cql3.cc',
                  'thrift/handler.cc',
                  'thrift/server.cc',

log.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2014 Cloudius Systems, Ltd.
+ */
+
+#include "log.hh"
+#include <cxxabi.h>
+
+namespace logging {
+
+logger::logger(sstring name) : _name(std::move(name)) {
+    g_registry.register_logger(this);
+}
+
+logger::logger(logger&& x) : _name(std::move(x._name)), _level(x._level) {
+    g_registry.moved(&x, this);
+}
+
+logger::~logger() {
+    g_registry.unregister_logger(this);
+}
+
+void
+logger::really_do_log(log_level level, const char* fmt, stringer** s, size_t n) {
+    const char* p = fmt;
+    while (*p != '\0') {
+        if (*p == '{' && *(p+1) == '}') {
+            p += 2;
+            if (n > 0) {
+                (*s++)->append(std::cout);
+                --n;
+            } else {
+                std::cout << "???";
+            }
+        } else {
+            std::cout << *p++;
+        }
+    }
+    std::cout << "\n";
+}
+
+void
+registry::register_logger(logger* l) {
+    _loggers[l->name()] = l;
+}
+
+void
+registry::unregister_logger(logger* l) {
+    _loggers.erase(l->name());
+}
+
+void
+registry::moved(logger* from, logger* to) {
+    _loggers[from->name()] = to;
+}
+
+sstring pretty_type_name(const std::type_info& ti) {
+    int status;
+    std::unique_ptr<char[], void (*)(void*)> result(
+            abi::__cxa_demangle(ti.name(), 0, 0, &status), std::free);
+    return result.get() ? result.get() : ti.name();
+}
+
+thread_local registry g_registry;
+
+}

log.hh

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014 Cloudius Systems, Ltd.
+ */
+
+#ifndef LOG_HH_
+#define LOG_HH_
+
+#include "core/sstring.hh"
+#include <unordered_map>
+
+namespace logging {
+
+enum class log_level {
+    error,
+    warn,
+    info,
+    debug,
+    trace,
+};
+
+class logger;
+class registry;
+
+class logger {
+    sstring _name;
+    log_level _level = log_level::warn;
+private:
+    struct stringer {
+        // no need for virtual dtor, since not dynamically destroyed
+        virtual void append(std::ostream& os) = 0;
+    };
+    template <typename Arg>
+    struct stringer_for final : stringer {
+        explicit stringer_for(const Arg& arg) : arg(arg) {}
+        const Arg& arg;
+        virtual void append(std::ostream& os) override {
+            os << arg;
+        }
+    };
+    template <typename... Args>
+    void do_log(log_level level, const char* fmt, Args&&... args);
+    template <typename Arg, typename... Args>
+    void do_log_step(log_level level, const char* fmt, stringer** s, size_t n, size_t idx, Arg&& arg, Args&&... args);
+    void do_log_step(log_level level, const char* fmt, stringer** s, size_t n, size_t idx);
+    void really_do_log(log_level level, const char* fmt, stringer** stringers, size_t n);
+public:
+    explicit logger(sstring name);
+    logger(logger&& x);
+    ~logger();
+    template <typename... Args>
+    void log(log_level level, const char* fmt, Args&&... args) {
+        if (level <= _level) {
+            do_log(level, fmt, std::forward<Args>(args)...);
+        }
+    }
+    template <typename... Args>
+    void error(const char* fmt, Args&&... args) {
+        log(log_level::error, fmt, std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    void warn(const char* fmt, Args&&... args) {
+        log(log_level::warn, fmt, std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    void info(const char* fmt, Args&&... args) {
+        log(log_level::info, fmt, std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    void debug(const char* fmt, Args&&... args) {
+        log(log_level::debug, fmt, std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    void trace(const char* fmt, Args&&... args) {
+        log(log_level::trace, fmt, std::forward<Args>(args)...);
+    }
+    const sstring& name() const {
+        return _name;
+    }
+};
+
+class registry {
+    std::unordered_map<sstring, logger*> _loggers;
+public:
+    void register_logger(logger* l);
+    void unregister_logger(logger* l);
+    void moved(logger* from, logger* to);
+};
+
+sstring pretty_type_name(const std::type_info&);
+
+extern thread_local registry g_registry;
+
+template <typename T>
+class logger_for : public logger {
+public:
+    logger_for() : logger(pretty_type_name(typeid(T))) {}
+};
+
+inline
+void
+logger::do_log_step(log_level level, const char* fmt, stringer** s, size_t n, size_t idx) {
+    really_do_log(level, fmt, s, n);
+}
+
+template <typename Arg, typename... Args>
+inline
+void
+logger::do_log_step(log_level level, const char* fmt, stringer** s, size_t n, size_t idx, Arg&& arg, Args&&... args) {
+    stringer_for<Arg> sarg{arg};
+    s[idx] = &sarg;
+    do_log_step(level, fmt, s, n, idx + 1, std::forward<Args>(args)...);
+}
+
+
+template <typename... Args>
+void
+logger::do_log(log_level level, const char* fmt, Args&&... args) {
+    stringer* s[sizeof...(Args)];
+    do_log_step(level, fmt, s, sizeof...(Args), 0, std::forward<Args>(args)...);
+}
+
+}
+
+#endif /* LOG_HH_ */