Add bytes support for OTLP recordables

Author: owent

api/include/opentelemetry/common/attribute_value.h

@@ -24,12 +24,12 @@ namespace common
 ///  - Homogenous arrays of primitive type values.
 ///
 /// \warning The OpenTelemetry C++ API does not support the following attribute:
-///  uint64_t, nostd::span<const uint64_t>, and nostd::span<uint8_t> types.
+///  uint64_t, nostd::span<const uint64_t>, and nostd::span<const uint8_t> types.
 /// \parblock The OpenTelemetry C++ API currently supports several attribute
 /// value types that are not covered by the OpenTelemetry specification:
 ///  - \c uint64_t
 ///  - \c nostd::span<const uint64_t>
-///  - \c nostd::span<uint8_t>
+///  - \c nostd::span<const uint8_t>
 ///
 /// Those types are reserved for future use and currently should not be
 /// used. There are no guarantees around how those values are handled by
@@ -55,8 +55,6 @@ using AttributeValue =
                    // Not currently supported by the specification, but reserved for future use.
                    // Added to provide support for all primitive C++ types.
                    nostd::span<const uint64_t>,
-                   // Not currently supported by the specification, but reserved for future use.
-                   // See https://github.com/open-telemetry/opentelemetry-specification/issues/780
                    nostd::span<const uint8_t>>;
 
 enum AttributeType

exporters/otlp/src/otlp_populate_attribute_utils.cc

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <stdint.h>
+#include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -89,11 +90,9 @@ void OtlpPopulateAttributeUtils::PopulateAnyValue(
   }
   else if (nostd::holds_alternative<nostd::span<const uint8_t>>(value))
   {
-    auto array_value = proto_value->mutable_array_value();
-    for (const auto &val : nostd::get<nostd::span<const uint8_t>>(value))
-    {
-      array_value->add_values()->set_int_value(val);
-    }
+    proto_value->set_bytes_value(
+        reinterpret_cast<const void *>(nostd::get<nostd::span<const uint8_t>>(value).data()),
+        nostd::get<nostd::span<const uint8_t>>(value).size());
   }
   else if (nostd::holds_alternative<nostd::span<const bool>>(value))
   {
@@ -194,6 +193,12 @@ void OtlpPopulateAttributeUtils::PopulateAnyValue(
   {
     proto_value->set_double_value(nostd::get<double>(value));
   }
+  else if (nostd::holds_alternative<std::vector<uint8_t>>(value))
+  {
+    const std::vector<uint8_t> &byte_array = nostd::get<std::vector<uint8_t>>(value);
+    proto_value->set_bytes_value(reinterpret_cast<const void *>(byte_array.data()),
+                                 byte_array.size());
+  }
   else if (nostd::holds_alternative<std::string>(value))
   {
     proto_value->set_string_value(nostd::get<std::string>(value));

exporters/otlp/test/otlp_log_recordable_test.cc

@@ -73,6 +73,16 @@ TEST(OtlpLogRecordable, Basic)
   EXPECT_EQ(rec.log_record().body().string_value(), name);
   EXPECT_EQ(rec.log_record().trace_id(), expected_trace_id_bytes);
   EXPECT_EQ(rec.log_record().span_id(), expected_span_id_bytes);
+
+  // Test bytes body
+  uint8_t byte_arr[] = {'T', 'e', '\0', 's', 't'};
+  common::AttributeValue byte_val(
+      nostd::span<const uint8_t>{reinterpret_cast<const uint8_t *>(byte_arr), 5});
+  rec.SetBody(byte_val);
+  EXPECT_TRUE(0 ==
+              memcmp(reinterpret_cast<const void *>(rec.log_record().body().bytes_value().data()),
+                     reinterpret_cast<const void *>(byte_arr), 5));
+  EXPECT_EQ(rec.log_record().body().bytes_value().size(), 5);
 }
 
 TEST(OtlpLogRecordable, GetResource)
@@ -111,6 +121,12 @@ TEST(OtlpLogRecordable, SetSingleAttribute)
   common::AttributeValue str_val(nostd::string_view("Test"));
   rec.SetAttribute(str_key, str_val);
 
+  nostd::string_view byte_key = "byte_attr";
+  uint8_t byte_arr[]          = {'T', 'e', 's', 't'};
+  common::AttributeValue byte_val(
+      nostd::span<const uint8_t>{reinterpret_cast<const uint8_t *>(byte_arr), 4});
+  rec.SetAttribute(byte_key, byte_val);
+
   int checked_attributes = 0;
   for (auto &attribute : rec.log_record().attributes())
   {
@@ -129,8 +145,16 @@ TEST(OtlpLogRecordable, SetSingleAttribute)
       ++checked_attributes;
       EXPECT_EQ(attribute.value().string_value(), nostd::get<nostd::string_view>(str_val).data());
     }
+    else if (attribute.key() == byte_key)
+    {
+      ++checked_attributes;
+      EXPECT_TRUE(0 ==
+                  memcmp(reinterpret_cast<const void *>(attribute.value().bytes_value().data()),
+                         reinterpret_cast<const void *>(byte_arr), 4));
+      EXPECT_EQ(attribute.value().bytes_value().size(), 4);
+    }
   }
-  EXPECT_EQ(3, checked_attributes);
+  EXPECT_EQ(4, checked_attributes);
 }
 
 // Test non-int array types. Int array types are tested using templates (see IntAttributeTest)

