feat logging: SetLocalLogLevel changes level in both directions

@ref tracing::Span::SetLocalLogLevel now overrides the global log level in both directions: can raise the threshold (suppress logs) or lower it (enable debug logs even if the global level is higher).

This PR leads to slowdown of a skipped `LOG_TRACE` from ~3 ns to ~10 ns, which we deemed acceptable. This place may be optimized in the future, especially if LTO will be re-enabled.
commit_hash:b4c0ab9b08409ef0cfeb10dce53ec913fb82df68

Author: koshkovka

core/include/userver/logging/logger.hpp

@@ -46,8 +46,6 @@ LoggerPtr MakeFileLogger(const std::string& name, const std::string& path, Forma
 
 namespace impl {
 
-bool DoShouldLog(Level) noexcept;
-
 void PrependCommonTags(TagWriter writer, Level logger_level);
 
 }  // namespace impl

core/include/userver/tracing/span.hpp

@@ -196,27 +196,18 @@ class Span final {
     /// See @ref tracing::Span::SetLogLevel.
     logging::Level GetLogLevel() const;
 
-    /// @brief Sets an additional cutoff for the logs written in the scope of this `Span`,
-    /// and in nested scopes recursively.
+    /// @brief Sets the log level for the scope of this `Span` and nested scopes recursively.
+    ///
+    /// Overrides the global log level in both directions: can raise the threshold
+    /// (suppress logs) or lower it (enable debug logs even if the global level is higher).
     ///
     /// For example, if the global log level is `info`, and the current `Span` has
-    /// (own or inherited) local log level `warning`, then all `LOG_INFO`s within the current
-    /// scope will be thrown away.
+    /// local log level `debug`, then all `LOG_DEBUG`s within the current scope will be written.
     ///
     /// The cutoff also applies to the span itself. If the @ref tracing::Span::SetLogLevel "span's log level"
     /// is less than the local log level, then the span is not written to the tracing system.
     ///
     /// Local log level of child spans can override local log level of parent spans in both directions.
-    /// For example:
-    /// * if local log level of a parent `Span` is `warning`,
-    /// * and local log level of a child span is set `info`,
-    /// * then `info` logs within that `Span` will be written,
-    /// * as long as the global log level is not higher than `info`.
-    ///
-    /// Currently, local log level cannot override the global log level of the logger.
-    /// For example, if the global log level is `info`, and the current `Span` has
-    /// (own or inherited) local log level `debug`, then all `LOG_DEBUG`s within the current
-    /// scope will **still** be thrown away.
     void SetLocalLogLevel(std::optional<logging::Level> log_level);
 
     /// See @ref tracing::Span::SetLocalLogLevel.

core/src/logging/logger.cpp

@@ -67,16 +67,16 @@ LoggerPtr MakeFileLogger(const std::string& name, const std::string& path, Forma
 
 namespace impl {
 
-bool DoShouldLog(Level level) noexcept {
+bool ShouldLogWithSpanCheck(const LoggerBase& logger, Level level) noexcept {
     const auto* const span = tracing::Span::CurrentSpanUnchecked();
     if (span) {
         const auto local_log_level = span->GetLocalLogLevel();
-        if (local_log_level && *local_log_level > level) {
-            return false;
+        if (local_log_level.has_value()) {
+            return local_log_level.value() <= level;
         }
     }
 
-    return true;
+    return ShouldLogNoSpan(logger, level);
 }
 
 void PrependCommonTags(TagWriter writer, Level logger_level) {

core/src/logging/tp_logger.cpp

@@ -6,8 +6,8 @@
 #include <userver/engine/async.hpp>
 #include <userver/engine/task/cancel.hpp>
 #include <userver/logging/impl/tag_writer.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/logging/logger.hpp>
-#include <userver/tracing/span.hpp>
 #include <userver/utils/enumerate.hpp>
 #include <userver/utils/fast_scope_guard.hpp>
 
@@ -159,8 +159,6 @@ void TpLogger::Log(Level level, impl::formatters::LoggerItemRef item) {
 
 void TpLogger::PrependCommonTags(TagWriter writer) const { impl::PrependCommonTags(writer, GetLevel()); }
 
-bool TpLogger::DoShouldLog(Level level) const noexcept { return impl::DoShouldLog(level); }
-
 void TpLogger::AddSink(impl::SinkPtr&& sink) {
     UASSERT(sink);
     sinks_.push_back(std::move(sink));

core/src/logging/tp_logger.hpp

@@ -87,9 +87,6 @@ class TpLogger final : public TextLogger {
 
     impl::LogStatistics& GetStatistics() noexcept;
 
-protected:
-    bool DoShouldLog(Level level) const noexcept override;
-
 private:
     struct ActionVisitor;
 

core/src/tracing/span.cpp

@@ -223,9 +223,20 @@ std::string_view Span::Impl::GetParentIdForLogging(const Span::Impl* parent) {
 bool Span::Impl::ShouldLog() const {
     /* We must honour default log level, but use span's level from ourselves,
      * not the previous spans.
+     * If local_log_level is set, it overrides the global level in both
+     * directions (can enable logging below global level).
      */
-    return logging::impl::ShouldLogNoSpan(logging::GetDefaultLogger(), log_level_) &&
-           local_log_level_.value_or(logging::Level::kTrace) <= log_level_;
+    if (log_level_ == logging::Level::kNone) {
+        return false;
+    }
+    const auto effective_local = local_log_level_.value_or(logging::Level::kTrace);
+    if (effective_local > log_level_) {
+        return false;
+    }
+    if (local_log_level_.has_value()) {
+        return true;
+    }
+    return logging::impl::ShouldLogNoSpan(logging::GetDefaultLogger(), log_level_);
 }
 
 std::optional<std::string_view> Span::Impl::GetSpanIdForChildLogs() const {

core/src/tracing/span_test.cpp

@@ -263,13 +263,12 @@ UTEST_F(Span, LowerLocalLogLevel) {
 
 UTEST_F(Span, LocalLogLevelLowerThanGlobal) {
     tracing::Span span("parent_span");
-    // This currently cannot overcome global log level, which is "info" for this test.
     span.SetLocalLogLevel(logging::Level::kDebug);
 
-    LOG_DEBUG() << "message";
+    LOG_DEBUG() << "debug_message";
     logging::LogFlush();
 
-    EXPECT_THAT(GetStreamString(), Not(HasSubstr("message")));
+    EXPECT_THAT(GetStreamString(), HasSubstr("debug_message"));
 }
 
 UTEST_F(Span, SpanLogLevelLowerThanGlobal) {

grpc/src/ugrpc/server/middlewares/log/component.cpp

@@ -23,7 +23,7 @@ Settings Parse(const yaml_config::YamlConfig& config, formats::parse::To<Setting
     settings.log_level = config["log-level"].As<logging::Level>(settings.log_level);
     settings.msg_log_level = config["msg-log-level"].As<logging::Level>(settings.msg_log_level);
     settings.max_msg_size = config["msg-size-log-limit"].As<std::size_t>(settings.max_msg_size);
-    settings.local_log_level = config["local-log-level"].As<logging::Level>(settings.local_log_level);
+    settings.local_log_level = config["local-log-level"].As<std::optional<logging::Level>>({});
     settings.status_codes_log_level =
         config["status-codes-log-level"].As<boost::container::flat_map<grpc::StatusCode, logging::Level>>({});
     return settings;

grpc/src/ugrpc/server/middlewares/log/component.yaml

@@ -17,7 +17,7 @@ properties:
     local-log-level:
         type: string
         description: local log level of the span for user-provided handler
-        default: debug
+        defaultDescription: not set
     status-codes-log-level:
         type: object
         properties: {}

grpc/src/ugrpc/server/middlewares/log/middleware.hpp

@@ -37,7 +37,7 @@ struct Settings final {
     /// Local log level of the server span
     /// It applies to logs in user-provided handler
     /// @ref tracing::Span::SetLocalLogLevel
-    logging::Level local_log_level{logging::Level::kDebug};
+    std::optional<logging::Level> local_log_level;
 
     /// map of "status_code": log_level items to override span log level for specific status codes
     /// see @ref ugrpc::kStatusCodesMap for available statuses