Implement basic OTLP Recordable

exporters/otlp/BUILD

@@ -28,3 +28,12 @@ cc_library(
         "@com_github_opentelemetry_proto//:trace_proto_cc",
     ],
 )
+
+cc_test(
+    name = "recordable_test",
+    srcs = ["recordable_test.cc"],
+    deps = [
+        ":recordable",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

exporters/otlp/CMakeLists.txt

@@ -1,3 +1,11 @@
 add_library(opentelemetry_exporter_otprotocol recordable.cc)
 target_link_libraries(opentelemetry_exporter_otprotocol
                       $<TARGET_OBJECTS:opentelemetry_proto>)
+
+add_executable(recordable_test recordable_test.cc)
+target_link_libraries(recordable_test
+                      ${GTEST_BOTH_LIBRARIES}
+                      ${CMAKE_THREAD_LIBS_INIT}
+                      opentelemetry_exporter_otprotocol
+                      protobuf::libprotobuf)
+gtest_add_tests(TARGET recordable_test TEST_PREFIX exporter. TEST_LIST recordable_test)

exporters/otlp/recordable.cc

@@ -5,6 +5,23 @@ namespace exporter
 {
 namespace otlp
 {
+void Recordable::SetIds(trace::TraceId trace_id,
+                        trace::SpanId span_id,
+                        trace::SpanId parent_span_id) noexcept
+{
+  span_.set_trace_id(reinterpret_cast<const char *>(trace_id.Id().data()), trace::TraceId::kSize);
+  span_.set_span_id(reinterpret_cast<const char *>(span_id.Id().data()), trace::SpanId::kSize);
+  span_.set_parent_span_id(reinterpret_cast<const char *>(parent_span_id.Id().data()),
+                           trace::SpanId::kSize);
+}
+
+void Recordable::SetAttribute(nostd::string_view key,
+                              const opentelemetry::common::AttributeValue &&value) noexcept
+{
+  (void)key;
+  (void)value;
+}
+
 void Recordable::AddEvent(nostd::string_view name, core::SystemTimestamp timestamp) noexcept
 {
   (void)name;
@@ -20,6 +37,18 @@ void Recordable::SetName(nostd::string_view name) noexcept
 {
   span_.set_name(name.data(), name.size());
 }
+
+void Recordable::SetStartTime(opentelemetry::core::SystemTimestamp start_time) noexcept
+{
+  const uint64_t nano_unix_time = start_time.time_since_epoch().count();
+  span_.set_start_time_unixnano(nano_unix_time);
+}
+
+void Recordable::SetDuration(std::chrono::nanoseconds duration) noexcept
+{
+  const uint64_t unix_end_time = span_.start_time_unixnano() + duration.count();
+  span_.set_end_time_unixnano(unix_end_time);
+}
 }  // namespace otlp
 }  // namespace exporter
 OPENTELEMETRY_END_NAMESPACE

exporters/otlp/recordable.h

@@ -14,13 +14,23 @@ class Recordable final : public sdk::trace::Recordable
 public:
   const proto::trace::v1::Span &span() const noexcept { return span_; }
 
-  // sdk::trace::Recordable
+  void SetIds(trace::TraceId trace_id,
+              trace::SpanId span_id,
+              trace::SpanId parent_span_id) noexcept override;
+
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &&value) noexcept override;
+
   void AddEvent(nostd::string_view name, core::SystemTimestamp timestamp) noexcept override;
 
   void SetStatus(trace::CanonicalCode code, nostd::string_view description) noexcept override;
 
   void SetName(nostd::string_view name) noexcept override;
 
+  void SetStartTime(opentelemetry::core::SystemTimestamp start_time) noexcept override;
+
+  void SetDuration(std::chrono::nanoseconds duration) noexcept override;
+
 private:
   proto::trace::v1::Span span_;
 };

exporters/otlp/recordable_test.cc

@@ -0,0 +1,73 @@
+#include "exporters/otlp/recordable.h"
+
+#include <gtest/gtest.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+TEST(Recordable, SetIds)
+{
+  const trace::TraceId trace_id(
+    std::array<const uint8_t, trace::TraceId::kSize>(
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}));
+
+  const trace::SpanId span_id(
+    std::array<const uint8_t, trace::SpanId::kSize>(
+    {0, 0, 0, 0, 0, 0, 0, 2}));
+
+  const trace::SpanId parent_span_id(
+    std::array<const uint8_t, trace::SpanId::kSize>(
+    {0, 0, 0, 0, 0, 0, 0, 3}));
+
+  Recordable rec;
+
+  rec.SetIds(trace_id, span_id, parent_span_id);
+
+  EXPECT_EQ(rec.span().trace_id(),
+            std::string(reinterpret_cast<const char *>(trace_id.Id().data()), trace::TraceId::kSize));
+  EXPECT_EQ(rec.span().span_id(),
+            std::string(reinterpret_cast<const char *>(span_id.Id().data()), trace::SpanId::kSize));
+  EXPECT_EQ(rec.span().parent_span_id(),
+            std::string(reinterpret_cast<const char *>(parent_span_id.Id().data()), trace::SpanId::kSize));
+}
+
+TEST(Recordable, SetName)
+{
+  Recordable rec;
+  nostd::string_view name = "TestSpan";
+  rec.SetName(name);
+  EXPECT_EQ(rec.span().name(), name);
+}
+
+TEST(Recordable, SetStartTime)
+{
+  Recordable rec;
+  std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
+  core::SystemTimestamp start_timestamp(start_time);
+
+  uint64_t unix_start =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(start_time.time_since_epoch()).count();
+
+  rec.SetStartTime(start_timestamp);
+  EXPECT_EQ(rec.span().start_time_unixnano(), unix_start);
+}
+
+TEST(Recordable, SetDuration)
+{
+  Recordable rec;
+  // Start time is 0
+  core::SystemTimestamp start_timestamp;
+
+  std::chrono::nanoseconds duration(10);
+  uint64_t unix_end = duration.count();
+
+  rec.SetStartTime(start_timestamp);
+  rec.SetDuration(duration);
+
+  EXPECT_EQ(rec.span().end_time_unixnano(), unix_end);
+}
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE