Add censor API to Log

It allows to set values to be masked from the log messages at runtime

Relates-To: NLAM-140
Signed-off-by: Rustam Gamidov <[email protected]>

Author: rustam-gamidov-here

olp-cpp-sdk-core/include/olp/core/logging/Log.h

@@ -562,6 +562,16 @@ class CORE_API Log {
                          const std::string& message, const char* file,
                          unsigned int line, const char* function,
                          const char* fullFunction);
+
+  /**
+   * @brief Adds a line to be censored out from the log.
+   *
+   * Censoring out is a replacement with a predefiend mask with length not
+   * correlated with the original line length.
+   *
+   * @param message The line to be censored out from the log.
+   */
+  static void censor(const std::string& message);
 };
 }  // namespace logging
 }  // namespace olp

olp-cpp-sdk-core/src/logging/Log.cpp

@@ -23,13 +23,24 @@
 
 #include <olp/core/logging/Configuration.h>
 #include <olp/core/logging/FilterGroup.h>
+#include <olp/core/porting/optional.h>
 #include <olp/core/thread/Atomic.h>
 
 #include <string>
 #include <unordered_map>
 
 namespace olp {
 namespace logging {
+
+namespace {
+
+constexpr auto kSecretMask = "*****";
+}
+
+struct LogMessageEx : public LogMessage {
+  olp::porting::optional<std::string> adjusted_message;
+};
+
 class LogImpl {
  public:
   friend class olp::thread::Atomic<logging::LogImpl>;
@@ -67,14 +78,20 @@ class LogImpl {
                   unsigned int line, const char* function,
                   const char* fullFunction);
 
+  void censor(std::string msg);
+
  private:
   LogImpl();
   template <class LogItem>
   void appendLogItem(const LogItem& log_item);
 
+  template <class LogItem>
+  void censorLogItem(LogItem& log_item, const std::string& original);
+
   Configuration m_configuration;
   std::unordered_map<std::string, Level> m_logLevels;
   Level m_defaultLevel;
+  std::vector<std::string> m_toCensor;
 };
 
 LogImpl::LogImpl()
@@ -159,7 +176,7 @@ void LogImpl::logMessage(Level level, const std::string& tag,
                          const std::string& message, const char* file,
                          unsigned int line, const char* function,
                          const char* fullFunction) {
-  LogMessage logMessage;
+  LogMessageEx logMessage;
   logMessage.level = level;
   logMessage.tag = tag.c_str();
   logMessage.message = message.c_str();
@@ -170,6 +187,7 @@ void LogImpl::logMessage(Level level, const std::string& tag,
   logMessage.time = std::chrono::system_clock::now();
   logMessage.threadId = getThreadId();
 
+  censorLogItem(logMessage, message);
   appendLogItem(logMessage);
 }
 
@@ -181,6 +199,31 @@ void LogImpl::appendLogItem(const LogItem& log_item) {
   }
 }
 
+template <class LogItem>
+void LogImpl::censorLogItem(LogItem& log_item, const std::string& original) {
+  bool has_copy = log_item.adjusted_message.has_value();
+  const std::string& src =
+      has_copy ? log_item.adjusted_message.value() : original;
+
+  for (const std::string& secret : m_toCensor) {
+    auto found_pos = src.find(secret);
+    while (found_pos != std::string::npos) {
+      if (!has_copy) {
+        log_item.adjusted_message = original;
+        has_copy = true;
+        log_item.message = log_item.adjusted_message.value().c_str();
+      }
+      log_item.adjusted_message.value().replace(found_pos, secret.length(),
+                                                kSecretMask);
+      found_pos = log_item.adjusted_message.value().find(secret, found_pos);
+    }
+  }
+}
+
+void LogImpl::censor(std::string msg) {
+  m_toCensor.emplace_back(std::move(msg));
+}
+
 // implementation of public static Log API
 //--------------------------------------------------------
 
@@ -286,5 +329,12 @@ void Log::logMessage(Level level, const std::string& tag,
   });
 }
 
+void Log::censor(const std::string& message) {
+  if (!LogImpl::aliveStatus())
+    return;
+
+  LogImpl::getInstance().locked([&](LogImpl& log) { log.censor(message); });
+}
+
 }  // namespace logging
 }  // namespace olp

olp-cpp-sdk-core/tests/logging/LogTest.cpp

@@ -409,6 +409,40 @@ TEST(LogTest, LogFormat) {
   ++index;
 }
 
+TEST(LogTest, LogCensor) {
+  auto appender = std::make_shared<testing::MockAppender>();
+  olp::logging::Configuration configuration;
+  configuration.addAppender(appender);
+  EXPECT_TRUE(olp::logging::Log::configure(configuration));
+  olp::logging::Log::setLevel(olp::logging::Level::Trace);
+
+  constexpr auto secret_01 = "1st secret";
+  constexpr auto secret_02 = "to hide";
+
+  olp::logging::Log::censor(secret_01);
+  olp::logging::Log::censor(secret_02);
+
+  OLP_SDK_LOG_INFO_F("", "Nothing to censor");
+  OLP_SDK_LOG_INFO_F("", "Inlined1st secretin message");
+  OLP_SDK_LOG_TRACE_F("trace", "%s %s", "plain", secret_01);
+  OLP_SDK_LOG_DEBUG_F("debug", "%s %s%s", "no spaces", secret_02, "**");
+  OLP_SDK_LOG_INFO_F("info", "%s %s %s", secret_02, "several", secret_01);
+  OLP_SDK_LOG_WARNING_F("warning", "%s %s %s", secret_02, "twice", secret_02);
+  OLP_SDK_LOG_ERROR_F("error", "%s %s", "Error", secret_01);
+  OLP_SDK_LOG_FATAL_F("fatal", "%s %s", "Fatal", secret_02);
+
+  ASSERT_EQ(8U, appender->messages_.size());
+
+  EXPECT_EQ("Nothing to censor", appender->messages_[0].message_);
+  EXPECT_EQ("Inlined*****in message", appender->messages_[1].message_);
+  EXPECT_EQ("plain *****", appender->messages_[2].message_);
+  EXPECT_EQ("no spaces *******", appender->messages_[3].message_);
+  EXPECT_EQ("***** several *****", appender->messages_[4].message_);
+  EXPECT_EQ("***** twice *****", appender->messages_[5].message_);
+  EXPECT_EQ("Error *****", appender->messages_[6].message_);
+  EXPECT_EQ("Fatal *****", appender->messages_[7].message_);
+}
+
 TEST(LogTest, LogLimits) {
   auto appender = std::make_shared<testing::MockAppender>();
   olp::logging::Configuration configuration;