Fix #1081

exporters/otlp/BUILD

@@ -175,6 +175,16 @@ cc_test(
  ],
 )
 
+cc_test(
+ name = "otlp_log_recordable_test",
+ srcs = ["test/otlp_log_recordable_test.cc"],
+ deps = [
+ ":otlp_recordable",
+ "@com_github_opentelemetry_proto//:logs_service_proto_cc",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
 cc_test(
  name = "otlp_grpc_exporter_test",
  srcs = ["test/otlp_grpc_exporter_test.cc"],

exporters/otlp/CMakeLists.txt

@@ -111,6 +111,18 @@ if(BUILD_TESTING)
  TARGET otlp_recordable_test
  TEST_PREFIX exporter.otlp.
  TEST_LIST otlp_recordable_test)
+
+ if(WITH_LOGS_PREVIEW)
+ add_executable(otlp_log_recordable_test test/otlp_log_recordable_test.cc)
+ target_link_libraries(
+ otlp_log_recordable_test ${GTEST_BOTH_LIBRARIES}
+ ${CMAKE_THREAD_LIBS_INIT} opentelemetry_otlp_recordable)
+ gtest_add_tests(
+ TARGET otlp_log_recordable_test
+ TEST_PREFIX exporter.otlp.
+ TEST_LIST otlp_log_recordable_test)
+ endif()
+
  if(MSVC)
  # Explicitly specify that we consume GTest from shared library. The rest of
  # code logic below determines whether we link Release or Debug flavor of the

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h

@@ -13,6 +13,7 @@
 # include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
 // clang-format on
 
+# include "opentelemetry/sdk/common/attribute_utils.h"
 # include "opentelemetry/sdk/logs/recordable.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -95,7 +96,7 @@ class OtlpLogRecordable final : public opentelemetry::sdk::logs::Recordable
 
 private:
  proto::logs::v1::LogRecord log_record_;
- proto::resource::v1::Resource private_resource_;
+ opentelemetry::sdk::common::AttributeMap resource_attributes_;
  // TODO shared resource
  // const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
  // TODO InstrumentationLibrary

exporters/otlp/src/otlp_log_recordable.cc

@@ -17,8 +17,10 @@ namespace otlp
 
 proto::resource::v1::Resource OtlpLogRecordable::ProtoResource() const noexcept
 {
- // TODO Populate shared resource
- return private_resource_;
+ proto::resource::v1::Resource proto;
+ OtlpRecordableUtils::PopulateAttribute(
+ &proto, opentelemetry::sdk::resource::Resource::Create(resource_attributes_));
+ return proto;
 }
 
 void OtlpLogRecordable::SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept
@@ -171,7 +173,7 @@ void OtlpLogRecordable::SetBody(nostd::string_view message) noexcept
 void OtlpLogRecordable::SetResource(nostd::string_view key,
  const opentelemetry::common::AttributeValue &value) noexcept
 {
- OtlpRecordableUtils::PopulateAttribute(private_resource_.add_attributes(), key, value);
+ resource_attributes_.SetAttribute(key, value);
 }
 
 void OtlpLogRecordable::SetAttribute(nostd::string_view key,

exporters/otlp/test/otlp_log_recordable_test.cc

@@ -0,0 +1,237 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+# include <gtest/gtest.h>
+
+# include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+# include "opentelemetry/sdk/resource/experimental_semantic_conventions.h"
+# include "opentelemetry/sdk/resource/resource.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+namespace resource = opentelemetry::sdk::resource;
+namespace proto = opentelemetry::proto;
+
+TEST(OtlpLogRecordable, SetName)
+{
+ OtlpLogRecordable rec;
+ nostd::string_view name = "Test Log Name";
+ rec.SetName(name);
+ EXPECT_EQ(rec.log_record().name(), name);
+}
+
+TEST(OtlpLogRecordable, SetTimestamp)
+{
+ OtlpLogRecordable rec;
+ std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+ common::SystemTimestamp start_timestamp(now);
+
+ uint64_t unix_start =
+ std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
+
+ rec.SetTimestamp(start_timestamp);
+ EXPECT_EQ(rec.log_record().time_unix_nano(), unix_start);
+}
+
+TEST(OtlpLogRecordable, SetSeverity)
+{
+ OtlpLogRecordable rec;
+ rec.SetSeverity(opentelemetry::logs::Severity::kError);
+
+ EXPECT_EQ(rec.log_record().severity_number(), proto::logs::v1::SEVERITY_NUMBER_ERROR);
+ EXPECT_EQ(rec.log_record().severity_text(), "ERROR");
+}
+
+TEST(OtlpLogRecordable, SetBody)
+{
+ OtlpLogRecordable rec;
+ nostd::string_view name = "Test Log Message";
+ rec.SetBody(name);
+ EXPECT_EQ(rec.log_record().body().string_value(), name);
+}
+
+TEST(OtlpLogRecordable, SetTraceId)
+{
+ OtlpLogRecordable rec;
+ uint8_t trace_id_bin[opentelemetry::trace::TraceId::kSize] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+ std::string expected_bytes;
+ expected_bytes.assign(
+ reinterpret_cast<char *>(trace_id_bin),
+ reinterpret_cast<char *>(trace_id_bin) + opentelemetry::trace::TraceId::kSize);
+ rec.SetTraceId(opentelemetry::trace::TraceId{trace_id_bin});
+ EXPECT_EQ(rec.log_record().trace_id(), expected_bytes);
+}
+
+TEST(OtlpLogRecordable, SetSpanId)
+{
+ OtlpLogRecordable rec;
+ uint8_t span_id_bin[opentelemetry::trace::SpanId::kSize] = {'7', '6', '5', '4',
+ '3', '2', '1', '0'};
+ std::string expected_bytes;
+ expected_bytes.assign(
+ reinterpret_cast<char *>(span_id_bin),
+ reinterpret_cast<char *>(span_id_bin) + opentelemetry::trace::SpanId::kSize);
+ rec.SetSpanId(opentelemetry::trace::SpanId{span_id_bin});
+ EXPECT_EQ(rec.log_record().span_id(), expected_bytes);
+}
+
+TEST(OtlpLogRecordable, SetResource)
+{
+ OtlpLogRecordable rec;
+ const std::string service_name_key = "service.name";
+ std::string service_name = "test-otlp";
+ rec.SetResource(service_name_key, service_name);
+
+ auto proto_resource = rec.ProtoResource();
+ bool found_service_name = false;
+ for (int i = 0; i < proto_resource.attributes_size(); i++)
+ {
+ auto attr = proto_resource.attributes(static_cast<int>(i));
+ if (attr.key() == service_name_key && attr.value().string_value() == service_name)
+ {
+ found_service_name = true;
+ }
+ }
+ EXPECT_TRUE(found_service_name);
+}
+
+TEST(OtlpLogRecordable, DefaultResource)
+{
+ OtlpLogRecordable rec;
+
+ auto proto_resource = rec.ProtoResource();
+ int found_resource_count = 0;
+ for (int i = 0; i < proto_resource.attributes_size(); i++)
+ {
+ auto attr = proto_resource.attributes(static_cast<int>(i));
+ if (attr.key() ==
+ opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkLanguage)))
+ {
+ EXPECT_EQ(attr.value().string_value(), "cpp");
+ ++found_resource_count;
+ }
+ else if (attr.key() ==
+ opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkName)))
+ {
+ EXPECT_EQ(attr.value().string_value(), "opentelemetry");
+ ++found_resource_count;
+ }
+ else if (attr.key() ==
+ opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkVersion)))
+ {
+ EXPECT_EQ(attr.value().string_value(), OPENTELEMETRY_SDK_VERSION);
+ ++found_resource_count;
+ }
+ }
+ EXPECT_EQ(3, found_resource_count);
+}
+
+// Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
+TEST(OtlpLogRecordable, SetSingleAttribute)
+{
+ OtlpLogRecordable rec;
+ nostd::string_view bool_key = "bool_attr";
+ common::AttributeValue bool_val(true);
+ rec.SetAttribute(bool_key, bool_val);
+
+ nostd::string_view double_key = "double_attr";
+ common::AttributeValue double_val(3.3);
+ rec.SetAttribute(double_key, double_val);
+
+ nostd::string_view str_key = "str_attr";
+ common::AttributeValue str_val(nostd::string_view("Test"));
+ rec.SetAttribute(str_key, str_val);
+
+ EXPECT_EQ(rec.log_record().attributes(0).key(), bool_key);
+ EXPECT_EQ(rec.log_record().attributes(0).value().bool_value(), nostd::get<bool>(bool_val));
+
+ EXPECT_EQ(rec.log_record().attributes(1).key(), double_key);
+ EXPECT_EQ(rec.log_record().attributes(1).value().double_value(), nostd::get<double>(double_val));
+
+ EXPECT_EQ(rec.log_record().attributes(2).key(), str_key);
+ EXPECT_EQ(rec.log_record().attributes(2).value().string_value(),
+ nostd::get<nostd::string_view>(str_val).data());
+}
+
+// Test non-int array types. Int array types are tested using templates (see IntAttributeTest)
+TEST(OtlpLogRecordable, SetArrayAttribute)
+{
+ OtlpLogRecordable rec;
+ const int kArraySize = 3;
+
+ bool bool_arr[kArraySize] = {true, false, true};
+ nostd::span<const bool> bool_span(bool_arr);
+ rec.SetAttribute("bool_arr_attr", bool_span);
+
+ double double_arr[kArraySize] = {22.3, 33.4, 44.5};
+ nostd::span<const double> double_span(double_arr);
+ rec.SetAttribute("double_arr_attr", double_span);
+
+ nostd::string_view str_arr[kArraySize] = {"Hello", "World", "Test"};
+ nostd::span<const nostd::string_view> str_span(str_arr);
+ rec.SetAttribute("str_arr_attr", str_span);
+
+ for (int i = 0; i < kArraySize; i++)
+ {
+ EXPECT_EQ(rec.log_record().attributes(0).value().array_value().values(i).bool_value(),
+ bool_span[i]);
+ EXPECT_EQ(rec.log_record().attributes(1).value().array_value().values(i).double_value(),
+ double_span[i]);
+ EXPECT_EQ(rec.log_record().attributes(2).value().array_value().values(i).string_value(),
+ str_span[i]);
+ }
+}
+
+/**
+ * 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
+ * use a template approach to test all int types.
+ */
+template <typename T>
+struct OtlpLogRecordableIntAttributeTest : public testing::Test
+{
+ using IntParamType = T;
+};
+
+using IntTypes = testing::Types<int, int64_t, unsigned int, uint64_t>;
+TYPED_TEST_SUITE(OtlpLogRecordableIntAttributeTest, IntTypes);
+
+TYPED_TEST(OtlpLogRecordableIntAttributeTest, SetIntSingleAttribute)
+{
+ using IntType = typename TestFixture::IntParamType;
+ IntType i = 2;
+ common::AttributeValue int_val(i);
+
+ OtlpLogRecordable rec;
+ rec.SetAttribute("int_attr", int_val);
+ EXPECT_EQ(rec.log_record().attributes(0).value().int_value(), nostd::get<IntType>(int_val));
+}
+
+TYPED_TEST(OtlpLogRecordableIntAttributeTest, SetIntArrayAttribute)
+{
+ using IntType = typename TestFixture::IntParamType;
+
+ const int kArraySize = 3;
+ IntType int_arr[kArraySize] = {4, 5, 6};
+ nostd::span<const IntType> int_span(int_arr);
+
+ OtlpLogRecordable rec;
+ rec.SetAttribute("int_arr_attr", int_span);
+
+ for (int i = 0; i < kArraySize; i++)
+ {
+ EXPECT_EQ(rec.log_record().attributes(0).value().array_value().values(i).int_value(),
+ int_span[i]);
+ }
+}
+} // namespace otlp
+} // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif

