feat tracing: native span kinds

commit_hash:1a8669b5e7aa7bf6c92532ff7bbd065313fa50e1

Author: segoon

core/include/userver/tracing/tags.hpp

@@ -16,6 +16,10 @@ namespace tracing {
 // inferred from a Zipkin span by the presence of ss/sr annotations.
 
 extern const std::string kType;
+extern const std::string kSpanKind;
+extern const std::string kSpanKindServer;
+extern const std::string kSpanKindClient;
+extern const std::string kSpanKindInternal;
 extern const std::string kHttpUrl;
 extern const std::string kHttpMetaType;
 extern const std::string kHttpMethod;

core/src/clients/http/plugins/yandex_tracing/plugin.cpp

@@ -3,6 +3,7 @@
 #include <userver/clients/http/response.hpp>
 #include <userver/logging/log.hpp>
 #include <userver/tracing/span.hpp>
+#include <userver/tracing/tags.hpp>
 #include <userver/utils/algo.hpp>
 
 #include <userver/http/common_headers.hpp>
@@ -27,7 +28,10 @@ Plugin::Plugin() : http::Plugin(kName) {}
 
 void Plugin::HookPerformRequest(PluginRequest&) {}
 
-void Plugin::HookCreateSpan(PluginRequest&, tracing::Span& span) { span.AddNonInheritableTag(kTypeTag, kTypeRequest); }
+void Plugin::HookCreateSpan(PluginRequest&, tracing::Span& span) {
+    span.AddNonInheritableTag(kTypeTag, kTypeRequest);
+    span.AddNonInheritableTag(tracing::kSpanKind, tracing::kSpanKindClient);
+}
 
 void Plugin::HookOnCompleted(PluginRequest&, Response& response) {
     const auto& headers = response.headers();

core/src/server/middlewares/tracing.cpp

@@ -95,6 +95,7 @@ tracing::Span Tracing::MakeSpan(const http::HttpRequest& http_request, std::stri
 
     span.AddNonInheritableTag(tracing::kHttpMetaType, std::string{meta_type});
     span.AddNonInheritableTag(tracing::kType, kTracingTypeResponse);
+    span.AddNonInheritableTag(tracing::kSpanKind, tracing::kSpanKindServer);
     span.AddNonInheritableTag(tracing::kHttpMethod, http_request.GetMethodStr());
 
     return span;

core/src/tracing/span.cpp

@@ -11,6 +11,7 @@
 #include <userver/logging/impl/logger_base.hpp>
 #include <userver/logging/impl/tag_writer.hpp>
 #include <userver/tracing/span.hpp>
+#include <userver/tracing/tags.hpp>
 #include <userver/tracing/tracer.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/encoding/hex.hpp>
@@ -143,6 +144,9 @@ void Span::Impl::PutIntoLogger(logging::impl::TagWriter writer) && {
         //  and log_extra_local_. Merge to deduplicate such tags.
         log_extra_inheritable_.Extend(std::move(*log_extra_local_));
     }
+    if (log_extra_inheritable_.GetValue(tracing::kSpanKind) == logging::LogExtra::Value{}) {
+        log_extra_inheritable_.Extend(tracing::kSpanKind, tracing::kSpanKindInternal);
+    }
     writer.PutLogExtra(log_extra_inheritable_);
 
     LogOpenTracing();

core/src/tracing/span_test.cpp

@@ -98,7 +98,8 @@ UTEST_F(Span, LogFormat) {
                                                   R"(start_timestamp=\d+(\.\d+)?\t)"
                                                   R"(my_timer_time=\d+(\.\d+)?\t)"
                                                   R"(link=[0-9a-f]+\t)"
-                                                  R"(my_tag_key=my_tag_value\n)";
+                                                  R"(my_tag_key=my_tag_value\t)"
+                                                  R"(span_kind=internal\n)";
     {
         tracing::Span span("span_name");
         span.AddTag("my_tag_key", "my_tag_value");

core/src/tracing/tags.cpp

@@ -6,6 +6,14 @@ namespace tracing {
 
 const std::string kType = "_type";
 
+const std::string kSpanKind = "span_kind";
+
+const std::string kSpanKindServer = "server";
+
+const std::string kSpanKindClient = "client";
+
+const std::string kSpanKindInternal = "internal";
+
 const std::string kHttpUrl = "http.url";
 
 const std::string kHttpMetaType = "meta_type";

grpc/src/ugrpc/client/middlewares/log/middleware.cpp

@@ -1,6 +1,7 @@
 #include "middleware.hpp"
 
 #include <userver/logging/log_extra.hpp>
+#include <userver/tracing/tags.hpp>
 
 #include <ugrpc/impl/logging.hpp>
 
@@ -45,6 +46,7 @@ void Middleware::PreStartCall(MiddlewareCallContext& context) const {
 
     span.AddTag("meta_type", std::string{context.GetCallName()});
     span.AddTag("type", "request");
+    span.AddTag(tracing::kSpanKind, tracing::kSpanKindClient);
 
     if (!IsSingleRequest(context.GetCallKind())) {
         SpanLogger{context.GetSpan(), settings_.log_level}.Log(

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

@@ -3,6 +3,7 @@
 #include <userver/logging/level_serialization.hpp>
 #include <userver/logging/log_extra.hpp>
 #include <userver/tracing/span.hpp>
+#include <userver/tracing/tags.hpp>
 #include <userver/yaml_config/yaml_config.hpp>
 
 #include <ugrpc/impl/logging.hpp>
@@ -73,6 +74,7 @@ void Middleware::Handle(MiddlewareCallContext& context) const {
 
     span.AddTag("meta_type", std::string{context.GetCall().GetCallName()});
     span.AddNonInheritableTag("type", "response");
+    span.AddNonInheritableTag(tracing::kSpanKind, tracing::kSpanKindServer);
     if (IsResponseStream(call_kind)) {
         // Just like in HTTP, there must be a single trailing Span log
         // with type=response and some `body`. We don't have a real single response