exporters/otlp/test/otlp_recordable_test.cc

@@ -4,8 +4,10 @@
 #include <gtest/gtest.h>
 #include <stdint.h>
 #include <chrono>
+#include <cstdint>
 #include <map>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -256,22 +258,93 @@ TEST(OtlpRecordable, AddLink)
 TEST(OtlpRecordable, SetResource)
 {
   OtlpRecordable rec;
-  const std::string service_name_key = "service.name";
-  std::string service_name           = "test-otlp";
-  auto resource = resource::Resource::Create({{service_name_key, service_name}});
+  bool array_bool[]                                = {true, false, true};
+  int32_t array_int[]                              = {1, 2, 3};
+  double array_double[]                            = {1.1, 2.2, 3.3};
+  opentelemetry::nostd::string_view array_string[] = {"str1", "str2", "str3"};
+
+  resource::ResourceAttributes attributes{
+      {"service.name", opentelemetry::nostd::string_view{"test-otlp"}},
+      {"bool_value", true},
+      {"int_value", 3},
+      {"double_value", static_cast<double>(1.4)},
+      {"bytes_value",
+       opentelemetry::nostd::span<const uint8_t>{reinterpret_cast<const uint8_t *>("\1\0\3abc"),
+                                                 6}},
+      {"bool_array", opentelemetry::nostd::span<const bool>{array_bool}},
+      {"int_array", opentelemetry::nostd::span<const int32_t>{array_int}},
+      {"double_array", opentelemetry::nostd::span<const double>{array_double}},
+      {"string_array",
+       opentelemetry::nostd::span<const opentelemetry::nostd::string_view>{array_string}}};
+
+  auto resource = resource::Resource::Create(attributes);
   rec.SetResource(resource);
 
-  auto proto_resource     = rec.ProtoResource();
-  bool found_service_name = false;
+  auto proto_resource          = rec.ProtoResource();
+  size_t found_attribute_count = 0;
   for (int i = 0; i < proto_resource.attributes_size(); i++)
   {
     const auto &attr = proto_resource.attributes(static_cast<int>(i));
-    if (attr.key() == service_name_key && attr.value().string_value() == service_name)
+    if (attr.key() == "service.name")
     {
-      found_service_name = true;
+      EXPECT_EQ(attr.value().string_value(), std::string{"test-otlp"});
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "bool_value")
+    {
+      EXPECT_EQ(attr.value().bool_value(), true);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "int_value")
+    {
+      EXPECT_EQ(attr.value().int_value(), 3);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "double_value")
+    {
+      EXPECT_EQ(attr.value().double_value(), static_cast<double>(1.4));
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "bytes_value")
+    {
+      EXPECT_TRUE(0 == memcmp(attr.value().bytes_value().data(), "\1\0\3abc", 6));
+      EXPECT_EQ(attr.value().bytes_value().size(), 6);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "bool_array")
+    {
+      EXPECT_EQ(attr.value().array_value().values_size(), 3);
+      EXPECT_EQ(attr.value().array_value().values(0).bool_value(), true);
+      EXPECT_EQ(attr.value().array_value().values(1).bool_value(), false);
+      EXPECT_EQ(attr.value().array_value().values(2).bool_value(), true);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "int_array")
+    {
+      EXPECT_EQ(attr.value().array_value().values_size(), 3);
+      EXPECT_EQ(attr.value().array_value().values(0).int_value(), 1);
+      EXPECT_EQ(attr.value().array_value().values(1).int_value(), 2);
+      EXPECT_EQ(attr.value().array_value().values(2).int_value(), 3);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "double_array")
+    {
+      EXPECT_EQ(attr.value().array_value().values_size(), 3);
+      EXPECT_EQ(attr.value().array_value().values(0).double_value(), 1.1);
+      EXPECT_EQ(attr.value().array_value().values(1).double_value(), 2.2);
+      EXPECT_EQ(attr.value().array_value().values(2).double_value(), 3.3);
+      ++found_attribute_count;
+    }
+    else if (attr.key() == "string_array")
+    {
+      EXPECT_EQ(attr.value().array_value().values_size(), 3);
+      EXPECT_EQ(attr.value().array_value().values(0).string_value(), "str1");
+      EXPECT_EQ(attr.value().array_value().values(1).string_value(), "str2");
+      EXPECT_EQ(attr.value().array_value().values(2).string_value(), "str3");
+      ++found_attribute_count;
     }
   }
-  EXPECT_TRUE(found_service_name);
+  EXPECT_EQ(found_attribute_count, attributes.size());
 }
 
 TEST(OtlpRecordable, SetResourceWithSchemaURL)
