refactor console consumer

repertory/librepertory/include/events/consumers/console_consumer.hpp

@@ -24,29 +24,24 @@
 
 #include "events/event_system.hpp"
 
+namespace spdlog {
+class async_logger;
+}
+
 namespace repertory {
 class console_consumer final {
   E_CONSUMER();
 
 public:
-  console_consumer() { E_SUBSCRIBE_ALL(process_event); }
+  console_consumer(event_level level);
 
-public:
+  ~console_consumer();
-  ~console_consumer() { E_CONSUMER_RELEASE(); }
 
 private:
-  void process_event(const event &e) {
+  std::shared_ptr<spdlog::async_logger> logger_;
-#if defined(_WIN32)
+
-#if defined(_DEBUG)
+private:
-    OutputDebugString((e.get_single_line() + "\n").c_str());
+  void process_event(const event &e) const;
-#endif
-#endif
-    if (e.get_event_level() == event_level::error) {
-      std::cerr << e.get_single_line() << std::endl;
-    } else {
-      std::cout << e.get_single_line() << std::endl;
-    }
-  }
 };
 } // namespace repertory
 

repertory/librepertory/include/events/consumers/logging_consumer.hpp

@@ -24,6 +24,10 @@
 
 #include "events/event_system.hpp"
 
+namespace spdlog {
+class async_logger;
+}
+
 namespace repertory {
 class logging_consumer {
   E_CONSUMER();
@@ -39,11 +43,10 @@ private:
                                                          5ULL};
 
 private:
-  event_level event_level_;
+  std::shared_ptr<spdlog::async_logger> logger_;
-  std::string log_directory_;
 
 private:
-  void process_event(const event &event);
+  void process_event(const event &event) const;
 };
 } // namespace repertory
 

repertory/librepertory/src/drives/fuse/fuse_drive.cpp

