Feature: Optimize local framework logging output (#62)

Author: peggiezhu

.github/.codecov.yml

@@ -7,4 +7,7 @@ coverage:
   status:
     project:
       default:
+        informational: true
         threshold: 1%
+      patch:
+        false

docs/README.md

@@ -56,6 +56,7 @@ English | [中文](README.zh_CN.md)
       * [custom metrics plugin](./en/custom_metrics.md)
       * [prometheus](./en/prometheus_metrics.md)
     * Logging
+      * [local logging tools](./en/local_logging.md)
       * [custom logging plugin](./en/custom_logging.md)
       * [cls](https://github.com/trpc-ecosystem/cpp-logging-cls/blob/main/README.md)
     * Tracing

docs/README.zh_CN.md

@@ -55,6 +55,7 @@
       * [开发自定义metrics插件](./zh/custom_metrics.md)
       * [prometheus](./zh/prometheus_metrics.md)
     * Logging插件
+      * [本地日志工具](./zh/local_logging.md)
       * [开发自定义logging插件](./zh/custom_logging.md)
       * [cls](https://github.com/trpc-ecosystem/cpp-logging-cls/blob/main/README.zh_CN.md)
     * Tracing插件

docs/en/local_logging.md

@@ -25,7 +25,7 @@ You can use it:
 
     Conventional framework performance test data is only performance data in relatively simple scenarios, and does not represent good performance in real and different business scenarios. Considering that Tencent has many different business scenarios, the requirements for framework performance are also different, for example:
 
-  - business accesses gateway scenarios: the feature is that the business logic is light, hign qps, large number of connections (long/short connections), heavy network io operations, and asynchronous programming is often used for programming;
+  - business accesses gateway scenarios: the feature is that the business logic is light, high qps, large number of connections (long/short connections), heavy network io operations, and asynchronous programming is often used for programming;
   - recommendation/search scenarios: the feature is that the business logic is heavy, the qps is not large, each request needs to be calculated in parallel, pay attention to the long tail delay, and the programming often use synchronous programming;
   - game business scenarios: the feature is that logic very complex and  has stateful, large qps, single-threaded programming, and use synchronous programming;
   - storage scenarios:  the feature is that the business logic is light, large qps, low latency requirement, heavy network io and disk io operations, and asynchronous programming is often used for programming;

docs/en/overview.md

@@ -136,3 +136,13 @@ cc_test(
         "@com_google_googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "config_test",
+    srcs = ["config_test.cc"],
+    deps = [
+        "//trpc/config/testing:mock_config",
+        "@com_google_googletest//:gtest",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

docs/images/log_design.png

@@ -22,7 +22,7 @@
 namespace trpc {
 
 /// @brief The tRPC Config plugin abstract interface definition class, targeting plugin developers.
-/// @note This class is reserved for 1.0 compatibility, and new data sources (rainbow, etcd, local cache)
+/// @note This class is reserved for 1.0 compatibility, and new data sources
 ///       should inherit provider_base.h directly.
 class Config : public Plugin {
  public:
@@ -31,15 +31,15 @@ class Config : public Plugin {
   ~Config() override = default;
 
   /// @brief Pulls file configuration.
-  /// @param config_name - For tconf, pass in the configuration file name; for rainbow, pass in the group_name.
+  /// @param config_name - The Group name.
   /// @param config - The content of the obtained configuration.
-  /// @param params - For tconf, this parameter is not required; for rainbow, pass in the file name.
+  /// @param params - File name.
   /// @return - true: Loading successful.
   ///           false: Loading failed.
   virtual bool PullFileConfig(const std::string& config_name, std::string* config, const std::any& params) = 0;
 
   /// @brief Pulls a single key-value configuration.
-  /// @param config_name - The filename of the KV configuration to be loaded, for rainbow pass in the group.
+  /// @param config_name - The filename of the KV configuration to be loaded, means group.
   /// @param key - Input key.
   /// @param config - Obtains the value corresponding to the key.
   /// @return - true: Loading successful.
@@ -48,7 +48,7 @@ class Config : public Plugin {
                             const std::any& params) = 0;
 
   /// @brief Pulls multiple key-value configurations.
-  /// @param config_name - The filename of the KV configuration to be loaded, for rainbow pass in the group.
+  /// @param config_name - The filename of the KV configuration to be loaded, means group.
   /// @param config - Obtains key-value pairs.
   /// @return - true: Loading successful.
   ///           false: Loading failed.

docs/zh/local_logging.md

@@ -0,0 +1,106 @@
+//
+//
+// Tencent is pleased to support the open source community by making tRPC available.
+//
+// Copyright (C) 2023 THL A29 Limited, a Tencent company.
+// All rights reserved.
+//
+// If you have downloaded a copy of the tRPC source code from Tencent,
+// please note that tRPC source code is licensed under the  Apache 2.0 License,
+// A copy of the Apache 2.0 License is included in this file.
+//
+//
+
+#include <any>
+#include <map>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "trpc/config/testing/mock_config.h"
+
+namespace trpc::testing {
+
+class AnyEqMatcher : public ::testing::MatcherInterface<const std::any&> {
+ public:
+  explicit AnyEqMatcher(const std::any& expected) : expected_(expected) {}
+
+  bool MatchAndExplain(const std::any& actual, ::testing::MatchResultListener* listener) const override {
+    if (!actual.has_value() && !expected_.has_value()) {
+      return true;
+    }
+
+    if (actual.type() != expected_.type()) {
+      return false;
+    }
+
+    if (actual.type() == typeid(int)) {
+      return std::any_cast<int>(actual) == std::any_cast<int>(expected_);
+    } else if (actual.type() == typeid(std::string)) {
+      return std::any_cast<std::string>(actual) == std::any_cast<std::string>(expected_);
+    }
+
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "is equal to the expected value";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "is not equal to the expected value";
+  }
+
+ private:
+  const std::any expected_;
+};
+
+inline ::testing::Matcher<const std::any&> AnyEq(const std::any& expected) {
+  return ::testing::MakeMatcher(new AnyEqMatcher(expected));
+}
+
+class TestConfig : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    mock_config_ = MakeRefCounted<MockConfig>();
+    ASSERT_TRUE(mock_config_ != nullptr);
+  }
+
+  RefPtr<MockConfig> mock_config_;
+};
+
+TEST_F(TestConfig, PullFileConfig) {
+  std::string config_name = "test_config";
+  std::string config;
+  std::any params;
+  EXPECT_CALL(*mock_config_, PullFileConfig(config_name, &config, AnyEq(params)))
+      .WillOnce(::testing::Return(true));
+  bool result = mock_config_->PullFileConfig(config_name, &config, params);
+
+  ASSERT_TRUE(result);
+}
+
+TEST_F(TestConfig, PullKVConfig) {
+  std::string config_name = "test_config";
+  std::string key = "test_key";
+  std::string config;
+  std::any params;
+  EXPECT_CALL(*mock_config_, PullKVConfig(config_name, key, &config, AnyEq(params)))
+      .WillOnce(::testing::Return(true));
+  bool result = mock_config_->PullKVConfig(config_name, key, &config, params);
+
+  ASSERT_TRUE(result);
+}
+
+TEST_F(TestConfig, PullMultiKVConfig) {
+  std::string config_name = "test_config";
+  std::map<std::string, std::string> config;
+  std::any params;
+  EXPECT_CALL(*mock_config_, PullMultiKVConfig(config_name, &config, AnyEq(params)))
+      .WillOnce(::testing::Return(true));
+  bool result = mock_config_->PullMultiKVConfig(config_name, &config, params);
+
+  ASSERT_TRUE(result);
+}
+
+}  // namespace trpc::testing