refactor tracing: remove Tracer from Span API, separate link & parent_link

* remove most methods from `Tracer` as a part of efforts to deprecate and remove this API
* remove `Tracer` from `Span` API
* store `link` and `parent_link` separately
* always fill in `link` at `Span::Impl` construction
commit_hash:c2bd09579ba0e41d56f41651eca86908feb6f374

Author: Anton3

core/include/userver/rcu/fwd.hpp

@@ -10,6 +10,7 @@ namespace rcu {
 struct DefaultRcuTraits;
 struct SyncRcuTraits;
 struct BlockingRcuTraits;
+struct ExclusiveRcuTraits;
 
 template <typename Key>
 struct DefaultRcuMapTraits;

core/include/userver/tracing/in_place_span.hpp

@@ -18,16 +18,24 @@ namespace tracing {
 /// cause stack overflow.
 class InPlaceSpan final {
 public:
+    struct DetachedTag {};
+
     explicit InPlaceSpan(
         std::string&& name,
-        utils::impl::SourceLocation source_location = utils::impl::SourceLocation::Current()
+        const utils::impl::SourceLocation& source_location = utils::impl::SourceLocation::Current()
     );
 
     explicit InPlaceSpan(
         std::string&& name,
         std::string&& trace_id,
         std::string&& parent_span_id,
-        utils::impl::SourceLocation source_location = utils::impl::SourceLocation::Current()
+        const utils::impl::SourceLocation& source_location = utils::impl::SourceLocation::Current()
+    );
+
+    explicit InPlaceSpan(
+        std::string&& name,
+        DetachedTag,
+        const utils::impl::SourceLocation& source_location = utils::impl::SourceLocation::Current()
     );
 
     InPlaceSpan(InPlaceSpan&&) = delete;
@@ -43,7 +51,7 @@ class InPlaceSpan final {
 
 private:
     struct Impl;
-    utils::FastPimpl<Impl, 4240, 8> impl_;
+    utils::FastPimpl<Impl, 4288, 8> impl_;
 };
 
 }  // namespace tracing

core/include/userver/tracing/span.hpp

@@ -34,15 +34,6 @@ class Span final {
 public:
     class Impl;
 
-    explicit Span(
-        TracerPtr tracer,
-        std::string name,
-        const Span* parent,
-        ReferenceType reference_type,
-        logging::Level log_level = logging::Level::kInfo,
-        utils::impl::SourceLocation source_location = utils::impl::SourceLocation::Current()
-    );
-
     /// Use default tracer and implicit coro local storage for parent
     /// identification, takes TraceID from the parent.
     ///
@@ -52,21 +43,22 @@ class Span final {
         std::string name,
         ReferenceType reference_type = ReferenceType::kChild,
         logging::Level log_level = logging::Level::kInfo,
-        utils::impl::SourceLocation source_location = utils::impl::SourceLocation::Current()
+        const utils::impl::SourceLocation& source_location = utils::impl::SourceLocation::Current()
     );
 
-    /// @cond
-    // For internal use only
-    explicit Span(Span::Impl& impl);
-    /// @endcond
+    explicit Span(
+        std::string name,
+        const Span* parent,
+        ReferenceType reference_type = ReferenceType::kChild,
+        logging::Level log_level = logging::Level::kInfo,
+        const utils::impl::SourceLocation& source_location = utils::impl::SourceLocation::Current()
+    );
 
     Span(Span&& other) noexcept;
-
-    ~Span();
-
-    Span& operator=(const Span&) = delete;
-
+    Span(const Span& other) = delete;
     Span& operator=(Span&&) = delete;
+    Span& operator=(const Span&) = delete;
+    ~Span();
 
     /// @brief Returns the Span of the current task.
     ///
@@ -214,11 +206,9 @@ class Span final {
     ///
     /// Propagates within a single service, but not from client to server. A new
     /// link is generated for the "root" request handling task
+    // TODO restrict SetLink to SpanBuilder.
     void SetLink(std::string link);
 
-    /// Set parent_link - an ID . Can be called only once.
-    void SetParentLink(std::string parent_link);
-
     /// Get link - a request ID within the service.
     ///
     /// Propagates within a single service, but not from client to server. A new
@@ -287,6 +277,7 @@ class Span final {
 
     friend class SpanBuilder;
     friend class TagScope;
+    friend class InPlaceSpan;
 
     explicit Span(std::unique_ptr<Impl, OptionalDeleter>&& pimpl);
 

core/include/userver/tracing/span_builder.hpp

@@ -3,6 +3,7 @@
 /// @file userver/tracing/span_builder.hpp
 /// @brief @copybrief tracing::SpanBuilder
 
+#include <cstddef>
 #include <string>
 
 #include <userver/tracing/span.hpp>
@@ -23,11 +24,14 @@ class SpanBuilder final {
     void SetTraceId(std::string trace_id);
     std::string_view GetTraceId() const noexcept;
     void SetSpanId(std::string span_id);
+    void SetLink(std::string link);
     void SetParentSpanId(std::string parent_span_id);
     void SetParentLink(std::string parent_link);
     void AddTagFrozen(std::string key, logging::LogExtra::Value value);
     void AddNonInheritableTag(std::string key, logging::LogExtra::Value value);
+
     Span Build() &&;
+    Span BuildDetachedFromCoroStack() &&;
 
 private:
     std::unique_ptr<Span::Impl, Span::OptionalDeleter> pimpl_;

core/include/userver/tracing/tracer.hpp

@@ -2,53 +2,59 @@
 
 #include <memory>
 
+#include <userver/rcu/fwd.hpp>
 #include <userver/tracing/span.hpp>
 #include <userver/tracing/tracer_fwd.hpp>
 
 #include <dynamic_config/variables/USERVER_NO_LOG_SPANS.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
-namespace logging::impl {
-class TagWriter;
-}  // namespace logging::impl
-
 /// Opentracing support
 namespace tracing {
 
 using NoLogSpans = ::dynamic_config::userver_no_log_spans::VariableType;
 
-class Tracer : public std::enable_shared_from_this<Tracer> {
+void SetNoLogSpans(NoLogSpans&& spans);
+bool IsNoLogSpan(const std::string& name);
+NoLogSpans CopyNoLogSpans();
+
+// For legacy opentracing support only.
+class Tracer final {
 public:
-    static void SetNoLogSpans(NoLogSpans&& spans);
-    static bool IsNoLogSpan(const std::string& name);
+    static void SetTracer(Tracer&& tracer);
 
-    static void SetTracer(TracerPtr tracer);
+    static rcu::ReadablePtr<Tracer, rcu::ExclusiveRcuTraits> ReadTracer();
 
-    static TracerPtr GetTracer();
+    static Tracer CopyCurrentTracer();
 
-    const std::string& GetServiceName() const;
+    Tracer(std::string_view service_name, logging::LoggerPtr optional_logger)
+        : service_name_(service_name), optional_logger_(std::move(optional_logger)) {}
 
-    Span CreateSpanWithoutParent(std::string name);
+    // Only works if legacy opentracing is set up.
+    const std::string& GetServiceName() const;
 
-    Span CreateSpan(std::string name, const Span& parent, ReferenceType reference_type);
+    const logging::LoggerPtr& GetOptionalLogger() const { return optional_logger_; }
 
-    logging::LoggerPtr GetOptionalLogger() const { return optional_logger_; }
+private:
+    std::string service_name_;
+    logging::LoggerPtr optional_logger_;
+};
 
-protected:
-    explicit Tracer(std::string_view service_name, logging::LoggerPtr optional_logger)
-        : service_name_(service_name), optional_logger_(std::move(optional_logger)) {}
+// For tests and benchmarks only!
+class TracerCleanupScope final {
+public:
+    TracerCleanupScope();
 
-    virtual ~Tracer();
+    TracerCleanupScope(TracerCleanupScope&&) = delete;
+    TracerCleanupScope& operator=(TracerCleanupScope&&) = delete;
+    ~TracerCleanupScope();
 
 private:
-    const std::string service_name_;
-    const logging::LoggerPtr optional_logger_;
+    Tracer old_tracer_;
+    NoLogSpans old_no_log_spans_;
 };
 
-/// Make a tracer that could be set globally via tracing::Tracer::SetTracer
-TracerPtr MakeTracer(std::string_view service_name, logging::LoggerPtr logger, std::string_view tracer_type = "native");
-
 }  // namespace tracing
 
 USERVER_NAMESPACE_END

core/include/userver/utils/async.hpp

@@ -22,7 +22,7 @@ namespace impl {
 struct SpanWrapCall {
     enum class InheritVariables { kYes, kNo };
 
-    explicit SpanWrapCall(std::string&& name, InheritVariables inherit_variables);
+    explicit SpanWrapCall(std::string&& name, InheritVariables inherit_variables, const SourceLocation& location);
 
     SpanWrapCall(const SpanWrapCall&) = delete;
     SpanWrapCall(SpanWrapCall&&) = delete;
@@ -41,14 +41,20 @@ struct SpanWrapCall {
 
     struct Impl;
 
-    static constexpr std::size_t kImplSize = 4280;
+    static constexpr std::size_t kImplSize = 4328;
     static constexpr std::size_t kImplAlign = 8;
     utils::FastPimpl<Impl, kImplSize, kImplAlign> pimpl_;
 };
 
-// Note: 'name' must outlive the result of this function
-inline auto SpanLazyPrvalue(std::string&& name) {
-    return utils::LazyPrvalue([&name] { return SpanWrapCall(std::move(name), SpanWrapCall::InheritVariables::kYes); });
+// Note: 'name' and 'location' must outlive the result of this function
+inline auto SpanLazyPrvalue(
+    std::string&& name,
+    SpanWrapCall::InheritVariables inherit_variables = SpanWrapCall::InheritVariables::kYes,
+    const SourceLocation& location = SourceLocation::Current()
+) {
+    return utils::LazyPrvalue([&name, inherit_variables, &location] {
+        return SpanWrapCall(std::move(name), inherit_variables, location);
+    });
 }
 
 }  // namespace impl
@@ -366,9 +372,7 @@ template <typename Function, typename... Args>
 AsyncBackground(std::string name, engine::TaskProcessor& task_processor, Function&& f, Args&&... args) {
     return engine::AsyncNoSpan(
         task_processor,
-        utils::LazyPrvalue([&] {
-            return impl::SpanWrapCall(std::move(name), impl::SpanWrapCall::InheritVariables::kNo);
-        }),
+        impl::SpanLazyPrvalue(std::move(name), impl::SpanWrapCall::InheritVariables::kNo),
         std::forward<Function>(f),
         std::forward<Args>(args)...
     );
@@ -392,9 +396,7 @@ template <typename Function, typename... Args>
 CriticalAsyncBackground(std::string name, engine::TaskProcessor& task_processor, Function&& f, Args&&... args) {
     return engine::CriticalAsyncNoSpan(
         task_processor,
-        utils::LazyPrvalue([&] {
-            return impl::SpanWrapCall(std::move(name), impl::SpanWrapCall::InheritVariables::kNo);
-        }),
+        impl::SpanLazyPrvalue(std::move(name), impl::SpanWrapCall::InheritVariables::kNo),
         std::forward<Function>(f),
         std::forward<Args>(args)...
     );

core/src/components/component_list_test.hpp

@@ -49,26 +49,13 @@ inline constexpr std::string_view kMinimalStaticConfig = R"(
           format: ltsv
 )";
 
-struct TracingGuard final {
-    TracingGuard() : tracer(tracing::Tracer::GetTracer()) {}
-
-    ~TracingGuard() {
-        if (tracing::Tracer::GetTracer() != tracer) {
-            tracing::Tracer::SetTracer(tracer);
-        }
-    }
-
-    const logging::LoggerPtr opentracing_logger;
-    const tracing::TracerPtr tracer;
-};
-
 std::string MergeYaml(std::string_view source, std::string_view patch);
 
 }  // namespace tests
 
 class ComponentList : public ::testing::Test {
     tests::impl::DefaultLoggerGuardTest default_logger_guard_;
-    tests::TracingGuard tracing_guard_;
+    tracing::TracerCleanupScope tracer_scope_;
 };
 
 USERVER_NAMESPACE_END

core/src/components/logging_configurator.cpp

@@ -43,7 +43,7 @@ LoggingConfigurator::~LoggingConfigurator() { config_subscription_.Unsubscribe()
 
 void LoggingConfigurator::OnConfigUpdate(const dynamic_config::Snapshot& config) {
     (void)this;  // silence clang-tidy
-    tracing::Tracer::SetNoLogSpans(tracing::NoLogSpans{config[::dynamic_config::USERVER_NO_LOG_SPANS]});
+    tracing::SetNoLogSpans(tracing::NoLogSpans{config[::dynamic_config::USERVER_NO_LOG_SPANS]});
 
     try {
         const auto& dd = config[kDynamicDebugConfig];

core/src/tracing/component.cpp

@@ -32,9 +32,7 @@ Tracer::Tracer(const ComponentConfig& config, const ComponentContext& context) {
             LOG_INFO() << "Opentracing logger is not registered";
         }
 
-        tracing::Tracer::SetTracer(
-            tracing::MakeTracer(std::move(service_name), std::move(opentracing_logger), tracer_type)
-        );
+        tracing::Tracer::SetTracer(tracing::Tracer(std::move(service_name), std::move(opentracing_logger)));
     } else {
         throw std::runtime_error("Tracer type is not supported: " + tracer_type);
     }

core/src/tracing/in_place_span.cpp

@@ -3,55 +3,47 @@
 #include <utility>
 
 #include <tracing/span_impl.hpp>
-#include <userver/utils/uuid4.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace tracing {
 
-namespace {
-
-void SetLinkIfRoot(tracing::Span& span) {
-    if (span.GetLink().empty()) {
-        span.SetLink(utils::generators::GenerateUuid());
-    }
-}
-
-}  // namespace
-
 struct InPlaceSpan::Impl final {
     template <typename... Args>
-    explicit Impl(Args&&... args) : span_impl(std::forward<Args>(args)...), span(span_impl) {}
+    explicit Impl(Args&&... args)
+        : span_impl(std::forward<Args>(args)...),
+          span(std::unique_ptr<Span::Impl, Span::OptionalDeleter>(&span_impl, Span::OptionalDeleter::DoNotDelete())) {}
 
-    tracing::Span::Impl span_impl;
-    tracing::Span span;
+    Span::Impl span_impl;
+    Span span;
 };
 
-InPlaceSpan::InPlaceSpan(std::string&& name, utils::impl::SourceLocation source_location)
-    : impl_(std::move(name), ReferenceType::kChild, logging::Level::kInfo, std::move(source_location)) {
+InPlaceSpan::InPlaceSpan(std::string&& name, const utils::impl::SourceLocation& source_location)
+    : impl_(std::move(name), GetParentSpanImpl(), ReferenceType::kChild, logging::Level::kInfo, source_location) {
     impl_->span.AttachToCoroStack();
-    SetLinkIfRoot(impl_->span);
 }
 
 InPlaceSpan::InPlaceSpan(
     std::string&& name,
     std::string&& trace_id,
     std::string&& parent_span_id,
-    utils::impl::SourceLocation source_location
+    const utils::impl::SourceLocation& source_location
 )
-    : impl_(std::move(name), ReferenceType::kChild, logging::Level::kInfo, std::move(source_location)) {
+    : impl_(std::move(name), GetParentSpanImpl(), ReferenceType::kChild, logging::Level::kInfo, source_location) {
     impl_->span.AttachToCoroStack();
     impl_->span_impl.SetTraceId(std::move(trace_id));
     impl_->span_impl.SetParentId(std::move(parent_span_id));
-    SetLinkIfRoot(impl_->span);
 }
 
+InPlaceSpan::InPlaceSpan(std::string&& name, DetachedTag, const utils::impl::SourceLocation& source_location)
+    : impl_(std::move(name), GetParentSpanImpl(), ReferenceType::kChild, logging::Level::kInfo, source_location) {}
+
 InPlaceSpan::~InPlaceSpan() = default;
 
 tracing::Span& InPlaceSpan::Get() noexcept { return impl_->span; }
 
 void InPlaceSpan::SetParentLink(utils::impl::InternalTag, std::string&& parent_link) {
-    impl_->span.SetParentLink(std::move(parent_link));
+    impl_->span_impl.SetParentLink(std::move(parent_link));
 }
 
 }  // namespace tracing