diff --git a/.bazelversion b/.bazelversion index 6aba2b245a..ade65226e0 100644 --- a/.bazelversion +++ b/.bazelversion @@ -1 +1 @@ -4.2.0 +5.4.1 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 82e200fd35..17465af27d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -366,6 +366,22 @@ jobs: sudo ./ci/setup_grpc.sh ./ci/do_ci.sh cmake.do_not_install.test + cmake_otprotocol_shared_libs_with_static_grpc_test: + name: CMake test (build shared libraries with otlp-exporter and static gRPC) + runs-on: ubuntu-20.04 + steps: + - uses: actions/checkout@v3 + with: + submodules: 'recursive' + - name: setup + run: | + sudo ./ci/setup_cmake.sh + sudo ./ci/setup_ci_environment.sh + - name: run otlp exporter tests + run: | + sudo ./ci/setup_grpc.sh -T + ./ci/do_ci.sh cmake.exporter.otprotocol.shared_libs.with_static_grpc.test + plugin_test: name: Plugin -> CMake runs-on: ubuntu-latest diff --git a/CHANGELOG.md b/CHANGELOG.md index dd8051e359..d7c7f88120 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,26 @@ Increment the: ## [Unreleased] +* [SDK] SDK support for the new OTel log + [#2123](https://github.com/open-telemetry/opentelemetry-cpp/pull/2123) +* [BUILD] Build break with old curl, macro CURL_VERSION_BITS unknown + [#2102](https://github.com/open-telemetry/opentelemetry-cpp/pull/2102) +* [BUILD] Add opentelemetry_proto_grpc and allow build shared opentelemetry_proto + and opentelemetry_proto_grpc on non-Windows platform. + [#2097](https://github.com/open-telemetry/opentelemetry-cpp/pull/2097) +* [API] Add user facing Logging API and Benchmarks + [#2094](https://github.com/open-telemetry/opentelemetry-cpp/pull/2094) + +Breaking changes: + +* Add opentelemetry_proto_grpc and move gRPC sources into it. + [#2097](https://github.com/open-telemetry/opentelemetry-cpp/pull/2097) + * There will be no breaking changes for users who only use OTLP exporters and + do not directly use opentelemetry-cpp::proto. However, it is important to + note that `opentelemetry-cpp::proto` no longer contains generated gRPC codes + , and all components that depend on these gRPC codes should also link to + `opentelemetry-cpp::proto_grpc`. + Deprecations: * The Jaeger Exporter is deprecated, see [DEPRECATED](./DEPRECATED.md) for details. @@ -462,7 +482,7 @@ update the semantic convention in instrumentation library is needed. * [BUILD] Don't require applications using jaeger exporter to know about libcurl [#1518](https://github.com/open-telemetry/opentelemetry-cpp/pull/1518) * [EXPORTER] Inline print_value() in ostream exporter [#1512](https://github.com/open-telemetry/opentelemetry-cpp/pull/1512) -* [SDK] fix: urlPaser will incorrect parsing url like "http://abc.com/xxx@xxx/a/b" +* [SDK] fix: urlPaser will incorrect parsing url like `http://abc.com/xxx@xxx/a/b` [#1511](https://github.com/open-telemetry/opentelemetry-cpp/pull/1511) * [SDK] Rename `InstrumentationLibrary` to `InstrumentationScope` [#1507](https://github.com/open-telemetry/opentelemetry-cpp/pull/1507) * [BUILD] Try to build nlohmann-json only it's depended. [#1505](https://github.com/open-telemetry/opentelemetry-cpp/pull/1505) diff --git a/CMakeLists.txt b/CMakeLists.txt index eef100f164..dbfb6a209d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -161,6 +161,13 @@ endif() option(WITH_OTLP "Whether to include the OpenTelemetry Protocol in the SDK" OFF) +if(WITH_OTLP) + message( + WARNING + "WITH_OTLP is deprecated and will be removed in future. Please set either WITH_OTLP_GRPC or WITH_OTLP_HTTP, or even both." + ) +endif() + option(WITH_OTLP_HTTP "Whether to include the OTLP http exporter in the SDK" OFF) @@ -188,6 +195,13 @@ option(OTELCPP_MAINTAINER_MODE "Build in maintainer mode (-Wall -Werror)" OFF) option(WITH_OPENTRACING "Whether to include the Opentracing shim" OFF) +option(OTELCPP_VERSIONED_LIBS "Whether to generate the versioned shared libs" + OFF) + +if(OTELCPP_VERSIONED_LIBS AND NOT BUILD_SHARED_LIBS) + message(FATAL_ERROR "OTELCPP_VERSIONED_LIBS=ON requires BUILD_SHARED_LIBS=ON") +endif() + set(OTELCPP_PROTO_PATH "" CACHE PATH "Path to opentelemetry-proto") @@ -267,6 +281,14 @@ function(install_windows_deps) PARENT_SCOPE) endfunction() +function(set_target_version target_name) + if(OTELCPP_VERSIONED_LIBS) + set_target_properties( + ${target_name} PROPERTIES VERSION ${OPENTELEMETRY_VERSION} + SOVERSION ${OPENTELEMETRY_ABI_VERSION_NO}) + endif() +endfunction() + if(WITH_JAEGER) if(WITH_NO_DEPRECATED_CODE) message(FATAL_ERROR "Jaeger is DEPRECATED.") diff --git a/README.md b/README.md index 9166fa690e..dd90c97221 100644 --- a/README.md +++ b/README.md @@ -98,13 +98,13 @@ For edit access, get in touch on * [Ehsan Saei](https://github.com/esigo) * [Lalit Kumar Bhasin](https://github.com/lalitb), Microsoft +* [Marc Alff](https://github.com/marcalff), Oracle * [Tom Tan](https://github.com/ThomsonTan), Microsoft [Approvers](https://github.com/open-telemetry/community/blob/main/community-membership.md#approver) ([@open-telemetry/cpp-approvers](https://github.com/orgs/open-telemetry/teams/cpp-approvers)): * [Josh Suereth](https://github.com/jsuereth), Google -* [Marc Alff](https://github.com/marcalff), Oracle * [Reiley Yang](https://github.com/reyang), Microsoft * [WenTao Ou](https://github.com/owent), Tencent diff --git a/api/include/opentelemetry/baggage/baggage.h b/api/include/opentelemetry/baggage/baggage.h index 66a77ed941..66eb9d9833 100644 --- a/api/include/opentelemetry/baggage/baggage.h +++ b/api/include/opentelemetry/baggage/baggage.h @@ -26,14 +26,12 @@ class OPENTELEMETRY_EXPORT Baggage static constexpr char kMembersSeparator = ','; static constexpr char kMetadataSeparator = ';'; - Baggage() noexcept : kv_properties_(new opentelemetry::common::KeyValueProperties()) {} - Baggage(size_t size) noexcept - : kv_properties_(new opentelemetry::common::KeyValueProperties(size)) - {} + Baggage() noexcept : kv_properties_(new common::KeyValueProperties()) {} + Baggage(size_t size) noexcept : kv_properties_(new common::KeyValueProperties(size)) {} template Baggage(const T &keys_and_values) noexcept - : kv_properties_(new opentelemetry::common::KeyValueProperties(keys_and_values)) + : kv_properties_(new common::KeyValueProperties(keys_and_values)) {} OPENTELEMETRY_API_SINGLETON static nostd::shared_ptr GetDefault() @@ -293,7 +291,7 @@ class OPENTELEMETRY_EXPORT Baggage private: // Store entries in a C-style array to avoid using std::array or std::vector. - nostd::unique_ptr kv_properties_; + nostd::unique_ptr kv_properties_; }; } // namespace baggage diff --git a/api/include/opentelemetry/baggage/baggage_context.h b/api/include/opentelemetry/baggage/baggage_context.h index 9a92bac77f..e5b9556d3f 100644 --- a/api/include/opentelemetry/baggage/baggage_context.h +++ b/api/include/opentelemetry/baggage/baggage_context.h @@ -15,22 +15,19 @@ namespace baggage static const std::string kBaggageHeader = "baggage"; -inline nostd::shared_ptr GetBaggage( - const opentelemetry::context::Context &context) noexcept +inline nostd::shared_ptr GetBaggage(const context::Context &context) noexcept { context::ContextValue context_value = context.GetValue(kBaggageHeader); - if (nostd::holds_alternative>(context_value)) + if (nostd::holds_alternative>(context_value)) { - return nostd::get>(context_value); + return nostd::get>(context_value); } - static nostd::shared_ptr empty_baggage{ - new opentelemetry::baggage::Baggage()}; + static nostd::shared_ptr empty_baggage{new Baggage()}; return empty_baggage; } -inline context::Context SetBaggage( - opentelemetry::context::Context &context, - nostd::shared_ptr baggage) noexcept +inline context::Context SetBaggage(context::Context &context, + nostd::shared_ptr baggage) noexcept { return context.SetValue(kBaggageHeader, baggage); } diff --git a/api/include/opentelemetry/baggage/propagation/baggage_propagator.h b/api/include/opentelemetry/baggage/propagation/baggage_propagator.h index 3de60860b2..6de32882c0 100644 --- a/api/include/opentelemetry/baggage/propagation/baggage_propagator.h +++ b/api/include/opentelemetry/baggage/propagation/baggage_propagator.h @@ -14,13 +14,13 @@ namespace baggage namespace propagation { -class BaggagePropagator : public opentelemetry::context::propagation::TextMapPropagator +class BaggagePropagator : public context::propagation::TextMapPropagator { public: - void Inject(opentelemetry::context::propagation::TextMapCarrier &carrier, - const opentelemetry::context::Context &context) noexcept override + void Inject(context::propagation::TextMapCarrier &carrier, + const context::Context &context) noexcept override { - auto baggage = opentelemetry::baggage::GetBaggage(context); + auto baggage = baggage::GetBaggage(context); auto header = baggage->ToHeader(); if (header.size()) { @@ -28,15 +28,15 @@ class BaggagePropagator : public opentelemetry::context::propagation::TextMapPro } } - context::Context Extract(const opentelemetry::context::propagation::TextMapCarrier &carrier, - opentelemetry::context::Context &context) noexcept override + context::Context Extract(const context::propagation::TextMapCarrier &carrier, + context::Context &context) noexcept override { - nostd::string_view baggage_str = carrier.Get(opentelemetry::baggage::kBaggageHeader); - auto baggage = opentelemetry::baggage::Baggage::FromHeader(baggage_str); + nostd::string_view baggage_str = carrier.Get(baggage::kBaggageHeader); + auto baggage = baggage::Baggage::FromHeader(baggage_str); if (baggage->ToHeader().size()) { - return opentelemetry::baggage::SetBaggage(context, baggage); + return baggage::SetBaggage(context, baggage); } else { diff --git a/api/include/opentelemetry/common/key_value_iterable.h b/api/include/opentelemetry/common/key_value_iterable.h index 732d361e7b..9d43e1571b 100644 --- a/api/include/opentelemetry/common/key_value_iterable.h +++ b/api/include/opentelemetry/common/key_value_iterable.h @@ -5,6 +5,7 @@ #include "opentelemetry/common/attribute_value.h" #include "opentelemetry/nostd/function_ref.h" +#include "opentelemetry/nostd/string_view.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE diff --git a/api/include/opentelemetry/common/key_value_iterable_view.h b/api/include/opentelemetry/common/key_value_iterable_view.h index daea8fce2e..fb1a6ea019 100644 --- a/api/include/opentelemetry/common/key_value_iterable_view.h +++ b/api/include/opentelemetry/common/key_value_iterable_view.h @@ -4,10 +4,10 @@ #pragma once #include -#include #include #include "opentelemetry/common/key_value_iterable.h" +#include "opentelemetry/nostd/function_ref.h" #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/type_traits.h" diff --git a/api/include/opentelemetry/common/kv_properties.h b/api/include/opentelemetry/common/kv_properties.h index 96442021b5..00fa2571c2 100644 --- a/api/include/opentelemetry/common/kv_properties.h +++ b/api/include/opentelemetry/common/kv_properties.h @@ -6,7 +6,6 @@ #include "opentelemetry/common/key_value_iterable_view.h" #include "opentelemetry/common/string_util.h" #include "opentelemetry/nostd/function_ref.h" -#include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/version.h" diff --git a/api/include/opentelemetry/common/macros.h b/api/include/opentelemetry/common/macros.h index 323e5cdc04..dd40c63bfa 100644 --- a/api/include/opentelemetry/common/macros.h +++ b/api/include/opentelemetry/common/macros.h @@ -10,6 +10,7 @@ # define OPENTELEMETRY_LIKELY_IF(...) \ if (__VA_ARGS__) \ [[likely]] + # endif # endif #endif @@ -176,6 +177,31 @@ point. #endif +// +// Atomic wrappers based on compiler intrinsics for memory read/write. +// The tailing number is read/write length in bits. +// +// N.B. Compiler instrinsic is used because the usage of C++ standard library is restricted in the +// OpenTelemetry C++ API. +// +#if defined(__GNUC__) + +# define OPENTELEMETRY_ATOMIC_READ_8(ptr) __atomic_load_n(ptr, __ATOMIC_SEQ_CST) +# define OPENTELEMETRY_ATOMIC_WRITE_8(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_SEQ_CST) + +#elif defined(_MSC_VER) + +# include + +# define OPENTELEMETRY_ATOMIC_READ_8(ptr) \ + static_cast(_InterlockedCompareExchange8(reinterpret_cast(ptr), 0, 0)) +# define OPENTELEMETRY_ATOMIC_WRITE_8(ptr, value) \ + _InterlockedExchange8(reinterpret_cast(ptr), static_cast(value)) + +#else +# error port atomics read/write for the current platform +#endif + /* clang-format on */ // // The if/elif order matters here. If both OPENTELEMETRY_BUILD_IMPORT_DLL and diff --git a/api/include/opentelemetry/common/string_util.h b/api/include/opentelemetry/common/string_util.h index 6dce79f1ba..a7070a0acd 100644 --- a/api/include/opentelemetry/common/string_util.h +++ b/api/include/opentelemetry/common/string_util.h @@ -4,6 +4,7 @@ #pragma once #include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace common diff --git a/api/include/opentelemetry/common/timestamp.h b/api/include/opentelemetry/common/timestamp.h index da8765b9bc..14aa457b5b 100644 --- a/api/include/opentelemetry/common/timestamp.h +++ b/api/include/opentelemetry/common/timestamp.h @@ -3,7 +3,6 @@ #pragma once -#include #include #include diff --git a/api/include/opentelemetry/context/context.h b/api/include/opentelemetry/context/context.h index 923b396c7f..d0b53c3ea8 100644 --- a/api/include/opentelemetry/context/context.h +++ b/api/include/opentelemetry/context/context.h @@ -7,6 +7,7 @@ #include "opentelemetry/context/context_value.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace context diff --git a/api/include/opentelemetry/context/context_value.h b/api/include/opentelemetry/context/context_value.h index 013b3a4608..27bd40fb05 100644 --- a/api/include/opentelemetry/context/context_value.h +++ b/api/include/opentelemetry/context/context_value.h @@ -5,16 +5,22 @@ #include -#include "opentelemetry/baggage/baggage.h" #include "opentelemetry/nostd/shared_ptr.h" -#include "opentelemetry/nostd/span.h" -#include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/nostd/variant.h" -#include "opentelemetry/trace/span.h" -#include "opentelemetry/trace/span_context.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE +namespace baggage +{ +class Baggage; +} // namespace baggage + +namespace trace +{ +class Span; +class SpanContext; +} // namespace trace + namespace context { using ContextValue = nostd::variant #include #include + #include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace context diff --git a/api/include/opentelemetry/context/propagation/global_propagator.h b/api/include/opentelemetry/context/propagation/global_propagator.h index 460764a74d..a62146e100 100644 --- a/api/include/opentelemetry/context/propagation/global_propagator.h +++ b/api/include/opentelemetry/context/propagation/global_propagator.h @@ -6,7 +6,6 @@ #include #include "opentelemetry/context/propagation/noop_propagator.h" -#include "opentelemetry/context/propagation/text_map_propagator.h" #include "opentelemetry/common/macros.h" #include "opentelemetry/common/spin_lock_mutex.h" @@ -20,6 +19,8 @@ namespace context namespace propagation { +class TextMapPropagator; + /* Stores the singleton TextMapPropagator */ class OPENTELEMETRY_EXPORT GlobalTextMapPropagator diff --git a/api/include/opentelemetry/context/propagation/text_map_propagator.h b/api/include/opentelemetry/context/propagation/text_map_propagator.h index bb0c6d8022..21bc293616 100644 --- a/api/include/opentelemetry/context/propagation/text_map_propagator.h +++ b/api/include/opentelemetry/context/propagation/text_map_propagator.h @@ -3,8 +3,8 @@ #pragma once -#include #include "opentelemetry/context/context.h" +#include "opentelemetry/nostd/function_ref.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/version.h" diff --git a/api/include/opentelemetry/context/runtime_context.h b/api/include/opentelemetry/context/runtime_context.h index bec96a9af4..2cd5b0ff90 100644 --- a/api/include/opentelemetry/context/runtime_context.h +++ b/api/include/opentelemetry/context/runtime_context.h @@ -5,6 +5,10 @@ #include "opentelemetry/common/macros.h" #include "opentelemetry/context/context.h" +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace context diff --git a/api/include/opentelemetry/logs/event_id.h b/api/include/opentelemetry/logs/event_id.h new file mode 100644 index 0000000000..60d020827c --- /dev/null +++ b/api/include/opentelemetry/logs/event_id.h @@ -0,0 +1,40 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#ifdef ENABLE_LOGS_PREVIEW + +# include + +# include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/nostd/unique_ptr.h" +# include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace logs +{ + +/** + * EventId class which acts the Id of the event with an optional name. + */ +class EventId +{ +public: + EventId(int64_t id, nostd::string_view name) noexcept : id_{id} + { + name_ = nostd::unique_ptr{new char[name.length() + 1]}; + std::copy(name.begin(), name.end(), name_.get()); + name_.get()[name.length()] = 0; + } + + EventId(int64_t id) noexcept : id_{id}, name_{nullptr} {} + +public: + int64_t id_; + nostd::unique_ptr name_; +}; + +} // namespace logs +OPENTELEMETRY_END_NAMESPACE +#endif diff --git a/api/include/opentelemetry/logs/event_logger.h b/api/include/opentelemetry/logs/event_logger.h index 654c6f6c69..c87997816b 100644 --- a/api/include/opentelemetry/logs/event_logger.h +++ b/api/include/opentelemetry/logs/event_logger.h @@ -4,15 +4,9 @@ #pragma once #ifdef ENABLE_LOGS_PREVIEW -# include -# include -# include - -# include "opentelemetry/common/macros.h" # include "opentelemetry/logs/log_record.h" # include "opentelemetry/logs/logger.h" # include "opentelemetry/logs/logger_type_traits.h" -# include "opentelemetry/logs/severity.h" # include "opentelemetry/nostd/shared_ptr.h" # include "opentelemetry/nostd/string_view.h" # include "opentelemetry/nostd/unique_ptr.h" diff --git a/api/include/opentelemetry/logs/event_logger_provider.h b/api/include/opentelemetry/logs/event_logger_provider.h index 8692222c10..06170dccab 100644 --- a/api/include/opentelemetry/logs/event_logger_provider.h +++ b/api/include/opentelemetry/logs/event_logger_provider.h @@ -4,16 +4,17 @@ #pragma once #ifdef ENABLE_LOGS_PREVIEW -# include "opentelemetry/common/key_value_iterable.h" -# include "opentelemetry/common/key_value_iterable_view.h" -# include "opentelemetry/logs/event_logger.h" -# include "opentelemetry/logs/logger.h" # include "opentelemetry/nostd/shared_ptr.h" # include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace logs { + +class EventLogger; +class Logger; + /** * Creates new EventLogger instances. */ diff --git a/api/include/opentelemetry/logs/log_record.h b/api/include/opentelemetry/logs/log_record.h index 7fb51c2d99..1014a880bc 100644 --- a/api/include/opentelemetry/logs/log_record.h +++ b/api/include/opentelemetry/logs/log_record.h @@ -5,17 +5,22 @@ #ifdef ENABLE_LOGS_PREVIEW # include "opentelemetry/common/attribute_value.h" -# include "opentelemetry/common/key_value_iterable.h" # include "opentelemetry/common/timestamp.h" -# include "opentelemetry/logs/severity.h" -# include "opentelemetry/trace/span_id.h" -# include "opentelemetry/trace/trace_flags.h" -# include "opentelemetry/trace/trace_id.h" # include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE +namespace trace +{ +class SpanId; +class TraceId; +class TraceFlags; +} // namespace trace + namespace logs { + +enum class Severity : uint8_t; + /** * Maintains a representation of a log in a format that can be processed by a recorder. * @@ -30,25 +35,25 @@ class LogRecord * Set the timestamp for this log. * @param timestamp the timestamp to set */ - virtual void SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept = 0; + virtual void SetTimestamp(common::SystemTimestamp timestamp) noexcept = 0; /** * Set the observed timestamp for this log. * @param timestamp the timestamp to set */ - virtual void SetObservedTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept = 0; + virtual void SetObservedTimestamp(common::SystemTimestamp timestamp) noexcept = 0; /** * Set the severity for this log. * @param severity the severity of the event */ - virtual void SetSeverity(opentelemetry::logs::Severity severity) noexcept = 0; + virtual void SetSeverity(logs::Severity severity) noexcept = 0; /** * Set body field for this log. * @param message the body to set */ - virtual void SetBody(const opentelemetry::common::AttributeValue &message) noexcept = 0; + virtual void SetBody(const common::AttributeValue &message) noexcept = 0; /** * Set an attribute of a log. @@ -56,25 +61,33 @@ class LogRecord * @param value the attribute value */ virtual void SetAttribute(nostd::string_view key, - const opentelemetry::common::AttributeValue &value) noexcept = 0; + const common::AttributeValue &value) noexcept = 0; + + /** + * Set the Event Id. + * @param id The event id to set + * @param name Optional event name to set + */ + // TODO: mark this as pure virtual once all exporters have been updated + virtual void SetEventId(int64_t id, nostd::string_view name = {}) noexcept = 0; /** * Set the trace id for this log. * @param trace_id the trace id to set */ - virtual void SetTraceId(const opentelemetry::trace::TraceId &trace_id) noexcept = 0; + virtual void SetTraceId(const trace::TraceId &trace_id) noexcept = 0; /** * Set the span id for this log. * @param span_id the span id to set */ - virtual void SetSpanId(const opentelemetry::trace::SpanId &span_id) noexcept = 0; + virtual void SetSpanId(const trace::SpanId &span_id) noexcept = 0; /** * Inject trace_flags for this log. * @param trace_flags the trace flags to set */ - virtual void SetTraceFlags(const opentelemetry::trace::TraceFlags &trace_flags) noexcept = 0; + virtual void SetTraceFlags(const trace::TraceFlags &trace_flags) noexcept = 0; }; } // namespace logs OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/logs/logger.h b/api/include/opentelemetry/logs/logger.h index 23aea11143..d991a13d88 100644 --- a/api/include/opentelemetry/logs/logger.h +++ b/api/include/opentelemetry/logs/logger.h @@ -4,8 +4,6 @@ #pragma once #ifdef ENABLE_LOGS_PREVIEW -# include "opentelemetry/common/key_value_iterable.h" -# include "opentelemetry/logs/log_record.h" # include "opentelemetry/logs/logger_type_traits.h" # include "opentelemetry/logs/severity.h" # include "opentelemetry/nostd/string_view.h" @@ -13,8 +11,17 @@ # include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE +namespace common +{ +class KeyValueIterable; +} // namespace common + namespace logs { + +class EventId; +class LogRecord; + /** * Handles log record creation. **/ @@ -246,10 +253,225 @@ class Logger this->EmitLogRecord(Severity::kFatal, std::forward(args)...); } + // + // OpenTelemetry C++ user-facing Logs API + // + + inline bool Enabled(Severity severity, const EventId &event_id) const noexcept + { + OPENTELEMETRY_LIKELY_IF(Enabled(severity) == false) { return false; } + return EnabledImplementation(severity, event_id); + } + + inline bool Enabled(Severity severity, int64_t event_id) const noexcept + { + OPENTELEMETRY_LIKELY_IF(Enabled(severity) == false) { return false; } + return EnabledImplementation(severity, event_id); + } + + inline bool Enabled(Severity severity) const noexcept + { + return static_cast(severity) >= OPENTELEMETRY_ATOMIC_READ_8(&minimum_severity_); + } + + /** + * Log an event + * + * @severity severity of the log + * @event_id event identifier of the log + * @format an utf-8 string following https://messagetemplates.org/ + * @attributes key value pairs of the log + */ + virtual void Log(Severity severity, + const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->EmitLogRecord(severity, event_id, format, attributes); + } + + virtual void Log(Severity severity, + int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->EmitLogRecord(severity, EventId{event_id}, format, attributes); + } + + virtual void Log(Severity severity, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->EmitLogRecord(severity, format, attributes); + } + + virtual void Log(Severity severity, nostd::string_view message) noexcept + { + this->EmitLogRecord(severity, message); + } + + // Convenient wrappers based on virtual methods Log(). + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#field-severitynumber + + inline void Trace(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kTrace, event_id, format, attributes); + } + + inline void Trace(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kTrace, EventId{event_id}, format, attributes); + } + + inline void Trace(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kTrace, format, attributes); + } + + inline void Trace(nostd::string_view message) noexcept { this->Log(Severity::kTrace, message); } + + inline void Debug(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kDebug, event_id, format, attributes); + } + + inline void Debug(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kDebug, EventId{event_id}, format, attributes); + } + + inline void Debug(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kDebug, format, attributes); + } + + inline void Debug(nostd::string_view message) noexcept { this->Log(Severity::kDebug, message); } + + inline void Info(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kInfo, event_id, format, attributes); + } + + inline void Info(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kInfo, EventId{event_id}, format, attributes); + } + + inline void Info(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kInfo, format, attributes); + } + + inline void Info(nostd::string_view message) noexcept { this->Log(Severity::kInfo, message); } + + inline void Warn(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kWarn, event_id, format, attributes); + } + + inline void Warn(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kWarn, EventId{event_id}, format, attributes); + } + + inline void Warn(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kWarn, format, attributes); + } + + inline void Warn(nostd::string_view message) noexcept { this->Log(Severity::kWarn, message); } + + inline void Error(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kError, event_id, format, attributes); + } + + inline void Error(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kError, EventId{event_id}, format, attributes); + } + + inline void Error(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kError, format, attributes); + } + + inline void Error(nostd::string_view message) noexcept { this->Log(Severity::kError, message); } + + inline void Fatal(const EventId &event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kFatal, event_id, format, attributes); + } + + inline void Fatal(int64_t event_id, + nostd::string_view format, + const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kFatal, EventId{event_id}, format, attributes); + } + + inline void Fatal(nostd::string_view format, const common::KeyValueIterable &attributes) noexcept + { + this->Log(Severity::kFatal, format, attributes); + } + + inline void Fatal(nostd::string_view message) noexcept { this->Log(Severity::kFatal, message); } + + // + // End of OpenTelemetry C++ user-facing Log API. + // + +protected: + // TODO: discuss with community about naming for internal methods. + virtual bool EnabledImplementation(Severity /*severity*/, + const EventId & /*event_id*/) const noexcept + { + return false; + } + + virtual bool EnabledImplementation(Severity /*severity*/, int64_t /*event_id*/) const noexcept + { + return false; + } + + void SetMinimumSeverity(uint8_t severity_or_max) noexcept + { + OPENTELEMETRY_ATOMIC_WRITE_8(&minimum_severity_, severity_or_max); + } + private: template void IgnoreTraitResult(ValueType &&...) {} + + // + // minimum_severity_ can be updated concurrently by multiple threads/cores, so race condition on + // read/write should be handled. And std::atomic can not be used here because it is not ABI + // compatible for OpenTelemetry C++ API. + // + mutable uint8_t minimum_severity_{kMaxSeverity}; }; } // namespace logs OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/logs/logger_provider.h b/api/include/opentelemetry/logs/logger_provider.h index 7979ab202a..89723725b8 100644 --- a/api/include/opentelemetry/logs/logger_provider.h +++ b/api/include/opentelemetry/logs/logger_provider.h @@ -7,13 +7,18 @@ # include "opentelemetry/common/key_value_iterable.h" # include "opentelemetry/common/key_value_iterable_view.h" -# include "opentelemetry/logs/logger.h" # include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/nostd/span.h" # include "opentelemetry/nostd/string_view.h" +# include "opentelemetry/nostd/type_traits.h" +# include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace logs { + +class Logger; + /** * Creates new Logger instances. */ @@ -35,7 +40,7 @@ class OPENTELEMETRY_EXPORT LoggerProvider virtual nostd::shared_ptr GetLogger( nostd::string_view logger_name, - nostd::string_view library_name, + nostd::string_view library_name = "", nostd::string_view library_version = "", nostd::string_view schema_url = "", bool include_trace_context = true, diff --git a/api/include/opentelemetry/logs/logger_type_traits.h b/api/include/opentelemetry/logs/logger_type_traits.h index 8736c03f7f..b1e5e560d3 100644 --- a/api/include/opentelemetry/logs/logger_type_traits.h +++ b/api/include/opentelemetry/logs/logger_type_traits.h @@ -10,13 +10,11 @@ # include "opentelemetry/common/attribute_value.h" # include "opentelemetry/common/key_value_iterable.h" # include "opentelemetry/common/timestamp.h" +# include "opentelemetry/logs/event_id.h" # include "opentelemetry/logs/log_record.h" # include "opentelemetry/logs/severity.h" -# include "opentelemetry/nostd/shared_ptr.h" -# include "opentelemetry/nostd/span.h" # include "opentelemetry/nostd/string_view.h" # include "opentelemetry/nostd/type_traits.h" -# include "opentelemetry/nostd/unique_ptr.h" # include "opentelemetry/trace/span_context.h" # include "opentelemetry/trace/span_id.h" # include "opentelemetry/trace/trace_flags.h" @@ -43,6 +41,18 @@ struct LogRecordSetterTrait } }; +template <> +struct LogRecordSetterTrait +{ + template + inline static LogRecord *Set(LogRecord *log_record, ArgumentType &&arg) noexcept + { + log_record->SetEventId(arg.id_, nostd::string_view{arg.name_.get()}); + + return log_record; + } +}; + template <> struct LogRecordSetterTrait { diff --git a/api/include/opentelemetry/logs/noop.h b/api/include/opentelemetry/logs/noop.h index 5061003274..ed4ba64bc7 100644 --- a/api/include/opentelemetry/logs/noop.h +++ b/api/include/opentelemetry/logs/noop.h @@ -9,28 +9,21 @@ // This file is part of the internal implementation of OpenTelemetry. Nothing in this file should be // used directly. Please refer to logger.h for documentation on these interfaces. -# include - -# include "opentelemetry/common/attribute_value.h" -# include "opentelemetry/common/key_value_iterable.h" -# include "opentelemetry/common/timestamp.h" -# include "opentelemetry/context/runtime_context.h" +# include "opentelemetry/logs/event_logger.h" # include "opentelemetry/logs/event_logger_provider.h" # include "opentelemetry/logs/logger.h" # include "opentelemetry/logs/logger_provider.h" -# include "opentelemetry/logs/severity.h" # include "opentelemetry/nostd/shared_ptr.h" -# include "opentelemetry/nostd/span.h" # include "opentelemetry/nostd/string_view.h" # include "opentelemetry/nostd/unique_ptr.h" -# include "opentelemetry/trace/span_id.h" -# include "opentelemetry/trace/trace_flags.h" -# include "opentelemetry/trace/trace_id.h" -# include "opentelemetry/version.h" - # include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE +namespace common +{ +class KeyValueIterable; +} // namespace common + namespace logs { /** @@ -52,13 +45,10 @@ class NoopLogger final : public Logger /** * No-op implementation of a LoggerProvider. */ -class NoopLoggerProvider final : public opentelemetry::logs::LoggerProvider +class NoopLoggerProvider final : public LoggerProvider { public: - NoopLoggerProvider() - : logger_{ - nostd::shared_ptr(new opentelemetry::logs::NoopLogger)} - {} + NoopLoggerProvider() : logger_{nostd::shared_ptr(new NoopLogger())} {} nostd::shared_ptr GetLogger(nostd::string_view /* logger_name */, nostd::string_view /* library_name */, @@ -71,7 +61,7 @@ class NoopLoggerProvider final : public opentelemetry::logs::LoggerProvider } private: - nostd::shared_ptr logger_; + nostd::shared_ptr logger_; }; class NoopEventLogger final : public EventLogger diff --git a/api/include/opentelemetry/logs/provider.h b/api/include/opentelemetry/logs/provider.h index e361c1e670..a33b26dbac 100644 --- a/api/include/opentelemetry/logs/provider.h +++ b/api/include/opentelemetry/logs/provider.h @@ -8,14 +8,17 @@ # include "opentelemetry/common/macros.h" # include "opentelemetry/common/spin_lock_mutex.h" -# include "opentelemetry/logs/event_logger_provider.h" -# include "opentelemetry/logs/logger_provider.h" # include "opentelemetry/logs/noop.h" # include "opentelemetry/nostd/shared_ptr.h" +# include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace logs { + +class EventLoggerProvider; +class LoggerProvider; + /** * Stores the singleton global LoggerProvider. */ diff --git a/api/include/opentelemetry/logs/severity.h b/api/include/opentelemetry/logs/severity.h index 9fcf457b26..8534ce7508 100644 --- a/api/include/opentelemetry/logs/severity.h +++ b/api/include/opentelemetry/logs/severity.h @@ -13,36 +13,41 @@ namespace logs /** * Severity Levels assigned to log events, based on Log Data Model, * with the addition of kInvalid (mapped to a severity number of 0). + * + * See + * https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#field-severitynumber */ enum class Severity : uint8_t { - kInvalid, - kTrace, - kTrace2, - kTrace3, - kTrace4, - kDebug, - kDebug2, - kDebug3, - kDebug4, - kInfo, - kInfo2, - kInfo3, - kInfo4, - kWarn, - kWarn2, - kWarn3, - kWarn4, - kError, - kError2, - kError3, - kError4, - kFatal, - kFatal2, - kFatal3, - kFatal4 + kInvalid = 0, + kTrace = 1, + kTrace2 = 2, + kTrace3 = 3, + kTrace4 = 4, + kDebug = 5, + kDebug2 = 6, + kDebug3 = 7, + kDebug4 = 8, + kInfo = 9, + kInfo2 = 10, + kInfo3 = 11, + kInfo4 = 12, + kWarn = 13, + kWarn2 = 14, + kWarn3 = 15, + kWarn4 = 16, + kError = 17, + kError2 = 18, + kError3 = 19, + kError4 = 20, + kFatal = 21, + kFatal2 = 22, + kFatal3 = 23, + kFatal4 = 24 }; +const uint8_t kMaxSeverity = 255; + /** * Mapping of the severity enum above, to a severity text string (in all caps). * This severity text can be printed out by exporters. Capital letters follow the @@ -51,7 +56,7 @@ enum class Severity : uint8_t * Included to follow the specification's recommendation to print both * severity number and text in each log record. */ -const opentelemetry::nostd::string_view SeverityNumToText[25] = { +const nostd::string_view SeverityNumToText[25] = { "INVALID", "TRACE", "TRACE2", "TRACE3", "TRACE4", "DEBUG", "DEBUG2", "DEBUG3", "DEBUG4", "INFO", "INFO2", "INFO3", "INFO4", "WARN", "WARN2", "WARN3", "WARN4", "ERROR", "ERROR2", "ERROR3", "ERROR4", "FATAL", "FATAL2", "FATAL3", "FATAL4"}; diff --git a/api/include/opentelemetry/metrics/async_instruments.h b/api/include/opentelemetry/metrics/async_instruments.h index 6e6d5012c4..f73eb2f51b 100644 --- a/api/include/opentelemetry/metrics/async_instruments.h +++ b/api/include/opentelemetry/metrics/async_instruments.h @@ -4,6 +4,7 @@ #pragma once #include "opentelemetry/metrics/observer_result.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics diff --git a/api/include/opentelemetry/metrics/meter.h b/api/include/opentelemetry/metrics/meter.h index 877453884a..8784fe788e 100644 --- a/api/include/opentelemetry/metrics/meter.h +++ b/api/include/opentelemetry/metrics/meter.h @@ -3,10 +3,7 @@ #pragma once -#include "opentelemetry/metrics/async_instruments.h" -#include "opentelemetry/metrics/sync_instruments.h" #include "opentelemetry/nostd/shared_ptr.h" -#include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/version.h" @@ -14,6 +11,18 @@ OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics { + +template +class Counter; + +template +class Histogram; + +template +class UpDownCounter; + +class ObservableInstrument; + /** * Handles instrument creation and provides a facility for batch recording. * diff --git a/api/include/opentelemetry/metrics/meter_provider.h b/api/include/opentelemetry/metrics/meter_provider.h index 4c3306ebf6..654c4022ea 100644 --- a/api/include/opentelemetry/metrics/meter_provider.h +++ b/api/include/opentelemetry/metrics/meter_provider.h @@ -3,13 +3,16 @@ #pragma once -#include "opentelemetry/metrics/meter.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics { + +class Meter; + /** * Creates new Meter instances. */ diff --git a/api/include/opentelemetry/metrics/noop.h b/api/include/opentelemetry/metrics/noop.h index 0d2eacde97..3a754a6e00 100644 --- a/api/include/opentelemetry/metrics/noop.h +++ b/api/include/opentelemetry/metrics/noop.h @@ -23,12 +23,11 @@ class NoopCounter : public Counter nostd::string_view /* unit */) noexcept {} void Add(T /* value */) noexcept override {} - void Add(T /* value */, const opentelemetry::context::Context & /* context */) noexcept override - {} + void Add(T /* value */, const context::Context & /* context */) noexcept override {} void Add(T /* value */, const common::KeyValueIterable & /* attributes */) noexcept override {} void Add(T /* value */, const common::KeyValueIterable & /* attributes */, - const opentelemetry::context::Context & /* context */) noexcept override + const context::Context & /* context */) noexcept override {} }; @@ -40,12 +39,10 @@ class NoopHistogram : public Histogram nostd::string_view /* description */, nostd::string_view /* unit */) noexcept {} - void Record(T /* value */, - const opentelemetry::context::Context & /* context */) noexcept override - {} + void Record(T /* value */, const context::Context & /* context */) noexcept override {} void Record(T /* value */, const common::KeyValueIterable & /* attributes */, - const opentelemetry::context::Context & /* context */) noexcept override + const context::Context & /* context */) noexcept override {} }; @@ -59,12 +56,11 @@ class NoopUpDownCounter : public UpDownCounter {} ~NoopUpDownCounter() override = default; void Add(T /* value */) noexcept override {} - void Add(T /* value */, const opentelemetry::context::Context & /* context */) noexcept override - {} + void Add(T /* value */, const context::Context & /* context */) noexcept override {} void Add(T /* value */, const common::KeyValueIterable & /* attributes */) noexcept override {} void Add(T /* value */, const common::KeyValueIterable & /* attributes */, - const opentelemetry::context::Context & /* context */) noexcept override + const context::Context & /* context */) noexcept override {} }; diff --git a/api/include/opentelemetry/metrics/observer_result.h b/api/include/opentelemetry/metrics/observer_result.h index 88cae28618..56c42bc20e 100644 --- a/api/include/opentelemetry/metrics/observer_result.h +++ b/api/include/opentelemetry/metrics/observer_result.h @@ -9,6 +9,8 @@ #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/type_traits.h" +#include "opentelemetry/nostd/variant.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics diff --git a/api/include/opentelemetry/metrics/provider.h b/api/include/opentelemetry/metrics/provider.h index ea710a4820..b2fa3e20e4 100644 --- a/api/include/opentelemetry/metrics/provider.h +++ b/api/include/opentelemetry/metrics/provider.h @@ -7,13 +7,16 @@ #include "opentelemetry/common/macros.h" #include "opentelemetry/common/spin_lock_mutex.h" -#include "opentelemetry/metrics/meter_provider.h" #include "opentelemetry/metrics/noop.h" #include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics { + +class MeterProvider; + /** * Stores the singleton global MeterProvider. */ diff --git a/api/include/opentelemetry/metrics/sync_instruments.h b/api/include/opentelemetry/metrics/sync_instruments.h index 8db77daae5..b81a412680 100644 --- a/api/include/opentelemetry/metrics/sync_instruments.h +++ b/api/include/opentelemetry/metrics/sync_instruments.h @@ -9,6 +9,7 @@ #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/type_traits.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace metrics @@ -33,7 +34,7 @@ class Counter : public SynchronousInstrument */ virtual void Add(T value) noexcept = 0; - virtual void Add(T value, const opentelemetry::context::Context &context) noexcept = 0; + virtual void Add(T value, const context::Context &context) noexcept = 0; /** * Add adds the value to the counter's sum. The attributes should contain @@ -48,19 +49,19 @@ class Counter : public SynchronousInstrument virtual void Add(T value, const common::KeyValueIterable &attributes, - const opentelemetry::context::Context &context) noexcept = 0; + const context::Context &context) noexcept = 0; template ::value> * = nullptr> void Add(T value, const U &attributes) noexcept { - auto context = opentelemetry::context::Context{}; + auto context = context::Context{}; this->Add(value, common::KeyValueIterableView{attributes}, context); } template ::value> * = nullptr> - void Add(T value, const U &attributes, const opentelemetry::context::Context &context) noexcept + void Add(T value, const U &attributes, const context::Context &context) noexcept { this->Add(value, common::KeyValueIterableView{attributes}, context); } @@ -69,7 +70,7 @@ class Counter : public SynchronousInstrument std::initializer_list> attributes) noexcept { - auto context = opentelemetry::context::Context{}; + auto context = context::Context{}; this->Add(value, nostd::span>{ attributes.begin(), attributes.end()}, @@ -78,7 +79,7 @@ class Counter : public SynchronousInstrument void Add(T value, std::initializer_list> attributes, - const opentelemetry::context::Context &context) noexcept + const context::Context &context) noexcept { this->Add(value, nostd::span>{ @@ -98,7 +99,7 @@ class Histogram : public SynchronousInstrument * * @param value The increment amount. May be positive, negative or zero. */ - virtual void Record(T value, const opentelemetry::context::Context &context) noexcept = 0; + virtual void Record(T value, const context::Context &context) noexcept = 0; /** * Records a value with a set of attributes. @@ -108,11 +109,11 @@ class Histogram : public SynchronousInstrument */ virtual void Record(T value, const common::KeyValueIterable &attributes, - const opentelemetry::context::Context &context) noexcept = 0; + const context::Context &context) noexcept = 0; template ::value> * = nullptr> - void Record(T value, const U &attributes, const opentelemetry::context::Context &context) noexcept + void Record(T value, const U &attributes, const context::Context &context) noexcept { this->Record(value, common::KeyValueIterableView{attributes}, context); } @@ -120,7 +121,7 @@ class Histogram : public SynchronousInstrument void Record( T value, std::initializer_list> attributes, - const opentelemetry::context::Context &context) noexcept + const context::Context &context) noexcept { this->Record(value, nostd::span>{ @@ -142,7 +143,7 @@ class UpDownCounter : public SynchronousInstrument */ virtual void Add(T value) noexcept = 0; - virtual void Add(T value, const opentelemetry::context::Context &context) noexcept = 0; + virtual void Add(T value, const context::Context &context) noexcept = 0; /** * Add a value with a set of attributes. @@ -154,19 +155,19 @@ class UpDownCounter : public SynchronousInstrument virtual void Add(T value, const common::KeyValueIterable &attributes, - const opentelemetry::context::Context &context) noexcept = 0; + const context::Context &context) noexcept = 0; template ::value> * = nullptr> void Add(T value, const U &attributes) noexcept { - auto context = opentelemetry::context::Context{}; + auto context = context::Context{}; this->Add(value, common::KeyValueIterableView{attributes}, context); } template ::value> * = nullptr> - void Add(T value, const U &attributes, const opentelemetry::context::Context &context) noexcept + void Add(T value, const U &attributes, const context::Context &context) noexcept { this->Add(value, common::KeyValueIterableView{attributes}, context); } @@ -175,7 +176,7 @@ class UpDownCounter : public SynchronousInstrument std::initializer_list> attributes) noexcept { - auto context = opentelemetry::context::Context{}; + auto context = context::Context{}; this->Add(value, nostd::span>{ attributes.begin(), attributes.end()}, @@ -184,7 +185,7 @@ class UpDownCounter : public SynchronousInstrument void Add(T value, std::initializer_list> attributes, - const opentelemetry::context::Context &context) noexcept + const context::Context &context) noexcept { this->Add(value, nostd::span>{ diff --git a/api/include/opentelemetry/plugin/detail/dynamic_load_unix.h b/api/include/opentelemetry/plugin/detail/dynamic_load_unix.h index bcc4bd0b87..1d249317a0 100644 --- a/api/include/opentelemetry/plugin/detail/dynamic_load_unix.h +++ b/api/include/opentelemetry/plugin/detail/dynamic_load_unix.h @@ -8,6 +8,8 @@ #include +#include "opentelemetry/plugin/detail/dynamic_library_handle.h" +#include "opentelemetry/plugin/detail/loader_info.h" #include "opentelemetry/plugin/detail/utility.h" #include "opentelemetry/plugin/factory.h" #include "opentelemetry/plugin/hook.h" diff --git a/api/include/opentelemetry/plugin/detail/dynamic_load_windows.h b/api/include/opentelemetry/plugin/detail/dynamic_load_windows.h index 7a586b6bcc..3f5e05f198 100644 --- a/api/include/opentelemetry/plugin/detail/dynamic_load_windows.h +++ b/api/include/opentelemetry/plugin/detail/dynamic_load_windows.h @@ -5,6 +5,8 @@ #include +#include "opentelemetry/plugin/detail/dynamic_library_handle.h" +#include "opentelemetry/plugin/detail/loader_info.h" #include "opentelemetry/plugin/detail/utility.h" #include "opentelemetry/plugin/factory.h" #include "opentelemetry/plugin/hook.h" diff --git a/api/include/opentelemetry/plugin/detail/tracer_handle.h b/api/include/opentelemetry/plugin/detail/tracer_handle.h index 559d7ddf40..46b128106a 100644 --- a/api/include/opentelemetry/plugin/detail/tracer_handle.h +++ b/api/include/opentelemetry/plugin/detail/tracer_handle.h @@ -3,10 +3,14 @@ #pragma once -#include "opentelemetry/trace/tracer.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE +namespace trace +{ +class Tracer; +} // namespace trace + namespace plugin { /** diff --git a/api/include/opentelemetry/plugin/detail/utility.h b/api/include/opentelemetry/plugin/detail/utility.h index 6f8dd5d462..8007f285df 100644 --- a/api/include/opentelemetry/plugin/detail/utility.h +++ b/api/include/opentelemetry/plugin/detail/utility.h @@ -3,10 +3,12 @@ #pragma once -#include +#if __EXCEPTIONS +# include +#endif // __EXCEPTIONS + #include -#include "opentelemetry/nostd/string_view.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE diff --git a/api/include/opentelemetry/plugin/dynamic_load.h b/api/include/opentelemetry/plugin/dynamic_load.h index 8318d534ac..58a69ad5c8 100644 --- a/api/include/opentelemetry/plugin/dynamic_load.h +++ b/api/include/opentelemetry/plugin/dynamic_load.h @@ -3,6 +3,7 @@ #pragma once +#include #include #ifdef _WIN32 @@ -10,12 +11,14 @@ #else # include "opentelemetry/plugin/detail/dynamic_load_unix.h" #endif - #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace plugin { + +class Factory; + /** * Load an OpenTelemetry implementation as a plugin. * @param plugin the path to the plugin to load diff --git a/api/include/opentelemetry/plugin/factory.h b/api/include/opentelemetry/plugin/factory.h index 0a285d65b1..6b484d8f2f 100644 --- a/api/include/opentelemetry/plugin/factory.h +++ b/api/include/opentelemetry/plugin/factory.h @@ -2,6 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 #pragma once + #include #include @@ -39,9 +40,8 @@ class Factory final * @param error_message on failure this will contain an error message. * @return a Tracer on success or nullptr on failure. */ - std::shared_ptr MakeTracer( - nostd::string_view tracer_config, - std::string &error_message) const noexcept + std::shared_ptr MakeTracer(nostd::string_view tracer_config, + std::string &error_message) const noexcept { nostd::unique_ptr plugin_error_message; auto tracer_handle = factory_impl_->MakeTracerHandle(tracer_config, plugin_error_message); @@ -50,8 +50,8 @@ class Factory final detail::CopyErrorMessage(plugin_error_message.get(), error_message); return nullptr; } - return std::shared_ptr{ - new (std::nothrow) Tracer{library_handle_, std::move(tracer_handle)}}; + return std::shared_ptr{new (std::nothrow) + Tracer{library_handle_, std::move(tracer_handle)}}; } private: diff --git a/api/include/opentelemetry/plugin/hook.h b/api/include/opentelemetry/plugin/hook.h index c06c0b3243..c9597e06a0 100644 --- a/api/include/opentelemetry/plugin/hook.h +++ b/api/include/opentelemetry/plugin/hook.h @@ -3,8 +3,7 @@ #pragma once -#include "opentelemetry/plugin/detail/loader_info.h" -#include "opentelemetry/plugin/factory.h" +#include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/version.h" #ifdef _WIN32 @@ -41,6 +40,10 @@ OPENTELEMETRY_BEGIN_NAMESPACE namespace plugin { + +struct LoaderInfo; +class FactoryImpl; + using OpenTelemetryHook = nostd::unique_ptr (*)(const LoaderInfo &loader_info, nostd::unique_ptr &error_message); diff --git a/api/include/opentelemetry/plugin/tracer.h b/api/include/opentelemetry/plugin/tracer.h index df8e542c0c..b87f9e889f 100644 --- a/api/include/opentelemetry/plugin/tracer.h +++ b/api/include/opentelemetry/plugin/tracer.h @@ -6,7 +6,6 @@ #include #include "opentelemetry/common/key_value_iterable.h" -#include "opentelemetry/plugin/detail/dynamic_library_handle.h" #include "opentelemetry/plugin/detail/tracer_handle.h" #include "opentelemetry/trace/tracer.h" #include "opentelemetry/version.h" @@ -14,6 +13,9 @@ OPENTELEMETRY_BEGIN_NAMESPACE namespace plugin { + +class DynamicLibraryHandle; + class Span final : public trace::Span { public: diff --git a/api/include/opentelemetry/std/shared_ptr.h b/api/include/opentelemetry/std/shared_ptr.h index 418d4ef71e..b1b99bd36c 100644 --- a/api/include/opentelemetry/std/shared_ptr.h +++ b/api/include/opentelemetry/std/shared_ptr.h @@ -3,10 +3,10 @@ #pragma once -#include "opentelemetry/version.h" - #include +#include "opentelemetry/version.h" + OPENTELEMETRY_BEGIN_NAMESPACE // Standard Type aliases in nostd namespace namespace nostd diff --git a/api/include/opentelemetry/std/string_view.h b/api/include/opentelemetry/std/string_view.h index 8fd159d3ad..5295eb4544 100644 --- a/api/include/opentelemetry/std/string_view.h +++ b/api/include/opentelemetry/std/string_view.h @@ -3,15 +3,9 @@ #pragma once -#include "opentelemetry/version.h" - -#include "opentelemetry/std/utility.h" - -#include -#include #include -#include -#include + +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE // Standard Type aliases in nostd namespace diff --git a/api/include/opentelemetry/std/type_traits.h b/api/include/opentelemetry/std/type_traits.h index 66308a42a8..f26af95b94 100644 --- a/api/include/opentelemetry/std/type_traits.h +++ b/api/include/opentelemetry/std/type_traits.h @@ -3,10 +3,10 @@ #pragma once -#include "opentelemetry/version.h" - #include +#include "opentelemetry/version.h" + OPENTELEMETRY_BEGIN_NAMESPACE // Standard Type aliases in nostd namespace namespace nostd diff --git a/api/include/opentelemetry/std/unique_ptr.h b/api/include/opentelemetry/std/unique_ptr.h index f15699b676..1d7d9b1fc7 100644 --- a/api/include/opentelemetry/std/unique_ptr.h +++ b/api/include/opentelemetry/std/unique_ptr.h @@ -3,10 +3,10 @@ #pragma once -#include "opentelemetry/version.h" - #include +#include "opentelemetry/version.h" + OPENTELEMETRY_BEGIN_NAMESPACE // Standard Type aliases in nostd namespace namespace nostd diff --git a/api/include/opentelemetry/std/utility.h b/api/include/opentelemetry/std/utility.h index 01cdc18331..9a1c76540b 100644 --- a/api/include/opentelemetry/std/utility.h +++ b/api/include/opentelemetry/std/utility.h @@ -3,11 +3,11 @@ #pragma once -#include "opentelemetry/version.h" - #include #include +#include "opentelemetry/version.h" + OPENTELEMETRY_BEGIN_NAMESPACE // Standard Type aliases in nostd namespace namespace nostd diff --git a/api/include/opentelemetry/trace/context.h b/api/include/opentelemetry/trace/context.h index 0a57e725c1..b68fe9e95a 100644 --- a/api/include/opentelemetry/trace/context.h +++ b/api/include/opentelemetry/trace/context.h @@ -4,6 +4,7 @@ #pragma once #include "opentelemetry/context/context.h" +#include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/trace/default_span.h" #include "opentelemetry/version.h" @@ -12,7 +13,7 @@ namespace trace { // Get Span from explicit context -inline nostd::shared_ptr GetSpan(const opentelemetry::context::Context &context) noexcept +inline nostd::shared_ptr GetSpan(const context::Context &context) noexcept { context::ContextValue span = context.GetValue(kSpanKey); if (nostd::holds_alternative>(span)) @@ -23,8 +24,7 @@ inline nostd::shared_ptr GetSpan(const opentelemetry::context::Context &co } // Set Span into explicit context -inline context::Context SetSpan(opentelemetry::context::Context &context, - nostd::shared_ptr span) noexcept +inline context::Context SetSpan(context::Context &context, nostd::shared_ptr span) noexcept { return context.SetValue(kSpanKey, span); } diff --git a/api/include/opentelemetry/trace/default_span.h b/api/include/opentelemetry/trace/default_span.h index dd1e5475f2..cccc7951ad 100644 --- a/api/include/opentelemetry/trace/default_span.h +++ b/api/include/opentelemetry/trace/default_span.h @@ -2,10 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 #pragma once + #include "opentelemetry/common/attribute_value.h" -#include "opentelemetry/trace/canonical_code.h" +#include "opentelemetry/nostd/string_view.h" #include "opentelemetry/trace/span.h" #include "opentelemetry/trace/span_context.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace diff --git a/api/include/opentelemetry/trace/noop.h b/api/include/opentelemetry/trace/noop.h index 8a9b13b7a1..2a2b7312ba 100644 --- a/api/include/opentelemetry/trace/noop.h +++ b/api/include/opentelemetry/trace/noop.h @@ -7,18 +7,18 @@ // This file is part of the internal implementation of OpenTelemetry. Nothing in this file should be // used directly. Please refer to span.h and tracer.h for documentation on these interfaces. +#include + #include "opentelemetry/context/runtime_context.h" +#include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/trace/span.h" #include "opentelemetry/trace/span_context.h" -#include "opentelemetry/trace/span_context_kv_iterable.h" #include "opentelemetry/trace/tracer.h" #include "opentelemetry/trace/tracer_provider.h" #include "opentelemetry/version.h" -#include - namespace trace_api = opentelemetry::trace; OPENTELEMETRY_BEGIN_NAMESPACE @@ -88,8 +88,7 @@ class OPENTELEMETRY_EXPORT NoopTracer final : public Tracer, { // Don't allocate a no-op span for every StartSpan call, but use a static // singleton for this case. - static nostd::shared_ptr noop_span( - new trace_api::NoopSpan{this->shared_from_this()}); + static nostd::shared_ptr noop_span(new trace::NoopSpan{this->shared_from_this()}); return noop_span; } @@ -102,24 +101,22 @@ class OPENTELEMETRY_EXPORT NoopTracer final : public Tracer, /** * No-op implementation of a TracerProvider. */ -class OPENTELEMETRY_EXPORT NoopTracerProvider final : public opentelemetry::trace::TracerProvider +class OPENTELEMETRY_EXPORT NoopTracerProvider final : public trace::TracerProvider { public: NoopTracerProvider() noexcept - : tracer_{nostd::shared_ptr( - new opentelemetry::trace::NoopTracer)} + : tracer_{nostd::shared_ptr(new trace::NoopTracer)} {} - nostd::shared_ptr GetTracer( - nostd::string_view /* library_name */, - nostd::string_view /* library_version */, - nostd::string_view /* schema_url */) noexcept override + nostd::shared_ptr GetTracer(nostd::string_view /* library_name */, + nostd::string_view /* library_version */, + nostd::string_view /* schema_url */) noexcept override { return tracer_; } private: - nostd::shared_ptr tracer_; + nostd::shared_ptr tracer_; }; } // namespace trace OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/trace/propagation/b3_propagator.h b/api/include/opentelemetry/trace/propagation/b3_propagator.h index d5661cb2a9..e52e42b747 100644 --- a/api/include/opentelemetry/trace/propagation/b3_propagator.h +++ b/api/include/opentelemetry/trace/propagation/b3_propagator.h @@ -3,13 +3,14 @@ #pragma once +#include + #include "detail/hex.h" #include "detail/string.h" #include "opentelemetry/context/propagation/text_map_propagator.h" #include "opentelemetry/trace/context.h" #include "opentelemetry/trace/default_span.h" - -#include +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace @@ -41,11 +42,11 @@ static const int kSpanIdHexStrLength = 16; // providing the object containing the headers, and a getter function for the extraction. Based on: // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/context/api-propagators.md#b3-extract -class B3PropagatorExtractor : public opentelemetry::context::propagation::TextMapPropagator +class B3PropagatorExtractor : public context::propagation::TextMapPropagator { public: // Returns the context that is stored in the HTTP header carrier. - context::Context Extract(const opentelemetry::context::propagation::TextMapCarrier &carrier, + context::Context Extract(const context::propagation::TextMapCarrier &carrier, context::Context &context) noexcept override { SpanContext span_context = ExtractImpl(carrier); @@ -77,7 +78,7 @@ class B3PropagatorExtractor : public opentelemetry::context::propagation::TextMa } private: - static SpanContext ExtractImpl(const opentelemetry::context::propagation::TextMapCarrier &carrier) + static SpanContext ExtractImpl(const context::propagation::TextMapCarrier &carrier) { nostd::string_view trace_id_hex; nostd::string_view span_id_hex; @@ -128,7 +129,7 @@ class B3Propagator : public B3PropagatorExtractor { public: // Sets the context for a HTTP header carrier with self defined rules. - void Inject(opentelemetry::context::propagation::TextMapCarrier &carrier, + void Inject(context::propagation::TextMapCarrier &carrier, const context::Context &context) noexcept override { SpanContext span_context = trace::GetSpan(context)->GetContext(); @@ -160,7 +161,7 @@ class B3Propagator : public B3PropagatorExtractor class B3PropagatorMultiHeader : public B3PropagatorExtractor { public: - void Inject(opentelemetry::context::propagation::TextMapCarrier &carrier, + void Inject(context::propagation::TextMapCarrier &carrier, const context::Context &context) noexcept override { SpanContext span_context = GetSpan(context)->GetContext(); diff --git a/api/include/opentelemetry/trace/propagation/detail/hex.h b/api/include/opentelemetry/trace/propagation/detail/hex.h index 10a17ff51b..c8bd58f8b8 100644 --- a/api/include/opentelemetry/trace/propagation/detail/hex.h +++ b/api/include/opentelemetry/trace/propagation/detail/hex.h @@ -3,11 +3,12 @@ #pragma once -#include "opentelemetry/nostd/string_view.h" - #include #include +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/version.h" + OPENTELEMETRY_BEGIN_NAMESPACE namespace trace { diff --git a/api/include/opentelemetry/trace/propagation/detail/string.h b/api/include/opentelemetry/trace/propagation/detail/string.h index 67e934b408..de4699952f 100644 --- a/api/include/opentelemetry/trace/propagation/detail/string.h +++ b/api/include/opentelemetry/trace/propagation/detail/string.h @@ -4,6 +4,7 @@ #pragma once #include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace diff --git a/api/include/opentelemetry/trace/propagation/http_trace_context.h b/api/include/opentelemetry/trace/propagation/http_trace_context.h index 9440960be3..bba7592ea6 100644 --- a/api/include/opentelemetry/trace/propagation/http_trace_context.h +++ b/api/include/opentelemetry/trace/propagation/http_trace_context.h @@ -4,12 +4,17 @@ #pragma once #include + #include "detail/hex.h" #include "detail/string.h" #include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/nostd/function_ref.h" +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/trace/context.h" #include "opentelemetry/trace/default_span.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace @@ -30,10 +35,10 @@ static const size_t kTraceParentSize = 55; // HttpTraceContext().Inject(carrier, context); // HttpTraceContext().Extract(carrier, context); -class HttpTraceContext : public opentelemetry::context::propagation::TextMapPropagator +class HttpTraceContext : public context::propagation::TextMapPropagator { public: - void Inject(opentelemetry::context::propagation::TextMapCarrier &carrier, + void Inject(context::propagation::TextMapCarrier &carrier, const context::Context &context) noexcept override { SpanContext span_context = trace::GetSpan(context)->GetContext(); @@ -44,7 +49,7 @@ class HttpTraceContext : public opentelemetry::context::propagation::TextMapProp InjectImpl(carrier, span_context); } - context::Context Extract(const opentelemetry::context::propagation::TextMapCarrier &carrier, + context::Context Extract(const context::propagation::TextMapCarrier &carrier, context::Context &context) noexcept override { SpanContext span_context = ExtractImpl(carrier); @@ -83,7 +88,7 @@ class HttpTraceContext : public opentelemetry::context::propagation::TextMapProp return version != kInvalidVersion; } - static void InjectImpl(opentelemetry::context::propagation::TextMapCarrier &carrier, + static void InjectImpl(context::propagation::TextMapCarrier &carrier, const SpanContext &span_context) { char trace_parent[kTraceParentSize]; @@ -152,10 +157,10 @@ class HttpTraceContext : public opentelemetry::context::propagation::TextMapProp } return SpanContext(trace_id, span_id, TraceFlagsFromHex(trace_flags_hex), true, - opentelemetry::trace::TraceState::FromHeader(trace_state)); + trace::TraceState::FromHeader(trace_state)); } - static SpanContext ExtractImpl(const opentelemetry::context::propagation::TextMapCarrier &carrier) + static SpanContext ExtractImpl(const context::propagation::TextMapCarrier &carrier) { nostd::string_view trace_parent = carrier.Get(kTraceParent); nostd::string_view trace_state = carrier.Get(kTraceState); diff --git a/api/include/opentelemetry/trace/provider.h b/api/include/opentelemetry/trace/provider.h index aff94d4d0e..d5a52a02f6 100644 --- a/api/include/opentelemetry/trace/provider.h +++ b/api/include/opentelemetry/trace/provider.h @@ -9,11 +9,14 @@ #include "opentelemetry/common/spin_lock_mutex.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/trace/noop.h" -#include "opentelemetry/trace/tracer_provider.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace { + +class TracerProvider; + /** * Stores the singleton global TracerProvider. */ diff --git a/api/include/opentelemetry/trace/scope.h b/api/include/opentelemetry/trace/scope.h index ecceba458f..11ded4ab6c 100644 --- a/api/include/opentelemetry/trace/scope.h +++ b/api/include/opentelemetry/trace/scope.h @@ -4,12 +4,17 @@ #pragma once #include "opentelemetry/context/runtime_context.h" -#include "opentelemetry/trace/span.h" +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/trace/span_metadata.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace { + +class Span; + /** * Controls how long a span is active. * diff --git a/api/include/opentelemetry/trace/span.h b/api/include/opentelemetry/trace/span.h index 77de4050d4..ffd145a30d 100644 --- a/api/include/opentelemetry/trace/span.h +++ b/api/include/opentelemetry/trace/span.h @@ -7,11 +7,9 @@ #include "opentelemetry/common/attribute_value.h" #include "opentelemetry/common/key_value_iterable_view.h" -#include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/type_traits.h" -#include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/trace/canonical_code.h" #include "opentelemetry/trace/span_context.h" #include "opentelemetry/trace/span_metadata.h" diff --git a/api/include/opentelemetry/trace/span_context.h b/api/include/opentelemetry/trace/span_context.h index e19bb99001..944bdc0221 100644 --- a/api/include/opentelemetry/trace/span_context.h +++ b/api/include/opentelemetry/trace/span_context.h @@ -3,11 +3,12 @@ #pragma once -#include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/trace/span_id.h" #include "opentelemetry/trace/trace_flags.h" #include "opentelemetry/trace/trace_id.h" #include "opentelemetry/trace/trace_state.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace @@ -29,7 +30,7 @@ class SpanContext final SpanContext(bool sampled_flag, bool is_remote) noexcept : trace_id_(), span_id_(), - trace_flags_(opentelemetry::trace::TraceFlags((uint8_t)sampled_flag)), + trace_flags_(trace::TraceFlags((uint8_t)sampled_flag)), is_remote_(is_remote), trace_state_(TraceState::GetDefault()) {} @@ -52,19 +53,16 @@ class SpanContext final bool IsValid() const noexcept { return trace_id_.IsValid() && span_id_.IsValid(); } // @returns the trace_flags associated with this span_context - const opentelemetry::trace::TraceFlags &trace_flags() const noexcept { return trace_flags_; } + const trace::TraceFlags &trace_flags() const noexcept { return trace_flags_; } // @returns the trace_id associated with this span_context - const opentelemetry::trace::TraceId &trace_id() const noexcept { return trace_id_; } + const trace::TraceId &trace_id() const noexcept { return trace_id_; } // @returns the span_id associated with this span_context - const opentelemetry::trace::SpanId &span_id() const noexcept { return span_id_; } + const trace::SpanId &span_id() const noexcept { return span_id_; } // @returns the trace_state associated with this span_context - const nostd::shared_ptr trace_state() const noexcept - { - return trace_state_; - } + const nostd::shared_ptr trace_state() const noexcept { return trace_state_; } /* * @param that SpanContext for comparing. @@ -86,11 +84,11 @@ class SpanContext final bool IsSampled() const noexcept { return trace_flags_.IsSampled(); } private: - opentelemetry::trace::TraceId trace_id_; - opentelemetry::trace::SpanId span_id_; - opentelemetry::trace::TraceFlags trace_flags_; + trace::TraceId trace_id_; + trace::SpanId span_id_; + trace::TraceFlags trace_flags_; bool is_remote_; - nostd::shared_ptr trace_state_; + nostd::shared_ptr trace_state_; }; } // namespace trace OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/trace/span_context_kv_iterable.h b/api/include/opentelemetry/trace/span_context_kv_iterable.h index 0f1ec307f1..8f3010ce9d 100644 --- a/api/include/opentelemetry/trace/span_context_kv_iterable.h +++ b/api/include/opentelemetry/trace/span_context_kv_iterable.h @@ -26,8 +26,8 @@ class SpanContextKeyValueIterable * @return true if every SpanContext/key-value pair was iterated over */ virtual bool ForEachKeyValue( - nostd::function_ref - callback) const noexcept = 0; + nostd::function_ref callback) + const noexcept = 0; /** * @return the number of key-value pairs */ @@ -40,9 +40,8 @@ class SpanContextKeyValueIterable class NullSpanContext : public SpanContextKeyValueIterable { public: - bool ForEachKeyValue( - nostd::function_ref - /* callback */) const noexcept override + bool ForEachKeyValue(nostd::function_ref + /* callback */) const noexcept override { return true; } diff --git a/api/include/opentelemetry/trace/span_context_kv_iterable_view.h b/api/include/opentelemetry/trace/span_context_kv_iterable_view.h index 252b4cf175..c20155edd6 100644 --- a/api/include/opentelemetry/trace/span_context_kv_iterable_view.h +++ b/api/include/opentelemetry/trace/span_context_kv_iterable_view.h @@ -8,6 +8,8 @@ #include #include "opentelemetry/common/key_value_iterable_view.h" +#include "opentelemetry/nostd/function_ref.h" +#include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/utility.h" #include "opentelemetry/trace/span_context_kv_iterable.h" #include "opentelemetry/version.h" @@ -57,9 +59,8 @@ class SpanContextKeyValueIterableView final : public SpanContextKeyValueIterable public: explicit SpanContextKeyValueIterableView(const T &links) noexcept : container_{&links} {} - bool ForEachKeyValue( - nostd::function_ref - callback) const noexcept override + bool ForEachKeyValue(nostd::function_ref + callback) const noexcept override { auto iter = std::begin(*container_); auto last = std::end(*container_); @@ -78,11 +79,10 @@ class SpanContextKeyValueIterableView final : public SpanContextKeyValueIterable private: const T *container_; - bool do_callback( - SpanContext span_context, - const common::KeyValueIterable &attributes, - nostd::function_ref - callback) const noexcept + bool do_callback(SpanContext span_context, + const common::KeyValueIterable &attributes, + nostd::function_ref + callback) const noexcept { if (!callback(span_context, attributes)) { diff --git a/api/include/opentelemetry/trace/span_metadata.h b/api/include/opentelemetry/trace/span_metadata.h index f27239c739..5e615ea537 100644 --- a/api/include/opentelemetry/trace/span_metadata.h +++ b/api/include/opentelemetry/trace/span_metadata.h @@ -4,6 +4,7 @@ #pragma once #include "opentelemetry/common/timestamp.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace diff --git a/api/include/opentelemetry/trace/span_startoptions.h b/api/include/opentelemetry/trace/span_startoptions.h index 9265574a57..2180394d72 100644 --- a/api/include/opentelemetry/trace/span_startoptions.h +++ b/api/include/opentelemetry/trace/span_startoptions.h @@ -3,9 +3,12 @@ #pragma once +#include "opentelemetry/common/timestamp.h" #include "opentelemetry/context/context.h" +#include "opentelemetry/nostd/variant.h" #include "opentelemetry/trace/span_context.h" #include "opentelemetry/trace/span_metadata.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace @@ -33,7 +36,7 @@ struct StartSpanOptions // // This defaults to an invalid span context. In this case, the Span is // automatically parented to the currently active span. - nostd::variant parent = SpanContext::GetInvalid(); + nostd::variant parent = SpanContext::GetInvalid(); // TODO: // SpanContext remote_parent; diff --git a/api/include/opentelemetry/trace/trace_flags.h b/api/include/opentelemetry/trace/trace_flags.h index 3cfbb022f4..1f7bf4f9b3 100644 --- a/api/include/opentelemetry/trace/trace_flags.h +++ b/api/include/opentelemetry/trace/trace_flags.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include "opentelemetry/nostd/span.h" #include "opentelemetry/version.h" diff --git a/api/include/opentelemetry/trace/trace_state.h b/api/include/opentelemetry/trace/trace_state.h index 28fd126fea..f424b01997 100644 --- a/api/include/opentelemetry/trace/trace_state.h +++ b/api/include/opentelemetry/trace/trace_state.h @@ -4,14 +4,15 @@ #pragma once #include -#include #include #include "opentelemetry/common/kv_properties.h" +#include "opentelemetry/nostd/function_ref.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/nostd/unique_ptr.h" +#include "opentelemetry/version.h" #if defined(OPENTELEMETRY_HAVE_WORKING_REGEX) # include @@ -73,7 +74,7 @@ class OPENTELEMETRY_EXPORT TraceState if (!IsValidKey(key) || !IsValidValue(value)) { // invalid header. return empty TraceState - ts->kv_properties_.reset(new opentelemetry::common::KeyValueProperties()); + ts->kv_properties_.reset(new common::KeyValueProperties()); break; } @@ -229,8 +230,8 @@ class OPENTELEMETRY_EXPORT TraceState } private: - TraceState() : kv_properties_(new opentelemetry::common::KeyValueProperties()) {} - TraceState(size_t size) : kv_properties_(new opentelemetry::common::KeyValueProperties(size)) {} + TraceState() : kv_properties_(new common::KeyValueProperties()) {} + TraceState(size_t size) : kv_properties_(new common::KeyValueProperties(size)) {} static nostd::string_view TrimString(nostd::string_view str, size_t left, size_t right) { @@ -311,7 +312,7 @@ class OPENTELEMETRY_EXPORT TraceState private: // Store entries in a C-style array to avoid using std::array or std::vector. - nostd::unique_ptr kv_properties_; + nostd::unique_ptr kv_properties_; }; } // namespace trace diff --git a/api/include/opentelemetry/trace/tracer.h b/api/include/opentelemetry/trace/tracer.h index b60336a48d..82b4d0ea02 100644 --- a/api/include/opentelemetry/trace/tracer.h +++ b/api/include/opentelemetry/trace/tracer.h @@ -3,10 +3,11 @@ #pragma once +#include + #include "opentelemetry/context/context.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" -#include "opentelemetry/nostd/unique_ptr.h" #include "opentelemetry/trace/default_span.h" #include "opentelemetry/trace/scope.h" #include "opentelemetry/trace/span.h" @@ -14,8 +15,6 @@ #include "opentelemetry/trace/span_startoptions.h" #include "opentelemetry/version.h" -#include - OPENTELEMETRY_BEGIN_NAMESPACE namespace trace { diff --git a/api/include/opentelemetry/trace/tracer_provider.h b/api/include/opentelemetry/trace/tracer_provider.h index 9d3125db40..bc8ff8da89 100644 --- a/api/include/opentelemetry/trace/tracer_provider.h +++ b/api/include/opentelemetry/trace/tracer_provider.h @@ -5,11 +5,14 @@ #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" -#include "opentelemetry/trace/tracer.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace trace { + +class Tracer; + /** * Creates new Tracer instances. */ diff --git a/api/test/logs/CMakeLists.txt b/api/test/logs/CMakeLists.txt index 92d4c72450..3d12782746 100644 --- a/api/test/logs/CMakeLists.txt +++ b/api/test/logs/CMakeLists.txt @@ -10,3 +10,9 @@ foreach(testname provider_test logger_test) TEST_PREFIX logs. TEST_LIST logs_api_${testname}) endforeach() + +if(WITH_BENCHMARK) + add_executable(logger_benchmark logger_benchmark.cc) + target_link_libraries(logger_benchmark benchmark::benchmark + ${CMAKE_THREAD_LIBS_INIT} opentelemetry_api) +endif() diff --git a/api/test/logs/logger_benchmark.cc b/api/test/logs/logger_benchmark.cc new file mode 100644 index 0000000000..fa5ad2b0c6 --- /dev/null +++ b/api/test/logs/logger_benchmark.cc @@ -0,0 +1,260 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/common/timestamp.h" +# include "opentelemetry/logs/logger.h" +# include "opentelemetry/logs/provider.h" +# include "opentelemetry/nostd/shared_ptr.h" + +# include +# include +# include +# include +# include +# include + +# include + +using opentelemetry::logs::EventId; +using opentelemetry::logs::Logger; +using opentelemetry::logs::LoggerProvider; +using opentelemetry::logs::Provider; +using opentelemetry::logs::Severity; +using opentelemetry::nostd::shared_ptr; +using opentelemetry::nostd::span; +using opentelemetry::nostd::string_view; + +namespace common = opentelemetry::common; +namespace nostd = opentelemetry::nostd; +namespace trace = opentelemetry::trace; +namespace log_api = opentelemetry::logs; + +namespace +{ + +constexpr int64_t kMaxIterations = 1000000000; + +class Barrier +{ +public: + explicit Barrier(std::size_t iCount) : mThreshold(iCount), mCount(iCount), mGeneration(0) {} + + void Wait() + { + std::unique_lock lLock{mMutex}; + auto lGen = mGeneration; + if (!--mCount) + { + mGeneration++; + mCount = mThreshold; + mCond.notify_all(); + } + else + { + mCond.wait(lLock, [this, lGen] { return lGen != mGeneration; }); + } + } + +private: + std::mutex mMutex; + std::condition_variable mCond; + std::size_t mThreshold; + std::size_t mCount; + std::size_t mGeneration; +}; + +static void ThreadRoutine(Barrier &barrier, + benchmark::State &state, + int thread_id, + std::function func) +{ + barrier.Wait(); + + if (thread_id == 0) + { + state.ResumeTiming(); + } + + barrier.Wait(); + + func(); + + if (thread_id == 0) + { + state.PauseTiming(); + } + + barrier.Wait(); +} + +void MultiThreadRunner(benchmark::State &state, std::function func) +{ + int num_threads = std::thread::hardware_concurrency(); + + Barrier barrier(num_threads); + + std::vector threads; + + for (int i = 0; i < num_threads; i++) + { + threads.emplace_back(ThreadRoutine, std::ref(barrier), std::ref(state), i, func); + } + + for (auto &thread : threads) + { + thread.join(); + } +} + +static void BM_UnstructuredLog(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("UnstructuredLog"); + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + logger->Trace("This is a simple unstructured log message"); + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_UnstructuredLog); + +static void BM_StructuredLogWithTwoAttributes(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("StructuredLog"); + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + logger->Trace( + "This is a simple structured log message from {process_id}:{thread_id}", + opentelemetry::common::MakeAttributes({{"process_id", 12347}, {"thread_id", 12348}})); + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_StructuredLogWithTwoAttributes); + +static void BM_StructuredLogWithEventIdAndTwoAttributes(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("StructuredLogWithEventId"); + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + logger->Trace( + 0x12345678, "This is a simple structured log message from {process_id}:{thread_id}", + opentelemetry::common::MakeAttributes({{"process_id", 12347}, {"thread_id", 12348}})); + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_StructuredLogWithEventIdAndTwoAttributes); + +static void BM_StructuredLogWithEventIdStructAndTwoAttributes(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("StructuredLogWithEventId"); + + const EventId function_name_event_id{0x12345678, "Company.Component.SubComponent.FunctionName"}; + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger, &function_name_event_id]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + logger->Trace( + function_name_event_id, + "Simulate function enter trace message from {process_id}:{thread_id}", + opentelemetry::common::MakeAttributes({{"process_id", 12347}, {"thread_id", 12348}})); + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_StructuredLogWithEventIdStructAndTwoAttributes); + +static void BM_EnabledOnSeverityReturnFalse(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("UnstructuredLogWithEnabledReturnFalse"); + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + if (logger->Enabled(Severity::kTrace)) + { + logger->Trace("This log line would not be called"); + } + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_EnabledOnSeverityReturnFalse); + +static void BM_EnabledOnSeverityAndEventIdReturnFalse(benchmark::State &state) +{ + auto lp = Provider::GetLoggerProvider(); + auto logger = lp->GetLogger("UnstructuredLogWithEnabledReturnFalse"); + + for (auto _ : state) + { + state.PauseTiming(); + + MultiThreadRunner(state, [&logger]() { + for (int64_t i = 0; i < kMaxIterations; i++) + { + if (logger->Enabled(Severity::kTrace, 0x12345678)) + { + logger->Trace("This log line would not be called"); + } + } + }); + + state.ResumeTiming(); + } +} +BENCHMARK(BM_EnabledOnSeverityAndEventIdReturnFalse); + +} // namespace + +int main(int argc, char **argv) +{ + benchmark::Initialize(&argc, argv); + benchmark::RunSpecifiedBenchmarks(); +} + +#endif diff --git a/api/test/logs/logger_test.cc b/api/test/logs/logger_test.cc index d07e12e40e..ccdcd990c5 100644 --- a/api/test/logs/logger_test.cc +++ b/api/test/logs/logger_test.cc @@ -12,6 +12,7 @@ # include "opentelemetry/logs/provider.h" # include "opentelemetry/nostd/shared_ptr.h" +using opentelemetry::logs::EventId; using opentelemetry::logs::Logger; using opentelemetry::logs::LoggerProvider; using opentelemetry::logs::Provider; @@ -52,6 +53,13 @@ TEST(Logger, LogMethodOverloads) const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"}; auto logger = lp->GetLogger("TestLogger", "opentelelemtry_library", "", schema_url); + EventId trace_event_id{0x1, "TraceEventId"}; + EventId debug_event_id{0x2, "DebugEventId"}; + EventId info_event_id{0x3, "InfoEventId"}; + EventId warn_event_id{0x4, "WarnEventId"}; + EventId error_event_id{0x5, "ErrorEventId"}; + EventId fatal_event_id{0x6, "FatalEventId"}; + // Create a map to test the logs with std::map m = {{"key1", "value1"}}; @@ -79,36 +87,65 @@ TEST(Logger, LogMethodOverloads) opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Trace(m); logger->Trace(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Trace(trace_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Trace(trace_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Debug("Test log message"); logger->Debug("Test log message", m); logger->Debug("Test log message", opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Debug(m); logger->Debug(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Debug(debug_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Debug(debug_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Info("Test log message"); logger->Info("Test log message", m); logger->Info("Test log message", opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Info(m); logger->Info(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Info(info_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Info(info_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Warn("Test log message"); logger->Warn("Test log message", m); logger->Warn("Test log message", opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Warn(m); logger->Warn(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Warn(warn_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Warn(warn_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Error("Test log message"); logger->Error("Test log message", m); logger->Error("Test log message", opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Error(m); logger->Error(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Error(error_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Error(error_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Fatal("Test log message"); logger->Fatal("Test log message", m); logger->Fatal("Test log message", opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); logger->Fatal(m); logger->Fatal(opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Fatal(fatal_event_id, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); + logger->Fatal(fatal_event_id.id_, "Test log message", + opentelemetry::common::MakeAttributes({{"key1", "value 1"}, {"key2", 2}})); } TEST(Logger, EventLogMethodOverloads) diff --git a/api/test/plugin/dynamic_load_test.cc b/api/test/plugin/dynamic_load_test.cc index 4fdc79eee6..8e8b14800c 100644 --- a/api/test/plugin/dynamic_load_test.cc +++ b/api/test/plugin/dynamic_load_test.cc @@ -2,6 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 #include "opentelemetry/plugin/dynamic_load.h" +#include "opentelemetry/plugin/factory.h" #include diff --git a/bazel/repository.bzl b/bazel/repository.bzl index e03e48ae5a..daa9dcd3eb 100644 --- a/bazel/repository.bzl +++ b/bazel/repository.bzl @@ -34,10 +34,10 @@ def opentelemetry_cpp_deps(): maybe( http_archive, name = "com_github_google_benchmark", - sha256 = "1f71c72ce08d2c1310011ea6436b31e39ccab8c2db94186d26657d41747c85d6", - strip_prefix = "benchmark-1.6.0", + sha256 = "6430e4092653380d9dc4ccb45a1e2dc9259d581f4866dc0759713126056bc1d7", + strip_prefix = "benchmark-1.7.1", urls = [ - "https://github.com/google/benchmark/archive/v1.6.0.tar.gz", + "https://github.com/google/benchmark/archive/v1.7.1.tar.gz", ], ) @@ -112,9 +112,9 @@ def opentelemetry_cpp_deps(): http_archive, name = "github_nlohmann_json", build_file = "@io_opentelemetry_cpp//bazel:nlohmann_json.BUILD", - sha256 = "b94997df68856753b72f0d7a3703b7d484d4745c567f3584ef97c96c25a5798e", + sha256 = "e5c7a9f49a16814be27e4ed0ee900ecd0092bfb7dbfca65b5a421b774dccaaed", urls = [ - "https://github.com/nlohmann/json/releases/download/v3.10.5/include.zip", + "https://github.com/nlohmann/json/releases/download/v3.11.2/include.zip", ], ) @@ -147,7 +147,10 @@ def opentelemetry_cpp_deps(): build_file = "@io_opentelemetry_cpp//bazel:curl.BUILD", sha256 = "ba98332752257b47b9dea6d8c0ad25ec1745c20424f1dd3ff2c99ab59e97cf91", strip_prefix = "curl-7.73.0", - urls = ["https://curl.haxx.se/download/curl-7.73.0.tar.gz"], + urls = [ + "https://curl.haxx.se/download/curl-7.73.0.tar.gz", + "https://github.com/curl/curl/releases/download/curl-7_73_0/curl-7.73.0.tar.gz", + ], ) # libthrift (optional) diff --git a/ci/do_ci.sh b/ci/do_ci.sh index 19695d2cf6..64d3b72308 100755 --- a/ci/do_ci.sh +++ b/ci/do_ci.sh @@ -243,6 +243,20 @@ elif [[ "$1" == "cmake.exporter.otprotocol.test" ]]; then make -j $(nproc) cd exporters/otlp && make test exit 0 +elif [[ "$1" == "cmake.exporter.otprotocol.shared_libs.with_static_grpc.test" ]]; then + cd "${BUILD_DIR}" + rm -rf * + cmake -DCMAKE_BUILD_TYPE=Debug \ + -DWITH_OTLP=ON \ + -DWITH_OTLP_HTTP=ON \ + -DBUILD_SHARED_LIBS=ON \ + "${SRC_DIR}" + grpc_cpp_plugin=`which grpc_cpp_plugin` + proto_make_file="CMakeFiles/opentelemetry_proto.dir/build.make" + sed -i "s~gRPC_CPP_PLUGIN_EXECUTABLE-NOTFOUND~$grpc_cpp_plugin~" ${proto_make_file} #fixme + make -j $(nproc) + cd exporters/otlp && make test + exit 0 elif [[ "$1" == "cmake.exporter.otprotocol.with_async_export.test" ]]; then cd "${BUILD_DIR}" rm -rf * diff --git a/ci/install_bazelisk.sh b/ci/install_bazelisk.sh index d8b6781775..674ca215e9 100755 --- a/ci/install_bazelisk.sh +++ b/ci/install_bazelisk.sh @@ -5,7 +5,7 @@ set -e -BAZELISK_VERSION=v1.10.1 +BAZELISK_VERSION=v1.16.0 wget -O /usr/local/bin/bazel https://github.com/bazelbuild/bazelisk/releases/download/$BAZELISK_VERSION/bazelisk-linux-amd64 chmod +x /usr/local/bin/bazel diff --git a/ci/install_windows_bazelisk.ps1 b/ci/install_windows_bazelisk.ps1 index 4867882afe..2f1f48c1e2 100644 --- a/ci/install_windows_bazelisk.ps1 +++ b/ci/install_windows_bazelisk.ps1 @@ -4,7 +4,7 @@ $ErrorActionPreference = "Stop" trap { $host.SetShouldExit(1) } -$BAZELISK_VERSION="1.7.4" +$BAZELISK_VERSION="1.16.0" $CWD=(Get-Item -Path ".\").FullName (new-object System.Net.WebClient). ` DownloadFile("https://github.com/bazelbuild/bazelisk/releases/download/v$BAZELISK_VERSION/bazelisk-windows-amd64.exe", diff --git a/ci/ports/benchmark/CONTROL b/ci/ports/benchmark/CONTROL deleted file mode 100644 index d82040748d..0000000000 --- a/ci/ports/benchmark/CONTROL +++ /dev/null @@ -1,5 +0,0 @@ -Source: benchmark -Version: 1.5 -Homepage: https://github.com/google/benchmark -Description: A library to support the benchmarking of functions, similar to unit-tests. -Supports: !uwp \ No newline at end of file diff --git a/ci/ports/benchmark/portfile.cmake b/ci/ports/benchmark/portfile.cmake index 6716c34312..efb5a2fce7 100644 --- a/ci/ports/benchmark/portfile.cmake +++ b/ci/ports/benchmark/portfile.cmake @@ -6,38 +6,31 @@ if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") endif() # Make sure vs2019 compiled binaries are compat with vs2017 -set(VCPKG_CXX_FLAGS "/Zc:__cplusplus /d2FH4-") -set(VCPKG_C_FLAGS "/Zc:__cplusplus /d2FH4-") - -include(vcpkg_common_functions) - vcpkg_check_linkage(ONLY_STATIC_LIBRARY) vcpkg_from_github( OUT_SOURCE_PATH SOURCE_PATH REPO google/benchmark - REF v1.5.0 - SHA512 a0df9aa3d03f676e302c76d83b436de36eea0a8517ab50a8f5a11c74ccc68a1f5128fa02474901002d8e6b5a4d290ef0272a798ff4670eab3e2d78dc86bb6cd3 + REF v1.7.1 + SHA512 396af1c1d3eaa2b78c6d23b1472f6088db85a294056ae1c2366dc5c0becdc8f141ba8fc3a235033324ab0a41c2298f5d242ef09b9b6f69d9877de6bcb2062efd HEAD_REF master ) -vcpkg_configure_cmake( +vcpkg_cmake_configure( SOURCE_PATH ${SOURCE_PATH} - PREFER_NINJA OPTIONS -DBENCHMARK_ENABLE_TESTING=OFF - -DCMAKE_DEBUG_POSTFIX=d ) -vcpkg_install_cmake() - +vcpkg_cmake_install() vcpkg_copy_pdbs() -vcpkg_fixup_cmake_targets(CONFIG_PATH lib/cmake/benchmark) +vcpkg_cmake_config_fixup(CONFIG_PATH lib/cmake/benchmark) + +vcpkg_fixup_pkgconfig() -file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include) -file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/share) +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/share") # Handle copyright -file(COPY ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/benchmark) -file(RENAME ${CURRENT_PACKAGES_DIR}/share/benchmark/LICENSE ${CURRENT_PACKAGES_DIR}/share/benchmark/copyright) +file(INSTALL "${SOURCE_PATH}/LICENSE" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright) diff --git a/ci/ports/benchmark/vcpkg.json b/ci/ports/benchmark/vcpkg.json new file mode 100644 index 0000000000..605f5af9f0 --- /dev/null +++ b/ci/ports/benchmark/vcpkg.json @@ -0,0 +1,19 @@ +{ + "$comment": "https://github.com/google/benchmark/issues/661 describes the missing UWP support upstream", + "name": "benchmark", + "version-semver": "1.7.1", + "description": "A library to support the benchmarking of functions, similar to unit-tests.", + "homepage": "https://github.com/google/benchmark", + "license": "Apache-2.0", + "supports": "!uwp", + "dependencies": [ + { + "name": "vcpkg-cmake", + "host": true + }, + { + "name": "vcpkg-cmake-config", + "host": true + } + ] + } \ No newline at end of file diff --git a/ci/setup_grpc.sh b/ci/setup_grpc.sh index d6e92d4ea6..e1002b6616 100755 --- a/ci/setup_grpc.sh +++ b/ci/setup_grpc.sh @@ -10,11 +10,11 @@ new_grpc_version='v1.49.2' gcc_version_for_new_grpc='5.1' std_version='14' install_grpc_version=${new_grpc_version} -grpc_version='v1.39.0' install_dir='/usr/local/' +build_shared_libs='' usage() { echo "Usage: $0 [-v ] [-i "] 1>&2; exit 1;} -while getopts ":v:i:r:s:" o; do +while getopts ":v:i:r:s:TH" o; do case "${o}" in v) gcc_version=${OPTARG} @@ -28,6 +28,12 @@ while getopts ":v:i:r:s:" o; do s) std_version=${OPTARG} ;; + T) + build_shared_libs="OFF" + ;; + H) + build_shared_libs="ON" + ;; *) usage ;; @@ -54,19 +60,34 @@ pushd grpc git submodule init git submodule update --depth 1 mkdir -p "third_party/abseil-cpp/build" && pushd "third_party/abseil-cpp/build" -cmake -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE \ - -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR .. -make -j${nproc} install && popd +set -x + +ABSEIL_CPP_BUILD_OPTIONS=( + -DCMAKE_BUILD_TYPE=Release + -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE + -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR +) +if [ ! -z "$build_shared_libs" ]; then + ABSEIL_CPP_BUILD_OPTIONS=(${ABSEIL_CPP_BUILD_OPTIONS[@]} "-DBUILD_SHARED_LIBS=$build_shared_libs") +fi +cmake ${ABSEIL_CPP_BUILD_OPTIONS[@]} .. +cmake --build . -j${nproc} --target install && popd mkdir -p build && pushd build -cmake -DgRPC_INSTALL=ON \ - -DCMAKE_CXX_STANDARD=${std_version} \ - -DgRPC_BUILD_TESTS=OFF \ - -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \ - -DCMAKE_PREFIX_PATH=$INSTALL_DIR \ - .. -make -j $(nproc) -make install + +GRPC_BUILD_OPTIONS=( + -DgRPC_INSTALL=ON + -DCMAKE_CXX_STANDARD=${std_version} + -DgRPC_BUILD_TESTS=OFF + -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR + -DCMAKE_PREFIX_PATH=$INSTALL_DIR +) +if [ ! -z "$build_shared_libs" ]; then + GRPC_BUILD_OPTIONS=(${GRPC_BUILD_OPTIONS[@]} "-DBUILD_SHARED_LIBS=$build_shared_libs") +fi + +cmake ${GRPC_BUILD_OPTIONS[@]} .. +cmake --build . -j$(nproc) +cmake --install . popd popd diff --git a/cmake/nlohmann-json.cmake b/cmake/nlohmann-json.cmake index 84f107b97c..d56a6cbb6d 100644 --- a/cmake/nlohmann-json.cmake +++ b/cmake/nlohmann-json.cmake @@ -33,6 +33,8 @@ find_package(nlohmann_json QUIET) set(nlohmann_json_clone FALSE) if(nlohmann_json_FOUND) message(STATUS "nlohmann::json dependency satisfied by: package") +elseif(TARGET nlohmann_json) + message(STATUS "nlohmann::json is already added as a CMake target!") elseif(EXISTS ${PROJECT_SOURCE_DIR}/.git AND EXISTS ${PROJECT_SOURCE_DIR}/third_party/nlohmann-json/CMakeLists.txt) diff --git a/cmake/opentelemetry-proto.cmake b/cmake/opentelemetry-proto.cmake index 1aa1ba0349..34b33d3cff 100644 --- a/cmake/opentelemetry-proto.cmake +++ b/cmake/opentelemetry-proto.cmake @@ -229,31 +229,47 @@ endif() include_directories("${GENERATED_PROTOBUF_PATH}") -if(WITH_OTLP_GRPC) - add_library( - opentelemetry_proto STATIC - ${COMMON_PB_CPP_FILE} - ${RESOURCE_PB_CPP_FILE} - ${TRACE_PB_CPP_FILE} - ${LOGS_PB_CPP_FILE} - ${METRICS_PB_CPP_FILE} - ${TRACE_SERVICE_PB_CPP_FILE} - ${TRACE_SERVICE_GRPC_PB_CPP_FILE} - ${LOGS_SERVICE_PB_CPP_FILE} - ${LOGS_SERVICE_GRPC_PB_CPP_FILE} - ${METRICS_SERVICE_PB_CPP_FILE} - ${METRICS_SERVICE_GRPC_PB_CPP_FILE}) +unset(OTELCPP_PROTO_TARGET_OPTIONS) +if(CMAKE_SYSTEM_NAME MATCHES "Windows|MinGW|WindowsStore") + list(APPEND OTELCPP_PROTO_TARGET_OPTIONS STATIC) +elseif(NOT DEFINED BUILD_SHARED_LIBS OR BUILD_SHARED_LIBS) + list(APPEND OTELCPP_PROTO_TARGET_OPTIONS SHARED) else() + list(APPEND OTELCPP_PROTO_TARGET_OPTIONS STATIC) +endif() + +set(OPENTELEMETRY_PROTO_TARGETS opentelemetry_proto) +add_library( + opentelemetry_proto + ${OTELCPP_PROTO_TARGET_OPTIONS} + ${COMMON_PB_CPP_FILE} + ${RESOURCE_PB_CPP_FILE} + ${TRACE_PB_CPP_FILE} + ${LOGS_PB_CPP_FILE} + ${METRICS_PB_CPP_FILE} + ${TRACE_SERVICE_PB_CPP_FILE} + ${LOGS_SERVICE_PB_CPP_FILE} + ${METRICS_SERVICE_PB_CPP_FILE}) + +if(WITH_OTLP_GRPC) add_library( - opentelemetry_proto STATIC - ${COMMON_PB_CPP_FILE} - ${RESOURCE_PB_CPP_FILE} - ${TRACE_PB_CPP_FILE} - ${LOGS_PB_CPP_FILE} - ${METRICS_PB_CPP_FILE} - ${TRACE_SERVICE_PB_CPP_FILE} - ${LOGS_SERVICE_PB_CPP_FILE} - ${METRICS_SERVICE_PB_CPP_FILE}) + opentelemetry_proto_grpc + ${OTELCPP_PROTO_TARGET_OPTIONS} ${TRACE_SERVICE_GRPC_PB_CPP_FILE} + ${LOGS_SERVICE_GRPC_PB_CPP_FILE} ${METRICS_SERVICE_GRPC_PB_CPP_FILE}) + + list(APPEND OPENTELEMETRY_PROTO_TARGETS opentelemetry_proto_grpc) + target_link_libraries(opentelemetry_proto_grpc PUBLIC opentelemetry_proto) + + set_target_properties(opentelemetry_proto_grpc PROPERTIES EXPORT_NAME + proto_grpc) + patch_protobuf_targets(opentelemetry_proto_grpc) + get_target_property(GRPC_INCLUDE_DIRECTORY gRPC::grpc++ + INTERFACE_INCLUDE_DIRECTORIES) + if(GRPC_INCLUDE_DIRECTORY) + target_include_directories( + opentelemetry_proto_grpc + PUBLIC "$") + endif() endif() if(needs_proto_download) @@ -264,7 +280,7 @@ patch_protobuf_targets(opentelemetry_proto) if(OPENTELEMETRY_INSTALL) install( - TARGETS opentelemetry_proto + TARGETS ${OPENTELEMETRY_PROTO_TARGETS} EXPORT "${PROJECT_NAME}-target" RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} @@ -282,9 +298,21 @@ if(TARGET protobuf::libprotobuf) else() # cmake 3.8 or lower target_include_directories(opentelemetry_proto PUBLIC ${Protobuf_INCLUDE_DIRS}) - target_link_libraries(opentelemetry_proto INTERFACE ${Protobuf_LIBRARIES}) + target_link_libraries(opentelemetry_proto PUBLIC ${Protobuf_LIBRARIES}) +endif() + +if(WITH_OTLP_GRPC) + if(WITH_ABSEIL) + find_package(absl CONFIG) + if(TARGET absl::synchronization) + target_link_libraries(opentelemetry_proto_grpc + PRIVATE absl::synchronization) + endif() + endif() endif() if(BUILD_SHARED_LIBS) - set_property(TARGET opentelemetry_proto PROPERTY POSITION_INDEPENDENT_CODE ON) + foreach(proto_target ${OPENTELEMETRY_PROTO_TARGETS}) + set_property(TARGET ${proto_target} PROPERTY POSITION_INDEPENDENT_CODE ON) + endforeach() endif() diff --git a/examples/common/foo_library/CMakeLists.txt b/examples/common/foo_library/CMakeLists.txt index cceb200596..1ef87df1e1 100644 --- a/examples/common/foo_library/CMakeLists.txt +++ b/examples/common/foo_library/CMakeLists.txt @@ -6,5 +6,7 @@ if(DEFINED OPENTELEMETRY_BUILD_DLL) endif() add_library(common_foo_library foo_library.h foo_library.cc) +set_target_version(common_foo_library) + target_link_libraries(common_foo_library PUBLIC ${CMAKE_THREAD_LIBS_INIT} opentelemetry_api) diff --git a/examples/common/logs_foo_library/CMakeLists.txt b/examples/common/logs_foo_library/CMakeLists.txt index 45fe112f4e..6fd9c79d85 100644 --- a/examples/common/logs_foo_library/CMakeLists.txt +++ b/examples/common/logs_foo_library/CMakeLists.txt @@ -6,5 +6,7 @@ if(DEFINED OPENTELEMETRY_BUILD_DLL) endif() add_library(common_logs_foo_library foo_library.h foo_library.cc) +set_target_version(common_logs_foo_library) + target_link_libraries(common_logs_foo_library PUBLIC ${CMAKE_THREAD_LIBS_INIT} opentelemetry_api) diff --git a/examples/common/metrics_foo_library/CMakeLists.txt b/examples/common/metrics_foo_library/CMakeLists.txt index e4f73fe037..a91b2595b8 100644 --- a/examples/common/metrics_foo_library/CMakeLists.txt +++ b/examples/common/metrics_foo_library/CMakeLists.txt @@ -2,4 +2,5 @@ # SPDX-License-Identifier: Apache-2.0 add_library(common_metrics_foo_library foo_library.h foo_library.cc) +set_target_version(common_metrics_foo_library) target_link_libraries(common_metrics_foo_library PUBLIC opentelemetry_api) diff --git a/exporters/elasticsearch/CMakeLists.txt b/exporters/elasticsearch/CMakeLists.txt index 94a12c62e0..e91b53f1c6 100644 --- a/exporters/elasticsearch/CMakeLists.txt +++ b/exporters/elasticsearch/CMakeLists.txt @@ -6,6 +6,7 @@ add_library(opentelemetry_exporter_elasticsearch_logs set_target_properties(opentelemetry_exporter_elasticsearch_logs PROPERTIES EXPORT_NAME elasticsearch_log_record_exporter) +set_target_version(opentelemetry_exporter_elasticsearch_logs) target_include_directories( opentelemetry_exporter_elasticsearch_logs diff --git a/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h b/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h index d6ed78d117..c5be2a2cd8 100644 --- a/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h +++ b/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h @@ -72,6 +72,16 @@ class ElasticSearchRecordable final : public sdk::logs::Recordable */ void SetBody(const opentelemetry::common::AttributeValue &message) noexcept override; + /** + * Set the Event Id + * @param id the event id to set + * @param name the event name to set + */ + void SetEventId(int64_t /* id */, nostd::string_view /* name */) noexcept override + { + // TODO: implement event id + } + /** * Set the trace id for this log. * @param trace_id the trace id to set diff --git a/exporters/jaeger/CMakeLists.txt b/exporters/jaeger/CMakeLists.txt index a02fa7c3e5..222084eeb7 100644 --- a/exporters/jaeger/CMakeLists.txt +++ b/exporters/jaeger/CMakeLists.txt @@ -35,6 +35,7 @@ add_library(opentelemetry_exporter_jaeger_trace ${JAEGER_EXPORTER_SOURCES} set_target_properties(opentelemetry_exporter_jaeger_trace PROPERTIES EXPORT_NAME jaeger_trace_exporter) +set_target_version(opentelemetry_exporter_jaeger_trace) target_include_directories( opentelemetry_exporter_jaeger_trace diff --git a/exporters/memory/CMakeLists.txt b/exporters/memory/CMakeLists.txt index 36ddca5ac5..3dff044018 100644 --- a/exporters/memory/CMakeLists.txt +++ b/exporters/memory/CMakeLists.txt @@ -11,6 +11,7 @@ target_include_directories( set_target_properties(opentelemetry_exporter_in_memory PROPERTIES EXPORT_NAME in_memory_span_exporter) +set_target_version(opentelemetry_exporter_in_memory) target_link_libraries(opentelemetry_exporter_in_memory PUBLIC opentelemetry_trace) diff --git a/exporters/ostream/CMakeLists.txt b/exporters/ostream/CMakeLists.txt index a674de8442..af24e9f1ad 100644 --- a/exporters/ostream/CMakeLists.txt +++ b/exporters/ostream/CMakeLists.txt @@ -6,6 +6,7 @@ add_library(opentelemetry_exporter_ostream_span src/span_exporter.cc set_target_properties(opentelemetry_exporter_ostream_span PROPERTIES EXPORT_NAME ostream_span_exporter) +set_target_version(opentelemetry_exporter_ostream_span) target_include_directories( opentelemetry_exporter_ostream_span @@ -42,6 +43,8 @@ endif() # BUILD_TESTING add_library(opentelemetry_exporter_ostream_metrics src/metric_exporter.cc) set_target_properties(opentelemetry_exporter_ostream_metrics PROPERTIES EXPORT_NAME ostream_metrics_exporter) +set_target_version(opentelemetry_exporter_ostream_metrics) + target_include_directories( opentelemetry_exporter_ostream_metrics PUBLIC "$") @@ -76,6 +79,8 @@ if(WITH_LOGS_PREVIEW) add_library(opentelemetry_exporter_ostream_logs src/log_record_exporter.cc) set_target_properties(opentelemetry_exporter_ostream_logs PROPERTIES EXPORT_NAME ostream_log_record_exporter) + set_target_version(opentelemetry_exporter_ostream_logs) + target_include_directories( opentelemetry_exporter_ostream_logs PUBLIC "$") diff --git a/exporters/ostream/src/log_record_exporter.cc b/exporters/ostream/src/log_record_exporter.cc index 751de71e2c..18552d7a65 100644 --- a/exporters/ostream/src/log_record_exporter.cc +++ b/exporters/ostream/src/log_record_exporter.cc @@ -52,6 +52,8 @@ sdk::common::ExportResult OStreamLogRecordExporter::Export( continue; } + int64_t event_id = log_record->GetEventId(); + // Convert trace, spanid, traceflags into exportable representation constexpr int trace_id_len = 32; constexpr int span_id__len = 16; @@ -96,6 +98,8 @@ sdk::common::ExportResult OStreamLogRecordExporter::Export( printAttributes(log_record->GetAttributes(), "\n "); sout_ << "\n" + << " event_id : " << event_id << "\n" + << " event_name : " << log_record->GetEventName() << "\n" << " trace_id : " << std::string(trace_id, trace_id_len) << "\n" << " span_id : " << std::string(span_id, span_id__len) << "\n" << " trace_flags : " << std::string(trace_flags, trace_flags_len) << "\n" diff --git a/exporters/ostream/test/ostream_log_test.cc b/exporters/ostream/test/ostream_log_test.cc index 95cdb69380..30cf64c5eb 100644 --- a/exporters/ostream/test/ostream_log_test.cc +++ b/exporters/ostream/test/ostream_log_test.cc @@ -20,6 +20,8 @@ namespace nostd = opentelemetry::nostd; namespace exporterlogs = opentelemetry::exporter::logs; namespace common = opentelemetry::common; +using Attributes = std::initializer_list>; + OPENTELEMETRY_BEGIN_NAMESPACE namespace exporter { @@ -103,6 +105,8 @@ TEST(OstreamLogExporter, DefaultLogRecordToCout) " telemetry.sdk.name: opentelemetry\n", " telemetry.sdk.language: cpp\n", " attributes : \n", + " event_id : 0\n" + " event_name : \n", " trace_id : 00000000000000000000000000000000\n", " span_id : 0000000000000000\n", " trace_flags : 00\n", @@ -176,6 +180,8 @@ TEST(OStreamLogRecordExporter, SimpleLogToCout) " telemetry.sdk.name: opentelemetry\n", " telemetry.sdk.language: cpp\n", " attributes : \n", + " event_id : 0\n" + " event_name : \n", " trace_id : 00000000000000000000000000000000\n", " span_id : 0000000000000000\n", " trace_flags : 00\n", @@ -248,6 +254,8 @@ TEST(OStreamLogRecordExporter, LogWithStringAttributesToCerr) " key1: val1\n", " attributes : \n", " a: 1\n", + " event_id : 0\n" + " event_name : \n", " trace_id : 00000000000000000000000000000000\n", " span_id : 0000000000000000\n", " trace_flags : 00\n", @@ -327,6 +335,8 @@ TEST(OStreamLogRecordExporter, LogWithVariantTypesToClog) " res1: [1,2,3]\n", " attributes : \n", " attr1: [0,1,0]\n", + " event_id : 0\n" + " event_name : \n", " trace_id : 00000000000000000000000000000000\n", " span_id : 0000000000000000\n", " trace_flags : 00\n", @@ -398,6 +408,79 @@ TEST(OStreamLogRecordExporter, IntegrationTest) " telemetry.sdk.name: opentelemetry\n", " telemetry.sdk.language: cpp\n", " attributes : \n", + " event_id : 0\n" + " event_name : \n", + " trace_id : 00000000000000000000000000000000\n", + " span_id : 0000000000000000\n", + " trace_flags : 00\n", + " scope : \n", + " name : opentelelemtry_library\n", + " version : " OPENTELEMETRY_SDK_VERSION "\n", + " schema_url : https://opentelemetry.io/schemas/1.11.0\n", + " attributes : \n", + " scope.attr.key: 123\n", + "}\n"}; + + std::string ostream_output = stdcoutOutput.str(); + for (auto &expected : expected_output) + { + std::string::size_type result = ostream_output.find(expected); + if (result == std::string::npos) + { + std::cout << "Can not find: \"" << expected << "\" in\n" << ostream_output << std::endl; + } + ASSERT_NE(result, std::string::npos); + } +} + +// Test using the simple log processor and ostream exporter to cout +// and use the rest of the logging pipeline (Logger, LoggerProvider, Provider) and user-facing API +// as well +TEST(OStreamLogRecordExporter, IntegrationTestWithEventId) +{ + // Initialize a logger + auto exporter = + std::unique_ptr(new exporterlogs::OStreamLogRecordExporter); + auto sdkProvider = std::shared_ptr(new sdklogs::LoggerProvider()); + sdkProvider->AddProcessor(std::unique_ptr( + new sdklogs::SimpleLogRecordProcessor(std::move(exporter)))); + auto apiProvider = nostd::shared_ptr(sdkProvider); + auto provider = nostd::shared_ptr(apiProvider); + logs_api::Provider::SetLoggerProvider(provider); + const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"}; + auto logger = logs_api::Provider::GetLoggerProvider()->GetLogger( + "Logger", "opentelelemtry_library", OPENTELEMETRY_SDK_VERSION, schema_url, true, + {{"scope.attr.key", 123}}); + + // Back up cout's streambuf + std::streambuf *original = std::cout.rdbuf(); + + // Redirect cout to our string stream + std::stringstream stdcoutOutput; + std::cout.rdbuf(stdcoutOutput.rdbuf()); + + logs_api::EventId event_id{12345678, "test_event_id"}; + + // Write a log to ostream exporter + logger->Debug(event_id, "Hello {key1} {key2}", + common::MakeKeyValueIterableView({{"key1", 123}, {"key2", "value2"}})); + + // Restore cout's original streambuf + std::cout.rdbuf(original); + + // Compare actual vs expected outputs + std::vector expected_output{ + " severity_num : 5\n" + " severity_text : DEBUG\n" + " body : Hello {key1} {key2}\n", + " resource : \n", + " telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n", + " service.name: unknown_service\n", + " telemetry.sdk.name: opentelemetry\n", + " telemetry.sdk.language: cpp\n", + " attributes : \n", + " event_id : 12345678\n" + " event_name : test_event_id\n", " trace_id : 00000000000000000000000000000000\n", " span_id : 0000000000000000\n", " trace_flags : 00\n", diff --git a/exporters/otlp/BUILD b/exporters/otlp/BUILD index 98ae13ebb1..01dc83f00b 100644 --- a/exporters/otlp/BUILD +++ b/exporters/otlp/BUILD @@ -61,6 +61,9 @@ cc_library( "//sdk/src/common:global_log_handler", "@com_github_grpc_grpc//:grpc++", "@com_github_opentelemetry_proto//:common_proto_cc", + "@com_github_opentelemetry_proto//:logs_service_grpc_cc", + "@com_github_opentelemetry_proto//:metrics_service_grpc_cc", + "@com_github_opentelemetry_proto//:trace_service_grpc_cc", ], ) @@ -268,7 +271,6 @@ cc_library( ":otlp_grpc_client", "//ext:headers", "//sdk/src/logs", - "@com_github_opentelemetry_proto//:logs_service_proto_cc", # For gRPC "@com_github_opentelemetry_proto//:logs_service_grpc_cc", ], @@ -407,6 +409,7 @@ cc_test( "test", ], deps = [ + ":otlp_grpc_exporter", ":otlp_grpc_log_record_exporter", "//api", "//sdk/src/logs", diff --git a/exporters/otlp/CMakeLists.txt b/exporters/otlp/CMakeLists.txt index 585e253939..386bfcd918 100644 --- a/exporters/otlp/CMakeLists.txt +++ b/exporters/otlp/CMakeLists.txt @@ -8,6 +8,7 @@ add_library( src/otlp_metric_utils.cc) set_target_properties(opentelemetry_otlp_recordable PROPERTIES EXPORT_NAME otlp_recordable) +set_target_version(opentelemetry_otlp_recordable) target_include_directories( opentelemetry_otlp_recordable @@ -15,9 +16,6 @@ target_include_directories( "$") set(OPENTELEMETRY_OTLP_TARGETS opentelemetry_otlp_recordable) -target_link_libraries( - opentelemetry_otlp_recordable - PUBLIC opentelemetry_trace opentelemetry_resources opentelemetry_proto) if(WITH_LOGS_PREVIEW) target_link_libraries(opentelemetry_otlp_recordable PUBLIC opentelemetry_logs) @@ -31,12 +29,20 @@ if(WITH_OTLP_GRPC) src/otlp_grpc_utils.cc) set_target_properties(opentelemetry_exporter_otlp_grpc_client PROPERTIES EXPORT_NAME otlp_grpc_client) + set_target_version(opentelemetry_exporter_otlp_grpc_client) + + # Because opentelemetry_proto_grpc depends on gRPC, and gRPC can only be + # linked in one dynamic library or executable (otherwise, there may be + # conflicts with some global variables in certain versions of gRPC), we have + # switched the link for opentelemetry_exporter_otlp_grpc_client into all + # targets that depend on opentelemetry_proto_grpc. target_link_libraries( opentelemetry_exporter_otlp_grpc_client - PUBLIC opentelemetry_sdk opentelemetry_ext opentelemetry_proto) + PUBLIC opentelemetry_sdk opentelemetry_common opentelemetry_ext + # gRPC::grpc++ must be linked before opentelemetry_proto_grpc. + opentelemetry_proto_grpc + PRIVATE gRPC::grpc++) - target_link_libraries(opentelemetry_exporter_otlp_grpc_client - PRIVATE gRPC::grpc++) get_target_property(GRPC_INCLUDE_DIRECTORY gRPC::grpc++ INTERFACE_INCLUDE_DIRECTORIES) if(GRPC_INCLUDE_DIRECTORY) @@ -57,6 +63,7 @@ if(WITH_OTLP_GRPC) set_target_properties(opentelemetry_exporter_otlp_grpc PROPERTIES EXPORT_NAME otlp_grpc_exporter) + set_target_version(opentelemetry_exporter_otlp_grpc) target_link_libraries( opentelemetry_exporter_otlp_grpc @@ -72,6 +79,7 @@ if(WITH_OTLP_GRPC) set_target_properties(opentelemetry_exporter_otlp_grpc_log PROPERTIES EXPORT_NAME otlp_grpc_log_record_exporter) + set_target_version(opentelemetry_exporter_otlp_grpc_log) target_link_libraries( opentelemetry_exporter_otlp_grpc_log @@ -86,6 +94,7 @@ if(WITH_OTLP_GRPC) set_target_properties(opentelemetry_exporter_otlp_grpc_metrics PROPERTIES EXPORT_NAME otlp_grpc_metrics_exporter) + set_target_version(opentelemetry_exporter_otlp_grpc_metrics) target_link_libraries( opentelemetry_exporter_otlp_grpc_metrics @@ -100,6 +109,8 @@ if(WITH_OTLP_HTTP) add_library(opentelemetry_exporter_otlp_http_client src/otlp_http_client.cc) set_target_properties(opentelemetry_exporter_otlp_http_client PROPERTIES EXPORT_NAME otlp_http_client) + set_target_version(opentelemetry_exporter_otlp_http_client) + target_link_libraries( opentelemetry_exporter_otlp_http_client PUBLIC opentelemetry_sdk opentelemetry_proto opentelemetry_http_client_curl @@ -121,6 +132,7 @@ if(WITH_OTLP_HTTP) set_target_properties(opentelemetry_exporter_otlp_http PROPERTIES EXPORT_NAME otlp_http_exporter) + set_target_version(opentelemetry_exporter_otlp_http) target_link_libraries( opentelemetry_exporter_otlp_http @@ -137,6 +149,7 @@ if(WITH_OTLP_HTTP) set_target_properties(opentelemetry_exporter_otlp_http_log PROPERTIES EXPORT_NAME otlp_http_log_record_exporter) + set_target_version(opentelemetry_exporter_otlp_http_log) target_link_libraries( opentelemetry_exporter_otlp_http_log @@ -152,6 +165,7 @@ if(WITH_OTLP_HTTP) set_target_properties(opentelemetry_exporter_otlp_http_metric PROPERTIES EXPORT_NAME otlp_http_metric_exporter) + set_target_version(opentelemetry_exporter_otlp_http_metric) target_link_libraries( opentelemetry_exporter_otlp_http_metric @@ -162,6 +176,10 @@ if(WITH_OTLP_HTTP) opentelemetry_exporter_otlp_http_metric) endif() +target_link_libraries( + opentelemetry_otlp_recordable + PUBLIC opentelemetry_trace opentelemetry_resources opentelemetry_proto) + if(OPENTELEMETRY_INSTALL) install( TARGETS ${OPENTELEMETRY_OTLP_TARGETS} @@ -249,9 +267,14 @@ if(BUILD_TESTING) add_executable(otlp_grpc_log_record_exporter_test test/otlp_grpc_log_record_exporter_test.cc) target_link_libraries( - otlp_grpc_log_record_exporter_test ${GTEST_BOTH_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} ${GMOCK_LIB} - opentelemetry_exporter_otlp_grpc_log opentelemetry_logs) + otlp_grpc_log_record_exporter_test + ${GTEST_BOTH_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ${GMOCK_LIB} + opentelemetry_exporter_otlp_grpc + opentelemetry_exporter_otlp_grpc_log + opentelemetry_trace + opentelemetry_logs) gtest_add_tests( TARGET otlp_grpc_log_record_exporter_test TEST_PREFIX exporter.otlp. diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client.h index 4ac2c4fe01..75defd6b42 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client.h @@ -9,6 +9,17 @@ #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" +#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h" + +#include "opentelemetry/proto/collector/metrics/v1/metrics_service.grpc.pb.h" +#include "opentelemetry/proto/collector/trace/v1/trace_service.grpc.pb.h" + +#ifdef ENABLE_LOGS_PREVIEW +# include "opentelemetry/proto/collector/logs/v1/logs_service.grpc.pb.h" +#endif + +#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h" + OPENTELEMETRY_BEGIN_NAMESPACE namespace exporter { @@ -33,14 +44,49 @@ class OtlpGrpcClient const OtlpGrpcExporterOptions &options); /** - * Create service stub to communicate with the OpenTelemetry Collector. + * Create gRPC CompletionQueue to async call RPC. + */ + static std::unique_ptr MakeCompletionQueue(); + + /** + * Create trace service stub to communicate with the OpenTelemetry Collector. + */ + static std::unique_ptr + MakeTraceServiceStub(const OtlpGrpcExporterOptions &options); + + /** + * Create metrics service stub to communicate with the OpenTelemetry Collector. + */ + static std::unique_ptr + MakeMetricsServiceStub(const OtlpGrpcExporterOptions &options); + +#ifdef ENABLE_LOGS_PREVIEW + /** + * Create logs service stub to communicate with the OpenTelemetry Collector. */ - template - static std::unique_ptr MakeServiceStub( - const OtlpGrpcExporterOptions &options) - { - return ServiceType::NewStub(MakeChannel(options)); - } + static std::unique_ptr + MakeLogsServiceStub(const OtlpGrpcExporterOptions &options); +#endif + + static grpc::Status DelegateExport( + proto::collector::trace::v1::TraceService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::trace::v1::ExportTraceServiceRequest &request, + proto::collector::trace::v1::ExportTraceServiceResponse *response); + + static grpc::Status DelegateExport( + proto::collector::metrics::v1::MetricsService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::metrics::v1::ExportMetricsServiceRequest &request, + proto::collector::metrics::v1::ExportMetricsServiceResponse *response); + +#ifdef ENABLE_LOGS_PREVIEW + static grpc::Status DelegateExport( + proto::collector::logs::v1::LogsService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::logs::v1::ExportLogsServiceRequest &request, + proto::collector::logs::v1::ExportLogsServiceResponse *response); +#endif }; } // namespace otlp } // namespace exporter diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h index ab64d7e769..7aff1e24a5 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h @@ -75,6 +75,7 @@ class OtlpGrpcExporter final : public opentelemetry::sdk::trace::SpanExporter // For testing friend class OtlpGrpcExporterTestPeer; + friend class OtlpGrpcLogRecordExporterTestPeer; // Store service stub internally. Useful for testing. std::unique_ptr trace_service_stub_; diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h index cef1b3ef8f..0648fe3308 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h @@ -67,6 +67,16 @@ class OtlpLogRecordable final : public opentelemetry::sdk::logs::Recordable */ void SetBody(const opentelemetry::common::AttributeValue &message) noexcept override; + /** + * @brief Set the Event Id for this log. + * @param id the event Id to set + * @param name the event name to set + */ + void SetEventId(int64_t /* id */, nostd::string_view /* name */) noexcept override + { + // TODO: export Event Id to OTLP + } + /** * Set the trace id for this log. * @param trace_id the trace id to set diff --git a/exporters/otlp/src/otlp_grpc_client.cc b/exporters/otlp/src/otlp_grpc_client.cc index 158f276000..9250f87cc4 100644 --- a/exporters/otlp/src/otlp_grpc_client.cc +++ b/exporters/otlp/src/otlp_grpc_client.cc @@ -103,6 +103,60 @@ std::unique_ptr OtlpGrpcClient::MakeClientContext( return context; } +std::unique_ptr OtlpGrpcClient::MakeCompletionQueue() +{ + return std::unique_ptr(new grpc::CompletionQueue()); +} + +std::unique_ptr +OtlpGrpcClient::MakeTraceServiceStub(const OtlpGrpcExporterOptions &options) +{ + return proto::collector::trace::v1::TraceService::NewStub(MakeChannel(options)); +} + +std::unique_ptr +OtlpGrpcClient::MakeMetricsServiceStub(const OtlpGrpcExporterOptions &options) +{ + return proto::collector::metrics::v1::MetricsService::NewStub(MakeChannel(options)); +} + +#ifdef ENABLE_LOGS_PREVIEW +std::unique_ptr +OtlpGrpcClient::MakeLogsServiceStub(const OtlpGrpcExporterOptions &options) +{ + return proto::collector::logs::v1::LogsService::NewStub(MakeChannel(options)); +} +#endif + +grpc::Status OtlpGrpcClient::DelegateExport( + proto::collector::trace::v1::TraceService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::trace::v1::ExportTraceServiceRequest &request, + proto::collector::trace::v1::ExportTraceServiceResponse *response) +{ + return stub->Export(context, request, response); +} + +grpc::Status OtlpGrpcClient::DelegateExport( + proto::collector::metrics::v1::MetricsService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::metrics::v1::ExportMetricsServiceRequest &request, + proto::collector::metrics::v1::ExportMetricsServiceResponse *response) +{ + return stub->Export(context, request, response); +} + +#ifdef ENABLE_LOGS_PREVIEW +grpc::Status OtlpGrpcClient::DelegateExport( + proto::collector::logs::v1::LogsService::StubInterface *stub, + grpc::ClientContext *context, + const proto::collector::logs::v1::ExportLogsServiceRequest &request, + proto::collector::logs::v1::ExportLogsServiceResponse *response) +{ + return stub->Export(context, request, response); +} +#endif + } // namespace otlp } // namespace exporter OPENTELEMETRY_END_NAMESPACE diff --git a/exporters/otlp/src/otlp_grpc_exporter.cc b/exporters/otlp/src/otlp_grpc_exporter.cc index 89ad1fb2cf..30a9b63fe4 100644 --- a/exporters/otlp/src/otlp_grpc_exporter.cc +++ b/exporters/otlp/src/otlp_grpc_exporter.cc @@ -23,9 +23,7 @@ namespace otlp OtlpGrpcExporter::OtlpGrpcExporter() : OtlpGrpcExporter(OtlpGrpcExporterOptions()) {} OtlpGrpcExporter::OtlpGrpcExporter(const OtlpGrpcExporterOptions &options) - : options_(options), - trace_service_stub_( - OtlpGrpcClient::MakeServiceStub(options)) + : options_(options), trace_service_stub_(OtlpGrpcClient::MakeTraceServiceStub(options)) {} OtlpGrpcExporter::OtlpGrpcExporter( @@ -60,7 +58,8 @@ sdk::common::ExportResult OtlpGrpcExporter::Export( auto context = OtlpGrpcClient::MakeClientContext(options_); proto::collector::trace::v1::ExportTraceServiceResponse response; - grpc::Status status = trace_service_stub_->Export(context.get(), request, &response); + grpc::Status status = + OtlpGrpcClient::DelegateExport(trace_service_stub_.get(), context.get(), request, &response); if (!status.ok()) { diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter.cc index 1873ac8ad7..6cef1d07b6 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter.cc @@ -36,9 +36,7 @@ OtlpGrpcLogRecordExporter::OtlpGrpcLogRecordExporter() {} OtlpGrpcLogRecordExporter::OtlpGrpcLogRecordExporter(const OtlpGrpcExporterOptions &options) - : options_(options), - log_service_stub_( - OtlpGrpcClient::MakeServiceStub(options)) + : options_(options), log_service_stub_(OtlpGrpcClient::MakeLogsServiceStub(options)) {} OtlpGrpcLogRecordExporter::OtlpGrpcLogRecordExporter( @@ -74,7 +72,8 @@ opentelemetry::sdk::common::ExportResult OtlpGrpcLogRecordExporter::Export( auto context = OtlpGrpcClient::MakeClientContext(options_); proto::collector::logs::v1::ExportLogsServiceResponse response; - grpc::Status status = log_service_stub_->Export(context.get(), request, &response); + grpc::Status status = + OtlpGrpcClient::DelegateExport(log_service_stub_.get(), context.get(), request, &response); if (!status.ok()) { diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter.cc b/exporters/otlp/src/otlp_grpc_metric_exporter.cc index 3fd50e421b..fd503f9836 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter.cc @@ -25,8 +25,7 @@ OtlpGrpcMetricExporter::OtlpGrpcMetricExporter(const OtlpGrpcMetricExporterOptio : options_(options), aggregation_temporality_selector_{ OtlpMetricUtils::ChooseTemporalitySelector(options_.aggregation_temporality)}, - metrics_service_stub_( - OtlpGrpcClient::MakeServiceStub(options)) + metrics_service_stub_(OtlpGrpcClient::MakeMetricsServiceStub(options)) {} OtlpGrpcMetricExporter::OtlpGrpcMetricExporter( @@ -67,7 +66,8 @@ opentelemetry::sdk::common::ExportResult OtlpGrpcMetricExporter::Export( auto context = OtlpGrpcClient::MakeClientContext(options_); proto::collector::metrics::v1::ExportMetricsServiceResponse response; - grpc::Status status = metrics_service_stub_->Export(context.get(), request, &response); + grpc::Status status = OtlpGrpcClient::DelegateExport(metrics_service_stub_.get(), context.get(), + request, &response); if (!status.ok()) { diff --git a/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc b/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc index 450bebc218..a0455adb70 100644 --- a/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc +++ b/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc @@ -5,11 +5,13 @@ # include +# include "opentelemetry/exporters/otlp/otlp_grpc_exporter.h" # include "opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter.h" # include "opentelemetry/exporters/otlp/protobuf_include_prefix.h" # include "opentelemetry/proto/collector/logs/v1/logs_service_mock.grpc.pb.h" +# include "opentelemetry/proto/collector/trace/v1/trace_service_mock.grpc.pb.h" # include "opentelemetry/exporters/otlp/protobuf_include_suffix.h" @@ -18,6 +20,10 @@ # include "opentelemetry/sdk/logs/exporter.h" # include "opentelemetry/sdk/logs/logger_provider.h" # include "opentelemetry/sdk/resource/resource.h" +# include "opentelemetry/sdk/trace/exporter.h" +# include "opentelemetry/sdk/trace/simple_processor_factory.h" +# include "opentelemetry/sdk/trace/tracer_provider_factory.h" +# include "opentelemetry/trace/provider.h" # include @@ -45,6 +51,13 @@ class OtlpGrpcLogRecordExporterTestPeer : public ::testing::Test new OtlpGrpcLogRecordExporter(std::move(stub_interface))); } + std::unique_ptr GetExporter( + std::unique_ptr &stub_interface) + { + return std::unique_ptr( + new OtlpGrpcExporter(std::move(stub_interface))); + } + // Get the options associated with the given exporter. const OtlpGrpcExporterOptions &GetOptions(std::unique_ptr &exporter) { @@ -135,29 +148,54 @@ TEST_F(OtlpGrpcLogRecordExporterTestPeer, ExportIntegrationTest) '3', '2', '1', '0'}; opentelemetry::trace::SpanId span_id{span_id_bin}; - const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"}; - auto logger = provider->GetLogger("test", "opentelelemtry_library", "", schema_url, true, - {{"scope_key1", "scope_value"}, {"scope_key2", 2}}); - std::unordered_map attributes; - attributes["service.name"] = "unit_test_service"; - attributes["tenant.id"] = "test_user"; - attributes["bool_value"] = true; - attributes["int32_value"] = static_cast(1); - attributes["uint32_value"] = static_cast(2); - attributes["int64_value"] = static_cast(0x1100000000LL); - attributes["uint64_value"] = static_cast(0x1200000000ULL); - attributes["double_value"] = static_cast(3.1); - attributes["vec_bool_value"] = attribute_storage_bool_value; - attributes["vec_int32_value"] = attribute_storage_int32_value; - attributes["vec_uint32_value"] = attribute_storage_uint32_value; - attributes["vec_int64_value"] = attribute_storage_int64_value; - attributes["vec_uint64_value"] = attribute_storage_uint64_value; - attributes["vec_double_value"] = attribute_storage_double_value; - attributes["vec_string_value"] = attribute_storage_string_value; - logger->EmitLogRecord( - opentelemetry::logs::Severity::kInfo, "Log message", attributes, trace_id, span_id, - opentelemetry::trace::TraceFlags{opentelemetry::trace::TraceFlags::kIsSampled}, - std::chrono::system_clock::now()); + auto trace_mock_stub = new proto::collector::trace::v1::MockTraceServiceStub(); + std::unique_ptr trace_stub_interface( + trace_mock_stub); + + auto trace_provider = opentelemetry::nostd::shared_ptr( + opentelemetry::sdk::trace::TracerProviderFactory::Create( + opentelemetry::sdk::trace::SimpleSpanProcessorFactory::Create( + GetExporter(trace_stub_interface)))); + + // Trace and Logs should both receive datas when links static gRPC on ELF ABI. + EXPECT_CALL(*trace_mock_stub, Export(_, _, _)) + .Times(AtLeast(1)) + .WillRepeatedly(Return(grpc::Status::OK)); + + { + const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"}; + + auto tracer = trace_provider->GetTracer("opentelelemtry_library", "", schema_url); + opentelemetry::trace::Provider::SetTracerProvider(std::move(trace_provider)); + auto trace_span = tracer->StartSpan("test_log"); + opentelemetry::trace::Scope trace_scope{trace_span}; + + auto logger = provider->GetLogger("test", "opentelelemtry_library", "", schema_url, true, + {{"scope_key1", "scope_value"}, {"scope_key2", 2}}); + std::unordered_map attributes; + attributes["service.name"] = "unit_test_service"; + attributes["tenant.id"] = "test_user"; + attributes["bool_value"] = true; + attributes["int32_value"] = static_cast(1); + attributes["uint32_value"] = static_cast(2); + attributes["int64_value"] = static_cast(0x1100000000LL); + attributes["uint64_value"] = static_cast(0x1200000000ULL); + attributes["double_value"] = static_cast(3.1); + attributes["vec_bool_value"] = attribute_storage_bool_value; + attributes["vec_int32_value"] = attribute_storage_int32_value; + attributes["vec_uint32_value"] = attribute_storage_uint32_value; + attributes["vec_int64_value"] = attribute_storage_int64_value; + attributes["vec_uint64_value"] = attribute_storage_uint64_value; + attributes["vec_double_value"] = attribute_storage_double_value; + attributes["vec_string_value"] = attribute_storage_string_value; + logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, "Log message", attributes, + trace_span->GetContext(), std::chrono::system_clock::now()); + } + + opentelemetry::trace::Provider::SetTracerProvider( + opentelemetry::nostd::shared_ptr( + new opentelemetry::trace::NoopTracerProvider())); + trace_provider = opentelemetry::nostd::shared_ptr(); } } // namespace otlp diff --git a/exporters/prometheus/CMakeLists.txt b/exporters/prometheus/CMakeLists.txt index 1e6c79e376..806ca01f70 100644 --- a/exporters/prometheus/CMakeLists.txt +++ b/exporters/prometheus/CMakeLists.txt @@ -11,6 +11,8 @@ add_library(opentelemetry_exporter_prometheus src/exporter.cc src/collector.cc set_target_properties(opentelemetry_exporter_prometheus PROPERTIES EXPORT_NAME prometheus_exporter) +set_target_version(opentelemetry_exporter_prometheus) + target_include_directories( opentelemetry_exporter_prometheus PUBLIC "$" diff --git a/exporters/zipkin/CMakeLists.txt b/exporters/zipkin/CMakeLists.txt index 9cc997023f..60f8a80a2a 100644 --- a/exporters/zipkin/CMakeLists.txt +++ b/exporters/zipkin/CMakeLists.txt @@ -12,6 +12,8 @@ target_include_directories( PUBLIC "$" "$") +set_target_version(opentelemetry_exporter_zipkin_trace) + target_link_libraries( opentelemetry_exporter_zipkin_trace PUBLIC opentelemetry_trace opentelemetry_http_client_curl diff --git a/ext/include/opentelemetry/ext/http/client/curl/http_client_curl.h b/ext/include/opentelemetry/ext/http/client/curl/http_client_curl.h index dfce580d9d..900c5b6e81 100644 --- a/ext/include/opentelemetry/ext/http/client/curl/http_client_curl.h +++ b/ext/include/opentelemetry/ext/http/client/curl/http_client_curl.h @@ -359,7 +359,7 @@ class HttpClient : public opentelemetry::ext::http::client::HttpClient std::recursive_mutex session_ids_m_; std::unordered_map> sessions_; std::unordered_set pending_to_add_session_ids_; - std::unordered_set pending_to_abort_session_ids_; + std::unordered_map> pending_to_abort_sessions_; std::unordered_map pending_to_remove_session_handles_; std::list> pending_to_remove_sessions_; diff --git a/ext/include/opentelemetry/ext/http/client/curl/http_operation_curl.h b/ext/include/opentelemetry/ext/http/client/curl/http_operation_curl.h index 55a488f131..65355a05cd 100644 --- a/ext/include/opentelemetry/ext/http/client/curl/http_operation_curl.h +++ b/ext/include/opentelemetry/ext/http/client/curl/http_operation_curl.h @@ -13,6 +13,7 @@ # include #endif +#include #include #include #include diff --git a/ext/include/opentelemetry/ext/http/common/url_parser.h b/ext/include/opentelemetry/ext/http/common/url_parser.h index b85bf379fd..31da004003 100644 --- a/ext/include/opentelemetry/ext/http/common/url_parser.h +++ b/ext/include/opentelemetry/ext/http/common/url_parser.h @@ -84,7 +84,7 @@ class UrlParser pos = url_.find_first_of("/?", cpos); if (pos == std::string::npos) { - path_ = "/"; // use default path + path_ = std::string("/"); // use default path if (is_port) { port_ = static_cast( @@ -123,7 +123,7 @@ class UrlParser } return; } - path_ = "/"; + path_ = std::string("/"); if (url_[cpos] == '?') { query_ = std::string(url_.begin() + cpos, url_.begin() + url_.length()); diff --git a/ext/src/http/client/curl/CMakeLists.txt b/ext/src/http/client/curl/CMakeLists.txt index 6684c5f820..7e2507bd75 100644 --- a/ext/src/http/client/curl/CMakeLists.txt +++ b/ext/src/http/client/curl/CMakeLists.txt @@ -7,7 +7,9 @@ add_library( set_target_properties(opentelemetry_http_client_curl PROPERTIES EXPORT_NAME http_client_curl) - +set_target_version(opentelemetry_http_client_curl) +target_link_libraries(opentelemetry_http_client_curl + PUBLIC opentelemetry_common) if(TARGET CURL::libcurl) target_link_libraries( opentelemetry_http_client_curl diff --git a/ext/src/http/client/curl/http_client_curl.cc b/ext/src/http/client/curl/http_client_curl.cc index 52942f6433..94bbf9fa7b 100644 --- a/ext/src/http/client/curl/http_client_curl.cc +++ b/ext/src/http/client/curl/http_client_curl.cc @@ -257,8 +257,8 @@ void HttpClient::CleanupSession(uint64_t session_id) } else if (session->IsSessionActive() && session->GetOperation()) { - // If this session is alread waiting to be removed, just wakeup background thread to call - // doRemoveSessions() + // If this session is already running, give it to the background thread for cleanup. + pending_to_abort_sessions_[session_id] = std::move(session); wakeupBackgroundThread(); } } @@ -392,7 +392,7 @@ void HttpClient::ScheduleAddSession(uint64_t session_id) std::lock_guard lock_guard{session_ids_m_}; pending_to_add_session_ids_.insert(session_id); pending_to_remove_session_handles_.erase(session_id); - pending_to_abort_session_ids_.erase(session_id); + pending_to_abort_sessions_.erase(session_id); } wakeupBackgroundThread(); @@ -401,9 +401,21 @@ void HttpClient::ScheduleAddSession(uint64_t session_id) void HttpClient::ScheduleAbortSession(uint64_t session_id) { { - std::lock_guard lock_guard{session_ids_m_}; - pending_to_abort_session_ids_.insert(session_id); - pending_to_add_session_ids_.erase(session_id); + std::lock_guard lock_guard{sessions_m_}; + auto session = sessions_.find(session_id); + if (session == sessions_.end()) + { + std::lock_guard lock_guard{session_ids_m_}; + pending_to_add_session_ids_.erase(session_id); + } + else + { + std::lock_guard lock_guard{session_ids_m_}; + pending_to_abort_sessions_[session_id] = std::move(session->second); + pending_to_add_session_ids_.erase(session_id); + + sessions_.erase(session); + } } wakeupBackgroundThread(); @@ -472,33 +484,23 @@ bool HttpClient::doAddSessions() bool HttpClient::doAbortSessions() { - std::list> abort_sessions; - std::unordered_set pending_to_abort_session_ids; + std::unordered_map> pending_to_abort_sessions; { std::lock_guard session_id_lock_guard{session_ids_m_}; - pending_to_abort_session_ids_.swap(pending_to_abort_session_ids); + pending_to_abort_sessions_.swap(pending_to_abort_sessions); } + bool has_data = false; + for (auto session : pending_to_abort_sessions) { - std::lock_guard lock_guard{sessions_m_}; - for (auto &session_id : pending_to_abort_session_ids) + if (!session.second) { - auto session = sessions_.find(session_id); - if (session == sessions_.end()) - { - continue; - } - - abort_sessions.push_back(session->second); + continue; } - } - bool has_data = false; - for (auto session : abort_sessions) - { - if (session->GetOperation()) + if (session.second->GetOperation()) { - session->FinishOperation(); + session.second->FinishOperation(); has_data = true; } } diff --git a/ext/src/http/client/curl/http_operation_curl.cc b/ext/src/http/client/curl/http_operation_curl.cc index 4d472ac7f5..dcb1ec9042 100644 --- a/ext/src/http/client/curl/http_operation_curl.cc +++ b/ext/src/http/client/curl/http_operation_curl.cc @@ -8,6 +8,11 @@ #include "opentelemetry/ext/http/client/curl/http_client_curl.h" #include "opentelemetry/sdk/common/global_log_handler.h" +// CURL_VERSION_BITS was added in CURL 7.43.0 +#ifndef CURL_VERSION_BITS +# define CURL_VERSION_BITS(x, y, z) ((x) << 16 | (y) << 8 | (z)) +#endif + OPENTELEMETRY_BEGIN_NAMESPACE namespace ext { diff --git a/ext/src/zpages/CMakeLists.txt b/ext/src/zpages/CMakeLists.txt index 5237d2da9b..8ff225112b 100644 --- a/ext/src/zpages/CMakeLists.txt +++ b/ext/src/zpages/CMakeLists.txt @@ -12,6 +12,7 @@ add_library( ../../include/opentelemetry/ext/zpages/tracez_http_server.h) set_target_properties(opentelemetry_zpages PROPERTIES EXPORT_NAME zpages) +set_target_version(opentelemetry_zpages) target_link_libraries(opentelemetry_zpages PUBLIC opentelemetry_ext opentelemetry_trace) diff --git a/opentracing-shim/CMakeLists.txt b/opentracing-shim/CMakeLists.txt index 3a57ac07bf..5f83de5474 100644 --- a/opentracing-shim/CMakeLists.txt +++ b/opentracing-shim/CMakeLists.txt @@ -7,6 +7,7 @@ add_library(${this_target} src/shim_utils.cc src/span_shim.cc src/span_context_shim.cc src/tracer_shim.cc) set_target_properties(${this_target} PROPERTIES EXPORT_NAME opentracing_shim) +set_target_version(${this_target}) target_include_directories( ${this_target} PUBLIC "$" diff --git a/sdk/include/opentelemetry/sdk/logs/multi_recordable.h b/sdk/include/opentelemetry/sdk/logs/multi_recordable.h index 8bbc2ae200..5944d49b39 100644 --- a/sdk/include/opentelemetry/sdk/logs/multi_recordable.h +++ b/sdk/include/opentelemetry/sdk/logs/multi_recordable.h @@ -55,6 +55,13 @@ class MultiRecordable final : public Recordable */ void SetBody(const opentelemetry::common::AttributeValue &message) noexcept override; + /** + * Set the event id + * @param id the event id to set + * @param name the event name to set + */ + void SetEventId(int64_t id, nostd::string_view name) noexcept override; + /** * Set the trace id for this log. * @param trace_id the trace id to set diff --git a/sdk/include/opentelemetry/sdk/logs/read_write_log_record.h b/sdk/include/opentelemetry/sdk/logs/read_write_log_record.h index c81a2da126..a850072134 100644 --- a/sdk/include/opentelemetry/sdk/logs/read_write_log_record.h +++ b/sdk/include/opentelemetry/sdk/logs/read_write_log_record.h @@ -87,6 +87,25 @@ class ReadWriteLogRecord final : public ReadableLogRecord */ const opentelemetry::common::AttributeValue &GetBody() const noexcept override; + /** + * Set the Event Id object + * @param id the event Id to set + * @param name the event name to set + */ + void SetEventId(int64_t id, nostd::string_view name) noexcept override; + + /** + * Get event Id of this log. + * @return the event Id of this log. + */ + int64_t GetEventId() const noexcept override; + + /** + * Get event name of this log. + * @return the event name of this log. + */ + nostd::string_view GetEventName() const noexcept override; + /** * Set the trace id for this log. * @param trace_id the trace id to set @@ -176,6 +195,9 @@ class ReadWriteLogRecord final : public ReadableLogRecord opentelemetry::common::SystemTimestamp timestamp_; opentelemetry::common::SystemTimestamp observed_timestamp_; + int64_t event_id_; + std::string event_name_; + // We do not pay for trace state when not necessary struct TraceState { diff --git a/sdk/include/opentelemetry/sdk/logs/readable_log_record.h b/sdk/include/opentelemetry/sdk/logs/readable_log_record.h index 7b3d8ad502..90a1c4b7b7 100644 --- a/sdk/include/opentelemetry/sdk/logs/readable_log_record.h +++ b/sdk/include/opentelemetry/sdk/logs/readable_log_record.h @@ -64,6 +64,18 @@ class ReadableLogRecord : public Recordable */ virtual const opentelemetry::common::AttributeValue &GetBody() const noexcept = 0; + /** + * Get the Event id. + * @return the event id + */ + virtual int64_t GetEventId() const noexcept = 0; + + /** + * Get the Event Name. + * @return the event name + */ + virtual nostd::string_view GetEventName() const noexcept = 0; + /** * Get the trace id of this log. * @return the trace id of this log diff --git a/sdk/include/opentelemetry/sdk/metrics/data/exemplar_data.h b/sdk/include/opentelemetry/sdk/metrics/data/exemplar_data.h index f04b06c9f6..b9f72e9b58 100644 --- a/sdk/include/opentelemetry/sdk/metrics/data/exemplar_data.h +++ b/sdk/include/opentelemetry/sdk/metrics/data/exemplar_data.h @@ -4,11 +4,13 @@ #pragma once #include + #include "opentelemetry/common/timestamp.h" #include "opentelemetry/context/context.h" #include "opentelemetry/sdk/common/attribute_utils.h" #include "opentelemetry/sdk/metrics/data/metric_data.h" #include "opentelemetry/sdk/metrics/export/metric_producer.h" +#include "opentelemetry/trace/span_context.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace sdk diff --git a/sdk/src/common/CMakeLists.txt b/sdk/src/common/CMakeLists.txt index b23a93e80c..7bb645f5b7 100644 --- a/sdk/src/common/CMakeLists.txt +++ b/sdk/src/common/CMakeLists.txt @@ -11,6 +11,7 @@ endif() add_library(opentelemetry_common ${COMMON_SRCS}) set_target_properties(opentelemetry_common PROPERTIES EXPORT_NAME common) +set_target_version(opentelemetry_common) target_link_libraries( opentelemetry_common PUBLIC opentelemetry_api opentelemetry_sdk diff --git a/sdk/src/logs/CMakeLists.txt b/sdk/src/logs/CMakeLists.txt index 2b7db6eb7c..e235e50696 100644 --- a/sdk/src/logs/CMakeLists.txt +++ b/sdk/src/logs/CMakeLists.txt @@ -26,6 +26,7 @@ set_target_properties(opentelemetry_logs PROPERTIES EXPORT_NAME logs) target_link_libraries(opentelemetry_logs PUBLIC opentelemetry_resources opentelemetry_common) +set_target_version(opentelemetry_logs) target_include_directories( opentelemetry_logs diff --git a/sdk/src/logs/multi_recordable.cc b/sdk/src/logs/multi_recordable.cc index 17e2c29777..c1e335ead2 100644 --- a/sdk/src/logs/multi_recordable.cc +++ b/sdk/src/logs/multi_recordable.cc @@ -101,6 +101,17 @@ void MultiRecordable::SetBody(const opentelemetry::common::AttributeValue &messa } } +void MultiRecordable::SetEventId(int64_t id, nostd::string_view name) noexcept +{ + for (auto &recordable : recordables_) + { + if (recordable.second) + { + recordable.second->SetEventId(id, name); + } + } +} + void MultiRecordable::SetTraceId(const opentelemetry::trace::TraceId &trace_id) noexcept { for (auto &recordable : recordables_) diff --git a/sdk/src/logs/read_write_log_record.cc b/sdk/src/logs/read_write_log_record.cc index e452fa20e9..f45c20adff 100644 --- a/sdk/src/logs/read_write_log_record.cc +++ b/sdk/src/logs/read_write_log_record.cc @@ -19,7 +19,9 @@ ReadWriteLogRecord::ReadWriteLogRecord() resource_(nullptr), instrumentation_scope_(nullptr), body_(nostd::string_view()), - observed_timestamp_(std::chrono::system_clock::now()) + observed_timestamp_(std::chrono::system_clock::now()), + event_id_(0), + event_name_("") {} ReadWriteLogRecord::~ReadWriteLogRecord() {} @@ -65,6 +67,22 @@ const opentelemetry::common::AttributeValue &ReadWriteLogRecord::GetBody() const return body_; } +void ReadWriteLogRecord::SetEventId(int64_t id, nostd::string_view name) noexcept +{ + event_id_ = id; + event_name_ = std::string{name}; +} + +int64_t ReadWriteLogRecord::GetEventId() const noexcept +{ + return event_id_; +} + +nostd::string_view ReadWriteLogRecord::GetEventName() const noexcept +{ + return nostd::string_view{event_name_}; +} + void ReadWriteLogRecord::SetTraceId(const opentelemetry::trace::TraceId &trace_id) noexcept { if (!trace_state_) diff --git a/sdk/src/metrics/CMakeLists.txt b/sdk/src/metrics/CMakeLists.txt index f53639332b..46d6d67212 100644 --- a/sdk/src/metrics/CMakeLists.txt +++ b/sdk/src/metrics/CMakeLists.txt @@ -22,8 +22,10 @@ add_library( sync_instruments.cc) set_target_properties(opentelemetry_metrics PROPERTIES EXPORT_NAME metrics) +set_target_version(opentelemetry_metrics) -target_link_libraries(opentelemetry_metrics PUBLIC opentelemetry_common) +target_link_libraries(opentelemetry_metrics PUBLIC opentelemetry_common + opentelemetry_resources) target_include_directories( opentelemetry_metrics diff --git a/sdk/src/resource/CMakeLists.txt b/sdk/src/resource/CMakeLists.txt index f39b6f2a8f..1a0510f678 100644 --- a/sdk/src/resource/CMakeLists.txt +++ b/sdk/src/resource/CMakeLists.txt @@ -4,6 +4,7 @@ add_library(opentelemetry_resources resource.cc resource_detector.cc) set_target_properties(opentelemetry_resources PROPERTIES EXPORT_NAME resources) +set_target_version(opentelemetry_resources) target_link_libraries(opentelemetry_resources opentelemetry_common) diff --git a/sdk/src/trace/CMakeLists.txt b/sdk/src/trace/CMakeLists.txt index 94c2059548..52c109acb8 100644 --- a/sdk/src/trace/CMakeLists.txt +++ b/sdk/src/trace/CMakeLists.txt @@ -23,6 +23,7 @@ add_library( random_id_generator_factory.cc) set_target_properties(opentelemetry_trace PROPERTIES EXPORT_NAME trace) +set_target_version(opentelemetry_trace) target_link_libraries(opentelemetry_trace PUBLIC opentelemetry_common opentelemetry_resources) diff --git a/sdk/src/version/CMakeLists.txt b/sdk/src/version/CMakeLists.txt index d8c48ed96d..f7be858000 100644 --- a/sdk/src/version/CMakeLists.txt +++ b/sdk/src/version/CMakeLists.txt @@ -4,6 +4,7 @@ add_library(opentelemetry_version version.cc) set_target_properties(opentelemetry_version PROPERTIES EXPORT_NAME version) +set_target_version(opentelemetry_version) target_link_libraries(opentelemetry_version PUBLIC opentelemetry_api opentelemetry_sdk) diff --git a/sdk/test/logs/batch_log_record_processor_test.cc b/sdk/test/logs/batch_log_record_processor_test.cc index 462e9b8397..41ae2c5123 100644 --- a/sdk/test/logs/batch_log_record_processor_test.cc +++ b/sdk/test/logs/batch_log_record_processor_test.cc @@ -42,6 +42,8 @@ class MockLogRecordable final : public opentelemetry::sdk::logs::Recordable void SetBody(const std::string &message) noexcept { body_ = message; } + void SetEventId(int64_t, nostd::string_view) noexcept override {} + void SetTraceId(const opentelemetry::trace::TraceId &) noexcept override {} void SetSpanId(const opentelemetry::trace::SpanId &) noexcept override {} diff --git a/sdk/test/logs/log_record_test.cc b/sdk/test/logs/log_record_test.cc index 3ad3acaca5..204827bfb0 100644 --- a/sdk/test/logs/log_record_test.cc +++ b/sdk/test/logs/log_record_test.cc @@ -3,6 +3,13 @@ #ifdef ENABLE_LOGS_PREVIEW +# include +# include +# include +# include + +# include "opentelemetry/logs/logger.h" +# include "opentelemetry/logs/provider.h" # include "opentelemetry/nostd/variant.h" # include "opentelemetry/sdk/logs/read_write_log_record.h" # include "opentelemetry/trace/span_id.h" @@ -69,4 +76,252 @@ TEST(ReadWriteLogRecord, SetAndGet) ASSERT_EQ(record.GetTraceFlags(), trace_flags); ASSERT_EQ(record.GetTimestamp().time_since_epoch(), now.time_since_epoch()); } + +// Define a basic Logger class +class TestBodyLogger : public opentelemetry::logs::Logger +{ +public: + const nostd::string_view GetName() noexcept override { return "test body logger"; } + + nostd::unique_ptr CreateLogRecord() noexcept override + { + return nostd::unique_ptr(new ReadWriteLogRecord()); + } + + using opentelemetry::logs::Logger::EmitLogRecord; + + void EmitLogRecord(nostd::unique_ptr &&record) noexcept override + { + if (record) + { + last_body_ = static_cast(record.get())->GetBody(); + } + } + + const opentelemetry::v1::common::AttributeValue &GetLastLogRecord() const noexcept + { + return last_body_; + } + +private: + opentelemetry::v1::common::AttributeValue last_body_; +}; + +// Define a basic LoggerProvider class that returns an instance of the logger class defined above +class TestBodyProvider : public opentelemetry::logs::LoggerProvider +{ +public: + using opentelemetry::logs::LoggerProvider::GetLogger; + + nostd::shared_ptr GetLogger( + nostd::string_view /* logger_name */, + nostd::string_view /* library_name */, + nostd::string_view /* library_version */, + nostd::string_view /* schema_url */, + bool /* include_trace_context */, + const opentelemetry::common::KeyValueIterable & /* attributes */) override + { + return nostd::shared_ptr(new TestBodyLogger()); + } +}; + +TEST(LogBody, BodyConversation) +{ + // Push the new loggerprovider class into the global singleton + TestBodyProvider lp; + + // Check that the implementation was pushed by calling TestLogger's GetName() + nostd::string_view schema_url{"https://opentelemetry.io/schemas/1.11.0"}; + auto logger = + lp.GetLogger("TestBodyProvider", "opentelelemtry_library", "", schema_url, false, {}); + + auto real_logger = static_cast(logger.get()); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, true); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_TRUE(opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, static_cast(123)); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_EQ(123, opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, static_cast(124)); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_EQ(124, opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, static_cast(125)); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_EQ(125, opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, static_cast(126)); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_EQ(126, opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, static_cast(127.0)); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + ASSERT_TRUE(std::abs(127.0 - opentelemetry::nostd::get(real_logger->GetLastLogRecord())) < + 0.0001); + + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, "128"); + ASSERT_TRUE( + opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord()) || + opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())); + if (opentelemetry::nostd::holds_alternative(real_logger->GetLastLogRecord())) + { + ASSERT_EQ(nostd::string_view{"128"}, + opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + } + else + { + ASSERT_EQ(nostd::string_view{"128"}, + opentelemetry::nostd::get(real_logger->GetLastLogRecord())); + } + + { + bool data[] = {true, false, true}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + int32_t data[] = {221, 222, 223}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + uint32_t data[] = {231, 232, 233}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + int64_t data[] = {241, 242, 243}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + uint64_t data[] = {251, 252, 253}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + uint8_t data[] = {161, 162, 163}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } + + { + double data[] = {271.0, 272.0, 273.0}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>(real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_TRUE(std::abs(data_span[i] - output[i]) < 0.0001); + } + } + + { + std::string data_origin[] = {"281", "282", "283"}; + nostd::string_view data[] = {data_origin[0], data_origin[1], data_origin[2]}; + nostd::span data_span = data; + real_logger->EmitLogRecord(opentelemetry::logs::Severity::kInfo, data_span); + ASSERT_TRUE(opentelemetry::nostd::holds_alternative>( + real_logger->GetLastLogRecord())); + + nostd::span output = + opentelemetry::nostd::get>( + real_logger->GetLastLogRecord()); + + ASSERT_EQ(data_span.size(), output.size()); + + for (size_t i = 0; i < data_span.size(); ++i) + { + ASSERT_EQ(data_span[i], output[i]); + } + } +} + #endif diff --git a/sdk/test/logs/logger_provider_sdk_test.cc b/sdk/test/logs/logger_provider_sdk_test.cc index cf993dc44c..ae606876b3 100644 --- a/sdk/test/logs/logger_provider_sdk_test.cc +++ b/sdk/test/logs/logger_provider_sdk_test.cc @@ -123,6 +123,8 @@ class DummyLogRecordable final : public opentelemetry::sdk::logs::Recordable void SetBody(const opentelemetry::common::AttributeValue &) noexcept override {} + void SetEventId(int64_t, nostd::string_view) noexcept override {} + void SetTraceId(const opentelemetry::trace::TraceId &) noexcept override {} void SetSpanId(const opentelemetry::trace::SpanId &) noexcept override {} diff --git a/sdk/test/logs/logger_sdk_test.cc b/sdk/test/logs/logger_sdk_test.cc index 5f6467cd91..78189ed8db 100644 --- a/sdk/test/logs/logger_sdk_test.cc +++ b/sdk/test/logs/logger_sdk_test.cc @@ -14,6 +14,7 @@ # include "opentelemetry/sdk/logs/recordable.h" # include "opentelemetry/sdk/trace/tracer_provider_factory.h" # include "opentelemetry/trace/scope.h" +# include "opentelemetry/trace/tracer.h" # include @@ -78,6 +79,12 @@ class MockLogRecordable final : public opentelemetry::sdk::logs::Recordable void SetBody(const std::string &message) noexcept { body_ = message; } + void SetEventId(int64_t id, nostd::string_view name) noexcept override + { + event_id_ = id; + log_record_event_name_ = static_cast(name); + } + void SetTraceId(const opentelemetry::trace::TraceId &trace_id) noexcept override { trace_id_ = trace_id; @@ -144,6 +151,8 @@ class MockLogRecordable final : public opentelemetry::sdk::logs::Recordable private: opentelemetry::logs::Severity severity_ = opentelemetry::logs::Severity::kInvalid; std::string body_; + int64_t event_id_; + std::string log_record_event_name_; opentelemetry::trace::TraceId trace_id_; opentelemetry::trace::SpanId span_id_; opentelemetry::trace::TraceFlags trace_flags_; diff --git a/sdk/test/logs/simple_log_record_processor_test.cc b/sdk/test/logs/simple_log_record_processor_test.cc index 2d377cd924..7d45cc85c2 100644 --- a/sdk/test/logs/simple_log_record_processor_test.cc +++ b/sdk/test/logs/simple_log_record_processor_test.cc @@ -42,6 +42,8 @@ class TestLogRecordable final : public opentelemetry::sdk::logs::Recordable void SetBody(const char *message) noexcept { body_ = message; } + void SetEventId(int64_t, nostd::string_view) noexcept override {} + void SetTraceId(const opentelemetry::trace::TraceId &) noexcept override {} void SetSpanId(const opentelemetry::trace::SpanId &) noexcept override {} diff --git a/third_party/benchmark b/third_party/benchmark index c05843a9f6..d572f47773 160000 --- a/third_party/benchmark +++ b/third_party/benchmark @@ -1 +1 @@ -Subproject commit c05843a9f622db08ad59804c190f98879b76beba +Subproject commit d572f4777349d43653b21d6c2fc63020ab326db2 diff --git a/third_party/nlohmann-json b/third_party/nlohmann-json index 4f8fba1406..bc889afb4c 160000 --- a/third_party/nlohmann-json +++ b/third_party/nlohmann-json @@ -1 +1 @@ -Subproject commit 4f8fba14066156b73f1189a2b8bd568bde5284c5 +Subproject commit bc889afb4c5bf1c0d8ee29ef35eaaf4c8bef8a5d diff --git a/third_party_release b/third_party_release index 7290896c2d..c8af81b0c4 100644 --- a/third_party_release +++ b/third_party_release @@ -16,10 +16,10 @@ gRPC=v1.49.2 thrift=0.14.1 abseil=20220623.1 -benchmark=v1.5.3 +benchmark=v1.7.1 googletest=release-1.12.1 ms-gsl=v3.1.0-67-g6f45293 -nlohmann-json=v3.10.5 +nlohmann-json=v3.11.2 opentelemetry-proto=v0.19.0 opentracing-cpp=v1.6.0 prometheus-cpp=v1.1.0