Propagate resource to exporters

exporters/memory/BUILD

@@ -8,6 +8,7 @@ cc_library(
     strip_include_prefix = "include",
     deps = [
         "//api",
+        "//sdk/src/resource",
         "//sdk/src/trace",
     ],
 )

exporters/memory/CMakeLists.txt

@@ -30,11 +30,12 @@ if(BUILD_TESTING)
 
   target_link_libraries(
     in_memory_span_data_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
-    opentelemetry_exporter_in_memory)
+    opentelemetry_exporter_in_memory opentelemetry_resources)
 
   target_link_libraries(
     in_memory_span_exporter_test ${GTEST_BOTH_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT} opentelemetry_exporter_in_memory)
+    ${CMAKE_THREAD_LIBS_INIT} opentelemetry_exporter_in_memory
+    opentelemetry_resources)
 
   gtest_add_tests(
     TARGET in_memory_span_data_test

exporters/otlp/BUILD

@@ -28,6 +28,7 @@ cc_library(
     ],
     strip_include_prefix = "include",
     deps = [
+        "//sdk/src/resource",
         "//sdk/src/trace",
         "@com_github_opentelemetry_proto//:trace_proto_cc",
     ],

exporters/otlp/CMakeLists.txt

@@ -4,8 +4,9 @@ add_library(opentelemetry_exporter_otprotocol src/recordable.cc
 set_target_properties(opentelemetry_exporter_otprotocol
                       PROPERTIES EXPORT_NAME otlp_exporter)
 
-target_link_libraries(opentelemetry_exporter_otprotocol
-                      PUBLIC opentelemetry_trace opentelemetry_proto)
+target_link_libraries(
+  opentelemetry_exporter_otprotocol
+  PUBLIC opentelemetry_trace opentelemetry_resources opentelemetry_proto)
 
 install(
   TARGETS opentelemetry_exporter_otprotocol

exporters/otlp/include/opentelemetry/exporters/otlp/recordable.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
-
+#include "opentelemetry/proto/resource/v1/resource.pb.h"
 #include "opentelemetry/proto/trace/v1/trace.pb.h"
 
 #include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
@@ -19,6 +19,9 @@ class Recordable final : public sdk::trace::Recordable
 public:
   const proto::trace::v1::Span &span() const noexcept { return span_; }
 
+  /** Dynamically converts the resource of this span into a proto. */
+  proto::resource::v1::Resource resource() const noexcept;
+
   void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
                    opentelemetry::trace::SpanId parent_span_id) noexcept override;
 
@@ -38,6 +41,8 @@ class Recordable final : public sdk::trace::Recordable
 
   void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
 
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
+
   void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override;
 
   void SetDuration(std::chrono::nanoseconds duration) noexcept override;
@@ -48,6 +53,7 @@ class Recordable final : public sdk::trace::Recordable
 
 private:
   proto::trace::v1::Span span_;
+  const opentelemetry::sdk::resource::Resource *resource_;
 };
 }  // namespace otlp
 }  // namespace exporter

exporters/otlp/src/otlp_exporter.cc

@@ -23,10 +23,12 @@ void PopulateRequest(const nostd::span<std::unique_ptr<sdk::trace::Recordable>>
 {
   auto resource_span       = request->add_resource_spans();
   auto instrumentation_lib = resource_span->add_instrumentation_library_spans();
+  bool has_resource        = false;
 
   for (auto &recordable : spans)
   {
     auto rec = std::unique_ptr<Recordable>(static_cast<Recordable *>(recordable.release()));
+    // TODO - Handle Resource
     *instrumentation_lib->add_spans() = std::move(rec->span());
   }
 }

exporters/otlp/src/recordable.cc

@@ -9,7 +9,8 @@ namespace otlp
 //
 // See `attribute_value.h` for details.
 //
-const int kAttributeValueSize = 15;
+const int kAttributeValueSize      = 15;
+const int kOwnedAttributeValueSize = 15;
 
 void Recordable::SetIdentity(const opentelemetry::trace::SpanContext &span_context,
                              opentelemetry::trace::SpanId parent_span_id) noexcept
@@ -123,6 +124,116 @@ void PopulateAttribute(opentelemetry::proto::common::v1::KeyValue *attribute,
   }
 }
 
