diff --git a/CHANGELOG.md b/CHANGELOG.md index e1ee4af753..8ac5e7012d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,9 @@ Increment the: * [SDK] Do not frequently create and destroy http client threads [#3198](https://github.com/open-telemetry/opentelemetry-cpp/pull/3198) +* [SDK] Fix instrumentation scope attributes evaluated in equal method + [#3214](https://github.com/open-telemetry/opentelemetry-cpp/pull/3214) + ## [1.18 2024-11-25] * [EXPORTER] Fix crash in ElasticsearchLogRecordExporter diff --git a/exporters/otlp/src/otlp_http_client.cc b/exporters/otlp/src/otlp_http_client.cc index 506295ad7f..a2620756cc 100644 --- a/exporters/otlp/src/otlp_http_client.cc +++ b/exporters/otlp/src/otlp_http_client.cc @@ -890,7 +890,7 @@ OtlpHttpClient::createSession( // Parse uri and store it to cache if (http_uri_.empty()) { - auto parse_url = opentelemetry::ext::http::common::UrlParser(std::string(options_.url)); + const auto parse_url = opentelemetry::ext::http::common::UrlParser(options_.url); if (!parse_url.success_) { std::string error_message = "[OTLP HTTP Client] Export failed, invalid url: " + options_.url; diff --git a/ext/src/http/client/curl/http_client_curl.cc b/ext/src/http/client/curl/http_client_curl.cc index e6292f54f2..a2b73ecb2b 100644 --- a/ext/src/http/client/curl/http_client_curl.cc +++ b/ext/src/http/client/curl/http_client_curl.cc @@ -3,14 +3,17 @@ #include #include +#include +#include #include #include -#include #include +#include #include #include #include #include +#include #include #include #include @@ -57,11 +60,85 @@ nostd::shared_ptr HttpCurlGlobalInitializer::GetInsta return shared_initializer; } +#ifdef ENABLE_OTLP_COMPRESSION_PREVIEW +// Original source: +// https://stackoverflow.com/questions/12398377/is-it-possible-to-have-zlib-read-from-and-write-to-the-same-memory-buffer/12412863#12412863 +int deflateInPlace(z_stream *strm, unsigned char *buf, uint32_t len, uint32_t *max_len) +{ + // must be large enough to hold zlib or gzip header (if any) and one more byte -- 11 works for the + // worst case here, but if gzip encoding is used and a deflateSetHeader() call is inserted in this + // code after the deflateReset(), then the 11 needs to be increased to accommodate the resulting + // gzip header size plus one + std::array temp{}; + + // kick start the process with a temporary output buffer -- this allows deflate to consume a large + // chunk of input data in order to make room for output data there + strm->next_in = buf; + strm->avail_in = len; + if (*max_len < len) + { + *max_len = len; + } + strm->next_out = temp.data(); + strm->avail_out = (std::min)(static_cast(temp.size()), *max_len); + auto ret = deflate(strm, Z_FINISH); + if (ret == Z_STREAM_ERROR) + { + return ret; + } + + // if we can, copy the temporary output data to the consumed portion of the input buffer, and then + // continue to write up to the start of the consumed input for as long as possible + auto have = strm->next_out - temp.data(); // number of bytes in temp[] + if (have <= static_cast(strm->avail_in ? len - strm->avail_in : *max_len)) + { + std::memcpy(buf, temp.data(), have); + strm->next_out = buf + have; + have = 0; + while (ret == Z_OK) + { + strm->avail_out = + strm->avail_in ? strm->next_in - strm->next_out : (buf + *max_len) - strm->next_out; + ret = deflate(strm, Z_FINISH); + } + if (ret != Z_BUF_ERROR || strm->avail_in == 0) + { + *max_len = strm->next_out - buf; + return ret == Z_STREAM_END ? Z_OK : ret; + } + } + + // the output caught up with the input due to insufficiently compressible data -- copy the + // remaining input data into an allocated buffer and complete the compression from there to the + // now empty input buffer (this will only occur for long incompressible streams, more than ~20 MB + // for the default deflate memLevel of 8, or when *max_len is too small and less than the length + // of the header plus one byte) + auto hold = static_cast>( + strm->zalloc(strm->opaque, strm->avail_in, 1)); // allocated buffer to hold input data + if (hold == Z_NULL) + { + return Z_MEM_ERROR; + } + std::memcpy(hold, strm->next_in, strm->avail_in); + strm->next_in = hold; + if (have) + { + std::memcpy(buf, temp.data(), have); + strm->next_out = buf + have; + } + strm->avail_out = (buf + *max_len) - strm->next_out; + ret = deflate(strm, Z_FINISH); + strm->zfree(strm->opaque, hold); + *max_len = strm->next_out - buf; + return ret == Z_OK ? Z_BUF_ERROR : (ret == Z_STREAM_END ? Z_OK : ret); +} +#endif // ENABLE_OTLP_COMPRESSION_PREVIEW + void Session::SendRequest( std::shared_ptr callback) noexcept { is_session_active_.store(true, std::memory_order_release); - std::string url = host_ + std::string(http_request_->uri_); + const auto &url = host_ + http_request_->uri_; auto callback_ptr = callback.get(); bool reuse_connection = false; @@ -76,44 +153,47 @@ void Session::SendRequest( if (http_request_->compression_ == opentelemetry::ext::http::client::Compression::kGzip) { #ifdef ENABLE_OTLP_COMPRESSION_PREVIEW - http_request_->AddHeader("Content-Encoding", "gzip"); - - opentelemetry::ext::http::client::Body compressed_body(http_request_->body_.size()); - z_stream zs; - zs.zalloc = Z_NULL; - zs.zfree = Z_NULL; - zs.opaque = Z_NULL; - zs.avail_in = static_cast(http_request_->body_.size()); - zs.next_in = http_request_->body_.data(); - zs.avail_out = static_cast(compressed_body.size()); - zs.next_out = compressed_body.data(); + z_stream zs{}; + zs.zalloc = Z_NULL; + zs.zfree = Z_NULL; + zs.opaque = Z_NULL; // ZLIB: Have to maually specify 16 bits for the Gzip headers - const int window_bits = 15 + 16; + static constexpr int kWindowBits = MAX_WBITS + 16; + static constexpr int kMemLevel = MAX_MEM_LEVEL; - int stream = - deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY); + auto stream = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, kWindowBits, kMemLevel, + Z_DEFAULT_STRATEGY); if (stream == Z_OK) { - deflate(&zs, Z_FINISH); - deflateEnd(&zs); - compressed_body.resize(zs.total_out); - http_request_->SetBody(compressed_body); + auto size = static_cast(http_request_->body_.size()); + auto max_size = size; + stream = deflateInPlace(&zs, http_request_->body_.data(), size, &max_size); + + if (stream == Z_OK) + { + http_request_->AddHeader("Content-Encoding", "gzip"); + http_request_->body_.resize(max_size); + } } - else + + if (stream != Z_OK) { if (callback) { - callback->OnEvent(opentelemetry::ext::http::client::SessionState::CreateFailed, ""); + callback->OnEvent(opentelemetry::ext::http::client::SessionState::CreateFailed, + zs.msg ? zs.msg : ""); } is_session_active_.store(false, std::memory_order_release); } + + deflateEnd(&zs); #else OTEL_INTERNAL_LOG_ERROR( "[HTTP Client Curl] Set WITH_OTLP_HTTP_COMPRESSION=ON to use gzip compression with the " "OTLP HTTP Exporter"); -#endif +#endif // ENABLE_OTLP_COMPRESSION_PREVIEW } curl_operation_.reset(new HttpOperation( @@ -226,7 +306,7 @@ HttpClient::~HttpClient() std::shared_ptr HttpClient::CreateSession( nostd::string_view url) noexcept { - auto parsedUrl = common::UrlParser(std::string(url)); + const auto parsedUrl = common::UrlParser(std::string(url)); if (!parsedUrl.success_) { return std::make_shared(*this); diff --git a/ext/src/http/client/curl/http_operation_curl.cc b/ext/src/http/client/curl/http_operation_curl.cc index b80624d069..c27cff1b41 100644 --- a/ext/src/http/client/curl/http_operation_curl.cc +++ b/ext/src/http/client/curl/http_operation_curl.cc @@ -301,9 +301,7 @@ HttpOperation::HttpOperation(opentelemetry::ext::http::client::Method method, { for (auto &kv : this->request_headers_) { - std::string header = std::string(kv.first); - header += ": "; - header += std::string(kv.second); + const auto header = std::string(kv.first).append(": ").append(kv.second); curl_resource_.headers_chunk = curl_slist_append(curl_resource_.headers_chunk, header.c_str()); } diff --git a/ext/test/http/curl_http_test.cc b/ext/test/http/curl_http_test.cc index 497c5bb529..f1fbe495b7 100644 --- a/ext/test/http/curl_http_test.cc +++ b/ext/test/http/curl_http_test.cc @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -558,7 +559,6 @@ TEST_F(BasicCurlHttpTests, ElegantQuitQuick) ASSERT_TRUE(handler->is_called_); ASSERT_TRUE(handler->got_response_); } - TEST_F(BasicCurlHttpTests, BackgroundThreadWaitMore) { { @@ -581,3 +581,128 @@ TEST_F(BasicCurlHttpTests, BackgroundThreadWaitMore) ASSERT_TRUE(http_client.MaybeSpawnBackgroundThread()); } } + +#ifdef ENABLE_OTLP_COMPRESSION_PREVIEW +struct GzipEventHandler : public CustomEventHandler +{ + ~GzipEventHandler() override = default; + + void OnResponse(http_client::Response & /* response */) noexcept override {} + + void OnEvent(http_client::SessionState state, nostd::string_view reason) noexcept override + { + is_called_ = true; + state_ = state; + reason_ = std::string{reason}; + } + + bool is_called_ = false; + http_client::SessionState state_ = static_cast(-1); + std::string reason_; +}; + +TEST_F(BasicCurlHttpTests, GzipCompressibleData) +{ + received_requests_.clear(); + auto session_manager = http_client::HttpClientFactory::Create(); + EXPECT_TRUE(session_manager != nullptr); + + auto session = session_manager->CreateSession("http://127.0.0.1:19000"); + auto request = session->CreateRequest(); + request->SetUri("post/"); + request->SetMethod(http_client::Method::Post); + + const auto original_size = 500UL; + http_client::Body body(original_size); + std::iota(body.begin(), body.end(), 0); + request->SetBody(body); + request->AddHeader("Content-Type", "text/plain"); + request->SetCompression(opentelemetry::ext::http::client::Compression::kGzip); + auto handler = std::make_shared(); + session->SendRequest(handler); + ASSERT_TRUE(waitForRequests(30, 1)); + session->FinishSession(); + ASSERT_TRUE(handler->is_called_); + ASSERT_EQ(handler->state_, http_client::SessionState::Response); + ASSERT_TRUE(handler->reason_.empty()); + + auto http_request = + dynamic_cast(request.get()); + ASSERT_TRUE(http_request != nullptr); + ASSERT_LT(http_request->body_.size(), original_size); + + session_manager->CancelAllSessions(); + session_manager->FinishAllSessions(); +} + +TEST_F(BasicCurlHttpTests, GzipIncompressibleData) +{ + received_requests_.clear(); + auto session_manager = http_client::HttpClientFactory::Create(); + EXPECT_TRUE(session_manager != nullptr); + + auto session = session_manager->CreateSession("http://127.0.0.1:19000"); + auto request = session->CreateRequest(); + request->SetUri("post/"); + request->SetMethod(http_client::Method::Post); + + // Random data generated using code snippet below. + // const auto original_size = 500UL; + // http_client::Body body(original_size); + // std::random_device rd; + // std::mt19937 gen(rd()); + // std::uniform_int_distribution<> uid(1, 255); + // std::generate(body.begin(), body.end(), [&]() { return uid(gen); }); + + // The input values are fixed to make the test repeatable in the event that some distributions + // might yield results that are, in fact, compressible. + http_client::Body body = { + 140, 198, 12, 56, 165, 185, 173, 20, 13, 83, 127, 223, 77, 38, 224, 43, 236, 10, 178, + 75, 169, 157, 136, 199, 74, 30, 148, 195, 51, 30, 225, 21, 121, 219, 7, 155, 198, 121, + 205, 102, 80, 38, 132, 202, 45, 229, 206, 90, 150, 202, 53, 221, 54, 37, 172, 90, 238, + 248, 191, 240, 109, 227, 248, 41, 251, 121, 35, 226, 107, 122, 15, 242, 203, 45, 64, 195, + 186, 23, 1, 158, 61, 196, 182, 26, 201, 47, 211, 241, 251, 209, 255, 170, 181, 192, 89, + 133, 176, 60, 178, 97, 168, 223, 152, 9, 118, 98, 169, 240, 170, 15, 13, 161, 24, 57, + 123, 117, 230, 30, 244, 117, 238, 255, 198, 232, 95, 148, 37, 61, 67, 103, 31, 240, 52, + 21, 145, 175, 201, 86, 19, 61, 228, 76, 131, 185, 111, 149, 203, 143, 16, 142, 95, 173, + 42, 106, 39, 203, 116, 235, 20, 162, 112, 173, 112, 70, 126, 191, 210, 219, 90, 145, 126, + 118, 43, 241, 101, 66, 175, 179, 5, 233, 208, 164, 180, 83, 214, 194, 173, 29, 179, 149, + 75, 202, 17, 152, 139, 130, 94, 247, 142, 249, 159, 224, 205, 131, 93, 82, 186, 226, 210, + 84, 17, 212, 155, 61, 226, 103, 152, 37, 3, 193, 216, 219, 203, 101, 99, 33, 59, 38, + 106, 62, 232, 127, 44, 125, 90, 169, 148, 238, 34, 106, 12, 221, 90, 173, 67, 122, 232, + 161, 89, 198, 43, 241, 195, 248, 219, 35, 47, 200, 11, 227, 168, 246, 243, 103, 38, 17, + 203, 237, 203, 158, 204, 89, 231, 19, 24, 25, 199, 160, 233, 43, 117, 144, 196, 117, 152, + 42, 121, 189, 217, 202, 221, 250, 157, 237, 47, 29, 64, 32, 10, 32, 243, 28, 114, 158, + 228, 102, 36, 191, 139, 217, 161, 162, 186, 19, 141, 212, 49, 1, 239, 153, 107, 249, 31, + 235, 138, 73, 80, 58, 152, 15, 149, 50, 42, 84, 75, 95, 82, 56, 86, 143, 45, 214, + 11, 184, 164, 181, 249, 74, 184, 26, 207, 165, 162, 240, 154, 90, 56, 175, 72, 4, 166, + 188, 78, 232, 87, 243, 50, 59, 62, 175, 213, 210, 182, 31, 123, 91, 118, 98, 249, 23, + 170, 240, 228, 236, 121, 87, 132, 129, 250, 41, 227, 204, 250, 147, 145, 109, 149, 210, 21, + 174, 165, 127, 234, 64, 211, 52, 93, 126, 117, 231, 216, 210, 15, 16, 2, 167, 215, 178, + 104, 245, 119, 211, 235, 120, 135, 202, 117, 150, 101, 94, 201, 136, 179, 205, 167, 212, 236, + 7, 178, 132, 228, 65, 230, 90, 171, 109, 31, 83, 31, 210, 123, 136, 76, 186, 81, 205, + 63, 35, 21, 121, 152, 22, 242, 199, 106, 217, 199, 211, 206, 165, 88, 77, 112, 108, 193, + 122, 8, 193, 74, 91, 50, 6, 156, 185, 165, 15, 92, 116, 3, 18, 244, 165, 191, 2, + 183, 9, 164, 116, 75, 127}; + const auto original_size = body.size(); + + request->SetBody(body); + request->AddHeader("Content-Type", "text/plain"); + request->SetCompression(opentelemetry::ext::http::client::Compression::kGzip); + auto handler = std::make_shared(); + session->SendRequest(handler); + ASSERT_TRUE(waitForRequests(30, 1)); + session->FinishSession(); + ASSERT_TRUE(handler->is_called_); + ASSERT_EQ(handler->state_, http_client::SessionState::Response); + ASSERT_TRUE(handler->reason_.empty()); + + auto http_request = + dynamic_cast(request.get()); + ASSERT_TRUE(http_request != nullptr); + ASSERT_EQ(http_request->body_.size(), original_size); + + session_manager->CancelAllSessions(); + session_manager->FinishAllSessions(); +} +#endif // ENABLE_OTLP_COMPRESSION_PREVIEW diff --git a/sdk/include/opentelemetry/sdk/common/attribute_utils.h b/sdk/include/opentelemetry/sdk/common/attribute_utils.h index 86b507a66b..c2d0209a7d 100644 --- a/sdk/include/opentelemetry/sdk/common/attribute_utils.h +++ b/sdk/include/opentelemetry/sdk/common/attribute_utils.h @@ -105,6 +105,60 @@ struct AttributeConverter } }; +/** + * Evaluates if an owned value (from an OwnedAttributeValue) is equal to another value (from a + * non-owning AttributeValue). This only supports the checking equality with + * nostd::visit(AttributeEqualToVisitor, OwnedAttributeValue, AttributeValue). + */ +struct AttributeEqualToVisitor +{ + // Different types are not equal including containers of different element types + template + bool operator()(const T &, const U &) const noexcept + { + return false; + } + + // Compare the same arithmetic types + template + bool operator()(const T &owned_value, const T &value) const noexcept + { + return owned_value == value; + } + + // Compare std::string and const char* + bool operator()(const std::string &owned_value, const char *value) const noexcept + { + return owned_value == value; + } + + // Compare std::string and nostd::string_view + bool operator()(const std::string &owned_value, nostd::string_view value) const noexcept + { + return owned_value == value; + } + + // Compare std::vector and nostd::span + bool operator()(const std::vector &owned_value, + const nostd::span &value) const noexcept + { + return owned_value.size() == value.size() && + std::equal(owned_value.begin(), owned_value.end(), value.begin(), + [](const std::string &owned_element, nostd::string_view element) { + return owned_element == element; + }); + } + + // Compare nostd::span and std::vector for arithmetic types + template + bool operator()(const std::vector &owned_value, + const nostd::span &value) const noexcept + { + return owned_value.size() == value.size() && + std::equal(owned_value.begin(), owned_value.end(), value.begin()); + } +}; + /** * Class for storing attributes. */ @@ -162,8 +216,37 @@ class AttributeMap : public std::unordered_map (*this)[std::string(key)] = nostd::visit(converter_, value); } + // Compare the attributes of this map with another KeyValueIterable + bool EqualTo(const opentelemetry::common::KeyValueIterable &attributes) const noexcept + { + if (attributes.size() != this->size()) + { + return false; + } + + const bool is_equal = attributes.ForEachKeyValue( + [this](nostd::string_view key, + const opentelemetry::common::AttributeValue &value) noexcept { + // Perform a linear search to find the key assuming the map is small + // This avoids temporary string creation from this->find(std::string(key)) + for (const auto &kv : *this) + { + if (kv.first == key) + { + // Order of arguments is important here. OwnedAttributeValue is first then + // AttributeValue AttributeEqualToVisitor does not support the reverse order + return nostd::visit(equal_to_visitor_, kv.second, value); + } + } + return false; + }); + + return is_equal; + } + private: AttributeConverter converter_; + AttributeEqualToVisitor equal_to_visitor_; }; /** diff --git a/sdk/include/opentelemetry/sdk/instrumentationscope/instrumentation_scope.h b/sdk/include/opentelemetry/sdk/instrumentationscope/instrumentation_scope.h index 1bf0facaa6..68e9d10d40 100644 --- a/sdk/include/opentelemetry/sdk/instrumentationscope/instrumentation_scope.h +++ b/sdk/include/opentelemetry/sdk/instrumentationscope/instrumentation_scope.h @@ -103,7 +103,8 @@ class InstrumentationScope */ bool operator==(const InstrumentationScope &other) const noexcept { - return equal(other.name_, other.version_, other.schema_url_); + return this->name_ == other.name_ && this->version_ == other.version_ && + this->schema_url_ == other.schema_url_ && this->attributes_ == other.attributes_; } /** @@ -112,14 +113,31 @@ class InstrumentationScope * @param name name of the instrumentation scope to compare. * @param version version of the instrumentation scope to compare. * @param schema_url schema url of the telemetry emitted by the scope. + * @param attributes attributes of the instrumentation scope to compare. * @returns true if name and version in this instrumentation scope are equal with the given name * and version. */ bool equal(const nostd::string_view name, const nostd::string_view version, - const nostd::string_view schema_url = "") const noexcept + const nostd::string_view schema_url = "", + const opentelemetry::common::KeyValueIterable *attributes = nullptr) const noexcept { - return this->name_ == name && this->version_ == version && this->schema_url_ == schema_url; + + if (this->name_ != name || this->version_ != version || this->schema_url_ != schema_url) + { + return false; + } + + if (attributes == nullptr) + { + if (attributes_.empty()) + { + return true; + } + return false; + } + + return attributes_.EqualTo(*attributes); } const std::string &GetName() const noexcept { return name_; } diff --git a/sdk/src/logs/logger_provider.cc b/sdk/src/logs/logger_provider.cc index 14febdf721..da282ab655 100644 --- a/sdk/src/logs/logger_provider.cc +++ b/sdk/src/logs/logger_provider.cc @@ -80,7 +80,7 @@ opentelemetry::nostd::shared_ptr LoggerProvider::Ge { auto &logger_lib = logger->GetInstrumentationScope(); if (logger->GetName() == logger_name && - logger_lib.equal(library_name, library_version, schema_url)) + logger_lib.equal(library_name, library_version, schema_url, &attributes)) { return opentelemetry::nostd::shared_ptr{logger}; } diff --git a/sdk/src/metrics/meter_provider.cc b/sdk/src/metrics/meter_provider.cc index 1c70fc2ed3..6856dac3a1 100644 --- a/sdk/src/metrics/meter_provider.cc +++ b/sdk/src/metrics/meter_provider.cc @@ -71,7 +71,7 @@ nostd::shared_ptr MeterProvider::GetMeter( for (auto &meter : context_->GetMeters()) { auto meter_lib = meter->GetInstrumentationScope(); - if (meter_lib->equal(name, version, schema_url)) + if (meter_lib->equal(name, version, schema_url, attributes)) { return nostd::shared_ptr{meter}; } diff --git a/sdk/src/trace/tracer_provider.cc b/sdk/src/trace/tracer_provider.cc index 6a26e13914..81bd7e6f11 100644 --- a/sdk/src/trace/tracer_provider.cc +++ b/sdk/src/trace/tracer_provider.cc @@ -101,7 +101,7 @@ nostd::shared_ptr TracerProvider::GetTracer( for (auto &tracer : tracers_) { auto &tracer_scope = tracer->GetInstrumentationScope(); - if (tracer_scope.equal(name, version, schema_url)) + if (tracer_scope.equal(name, version, schema_url, attributes)) { return nostd::shared_ptr{tracer}; } diff --git a/sdk/test/common/attribute_utils_test.cc b/sdk/test/common/attribute_utils_test.cc index 9b1f6bd56e..da303643d0 100644 --- a/sdk/test/common/attribute_utils_test.cc +++ b/sdk/test/common/attribute_utils_test.cc @@ -2,11 +2,14 @@ // SPDX-License-Identifier: Apache-2.0 #include +#include #include #include #include #include "opentelemetry/common/key_value_iterable_view.h" +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/variant.h" #include "opentelemetry/sdk/common/attribute_utils.h" @@ -55,3 +58,132 @@ TEST(OrderedAttributeMapTest, AttributesConstruction) EXPECT_EQ(opentelemetry::nostd::get(attribute_map.GetAttributes().at(keys[i])), values[i]); } } + +TEST(AttributeEqualToVisitorTest, AttributeValueEqualTo) +{ + namespace sdk = opentelemetry::sdk::common; + namespace api = opentelemetry::common; + namespace nostd = opentelemetry::nostd; + + using AV = api::AttributeValue; + using OV = sdk::OwnedAttributeValue; + + sdk::AttributeEqualToVisitor equal_to_visitor; + + // arithmetic types + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{bool(true)}, AV{bool(true)})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{int32_t(22)}, AV{int32_t(22)})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{int64_t(22)}, AV{int64_t(22)})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{uint32_t(22)}, AV{uint32_t(22)})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{uint64_t(22)}, AV{uint64_t(22)})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{double(22.0)}, AV{double(22.0)})); + + // string types + EXPECT_TRUE(opentelemetry::nostd::visit( + equal_to_visitor, OV{std::string("string to const char*")}, AV{"string to const char*"})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, + OV{std::string("string to string_view")}, + AV{nostd::string_view("string to string_view")})); + + // container types + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{true, false}}, + AV{std::array{true, false}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33, 44}}, + AV{std::array{33, 44}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33, 44}}, + AV{std::array{33, 44}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33, 44}}, + AV{std::array{33, 44}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33, 44}}, + AV{std::array{33, 44}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33, 44}}, + AV{std::array{33, 44}})); + EXPECT_TRUE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{33.0, 44.0}}, + AV{std::array{33.0, 44.0}})); + EXPECT_TRUE(opentelemetry::nostd::visit( + equal_to_visitor, OV{std::vector{"a string", "another string"}}, + AV{std::array{"a string", "another string"}})); +} + +TEST(AttributeEqualToVisitorTest, AttributeValueNotEqualTo) +{ + namespace sdk = opentelemetry::sdk::common; + namespace api = opentelemetry::common; + namespace nostd = opentelemetry::nostd; + + using AV = api::AttributeValue; + using OV = sdk::OwnedAttributeValue; + + sdk::AttributeEqualToVisitor equal_to_visitor; + + // check different values of the same type + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{bool(true)}, AV{bool(false)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{int32_t(22)}, AV{int32_t(33)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{int64_t(22)}, AV{int64_t(33)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{uint32_t(22)}, AV{uint32_t(33)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{double(22.2)}, AV{double(33.3)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::string("string one")}, + AV{"another string"})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::string("string one")}, + AV{nostd::string_view("another string")})); + + // check different value types + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{bool(true)}, AV{uint32_t(1)})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{int32_t(22)}, AV{uint32_t(22)})); + + // check containers of different element values + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{true, false}}, + AV{std::array{false, true}})); + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{22, 33}}, + AV{std::array{33, 44}})); + EXPECT_FALSE(opentelemetry::nostd::visit( + equal_to_visitor, OV{std::vector{"a string", "another string"}}, + AV{std::array{"a string", "a really different string"}})); + + // check containers of different element types + EXPECT_FALSE(opentelemetry::nostd::visit(equal_to_visitor, OV{std::vector{22, 33}}, + AV{std::array{22, 33}})); +} + +TEST(AttributeMapTest, EqualTo) +{ + using Attributes = std::initializer_list< + std::pair>; + + // check for case where both are empty + Attributes attributes_empty = {}; + auto kv_iterable_empty = + opentelemetry::common::MakeKeyValueIterableView(attributes_empty); + opentelemetry::sdk::common::AttributeMap attribute_map_empty(kv_iterable_empty); + EXPECT_TRUE(attribute_map_empty.EqualTo(kv_iterable_empty)); + + // check for equality with a range of attributes and types + Attributes attributes = {{"key0", "some value"}, {"key1", 1}, {"key2", 2.0}, {"key3", true}}; + auto kv_iterable_match = opentelemetry::common::MakeKeyValueIterableView(attributes); + opentelemetry::sdk::common::AttributeMap attribute_map(attributes); + EXPECT_TRUE(attribute_map.EqualTo(kv_iterable_match)); + + // check for several cases where the attributes are different + Attributes attributes_different_value = { + {"key0", "some value"}, {"key1", 1}, {"key2", 2.0}, {"key3", false}}; + Attributes attributes_different_type = { + {"key0", "some value"}, {"key1", 1.0}, {"key2", 2.0}, {"key3", true}}; + Attributes attributes_different_size = {{"key0", "some value"}}; + + // check for the case where the number of attributes is the same but all keys are different + Attributes attributes_different_all = {{"a", "b"}, {"c", "d"}, {"e", 4.0}, {"f", uint8_t(5)}}; + + auto kv_iterable_different_value = + opentelemetry::common::MakeKeyValueIterableView(attributes_different_value); + auto kv_iterable_different_type = + opentelemetry::common::MakeKeyValueIterableView(attributes_different_type); + auto kv_iterable_different_size = + opentelemetry::common::MakeKeyValueIterableView(attributes_different_size); + auto kv_iterable_different_all = + opentelemetry::common::MakeKeyValueIterableView(attributes_different_all); + + EXPECT_FALSE(attribute_map.EqualTo(kv_iterable_different_value)); + EXPECT_FALSE(attribute_map.EqualTo(kv_iterable_different_type)); + EXPECT_FALSE(attribute_map.EqualTo(kv_iterable_different_size)); + EXPECT_FALSE(attribute_map.EqualTo(kv_iterable_different_all)); +} diff --git a/sdk/test/instrumentationscope/instrumentationscope_test.cc b/sdk/test/instrumentationscope/instrumentationscope_test.cc index da00ec8e93..347e107aca 100644 --- a/sdk/test/instrumentationscope/instrumentationscope_test.cc +++ b/sdk/test/instrumentationscope/instrumentationscope_test.cc @@ -208,3 +208,99 @@ TEST(InstrumentationScope, LegacyInstrumentationLibrary) EXPECT_EQ(instrumentation_library->GetVersion(), library_version); EXPECT_EQ(instrumentation_library->GetSchemaURL(), schema_url); } + +TEST(InstrumentationScope, Equal) +{ + using Attributes = std::initializer_list< + std::pair>; + Attributes attributes_empty = {}; + Attributes attributes_match = { + {"key0", "some value"}, {"key1", 1}, {"key2", 2.0}, {"key3", true}}; + Attributes attributes_different = {{"key42", "some other"}}; + + auto kv_iterable_empty = + opentelemetry::common::MakeKeyValueIterableView(attributes_empty); + auto kv_iterable_match = + opentelemetry::common::MakeKeyValueIterableView(attributes_match); + auto kv_iterable_different = + opentelemetry::common::MakeKeyValueIterableView(attributes_different); + + // try with no attributes added to the instrumentation scope + auto instrumentation_scope = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name", "library_version", "schema_url"); + + // the instrumentation scope is equal if all parameters are equal (must handle nullptr attributes + // or empty attributes) + EXPECT_TRUE(instrumentation_scope->equal("library_name", "library_version", "schema_url")); + EXPECT_TRUE( + instrumentation_scope->equal("library_name", "library_version", "schema_url", nullptr)); + EXPECT_TRUE(instrumentation_scope->equal("library_name", "library_version", "schema_url", + &kv_iterable_empty)); + + // the instrumentation scope is not equal if any parameter is different + EXPECT_FALSE(instrumentation_scope->equal("library_name", "")); + EXPECT_FALSE(instrumentation_scope->equal("library_name", "library_version", "")); + EXPECT_FALSE(instrumentation_scope->equal("library_name", "library_version", "schema_url", + &kv_iterable_different)); + + // try with attributes added to the instrumentation scope + auto instrumentation_scope_w_attributes = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name", "library_version", "schema_url", attributes_match); + + // the instrumentation scope is equal if all parameters including all attribute keys, types, and + // values are equal + EXPECT_TRUE(instrumentation_scope_w_attributes->equal("library_name", "library_version", + "schema_url", &kv_iterable_match)); + EXPECT_FALSE(instrumentation_scope_w_attributes->equal("library_name", "library_version", + "schema_url", nullptr)); + EXPECT_FALSE(instrumentation_scope_w_attributes->equal("library_name", "library_version", + "schema_url", &kv_iterable_empty)); + EXPECT_FALSE(instrumentation_scope_w_attributes->equal("library_name", "library_version", + "schema_url", &kv_iterable_different)); +} + +TEST(InstrumentationScope, OperatorEqual) +{ + using Attributes = std::initializer_list< + std::pair>; + Attributes attributes_empty = {}; + Attributes attributes_match = { + {"key0", "some value"}, {"key1", 1}, {"key2", 2.0}, {"key3", true}}; + Attributes attributes_different = {{"key42", "some other"}}; + + auto instrumentation_scope_1a = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name", "library_version", "schema_url"); + + auto instrumentation_scope_1b = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name", "library_version", "schema_url"); + + auto instrumentation_scope_2a = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name_2", "library_version", "schema_url"); + + auto instrumentation_scope_2b = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name_2", "library_version", "schema_url", attributes_empty); + + auto instrumentation_scope_3a = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name_2", "library_version", "schema_url", attributes_match); + + auto instrumentation_scope_3b = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name_2", "library_version", "schema_url", attributes_match); + + auto instrumentation_scope_4 = + opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create( + "library_name_2", "library_version", "schema_url", attributes_different); + + EXPECT_EQ(*instrumentation_scope_1a, *instrumentation_scope_1b); + EXPECT_FALSE(*instrumentation_scope_1a == *instrumentation_scope_2a); + EXPECT_EQ(*instrumentation_scope_2a, *instrumentation_scope_2b); + EXPECT_EQ(*instrumentation_scope_3a, *instrumentation_scope_3b); + EXPECT_FALSE(*instrumentation_scope_3a == *instrumentation_scope_4); +} diff --git a/sdk/test/logs/logger_provider_sdk_test.cc b/sdk/test/logs/logger_provider_sdk_test.cc index a5a3d3a68a..edddf2ef96 100644 --- a/sdk/test/logs/logger_provider_sdk_test.cc +++ b/sdk/test/logs/logger_provider_sdk_test.cc @@ -129,7 +129,7 @@ TEST(LoggerProviderSDK, EventLoggerProviderFactory) auto event_logger = elp->CreateEventLogger(logger1, "otel-cpp.test"); } -TEST(LoggerPviderSDK, LoggerEquityCheck) +TEST(LoggerProviderSDK, LoggerEqualityCheck) { auto lp = std::shared_ptr(new LoggerProvider()); nostd::string_view schema_url{"https://opentelemetry.io/schemas/1.11.0"}; @@ -141,6 +141,48 @@ TEST(LoggerPviderSDK, LoggerEquityCheck) auto logger3 = lp->GetLogger("logger3"); auto another_logger3 = lp->GetLogger("logger3"); EXPECT_EQ(logger3, another_logger3); + + auto logger4 = lp->GetLogger("logger4", "opentelelemtry_library", "1.0.0", schema_url); + auto another_logger4 = lp->GetLogger("logger4", "opentelelemtry_library", "1.0.0", schema_url); + EXPECT_EQ(logger4, another_logger4); + + auto logger5 = + lp->GetLogger("logger5", "opentelelemtry_library", "1.0.0", schema_url, {{"key", "value"}}); + auto another_logger5 = + lp->GetLogger("logger5", "opentelelemtry_library", "1.0.0", schema_url, {{"key", "value"}}); + EXPECT_EQ(logger5, another_logger5); +} + +TEST(LoggerProviderSDK, GetLoggerInequalityCheck) +{ + auto lp = std::shared_ptr(new LoggerProvider()); + auto logger_library_1 = lp->GetLogger("logger1", "library_1"); + auto logger_library_2 = lp->GetLogger("logger1", "library_2"); + auto logger_version_1 = lp->GetLogger("logger1", "library_1", "1.0.0"); + auto logger_version_2 = lp->GetLogger("logger1", "library_1", "2.0.0"); + auto logger_url_1 = lp->GetLogger("logger1", "library_1", "1.0.0", "url_1"); + auto logger_url_2 = lp->GetLogger("logger1", "library_1", "1.0.0", "url_2"); + auto logger_attribute_1 = + lp->GetLogger("logger1", "library_1", "1.0.0", "url_1", {{"key", "one"}}); + auto logger_attribute_2 = + lp->GetLogger("logger1", "library_1", "1.0.0", "url_1", {{"key", "two"}}); + + // different scope names should return distinct loggers + EXPECT_NE(logger_library_1, logger_library_2); + + // different scope versions should return distinct loggers + EXPECT_NE(logger_version_1, logger_library_1); + EXPECT_NE(logger_version_1, logger_version_2); + + // different scope schema urls should return distinct loggers + EXPECT_NE(logger_url_1, logger_library_1); + EXPECT_NE(logger_url_1, logger_version_1); + EXPECT_NE(logger_url_1, logger_url_2); + + // different scope attributes should return distinct loggers + EXPECT_NE(logger_attribute_1, logger_library_1); + EXPECT_NE(logger_attribute_1, logger_url_1); + EXPECT_NE(logger_attribute_1, logger_attribute_2); } class DummyLogRecordable final : public opentelemetry::sdk::logs::Recordable diff --git a/sdk/test/metrics/meter_provider_sdk_test.cc b/sdk/test/metrics/meter_provider_sdk_test.cc index 36cb28c228..ee8a8a88c6 100644 --- a/sdk/test/metrics/meter_provider_sdk_test.cc +++ b/sdk/test/metrics/meter_provider_sdk_test.cc @@ -12,6 +12,7 @@ #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/meter.h" #include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider_factory.h" #include "opentelemetry/sdk/metrics/metric_reader.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry/sdk/metrics/view/instrument_selector.h" @@ -239,3 +240,74 @@ TEST(MeterProvider, RemoveMeter) mp.Shutdown(); } #endif /* OPENTELEMETRY_ABI_VERSION_NO >= 2 */ + +TEST(MeterProvider, GetMeterEqualityCheck) +{ + auto provider = MeterProviderFactory::Create(); + + // providing the same scope names should return the same Meter + auto meter_library_1a = provider->GetMeter("library_name"); + auto meter_library_1b = provider->GetMeter("library_name"); + EXPECT_EQ(meter_library_1a, meter_library_1b); + + // providing the same scope name and version should return the same meter + auto meter_version_1a = provider->GetMeter("library_name", "v1.0"); + auto meter_version_1b = provider->GetMeter("library_name", "v1.0"); + EXPECT_EQ(meter_version_1a, meter_version_1b); + + // providing the same name, version, and schema urls should return the same meter + auto meter_urla = provider->GetMeter("library_name", "v1.0", "url"); + auto meter_urlb = provider->GetMeter("library_name", "v1.0", "url"); + EXPECT_EQ(meter_urla, meter_urlb); +} + +TEST(MeterProvider, GetMeterInequalityCheck) +{ + auto provider = MeterProviderFactory::Create(); + + auto meter_library_1 = provider->GetMeter("library_1"); + auto meter_library_2 = provider->GetMeter("library_2"); + auto meter_version_1 = provider->GetMeter("library_1", "v1.0"); + auto meter_version_2 = provider->GetMeter("library_1", "v2.0"); + auto meter_url_1 = provider->GetMeter("library_1", "v1.0", "url_1"); + auto meter_url_2 = provider->GetMeter("library_1", "v1.0", "url_2"); + + // different scope names should return distinct meters + EXPECT_NE(meter_library_1, meter_library_2); + + // different scope versions should return distinct meters + EXPECT_NE(meter_version_1, meter_library_1); + EXPECT_NE(meter_version_1, meter_version_2); + + // different scope schema urls should return distinct meters + EXPECT_NE(meter_url_1, meter_library_1); + EXPECT_NE(meter_url_1, meter_version_1); + EXPECT_NE(meter_url_1, meter_url_2); +} + +#if OPENTELEMETRY_ABI_VERSION_NO >= 2 + +TEST(MeterProvider, GetMeterEqualityCheckAbiv2) +{ + auto provider = MeterProviderFactory::Create(); + + // providing the same name, version, schema url and attributes should return the same meter + auto meter_attribute1a = provider->GetMeter("library_name", "v1.0", "url", {{"key", "one"}}); + auto meter_attribute1b = provider->GetMeter("library_name", "v1.0", "url", {{"key", "one"}}); + EXPECT_EQ(meter_attribute1a, meter_attribute1b); +} + +TEST(MeterProvider, GetMeterInequalityCheckAbiv2) +{ + auto provider = MeterProviderFactory::Create(); + + auto meter_1 = provider->GetMeter("library_name", "v1.0", "url"); + auto meter_attribute_1 = provider->GetMeter("library_name", "v1.0", "url", {{"key", "one"}}); + auto meter_attribute_2 = provider->GetMeter("library_name", "v1.0", "url", {{"key", "two"}}); + + // different scope attributes should return distinct meters + EXPECT_NE(meter_attribute_1, meter_1); + EXPECT_NE(meter_attribute_1, meter_attribute_2); +} + +#endif /* OPENTELEMETRY_ABI_VERSION_NO >= 2 */ diff --git a/sdk/test/trace/tracer_provider_test.cc b/sdk/test/trace/tracer_provider_test.cc index fa3afa2690..8bdad908ad 100644 --- a/sdk/test/trace/tracer_provider_test.cc +++ b/sdk/test/trace/tracer_provider_test.cc @@ -19,9 +19,11 @@ #include "opentelemetry/sdk/trace/sampler.h" #include "opentelemetry/sdk/trace/samplers/always_off.h" #include "opentelemetry/sdk/trace/simple_processor.h" +#include "opentelemetry/sdk/trace/simple_processor_factory.h" #include "opentelemetry/sdk/trace/tracer.h" #include "opentelemetry/sdk/trace/tracer_context.h" #include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/sdk/trace/tracer_provider_factory.h" using namespace opentelemetry::sdk::trace; using namespace opentelemetry::sdk::resource; @@ -89,7 +91,80 @@ TEST(TracerProvider, GetTracer) ASSERT_EQ(instrumentation_scope3.GetVersion(), "1.0.0"); } +TEST(TracerProvider, GetTracerEqualityCheck) +{ + auto processor = SimpleSpanProcessorFactory::Create(nullptr); + auto provider = TracerProviderFactory::Create(std::move(processor)); + + // providing the same scope names should return the same tracer + auto tracer_1a = provider->GetTracer("library_name"); + auto tracer_1b = provider->GetTracer("library_name"); + EXPECT_EQ(tracer_1a, tracer_1b); + + // providing the same scope name and version should return the same tracer + auto tracer_version1a = provider->GetTracer("library_name", "v1.0"); + auto tracer_version1b = provider->GetTracer("library_name", "v1.0"); + EXPECT_EQ(tracer_version1a, tracer_version1b); + + // providing the same name, version, and schema urls should return the same tracer + auto tracer_urla = provider->GetTracer("library_name", "v1.0", "url"); + auto tracer_urlb = provider->GetTracer("library_name", "v1.0", "url"); + EXPECT_EQ(tracer_urla, tracer_urlb); +} + +TEST(TracerProvider, GetTracerInequalityCheck) +{ + auto processor = SimpleSpanProcessorFactory::Create(nullptr); + auto provider = TracerProviderFactory::Create(std::move(processor)); + + auto tracer_library_1 = provider->GetTracer("library_1"); + auto tracer_library_2 = provider->GetTracer("library_2"); + auto tracer_version_1 = provider->GetTracer("library_1", "v1.0"); + auto tracer_version_2 = provider->GetTracer("library_1", "v2.0"); + auto tracer_url_1 = provider->GetTracer("library_1", "v1.0", "url_1"); + auto tracer_url_2 = provider->GetTracer("library_1", "v1.0", "url_2"); + + // different scope names should return distinct tracers + EXPECT_NE(tracer_library_1, tracer_library_2); + + // different scope versions should return distinct tracers + EXPECT_NE(tracer_version_1, tracer_library_1); + EXPECT_NE(tracer_version_1, tracer_version_2); + + // different scope schema urls should return distinct tracers + EXPECT_NE(tracer_url_1, tracer_library_1); + EXPECT_NE(tracer_url_1, tracer_version_1); + EXPECT_NE(tracer_url_1, tracer_url_2); +} + #if OPENTELEMETRY_ABI_VERSION_NO >= 2 + +TEST(TracerProvider, GetTracerEqualityCheckAbiv2) +{ + auto processor = SimpleSpanProcessorFactory::Create(nullptr); + auto provider = TracerProviderFactory::Create(std::move(processor)); + + auto tracer_attribute1a = provider->GetTracer("library_name", "v1.0", "url", {{"key", "one"}}); + auto tracer_attribute1b = provider->GetTracer("library_name", "v1.0", "url", {{"key", "one"}}); + + // providing the same name, version, schema url and attributes should return the same tracer + EXPECT_EQ(tracer_attribute1a, tracer_attribute1b); +} + +TEST(TracerProvider, GetTracerInequalityCheckAbiv2) +{ + auto processor = SimpleSpanProcessorFactory::Create(nullptr); + auto provider = TracerProviderFactory::Create(std::move(processor)); + + auto tracer_1 = provider->GetTracer("library_name", "v1.0", "url"); + auto tracer_attribute1 = provider->GetTracer("library_name", "v1.0", "url", {{"key", "one"}}); + auto tracer_attribute2 = provider->GetTracer("library_name", "v1.0", "url", {{"key", "two"}}); + + // different scope attributes should return distinct tracers + EXPECT_NE(tracer_attribute1, tracer_1); + EXPECT_NE(tracer_attribute1, tracer_attribute2); +} + TEST(TracerProvider, GetTracerAbiv2) { std::unique_ptr processor(new SimpleSpanProcessor(nullptr));