@@ -303,6 +376,12 @@ TEST(OtlpRecordable, SetSingleAttribute)
   common::AttributeValue str_val(nostd::string_view("Test"));
   rec.SetAttribute(str_key, str_val);
 
+  nostd::string_view byte_key = "byte_attr";
+  uint8_t byte_arr[]          = {'T', 'e', 's', 't'};
+  common::AttributeValue byte_val(
+      nostd::span<const uint8_t>{reinterpret_cast<const uint8_t *>(byte_arr), 4});
+  rec.SetAttribute(byte_key, byte_val);
+
   EXPECT_EQ(rec.span().attributes(0).key(), bool_key);
   EXPECT_EQ(rec.span().attributes(0).value().bool_value(), nostd::get<bool>(bool_val));
 
@@ -312,6 +391,12 @@ TEST(OtlpRecordable, SetSingleAttribute)
   EXPECT_EQ(rec.span().attributes(2).key(), str_key);
   EXPECT_EQ(rec.span().attributes(2).value().string_value(),
             nostd::get<nostd::string_view>(str_val).data());
+
+  EXPECT_EQ(rec.span().attributes(3).key(), byte_key);
+  EXPECT_EQ(rec.span().attributes(3).value().bytes_value().size(), 4);
+  EXPECT_TRUE(0 == memcmp(reinterpret_cast<const void *>(
+                              rec.span().attributes(3).value().bytes_value().data()),
+                          reinterpret_cast<const void *>(byte_arr), 4));
 }
 
 // Test non-int array types. Int array types are tested using templates (see IntAttributeTest)