+/** Maps from C++ attribute into OTLP proto attribute. */
+void PopulateAttribute(opentelemetry::proto::common::v1::KeyValue *attribute,
+                       nostd::string_view key,
+                       const sdk::common::OwnedAttributeValue &value)
+{
+  // Assert size of variant to ensure that this method gets updated if the variant
+  // definition changes
+  static_assert(
+      nostd::variant_size<opentelemetry::common::AttributeValue>::value == kOwnedAttributeValueSize,
+      "AttributeValue contains unknown type");
+
+  attribute->set_key(key.data(), key.size());
+
+  if (nostd::holds_alternative<bool>(value))
+  {
+    attribute->mutable_value()->set_bool_value(nostd::get<bool>(value));
+  }
+  else if (nostd::holds_alternative<int32_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int32_t>(value));
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int64_t>(value));
+  }
+  else if (nostd::holds_alternative<uint32_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<uint32_t>(value));
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<uint64_t>(value));
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    attribute->mutable_value()->set_double_value(nostd::get<double>(value));
+  }
+  else if (nostd::holds_alternative<std::string>(value))
+  {
+    attribute->mutable_value()->set_string_value(nostd::get<std::string>(value));
+  }
+  else if (nostd::holds_alternative<std::vector<bool>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<bool>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_bool_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<int32_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<int32_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<uint32_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<uint32_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<int64_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<int64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<uint64_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<uint64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<double>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<double>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_double_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<std::string>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<std::string>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_string_value(val);
+    }
+  }
+}
+
+proto::resource::v1::Resource Recordable::resource() const noexcept
+{
+  proto::resource::v1::Resource proto;
+  if (resource_)
+  {
+    for (const auto &kv : resource_->GetAttributes())
+    {
+      PopulateAttribute(proto.add_attributes(), kv.first, kv.second);
+    }
+  }
+  return proto;
+}
+
+void Recordable::SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept
+{
+  resource_ = &resource;
+};
+
 void Recordable::SetAttribute(nostd::string_view key,
                               const opentelemetry::common::AttributeValue &value) noexcept
 {
@@ -213,6 +324,8 @@ void Recordable::SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept
   span_.set_kind(proto_span_kind);
 }
 
+void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept {}
+
 void Recordable::SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept
 {
   span_.set_start_time_unix_nano(start_time.time_since_epoch().count());

exporters/zipkin/CMakeLists.txt

@@ -38,7 +38,8 @@ if(BUILD_TESTING)
 
   target_link_libraries(
     zipkin_recordable_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
-    opentelemetry_exporter_zipkin_trace http_client_curl)
+    opentelemetry_exporter_zipkin_trace opentelemetry_resources
+    http_client_curl)
 
   gtest_add_tests(
     TARGET zipkin_recordable_test

exporters/zipkin/include/opentelemetry/exporters/zipkin/recordable.h

@@ -38,6 +38,8 @@ class Recordable final : public sdk::trace::Recordable
 public:
   const ZipkinSpan &span() const noexcept { return span_; }
 
+  const std::string &GetServiceName() const noexcept { return service_name_; }
+
   void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
                    opentelemetry::trace::SpanId parent_span_id) noexcept override;
 
@@ -57,7 +59,9 @@ class Recordable final : public sdk::trace::Recordable
 
   void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override;
 
-  virtual void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+  void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
 
   void SetDuration(std::chrono::nanoseconds duration) noexcept override;
 
@@ -67,6 +71,7 @@ class Recordable final : public sdk::trace::Recordable
 
 private:
   ZipkinSpan span_;
+  std::string service_name_;
 };
 }  // namespace zipkin
 }  // namespace exporter

exporters/zipkin/src/recordable.cc

@@ -213,6 +213,16 @@ void Recordable::SetName(nostd::string_view name) noexcept
   span_["name"] = name.data();
 }
 
+void Recordable::SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept
+{
+  // only service.name attribute is supported by specs as of now.
+  auto attributes = resource.GetAttributes();
+  if (attributes.find("service.name") != attributes.end())
+  {
+    service_name_ = nostd::get<std::string>(attributes["service.name"]);
+  }
+}
+
 void Recordable::SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept
 {
   span_["timestamp"] =

exporters/zipkin/src/zipkin_exporter.cc

@@ -62,6 +62,12 @@ sdk::common::ExportResult ZipkinExporter::Export(
       auto json_span = rec->span();
       // add localEndPoint
       json_span["localEndpoint"] = local_end_point_;
+      // check service.name
+      auto service_name = rec->GetServiceName();
+      if (service_name.size())
+      {
+        json_span["localEndpoint"]["serviceName"] = service_name;
+      }
       json_spans.push_back(json_span);
     }
   }

exporters/zipkin/test/zipkin_recordable_test.cc

@@ -228,6 +228,15 @@ TEST(ZipkinSpanRecordable, SetArrayAtrribute)
   EXPECT_EQ(rec.span(), j_span);
 }
 
+TEST(ZipkinSpanRecordable, SetResource)
+{
+  opentelemetry::exporter::zipkin::Recordable rec;
+  std::string service_name = "test";
+  auto resource = opentelemetry::sdk::resource::Resource::Create({{"service.name", service_name}});
+  rec.SetResource(resource);
+  EXPECT_EQ(rec.GetServiceName(), service_name);
+}
+
 /**
  * AttributeValue can contain different int types, such as int, int64_t,
  * unsigned int, and uint64_t. To avoid writing test cases for each, we can

ext/include/opentelemetry/ext/zpages/threadsafe_span_data.h

@@ -160,6 +160,11 @@ class ThreadsafeSpanData final : public opentelemetry::sdk::trace::Recordable
     span_kind_ = span_kind;
   }
 
+  void SetResource(const opentelemetry::sdk::resource::Resource & /*resource*/) noexcept override
+  {
+    // Not Implemented
+  }
+
   void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override
   {
     std::lock_guard<std::mutex> lock(mutex_);