feat(logger): add spdlog log library

cpp/CMakeLists.txt

@@ -11,12 +11,14 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 find_package(Boost REQUIRED)
 find_package(Arrow REQUIRED)
 find_package(protobuf REQUIRED)
+find_package(spdlog REQUIRED)
 
 file(GLOB_RECURSE SRC_FILES src/*.cpp src/*.cc)
 message(STATUS "SRC_FILES: ${SRC_FILES}")
 add_library(storage ${SRC_FILES})
 target_include_directories(storage PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)
 target_link_libraries(storage PUBLIC arrow::libarrow arrow::libparquet Boost::boost protobuf::protobuf)
+target_link_libraries(storage PUBLIC spdlog::spdlog)
 
 if (WITH_UT)
   enable_testing()

cpp/conanfile.py

@@ -76,6 +76,7 @@ def requirements(self):
         self.requires("boost/1.81.0")
         self.requires("arrow/12.0.0")
         self.requires("protobuf/3.21.9")
+        self.requires("spdlog/1.10.0")
         if self.options.with_ut:
             self.requires("gtest/1.13.0")
 

cpp/src/common/logger.cpp

@@ -0,0 +1,65 @@
+#include "logger.h"
+
+namespace milvus_storage {
+/**
+ * Set the global level of the logger.
+ */
+spdlog::level::level_enum Logger::global_level = spdlog::level::debug;
+
+/**
+ * Get the global level of the logger.
+ */
+spdlog::level::level_enum Logger::get_global_Level() { return global_level; }
+
+/**
+ * Create sinks for the logger.
+ */
+std::vector<spdlog::sink_ptr> Logger::create_sinks(const std::string& log_file_name) {
+  std::vector<spdlog::sink_ptr> sinks;
+
+  auto sink1 = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+  sink1->set_level(Logger::get_global_Level());
+  sinks.push_back(sink1);
+
+  auto sink2 = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(log_file_name, 1024 * 1024 * 10, 100, false);
+  sink2->set_level(spdlog::level::debug);
+  sinks.push_back(sink2);
+  return sinks;
+}
+
+/**
+ * Create a logger.
+ */
+void Logger::create_logger(const std::string& logger_name) {
+  std::string log_file_name = logger_name + "_log.txt";
+  auto sinks = Logger::create_sinks(log_file_name);
+
+  auto logger = std::make_shared<spdlog::logger>(logger_name, begin(sinks), end(sinks));
+  logger->set_level(spdlog::level::debug);
+  spdlog::register_logger(logger);
+}
+/**
+ * Get a logger.
+ */
+std::shared_ptr<spdlog::logger> Logger::get_logger(const std::string& logger_name) {
+  auto logger = spdlog::get(logger_name);
+
+  if (!logger) {
+    create_logger(logger_name);
+    logger = spdlog::get(logger_name);
+  }
+  return logger;
+}
+
+/**
+ * Initialize the logger.
+ */
+void Logger::init() {
+  auto level = spdlog::level::debug;
+  Logger::global_level = level;
+  spdlog::flush_every(std::chrono::seconds(1));
+  spdlog::flush_on(spdlog::level::debug);
+  spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] [thread %t] %v");
+  Logger::create_logger("service");
+}
+}  // namespace milvus_storage

cpp/src/common/logger.h

@@ -0,0 +1,28 @@
+#ifndef MILVUS_STORAGE_LOGGER_H
+#define MILVUS_STORAGE_LOGGER_H
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
+
+#include <stdlib.h>
+#include "spdlog/spdlog.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/sinks/stdout_sinks.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/sinks/daily_file_sink.h"
+#include <vector>
+namespace milvus_storage {
+class Logger {
+  public:
+  static void init();
+  static spdlog::level::level_enum get_global_Level();
+  static std::vector<spdlog::sink_ptr> create_sinks(const std::string& log_file_name);
+  static void create_logger(const std::string& logger_name);
+  static std::shared_ptr<spdlog::logger> get_logger(const std::string& logger_name);
+
+  private:
+  static spdlog::level::level_enum global_level;
+};
+
+}  // namespace milvus_storage
+
+#endif  // MILVUS_STORAGE_LOGGER_H

cpp/test/CMakeLists.txt

@@ -5,7 +5,9 @@ add_executable(
   options_test.cpp
   schema_test.cpp
   manifest_test.cpp
-  space_test.cpp)
+  space_test.cpp
+  logger_test.cpp
+)
 
 target_link_libraries(
   milvus_test storage GTest::gtest_main

cpp/test/logger_test.cpp

@@ -0,0 +1,47 @@
+#include "gtest/gtest.h"
+#include "common/logger.h"
+
+namespace milvus_storage {
+TEST(LoggerTest, LoggerInitTest) {
+  /**
+   * Spdlog console logger.
+   */
+  auto console = spdlog::stdout_color_mt("console");
+  spdlog::get("console")->set_level(spdlog::level::debug);
+  spdlog::get("console")->set_pattern("[%Y-%m-%d %H:%M:%S.%e][%n][%^%l%$][%#@%s::%!] %v");
+  SPDLOG_LOGGER_TRACE(console, "Some TRACE message here..");
+  SPDLOG_LOGGER_DEBUG(console, "Some DEBUG message here..");
+  SPDLOG_LOGGER_INFO(console, "Some INFO message here..");
+  SPDLOG_LOGGER_WARN(console, "Some WARN message here..");
+  SPDLOG_LOGGER_ERROR(console, "Some ERROR message here..");
+  SPDLOG_LOGGER_CRITICAL(console, "Some CRITICAL message here..");
+
+  /**
+   * Spdlog logger.
+   */
+  spdlog::set_level(spdlog::level::debug);
+  SPDLOG_WARN("Some warn message");
+  SPDLOG_INFO("Some info message");
+  SPDLOG_DEBUG("Some debug message");
+
+  /**
+   * Milvus logger.
+   */
+  Logger::init();
+  auto logger = Logger::get_logger("Milvus Storage");
+  logger->debug("Logger initialized.");
+  logger->info("Logger initialized.");
+  logger->warn("Logger initialized.");
+  logger->error("Logger initialized.");
+  logger->critical("Logger initialized.");
+  logger->trace("Logger initialized.");
+
+  SPDLOG_LOGGER_DEBUG(logger, "Some DEBUG message here..");
+  SPDLOG_LOGGER_INFO(logger, "Some INFO message here..");
+  SPDLOG_LOGGER_WARN(logger, "Some WARN message here..");
+  SPDLOG_LOGGER_ERROR(logger, "Some ERROR message here..");
+  SPDLOG_LOGGER_CRITICAL(logger, "Some CRITICAL message here..");
+  SPDLOG_LOGGER_TRACE(logger, "Some TRACE message here..");
+}
+
+}  // namespace milvus_storage