[core] Use separate thread for logging

include/mbgl/util/logging.hpp

@@ -3,6 +3,7 @@
 #include <mbgl/util/event.hpp>
 
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/optional.hpp>
 
 #include <memory>
 #include <string>
@@ -36,6 +37,11 @@ class Log {
     }
 
 public:
+    Log();
+    ~Log();
+
+    static void useLogThread(bool enable);
+
     template <typename ...Args>
     static void Debug(Event event, Args&& ...args) {
         Record(EventSeverity::Debug, event, ::std::forward<Args>(args)...);
@@ -66,15 +72,23 @@ class Log {
     }
 
 private:
+    static Log* get() noexcept;
+
     static void record(EventSeverity severity, Event event, const std::string &msg);
     static void record(EventSeverity severity, Event event, const char* format = "", ...);
     static void record(EventSeverity severity, Event event, int64_t code, const char* format = "", ...);
-    static void record(EventSeverity severity, Event event, int64_t code, const std::string &msg);
+    static void record(EventSeverity severity,
+                       Event event,
+                       int64_t code,
+                       const std::string& msg,
+                       const optional<std::string>& threadName);
 
     // This method is the data sink that must be implemented by each platform we
     // support. It should ideally output the error message in a human readable
     // format to the developer.
     static void platformRecord(EventSeverity severity, const std::string &msg);
+    class Impl;
+    const std::unique_ptr<Impl> impl;
 };
 
 } // namespace mbgl

src/mbgl/util/logging.cpp

@@ -1,5 +1,7 @@
-#include <mbgl/util/logging.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/platform/settings.hpp>
 #include <mbgl/util/enum.hpp>
+#include <mbgl/util/logging.hpp>
 #include <mbgl/util/platform.hpp>
 
 #include <cstdio>
@@ -10,22 +12,56 @@ namespace mbgl {
 
 namespace {
 
-static std::unique_ptr<Log::Observer> currentObserver;
+std::unique_ptr<Log::Observer> currentObserver;
+std::atomic<bool> useThread(true);
+std::mutex mutex;
 
 } // namespace
 
+class Log::Impl {
+public:
+    Impl() : scheduler(Scheduler::GetSequenced()) {}
+
+    void record(EventSeverity severity, Event event, int64_t code, const std::string& msg) {
+        if (useThread) {
+            auto threadName = platform::getCurrentThreadName();
+            scheduler->schedule([=]() { Log::record(severity, event, code, msg, threadName); });
+        } else {
+            Log::record(severity, event, code, msg, {});
+        }
+    }
+
+private:
+    const std::shared_ptr<Scheduler> scheduler;
+};
+
+Log::Log() : impl(std::make_unique<Impl>()) {}
+
+Log::~Log() = default;
+
+Log* Log::get() noexcept {
+    static Log instance;
+    return &instance;
+}
+
+void Log::useLogThread(bool enable) {
+    useThread = enable;
+}
+
 void Log::setObserver(std::unique_ptr<Observer> observer) {
+    std::lock_guard<std::mutex> lock(mutex);
     currentObserver = std::move(observer);
 }
 
 std::unique_ptr<Log::Observer> Log::removeObserver() {
+    std::lock_guard<std::mutex> lock(mutex);
     std::unique_ptr<Observer> observer;
     std::swap(observer, currentObserver);
     return observer;
 }
 
 void Log::record(EventSeverity severity, Event event, const std::string &msg) {
-    record(severity, event, -1, msg);
+    get()->impl->record(severity, event, -1, msg);
 }
 
 void Log::record(EventSeverity severity, Event event, const char* format, ...) {
@@ -35,7 +71,7 @@ void Log::record(EventSeverity severity, Event event, const char* format, ...) {
     vsnprintf(msg, sizeof(msg), format, args);
     va_end(args);
 
-    record(severity, event, -1, std::string{ msg });
+    get()->impl->record(severity, event, -1, std::string{msg});
 }
 
 void Log::record(EventSeverity severity, Event event, int64_t code, const char* format, ...) {
@@ -45,18 +81,23 @@ void Log::record(EventSeverity severity, Event event, int64_t code, const char*
     vsnprintf(msg, sizeof(msg), format, args);
     va_end(args);
 
-    record(severity, event, code, std::string{ msg });
+    get()->impl->record(severity, event, code, std::string{msg});
 }
 
-void Log::record(EventSeverity severity, Event event, int64_t code, const std::string &msg) {
+void Log::record(EventSeverity severity,
+                 Event event,
+                 int64_t code,
+                 const std::string& msg,
+                 const optional<std::string>& threadName) {
+    std::lock_guard<std::mutex> lock(mutex);
     if (currentObserver && severity != EventSeverity::Debug &&
         currentObserver->onRecord(severity, event, code, msg)) {
         return;
     }
 
     std::stringstream logStream;
 
-    logStream << "{" << platform::getCurrentThreadName() << "}";
+    logStream << "{" << threadName.value_or(platform::getCurrentThreadName()) << "}";
     logStream << "[" << Enum<Event>::toString(event) << "]";
 
     if (code >= 0) {