exporters/otlp/test/otlp_recordable_test.cc

@@ -221,7 +221,7 @@ TEST(OtlpRecordable, SetResourceWithSchemaURL)
 }
 
 // Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
-TEST(OtlpRecordable, SetSingleAtrribute)
+TEST(OtlpRecordable, SetSingleAttribute)
 {
  OtlpRecordable rec;
  nostd::string_view bool_key = "bool_attr";
@@ -248,7 +248,7 @@ TEST(OtlpRecordable, SetSingleAtrribute)
 }
 
 // Test non-int array types. Int array types are tested using templates (see IntAttributeTest)
-TEST(OtlpRecordable, SetArrayAtrribute)
+TEST(OtlpRecordable, SetArrayAttribute)
 {
  OtlpRecordable rec;
  const int kArraySize = 3;

sdk/include/opentelemetry/sdk/logs/recordable.h

@@ -8,6 +8,9 @@
 # include "opentelemetry/common/key_value_iterable.h"
 # include "opentelemetry/common/timestamp.h"
 # include "opentelemetry/logs/severity.h"
+# include "opentelemetry/sdk/common/empty_attributes.h"
+# include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h"
+# include "opentelemetry/sdk/resource/resource.h"
 # include "opentelemetry/trace/span.h"
 # include "opentelemetry/trace/span_context.h"
 # include "opentelemetry/trace/span_id.h"