@@ -536,7 +536,8 @@ void *fuse_drive::init_impl(struct fuse_conn_info *conn) {
 #endif
 
   if (console_enabled_) {
-    console_consumer_ = std::make_unique<console_consumer>();
+    console_consumer_ =
+        std::make_unique<console_consumer>(config_.get_event_level());
   }
 
   logging_consumer_ = std::make_unique<logging_consumer>(

repertory/librepertory/src/drives/fuse/remotefuse/remote_fuse_drive.cpp

@@ -232,7 +232,8 @@ auto remote_fuse_drive::init_impl(struct fuse_conn_info *conn) -> void * {
   was_mounted_ = true;
 
   if (console_enabled_) {
-    console_consumer_ = std::make_shared<console_consumer>();
+    console_consumer_ =
+        std::make_shared<console_consumer>(config_.get_event_level());
   }
   logging_consumer_ = std::make_shared<logging_consumer>(
       config_.get_event_level(), config_.get_log_directory());

repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_winfsp_drive.cpp

@@ -248,7 +248,7 @@ auto remote_winfsp_drive::mount(const std::vector<std::string> &drive_args)
   logging_consumer l(config_.get_event_level(), config_.get_log_directory());
   std::unique_ptr<console_consumer> c;
   if (enable_console) {
-    c = std::make_unique<console_consumer>();
+    c = std::make_unique<console_consumer>(config_.get_event_level());
   }
   event_system::instance().start();
   const auto ret =

repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp

@@ -576,7 +576,7 @@ auto winfsp_drive::mount(const std::vector<std::string> &drive_args) -> int {
   logging_consumer log(config_.get_event_level(), config_.get_log_directory());
   std::unique_ptr<console_consumer> cons;
   if (enable_console) {
-    cons = std::make_unique<console_consumer>();
+    cons = std::make_unique<console_consumer>(config_.get_event_level());
   }
   event_system::instance().start();
   auto svc = winfsp_service(lock_, *this, parsed_drive_args, config_);

repertory/librepertory/src/events/consumers/console_consumer.cpp

@@ -0,0 +1,101 @@
+/*
+  Copyright <2018-2024> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "events/consumers/console_consumer.hpp"
+
+#include "events/events.hpp"
+#include "spdlog/async.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/spdlog.h"
+
+namespace repertory {
+console_consumer::console_consumer(event_level level) {
+  static const auto set_level = [](auto *logger, auto next_level) {
+    switch (next_level) {
+    case event_level::critical:
+      logger->set_level(spdlog::level::critical);
+      break;
+    case event_level::error:
+      logger->set_level(spdlog::level::err);
+      break;
+    case event_level::warn:
+      logger->set_level(spdlog::level::warn);
+      break;
+    case event_level::info:
+      logger->set_level(spdlog::level::info);
+      break;
+    case event_level::debug:
+      logger->set_level(spdlog::level::debug);
+      break;
+    case event_level::trace:
+      logger->set_level(spdlog::level::trace);
+      break;
+    default:
+      logger->set_level(spdlog::level::info);
+      break;
+    }
+  };
+
+  std::vector<spdlog::sink_ptr> sinks{
+      std::make_shared<spdlog::sinks::stdout_color_sink_mt>(),
+  };
+
+  logger_ = std::make_shared<spdlog::async_logger>(
+      "console_logger", sinks.begin(), sinks.end(), spdlog::thread_pool(),
+      spdlog::async_overflow_policy::block);
+
+  set_level(logger_, level);
+
+  E_SUBSCRIBE_ALL(process_event);
+  E_SUBSCRIBE_EXACT(
+      event_level_changed, [this](const event_level_changed &changed) {
+        set_level(logger_,
+                  event_level_from_string(
+                      changed.get_new_event_level().get<std::string>()));
+      });
+}
+
+console_consumer::~console_consumer() { E_CONSUMER_RELEASE(); }
+
+void console_consumer::process_event(const event &event) const {
+  switch (event.get_event_level()) {
+  case event_level::critical:
+    logger_->critical(event.get_single_line());
+    break;
+  case event_level::error:
+    logger_->error(event.get_single_line());
+    break;
+  case event_level::warn:
+    logger_->warn(event.get_single_line());
+    break;
+  case event_level::info:
+    logger_->info(event.get_single_line());
+    break;
+  case event_level::debug:
+    logger_->debug(event.get_single_line());
+    break;
+  case event_level::trace:
+  default:
+    logger_->trace(event.get_single_line());
+    break;
+  }
+}
+} // namespace repertory

repertory/librepertory/src/events/consumers/logging_consumer.cpp

@@ -22,87 +22,85 @@
 #include "events/consumers/logging_consumer.hpp"
 
 #include "events/events.hpp"
-#include "spdlog/spdlog.h"
 #include "spdlog/async.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/spdlog.h"
 #include "utils/path_utils.hpp"
 
 namespace repertory {
-logging_consumer::logging_consumer(event_level level, std::string log_directory)
+logging_consumer::logging_consumer(event_level level,
-    : event_level_(level),
+                                   std::string log_directory) {
-      log_directory_(utils::path::absolute(log_directory)) {
+  log_directory = utils::path::absolute(log_directory);
-  static const auto set_level = [](auto next_level) {
+
+  static const auto set_level = [](auto *logger, auto next_level) {
     switch (next_level) {
     case event_level::critical:
-      spdlog::set_level(spdlog::level::critical);
+      logger->set_level(spdlog::level::critical);
       break;
     case event_level::error:
-      spdlog::set_level(spdlog::level::err);
+      logger->set_level(spdlog::level::err);
       break;
     case event_level::warn:
-      spdlog::set_level(spdlog::level::warn);
+      logger->set_level(spdlog::level::warn);
       break;
     case event_level::info:
-      spdlog::set_level(spdlog::level::info);
+      logger->set_level(spdlog::level::info);
       break;
     case event_level::debug:
-      spdlog::set_level(spdlog::level::debug);
+      logger->set_level(spdlog::level::debug);
       break;
     case event_level::trace:
-      spdlog::set_level(spdlog::level::trace);
+      logger->set_level(spdlog::level::trace);
       break;
     default:
-      spdlog::set_level(spdlog::level::info);
+      logger->set_level(spdlog::level::info);
       break;
     }
   };
 
-  E_SUBSCRIBE_ALL(process_event);
-  E_SUBSCRIBE_EXACT(event_level_changed,
-                    [this](const event_level_changed &changed) {
-                      event_level_ = event_level_from_string(
-                          changed.get_new_event_level().get<std::string>());
-                      set_level(event_level_);
-                    });
-
-  spdlog::init_thread_pool(8192, 2);
   std::vector<spdlog::sink_ptr> sinks{
-      std::make_shared<spdlog::sinks::stdout_color_sink_mt>(),
       std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
-          utils::path::combine(log_directory_, {"repertory.log"}),
+          utils::path::combine(log_directory, {"repertory.log"}),
           MAX_LOG_FILE_SIZE, MAX_LOG_FILES),
   };
 
-  spdlog::register_logger(std::make_shared<spdlog::async_logger>(
+  logger_ = std::make_shared<spdlog::async_logger>(
-      "logger", sinks.begin(), sinks.end(), spdlog::thread_pool(),
+      "file_logger", sinks.begin(), sinks.end(), spdlog::thread_pool(),
-      spdlog::async_overflow_policy::block));
+      spdlog::async_overflow_policy::block);
 
-  set_level(event_level_);
+  set_level(logger_, level);
+
+  E_SUBSCRIBE_ALL(process_event);
+  E_SUBSCRIBE_EXACT(
+      event_level_changed, [this](const event_level_changed &changed) {
+        set_level(logger_,
+                  event_level_from_string(
+                      changed.get_new_event_level().get<std::string>()));
+      });
 }
 
 logging_consumer::~logging_consumer() { E_CONSUMER_RELEASE(); }
 
-void logging_consumer::process_event(const event &event) {
+void logging_consumer::process_event(const event &event) const {
   switch (event.get_event_level()) {
   case event_level::critical:
-    spdlog::critical(event.get_single_line());
+    logger_->critical(event.get_single_line());
     break;
   case event_level::error:
-    spdlog::error(event.get_single_line());
+    logger_->error(event.get_single_line());
     break;
   case event_level::warn:
-    spdlog::warn(event.get_single_line());
+    logger_->warn(event.get_single_line());
     break;
   case event_level::info:
-    spdlog::info(event.get_single_line());
+    logger_->info(event.get_single_line());
     break;
   case event_level::debug:
-    spdlog::debug(event.get_single_line());
+    logger_->debug(event.get_single_line());
     break;
   case event_level::trace:
   default:
-    spdlog::trace(event.get_single_line());
+    logger_->trace(event.get_single_line());
     break;
   }
 }

repertory/librepertory/src/initialize.cpp

@@ -41,10 +41,13 @@
 #include <sqlite3.h>
 #endif // defined(PROJECT_ENABLE_SQLITE)
 
+#include "spdlog/spdlog.h"
+
 #include "initialize.hpp"
 
 namespace repertory {
 auto project_initialize() -> bool {
+  spdlog::init_thread_pool(8192, 2);
 #if defined(PROJECT_REQUIRE_ALPINE) && !defined(PROJECT_IS_MINGW)
   {
     static constexpr const auto guard_size{4096U};

repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp

@@ -744,8 +744,6 @@ auto encrypt_provider::process_directory_entry(
 
       current_encrypted_path = utils::path::create_api_path(
           current_encrypted_path + '/' + encrypted_parts.at(current_idx++));
-      std::cout << current_source_path << ':' << current_encrypted_path
-                << std::endl;
     }
 
     return current_encrypted_path;