From 3be8aad1afcba0496e709d050fcb3350421769da Mon Sep 17 00:00:00 2001 From: Wang XiangYu Date: Tue, 28 Apr 2020 20:21:21 +0800 Subject: [PATCH] Merge config file (#2168) * Using el::Configurations Class init easylog Signed-off-by: wxyu * add logs config constant Signed-off-by: wxyu * add config check function Signed-off-by: wxyu * add config get function Signed-off-by: wxyu * logs config set function Signed-off-by: wxyu * update Signed-off-by: wxyu * update InitLog function Signed-off-by: wxyu * fix clang-format Signed-off-by: wxyu * update server_config.template Signed-off-by: wxyu * update changelog Signed-off-by: wxyu --- CHANGELOG.md | 1 + core/conf/server_config.template | 10 ++ core/src/config/Config.cpp | 231 +++++++++++++++++++++++++++++ core/src/config/Config.h | 64 ++++++++ core/src/server/Server.cpp | 39 ++++- core/src/utils/LogUtil.cpp | 67 ++++++++- core/src/utils/LogUtil.h | 3 +- core/unittest/server/test_util.cpp | 2 +- 8 files changed, 411 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ec7c3bb..a3d0d20c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ Please mark all change in change log and use the issue from GitHub - \#221 Refactor LOG macro - \#2039 Support Milvus run on SSE CPUs - \#2149 Merge server_cpu_config.template and server_gpu_config.template +- \#2167 Merge config file ## Task diff --git a/core/conf/server_config.template b/core/conf/server_config.template index 3115fd2f..c9ea40dd 100644 --- a/core/conf/server_config.template +++ b/core/conf/server_config.template @@ -186,3 +186,13 @@ wal_config: recovery_error_ignore: true buffer_size: 256 wal_path: @MILVUS_DB_PATH@/wal + +logs: + trace.enable: true + debug.enable: true + info.enable: true + warning.enable: true + error.enable: true + fatal.enable: true + path: @MILVUS_DB_PATH@/logs + diff --git a/core/src/config/Config.cpp b/core/src/config/Config.cpp index e7596331..5108fbbc 100644 --- a/core/src/config/Config.cpp +++ b/core/src/config/Config.cpp @@ -153,6 +153,23 @@ const int64_t CONFIG_WAL_BUFFER_SIZE_MIN = 64; const char* CONFIG_WAL_WAL_PATH = "wal_path"; const char* CONFIG_WAL_WAL_PATH_DEFAULT = "/tmp/milvus/wal"; +/* logs config */ +const char* CONFIG_LOGS = "logs"; +const char* CONFIG_LOGS_TRACE_ENABLE = "trace.enable"; +const char* CONFIG_LOGS_TRACE_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_DEBUG_ENABLE = "debug.enable"; +const char* CONFIG_LOGS_DEBUG_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_INFO_ENABLE = "info.enable"; +const char* CONFIG_LOGS_INFO_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_WARNING_ENABLE = "warning.enable"; +const char* CONFIG_LOGS_WARNING_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_ERROR_ENABLE = "error.enable"; +const char* CONFIG_LOGS_ERROR_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_FATAL_ENABLE = "fatal.enable"; +const char* CONFIG_LOGS_FATAL_ENABLE_DEFAULT = "true"; +const char* CONFIG_LOGS_PATH = "path"; +const char* CONFIG_LOGS_PATH_DEFAULT = "/tmp/milvus/logs"; + constexpr int64_t GB = 1UL << 30; constexpr int32_t PORT_NUMBER_MIN = 1024; constexpr int32_t PORT_NUMBER_MAX = 65535; @@ -367,6 +384,28 @@ Config::ValidateConfig() { std::string wal_path; CONFIG_CHECK(GetWalConfigWalPath(wal_path)); + /* logs config */ + bool trace_enable; + CONFIG_CHECK(GetLogsTraceEnable(trace_enable)); + + bool debug_enable; + CONFIG_CHECK(GetLogsDebugEnable(trace_enable)); + + bool info_enable; + CONFIG_CHECK(GetLogsInfoEnable(trace_enable)); + + bool warning_enable; + CONFIG_CHECK(GetLogsWarningEnable(trace_enable)); + + bool error_enable; + CONFIG_CHECK(GetLogsErrorEnable(trace_enable)); + + bool fatal_enable; + CONFIG_CHECK(GetLogsFatalEnable(trace_enable)); + + std::string logs_path; + CONFIG_CHECK(GetLogsPath(logs_path)); + return Status::OK(); } @@ -418,6 +457,16 @@ Config::ResetDefaultConfig() { CONFIG_CHECK(SetWalConfigRecoveryErrorIgnore(CONFIG_WAL_RECOVERY_ERROR_IGNORE_DEFAULT)); CONFIG_CHECK(SetWalConfigBufferSize(CONFIG_WAL_BUFFER_SIZE_DEFAULT)); CONFIG_CHECK(SetWalConfigWalPath(CONFIG_WAL_WAL_PATH_DEFAULT)); + + /* logs config */ + CONFIG_CHECK(SetLogsTraceEnable(CONFIG_LOGS_TRACE_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsDebugEnable(CONFIG_LOGS_DEBUG_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsInfoEnable(CONFIG_LOGS_INFO_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsWarningEnable(CONFIG_LOGS_WARNING_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsErrorEnable(CONFIG_LOGS_ERROR_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsFatalEnable(CONFIG_LOGS_FATAL_ENABLE_DEFAULT)); + CONFIG_CHECK(SetLogsPath(CONFIG_LOGS_PATH_DEFAULT)); + #ifdef MILVUS_GPU_VERSION CONFIG_CHECK(SetEngineConfigGpuSearchThreshold(CONFIG_ENGINE_GPU_SEARCH_THRESHOLD_DEFAULT)); #endif @@ -1492,6 +1541,89 @@ Config::CheckWalConfigWalPath(const std::string& value) { return ValidationUtil::ValidateStoragePath(value); } +/* logs config */ +Status +Config::CheckLogsTraceEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_trace_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.trace.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsDebugEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_debug_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.debug.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsInfoEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_info_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.info.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsWarningEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_warning_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.warning.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsErrorEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_error_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.error.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsFatalEnable(const std::string& value) { + auto exist_error = !ValidationUtil::ValidateStringIsBool(value).ok(); + fiu_do_on("check_logs_fatal_enable_fail", exist_error = true); + + if (exist_error) { + std::string msg = "Invalid logs config: " + value + ". Possible reason: logs.fatal.enable is not a boolean."; + return Status(SERVER_INVALID_ARGUMENT, msg); + } + return Status::OK(); +} + +Status +Config::CheckLogsPath(const std::string& value) { + fiu_return_on("check_logs_path_fail", Status(SERVER_INVALID_ARGUMENT, "")); + if (value.empty()) { + return Status(SERVER_INVALID_ARGUMENT, "logs.path is empty!"); + } + + return ValidationUtil::ValidateStoragePath(value); +} + //////////////////////////////////////////////////////////////////////////////// ConfigNode& Config::GetConfigRoot() { @@ -1958,6 +2090,62 @@ Config::GetWalConfigWalPath(std::string& wal_path) { return Status::OK(); } +/* logs config */ +Status +Config::GetLogsTraceEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_TRACE_ENABLE, CONFIG_LOGS_TRACE_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsTraceEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsDebugEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_DEBUG_ENABLE, CONFIG_LOGS_DEBUG_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsDebugEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsInfoEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_INFO_ENABLE, CONFIG_LOGS_INFO_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsInfoEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsWarningEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_WARNING_ENABLE, CONFIG_LOGS_WARNING_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsWarningEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsErrorEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_ERROR_ENABLE, CONFIG_LOGS_ERROR_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsErrorEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsFatalEnable(bool& value) { + std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_FATAL_ENABLE, CONFIG_LOGS_FATAL_ENABLE_DEFAULT); + CONFIG_CHECK(CheckLogsFatalEnable(str)); + CONFIG_CHECK(StringHelpFunctions::ConvertToBoolean(str, value)); + return Status::OK(); +} + +Status +Config::GetLogsPath(std::string& value) { + value = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_PATH, CONFIG_LOGS_PATH_DEFAULT); + CONFIG_CHECK(CheckWalConfigWalPath(value)); + return Status::OK(); +} + Status Config::GetServerRestartRequired(bool& required) { required = restart_required_; @@ -2182,6 +2370,49 @@ Config::SetWalConfigWalPath(const std::string& value) { return SetConfigValueInMem(CONFIG_WAL, CONFIG_WAL_WAL_PATH, value); } +/* logs config */ +Status +Config::SetLogsTraceEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsTraceEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_TRACE_ENABLE, value); +} + +Status +Config::SetLogsDebugEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsDebugEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_DEBUG_ENABLE, value); +} + +Status +Config::SetLogsInfoEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsInfoEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_INFO_ENABLE, value); +} + +Status +Config::SetLogsWarningEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsWarningEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_WARNING_ENABLE, value); +} + +Status +Config::SetLogsErrorEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsErrorEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_ERROR_ENABLE, value); +} + +Status +Config::SetLogsFatalEnable(const std::string& value) { + CONFIG_CHECK(CheckLogsFatalEnable(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_FATAL_ENABLE, value); +} + +Status +Config::SetLogsPath(const std::string& value) { + CONFIG_CHECK(CheckLogsPath(value)); + return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_PATH, value); +} + #ifdef MILVUS_GPU_VERSION Status Config::SetEngineConfigGpuSearchThreshold(const std::string& value) { diff --git a/core/src/config/Config.h b/core/src/config/Config.h index 6dad2943..c74e75d9 100644 --- a/core/src/config/Config.h +++ b/core/src/config/Config.h @@ -149,6 +149,22 @@ extern const int64_t CONFIG_WAL_BUFFER_SIZE_MIN; extern const char* CONFIG_WAL_WAL_PATH; extern const char* CONFIG_WAL_WAL_PATH_DEFAULT; +/* logs config */ +extern const char* CONFIG_LOGS; +extern const char* CONFIG_LOGS_TRACE_ENABLE; +extern const char* CONFIG_LOGS_TRACE_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_DEBUG_ENABLE; +extern const char* CONFIG_LOGS_DEBUG_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_INFO_ENABLE; +extern const char* CONFIG_LOGS_INFO_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_WARNING_ENABLE; +extern const char* CONFIG_LOGS_WARNING_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_ERROR_ENABLE; +extern const char* CONFIG_LOGS_ERROR_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_FATAL_ENABLE; +extern const char* CONFIG_LOGS_FATAL_ENABLE_DEFAULT; +extern const char* CONFIG_LOGS_PATH; + class Config { private: Config(); @@ -301,6 +317,22 @@ class Config { Status CheckWalConfigWalPath(const std::string& value); + /* logs config */ + Status + CheckLogsTraceEnable(const std::string& value); + Status + CheckLogsDebugEnable(const std::string& value); + Status + CheckLogsInfoEnable(const std::string& value); + Status + CheckLogsWarningEnable(const std::string& value); + Status + CheckLogsErrorEnable(const std::string& value); + Status + CheckLogsFatalEnable(const std::string& value); + Status + CheckLogsPath(const std::string& value); + std::string GetConfigStr(const std::string& parent_key, const std::string& child_key, const std::string& default_value = ""); std::string @@ -414,6 +446,22 @@ class Config { Status GetWalConfigWalPath(std::string& value); + /* logs config */ + Status + GetLogsTraceEnable(bool& value); + Status + GetLogsDebugEnable(bool& value); + Status + GetLogsInfoEnable(bool& value); + Status + GetLogsWarningEnable(bool& value); + Status + GetLogsErrorEnable(bool& value); + Status + GetLogsFatalEnable(bool& value); + Status + GetLogsPath(std::string& value); + Status GetServerRestartRequired(bool& required); @@ -502,6 +550,22 @@ class Config { Status SetWalConfigWalPath(const std::string& value); + /* logs config */ + Status + SetLogsTraceEnable(const std::string& value); + Status + SetLogsDebugEnable(const std::string& value); + Status + SetLogsInfoEnable(const std::string& value); + Status + SetLogsWarningEnable(const std::string& value); + Status + SetLogsErrorEnable(const std::string& value); + Status + SetLogsFatalEnable(const std::string& value); + Status + SetLogsPath(const std::string& value); + #ifdef MILVUS_GPU_VERSION Status SetEngineConfigGpuSearchThreshold(const std::string& value); diff --git a/core/src/server/Server.cpp b/core/src/server/Server.cpp index 24d982c7..692459a9 100644 --- a/core/src/server/Server.cpp +++ b/core/src/server/Server.cpp @@ -190,7 +190,44 @@ Server::Start() { } tzset(); - InitLog(log_config_file_); + { + bool trace_enable = false; + bool debug_enable = false; + bool info_enable = false; + bool warning_enable = false; + bool error_enable = false; + bool fatal_enable = false; + std::string logs_path; + s = config.GetLogsTraceEnable(trace_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsDebugEnable(debug_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsInfoEnable(info_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsWarningEnable(warning_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsErrorEnable(error_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsFatalEnable(fatal_enable); + if (!s.ok()) { + return s; + } + s = config.GetLogsPath(logs_path); + if (!s.ok()) { + return s; + } + InitLog(trace_enable, debug_enable, info_enable, warning_enable, error_enable, fatal_enable, logs_path); + } std::string deploy_mode; s = config.GetServerConfigDeployMode(deploy_mode); diff --git a/core/src/utils/LogUtil.cpp b/core/src/utils/LogUtil.cpp index f8d5e236..865070d1 100644 --- a/core/src/utils/LogUtil.cpp +++ b/core/src/utils/LogUtil.cpp @@ -83,9 +83,70 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) { } Status -InitLog(const std::string& log_config_file) { - el::Configurations conf(log_config_file); - el::Loggers::reconfigureAllLoggers(conf); +InitLog(bool trace_enable, bool debug_enable, bool info_enable, bool warning_enable, bool error_enable, + bool fatal_enable, const std::string& logs_path) { + el::Configurations defaultConf; + defaultConf.setToDefault(); + defaultConf.setGlobally(el::ConfigurationType::Format, "[%datetime][%level]%msg"); + defaultConf.setGlobally(el::ConfigurationType::ToFile, "true"); + defaultConf.setGlobally(el::ConfigurationType::ToStandardOutput, "false"); + defaultConf.setGlobally(el::ConfigurationType::SubsecondPrecision, "3"); + defaultConf.setGlobally(el::ConfigurationType::PerformanceTracking, "false"); + defaultConf.setGlobally(el::ConfigurationType::MaxLogFileSize, "209715200"); + + std::string global_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-global.log"; + defaultConf.set(el::Level::Global, el::ConfigurationType::Filename, global_log_path.c_str()); + defaultConf.set(el::Level::Global, el::ConfigurationType::Enabled, "true"); + + std::string info_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-info.log"; + defaultConf.set(el::Level::Info, el::ConfigurationType::Filename, info_log_path.c_str()); + if (info_enable) { + defaultConf.set(el::Level::Info, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Info, el::ConfigurationType::Enabled, "false"); + } + + std::string debug_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-debug.log"; + defaultConf.set(el::Level::Debug, el::ConfigurationType::Filename, debug_log_path.c_str()); + if (debug_enable) { + defaultConf.set(el::Level::Debug, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Debug, el::ConfigurationType::Enabled, "false"); + } + + std::string warning_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-warning.log"; + defaultConf.set(el::Level::Warning, el::ConfigurationType::Filename, warning_log_path.c_str()); + if (warning_enable) { + defaultConf.set(el::Level::Warning, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Warning, el::ConfigurationType::Enabled, "false"); + } + + std::string trace_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-trace.log"; + defaultConf.set(el::Level::Trace, el::ConfigurationType::Filename, trace_log_path.c_str()); + if (trace_enable) { + defaultConf.set(el::Level::Trace, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Trace, el::ConfigurationType::Enabled, "false"); + } + + std::string error_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-error.log"; + defaultConf.set(el::Level::Error, el::ConfigurationType::Filename, error_log_path.c_str()); + if (error_enable) { + defaultConf.set(el::Level::Error, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Error, el::ConfigurationType::Enabled, "false"); + } + + std::string fatal_log_path = logs_path + "milvus-%datetime{%y-%M-%d-%H:%m}-fatal.log"; + defaultConf.set(el::Level::Fatal, el::ConfigurationType::Filename, fatal_log_path.c_str()); + if (fatal_enable) { + defaultConf.set(el::Level::Fatal, el::ConfigurationType::Enabled, "true"); + } else { + defaultConf.set(el::Level::Fatal, el::ConfigurationType::Enabled, "false"); + } + + el::Loggers::reconfigureLogger("default", defaultConf); el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck); el::Helpers::installPreRollOutCallback(RolloutHandler); diff --git a/core/src/utils/LogUtil.h b/core/src/utils/LogUtil.h index 2d8b38dd..b8c78b9c 100644 --- a/core/src/utils/LogUtil.h +++ b/core/src/utils/LogUtil.h @@ -21,7 +21,8 @@ namespace milvus { namespace server { Status -InitLog(const std::string& log_config_file); +InitLog(bool trace_enable, bool debug_enable, bool info_enable, bool warning_enable, bool error_enable, + bool fatal_enable, const std::string& logs_path); void RolloutHandler(const char* filename, std::size_t size, el::Level level); diff --git a/core/unittest/server/test_util.cpp b/core/unittest/server/test_util.cpp index 2602056e..c8d4d3e0 100644 --- a/core/unittest/server/test_util.cpp +++ b/core/unittest/server/test_util.cpp @@ -246,7 +246,7 @@ TEST(UtilTest, BLOCKINGQUEUE_TEST) { } TEST(UtilTest, LOG_TEST) { - auto status = milvus::server::InitLog(LOG_FILE_PATH); + auto status = milvus::server::InitLog(true, true, true, true, true, true, "/tmp/test_util"); ASSERT_TRUE(status.ok()); EXPECT_FALSE(el::Loggers::hasFlag(el::LoggingFlag::NewLineForContainer)); -- GitLab