diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cf95716d4d..d296bd7a5f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -73,7 +73,7 @@ jobs: - name: install dependencies run: | sudo -E apt-get update - sudo -E apt-get install -y zlib1g-dev libabsl-dev libprotobuf-dev libgrpc++-dev protobuf-compiler protobuf-compiler-grpc + sudo -E apt-get install -y zlib1g-dev - name: run fetch content cmake test run: | ./ci/do_ci.sh cmake.fetch_content.test diff --git a/CMakeLists.txt b/CMakeLists.txt index 6083010b3a..005717c46d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -344,83 +344,23 @@ if(WITH_PROMETHEUS) include("${opentelemetry-cpp_SOURCE_DIR}/cmake/prometheus-cpp.cmake") endif() +# +# Do we need protobuf and/or gRPC ? +# + if(WITH_OTLP_GRPC OR WITH_OTLP_HTTP OR WITH_OTLP_FILE) - # Including the CMakeFindDependencyMacro resolves an error from - # gRPCConfig.cmake on some grpc versions. See - # https://github.com/grpc/grpc/pull/33361 for more details. - include(CMakeFindDependencyMacro) - - # Protobuf 3.22+ depends on abseil-cpp and must be found using the cmake - # find_package CONFIG search mode. The following attempts to find Protobuf - # using the CONFIG mode first, and if not found, falls back to the MODULE - # mode. See https://gitlab.kitware.com/cmake/cmake/-/issues/24321 for more - # details. - find_package(Protobuf CONFIG) - if(NOT Protobuf_FOUND) - find_package(Protobuf MODULE) - if(Protobuf_FOUND AND Protobuf_VERSION VERSION_GREATER_EQUAL "3.22.0") - message( - WARNING - "Found Protobuf version ${Protobuf_VERSION} using MODULE mode. " - "Linking errors may occur. Protobuf 3.22+ depends on abseil-cpp " - "and should be found using the CONFIG mode.") - endif() - endif() - + # find or fetch grpc before protobuf to allow protobuf to be built in-tree as + # a grpc submodule. if(WITH_OTLP_GRPC) - find_package(gRPC CONFIG) + include("${opentelemetry-cpp_SOURCE_DIR}/cmake/grpc.cmake") endif() - if((NOT Protobuf_FOUND) OR (WITH_OTLP_GRPC AND NOT gRPC_FOUND)) - if(WIN32 AND (NOT DEFINED CMAKE_TOOLCHAIN_FILE)) - message(FATAL_ERROR "Windows dependency installation failed!") - endif() - if(WIN32) - include(${CMAKE_TOOLCHAIN_FILE}) - endif() - - if(NOT Protobuf_FOUND) - find_package(Protobuf CONFIG REQUIRED) - endif() - if(NOT gRPC_FOUND AND WITH_OTLP_GRPC) - find_package(gRPC CONFIG) - endif() - if(WIN32) - # Always use x64 protoc.exe - if(NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}") - set(Protobuf_PROTOC_EXECUTABLE - ${CMAKE_CURRENT_SOURCE_DIR}/tools/vcpkg/packages/protobuf_x64-windows/tools/protobuf/protoc.exe - ) - endif() - endif() - endif() - # Latest Protobuf imported targets and without legacy module support - if(TARGET protobuf::protoc) - if(CMAKE_CROSSCOMPILING AND Protobuf_PROTOC_EXECUTABLE) - set(PROTOBUF_PROTOC_EXECUTABLE ${Protobuf_PROTOC_EXECUTABLE}) - else() - project_build_tools_get_imported_location(PROTOBUF_PROTOC_EXECUTABLE - protobuf::protoc) - # If protobuf::protoc is not a imported target, then we use the target - # directly for fallback - if(NOT PROTOBUF_PROTOC_EXECUTABLE) - set(PROTOBUF_PROTOC_EXECUTABLE protobuf::protoc) - endif() - endif() - elseif(Protobuf_PROTOC_EXECUTABLE) - # Some versions of FindProtobuf.cmake uses mixed case instead of uppercase - set(PROTOBUF_PROTOC_EXECUTABLE ${Protobuf_PROTOC_EXECUTABLE}) - endif() - include(CMakeDependentOption) + include("${opentelemetry-cpp_SOURCE_DIR}/cmake/protobuf.cmake") - message(STATUS "PROTOBUF_PROTOC_EXECUTABLE=${PROTOBUF_PROTOC_EXECUTABLE}") - set(SAVED_CMAKE_CXX_CLANG_TIDY ${CMAKE_CXX_CLANG_TIDY}) - set(CMAKE_CXX_CLANG_TIDY "") include("${opentelemetry-cpp_SOURCE_DIR}/cmake/opentelemetry-proto.cmake") - set(CMAKE_CXX_CLANG_TIDY ${SAVED_CMAKE_CXX_CLANG_TIDY}) endif() # @@ -644,11 +584,14 @@ if(opentelemetry-proto_VERSION) "opentelemetry-proto: ${opentelemetry-proto_VERSION} (${opentelemetry-proto_PROVIDER})" ) endif() -if(Protobuf_FOUND) - message(STATUS "Protobuf: ${Protobuf_VERSION}") +if(Protobuf_VERSION) + message( + STATUS + "Protobuf: ${Protobuf_VERSION} (${Protobuf_PROVIDER} - ${protobuf_lib_type})" + ) endif() -if(gRPC_FOUND) - message(STATUS "gRPC: ${gRPC_VERSION}") +if(gRPC_VERSION) + message(STATUS "gRPC: ${gRPC_VERSION} (${gRPC_PROVIDER} - ${grpc_lib_type})") endif() if(CURL_VERSION) message(STATUS "CURL: ${CURL_VERSION} (${CURL_PROVIDER})") diff --git a/ci/do_ci.sh b/ci/do_ci.sh index e9cea09648..6e0be2eec4 100755 --- a/ci/do_ci.sh +++ b/ci/do_ci.sh @@ -400,6 +400,7 @@ elif [[ "$1" == "cmake.exporter.otprotocol.shared_libs.with_static_grpc.test" ]] -DWITH_OTLP_HTTP=ON \ -DWITH_OTLP_FILE=ON \ -DBUILD_SHARED_LIBS=ON \ + -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ "${SRC_DIR}" grpc_cpp_plugin=`which grpc_cpp_plugin` proto_make_file="CMakeFiles/opentelemetry_proto.dir/build.make" diff --git a/cmake/grpc.cmake b/cmake/grpc.cmake new file mode 100644 index 0000000000..b209c0ae5a --- /dev/null +++ b/cmake/grpc.cmake @@ -0,0 +1,84 @@ +# Copyright The OpenTelemetry Authors +# SPDX-License-Identifier: Apache-2.0 + +# Import gRPC targets (gRPC::grpc++ and gRPC::grpc_cpp_plugin). +# 1. Find an installed gRPC package +# 2. Use FetchContent to fetch and build gRPC (and its submodules) from GitHub + +# Including the CMakeFindDependencyMacro resolves an error from +# gRPCConfig.cmake on some grpc versions. See +# https://github.com/grpc/grpc/pull/33361 for more details. +include(CMakeFindDependencyMacro) + +find_package(gRPC CONFIG QUIET) +set(gRPC_PROVIDER "find_package") + +if(NOT gRPC_FOUND) + FetchContent_Declare( + "grpc" + GIT_REPOSITORY "https://github.com/grpc/grpc.git" + GIT_TAG "${grpc_GIT_TAG}" + GIT_SUBMODULES + "third_party/re2" + "third_party/abseil-cpp" + "third_party/protobuf" + "third_party/cares/cares" + "third_party/boringssl-with-bazel" + ) + set(gRPC_PROVIDER "fetch_repository") + + set(gRPC_INSTALL ${OPENTELEMETRY_INSTALL} CACHE BOOL "" FORCE) + set(gRPC_BUILD_TESTS OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_CPP_PLUGIN ON CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_CSHARP_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_OBJECTIVE_C_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_PHP_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_NODE_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_PYTHON_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPC_RUBY_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_BUILD_GRPCPP_OTEL_PLUGIN OFF CACHE BOOL "" FORCE) + set(gRPC_ZLIB_PROVIDER "package" CACHE STRING "" FORCE) + set(gRPC_RE2_PROVIDER "module" CACHE STRING "" FORCE) + set(RE2_BUILD_TESTING OFF CACHE BOOL "" FORCE) + set(gRPC_PROTOBUF_PROVIDER "module" CACHE STRING "" FORCE) + set(gRPC_PROTOBUF_PACKAGE_TYPE "CONFIG" CACHE STRING "" FORCE) + set(gRPC_ABSL_PROVIDER "module" CACHE STRING "" FORCE) + set(gRPC_CARES_PROVIDER "module" CACHE STRING "" FORCE) + + FetchContent_MakeAvailable(grpc) + + # Set the gRPC_VERSION variable from the git tag. + string(REGEX REPLACE "^v([0-9]+\\.[0-9]+\\.[0-9]+)$" "\\1" gRPC_VERSION "${grpc_GIT_TAG}") + + #Disable iwyu and clang-tidy + foreach(_grpc_target grpc++ grpc_cpp_plugin) + if(TARGET ${_grpc_target}) + set_target_properties(${_grpc_target} PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_INCLUDE_WHAT_YOU_USE "" + CXX_CLANG_TIDY "") + endif() + endforeach() + + if(TARGET grpc++ AND NOT TARGET gRPC::grpc++) + add_library(gRPC::grpc++ ALIAS grpc++) + endif() + + if(TARGET grpc_cpp_plugin AND NOT TARGET gRPC::grpc_cpp_plugin) + add_executable(gRPC::grpc_cpp_plugin ALIAS grpc_cpp_plugin) + endif() + +endif() + +if(NOT TARGET gRPC::grpc++) + message(FATAL_ERROR "A required gRPC target (gRPC::grpc++) was not imported") +endif() + +if(CMAKE_CROSSCOMPILING) + find_program(gRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin) +else() + if(NOT TARGET gRPC::grpc_cpp_plugin) + message(FATAL_ERROR "A required gRPC target (gRPC::grpc_cpp_plugin) was not imported") + endif() + set(gRPC_CPP_PLUGIN_EXECUTABLE "$") +endif() + +message(STATUS "gRPC_CPP_PLUGIN_EXECUTABLE=${gRPC_CPP_PLUGIN_EXECUTABLE}") diff --git a/cmake/opentelemetry-proto.cmake b/cmake/opentelemetry-proto.cmake index 7fb74eba51..648d21d2f2 100644 --- a/cmake/opentelemetry-proto.cmake +++ b/cmake/opentelemetry-proto.cmake @@ -174,20 +174,6 @@ foreach(IMPORT_DIR ${PROTOBUF_IMPORT_DIRS}) list(APPEND PROTOBUF_INCLUDE_FLAGS "-I${IMPORT_DIR}") endforeach() -if(WITH_OTLP_GRPC) - if(CMAKE_CROSSCOMPILING) - find_program(gRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin) - else() - if(TARGET gRPC::grpc_cpp_plugin) - project_build_tools_get_imported_location(gRPC_CPP_PLUGIN_EXECUTABLE - gRPC::grpc_cpp_plugin) - else() - find_program(gRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin) - endif() - endif() - message(STATUS "gRPC_CPP_PLUGIN_EXECUTABLE=${gRPC_CPP_PLUGIN_EXECUTABLE}") -endif() - set(PROTOBUF_COMMON_FLAGS "--proto_path=${PROTO_PATH}" "--cpp_out=${GENERATED_PROTOBUF_PATH}") # --experimental_allow_proto3_optional is available from 3.13 and be stable and @@ -239,7 +225,10 @@ set(PROTOBUF_GENERATED_FILES ${PROFILES_SERVICE_PB_H_FILE} ${PROFILES_SERVICE_PB_CPP_FILE}) +set(PROTOBUF_GENERATE_DEPENDS ${PROTOBUF_PROTOC_EXECUTABLE}) + if(WITH_OTLP_GRPC) + list(APPEND PROTOBUF_GENERATE_DEPENDS ${gRPC_CPP_PLUGIN_EXECUTABLE}) list(APPEND PROTOBUF_COMMON_FLAGS "--grpc_out=generate_mock_code=true:${GENERATED_PROTOBUF_PATH}" --plugin=protoc-gen-grpc="${gRPC_CPP_PLUGIN_EXECUTABLE}") @@ -284,7 +273,7 @@ add_custom_command( ${LOGS_PROTO} ${METRICS_PROTO} ${TRACE_SERVICE_PROTO} ${LOGS_SERVICE_PROTO} ${METRICS_SERVICE_PROTO} ${PROFILES_PROTO} ${PROFILES_SERVICE_PROTO} COMMENT "[Run]: ${PROTOBUF_RUN_PROTOC_COMMAND}" - DEPENDS ${PROTOBUF_PROTOC_EXECUTABLE}) + DEPENDS ${PROTOBUF_GENERATE_DEPENDS}) unset(OTELCPP_PROTO_TARGET_OPTIONS) if(CMAKE_SYSTEM_NAME MATCHES "Windows|MinGW|WindowsStore") diff --git a/cmake/protobuf.cmake b/cmake/protobuf.cmake new file mode 100644 index 0000000000..9bdcac91c0 --- /dev/null +++ b/cmake/protobuf.cmake @@ -0,0 +1,80 @@ +# Copyright The OpenTelemetry Authors +# SPDX-License-Identifier: Apache-2.0 + + +# Import Protobuf targets (protobuf::libprotobuf and protobuf::protoc) and set PROTOBUF_PROTOC_EXECUTABLE. +# 1. If gRPC was fetched from github then use the Protobuf submodule built with gRPC +# 2. Find an installed Protobuf package +# 3. Use FetchContent to fetch and build Protobuf from GitHub + +if(DEFINED gRPC_PROVIDER AND NOT gRPC_PROVIDER STREQUAL "find_package" AND TARGET libprotobuf) + # gRPC was fetched and built Protobuf as a submodule + + set(_Protobuf_VERSION_REGEX "\"cpp\"[ \t]*:[ \t]*\"([0-9]+\\.[0-9]+(\\.[0-9]+)?)\"") + set(_Protobuf_VERSION_FILE "${grpc_SOURCE_DIR}/third_party/protobuf/version.json") + + file(READ "${_Protobuf_VERSION_FILE}" _Protobuf_VERSION_FILE_CONTENTS) + if(_Protobuf_VERSION_FILE_CONTENTS MATCHES ${_Protobuf_VERSION_REGEX}) + set(Protobuf_VERSION "${CMAKE_MATCH_1}") + else() + message(WARNING "Failed to parse Protobuf version from ${_Protobuf_VERSION_FILE} using regex ${_Protobuf_VERSION_REGEX}") + endif() + set(Protobuf_PROVIDER "grpc_submodule") +else() + + # Search for an installed Protobuf package explicitly using the CONFIG search mode first followed by the MODULE search mode. + # Protobuf versions < 3.22.0 may be found using the module mode and some protobuf apt packages do not support the CONFIG search. + + find_package(Protobuf CONFIG QUIET) + set(Protobuf_PROVIDER "find_package") + + if(NOT Protobuf_FOUND) + find_package(Protobuf MODULE QUIET) + endif() + + if(NOT Protobuf_FOUND) + FetchContent_Declare( + "protobuf" + GIT_REPOSITORY "https://github.com/protocolbuffers/protobuf.git" + GIT_TAG "${protobuf_GIT_TAG}" + ) + + set(protobuf_INSTALL ${OPENTELEMETRY_INSTALL} CACHE BOOL "" FORCE) + set(protobuf_BUILD_TESTS OFF CACHE BOOL "" FORCE) + set(protobuf_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) + + FetchContent_MakeAvailable(protobuf) + + set(Protobuf_PROVIDER "fetch_repository") + + # Set the Protobuf_VERSION variable from the git tag. + string(REGEX REPLACE "^v([0-9]+\\.[0-9]+\\.[0-9]+)$" "\\1" Protobuf_VERSION "${protobuf_GIT_TAG}") + + if(TARGET libprotobuf) + set_target_properties(libprotobuf PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_CLANG_TIDY "" CXX_INCLUDE_WHAT_YOU_USE "") + endif() + + endif() +endif() + +if(NOT TARGET protobuf::libprotobuf) + message(FATAL_ERROR "A required protobuf target (protobuf::libprotobuf) was not imported") +endif() + +if(PROTOBUF_PROTOC_EXECUTABLE AND NOT Protobuf_PROTOC_EXECUTABLE) + message(WARNING "Use of PROTOBUF_PROTOC_EXECUTABLE is deprecated. Please use Protobuf_PROTOC_EXECUTABLE instead.") + set(Protobuf_PROTOC_EXECUTABLE "${PROTOBUF_PROTOC_EXECUTABLE}") +endif() + +if(CMAKE_CROSSCOMPILING) + find_program(Protobuf_PROTOC_EXECUTABLE protoc) +else() + if(NOT TARGET protobuf::protoc) + message(FATAL_ERROR "A required protobuf target (protobuf::protoc) was not imported") + endif() + set(Protobuf_PROTOC_EXECUTABLE "$") +endif() + +set(PROTOBUF_PROTOC_EXECUTABLE "${Protobuf_PROTOC_EXECUTABLE}") + +message(STATUS "PROTOBUF_PROTOC_EXECUTABLE=${PROTOBUF_PROTOC_EXECUTABLE}") diff --git a/exporters/otlp/CMakeLists.txt b/exporters/otlp/CMakeLists.txt index def5a02551..9ad6d7922d 100644 --- a/exporters/otlp/CMakeLists.txt +++ b/exporters/otlp/CMakeLists.txt @@ -32,7 +32,6 @@ target_link_libraries(opentelemetry_otlp_recordable PUBLIC opentelemetry_metrics) if(WITH_OTLP_GRPC) - find_package(gRPC REQUIRED) if(NOT DEFINED grpc_lib_type) message( FATAL_ERROR "cmake/opentelemetry-proto.cmake should be included first") diff --git a/install/cmake/CMakeLists.txt b/install/cmake/CMakeLists.txt index e999e2dd1d..e83964375b 100644 --- a/install/cmake/CMakeLists.txt +++ b/install/cmake/CMakeLists.txt @@ -232,6 +232,7 @@ if(grpc IN_LIST _THIRDPARTY_PACKAGE_LIST) "-DRE2_BUILD_TESTING=OFF" "-DgRPC_ZLIB_PROVIDER=package" "-DgRPC_PROTOBUF_PROVIDER=package" + "-DgRPC_PROTOBUF_PACKAGE_TYPE=CONFIG" "-DgRPC_ABSL_PROVIDER=package") add_dependencies(grpc-build zlib-install abseil-install protobuf-install) diff --git a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h new file mode 100644 index 0000000000..c2205a8be3 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h @@ -0,0 +1,60 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +/** + * This class represents a fully configured SDK. + * A SDK contains various objects, like propagators and providers for each + * signals, that collectively describe the opentelemetry configuration. + */ +class ConfiguredSdk +{ +public: + static std::unique_ptr Create( + std::shared_ptr registry, + const std::unique_ptr &model); + + ConfiguredSdk() : resource(opentelemetry::sdk::resource::Resource::GetEmpty()) {} + + /** + * Install the SDK, so that an instrumented application can make calls + * to it. + * This methods sets the global provider singletons to point to the SDK. + */ + void Install(); + + /** + * Uninstall the SDK, so that an instrumented application no longer makes + * calls to it. + * This method clears the global provider singletons. + */ + void UnInstall(); + + opentelemetry::sdk::resource::Resource resource; + std::shared_ptr tracer_provider; + std::shared_ptr propagator; + std::shared_ptr meter_provider; + std::shared_ptr logger_provider; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h b/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h new file mode 100644 index 0000000000..9f31ba68e0 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h @@ -0,0 +1,271 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/always_off_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/base2_exponential_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/batch_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/batch_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/double_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/double_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/explicit_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/integer_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/integer_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/periodic_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/simple_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/string_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/string_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_configuration.h" +#include "opentelemetry/sdk/logs/exporter.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/sampler.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class SdkBuilder +{ +public: + SdkBuilder(std::shared_ptr registry) : registry_(std::move(registry)) {} + SdkBuilder(SdkBuilder &&) = default; + SdkBuilder(const SdkBuilder &) = default; + SdkBuilder &operator=(SdkBuilder &&) = default; + SdkBuilder &operator=(const SdkBuilder &other) = default; + ~SdkBuilder() = default; + + std::unique_ptr CreateAlwaysOffSampler( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration *model) const; + + std::unique_ptr CreateAlwaysOnSampler( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) const; + + std::unique_ptr CreateJaegerRemoteSampler( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) const; + + std::unique_ptr CreateParentBasedSampler( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) const; + + std::unique_ptr CreateTraceIdRatioBasedSampler( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) const; + + std::unique_ptr CreateExtensionSampler( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const; + + std::unique_ptr CreateSampler( + const std::unique_ptr &model) const; + + std::unique_ptr CreateOtlpHttpSpanExporter( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpGrpcSpanExporter( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpFileSpanExporter( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) const; + + std::unique_ptr CreateConsoleSpanExporter( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) const; + + std::unique_ptr CreateZipkinSpanExporter( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) const; + + std::unique_ptr CreateExtensionSpanExporter( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const; + + std::unique_ptr CreateSpanExporter( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateBatchSpanProcessor( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateSimpleSpanProcessor( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateExtensionSpanProcessor( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateSpanProcessor( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateTracerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + std::unique_ptr CreateTextMapPropagator( + const std::string &name) const; + + std::unique_ptr CreatePropagator( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateOtlpHttpPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateOtlpGrpcPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateOtlpFilePushMetricExporter( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateConsolePushMetricExporter( + const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model) const; + + std::unique_ptr + CreateExtensionPushMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreatePrometheusPullMetricExporter( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateExtensionPullMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + const; + + std::unique_ptr CreatePushMetricExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreatePullMetricExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreatePeriodicMetricReader( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) const; + + std::unique_ptr CreatePullMetricReader( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) const; + + std::unique_ptr CreateMetricReader( + const std::unique_ptr &model) + const; + + std::unique_ptr + CreateBase2ExponentialBucketHistogramAggregation( + const opentelemetry::sdk::configuration:: + Base2ExponentialBucketHistogramAggregationConfiguration *model) const; + + std::unique_ptr + CreateExplicitBucketHistogramAggregation( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration + *model) const; + + std::unique_ptr CreateAggregationConfig( + const std::unique_ptr &model, + opentelemetry::sdk::metrics::AggregationType &aggregation_type) const; + + std::unique_ptr CreateAttributesProcessor( + const std::unique_ptr &model) + const; + + void AddView( + opentelemetry::sdk::metrics::ViewRegistry *view_registry, + const std::unique_ptr &model) const; + + std::unique_ptr CreateMeterProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + std::unique_ptr CreateOtlpHttpLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpGrpcLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpFileLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateConsoleLogRecordExporter( + const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateExtensionLogRecordExporter( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + const; + + std::unique_ptr CreateLogRecordExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreateBatchLogRecordProcessor( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) const; + + std::unique_ptr CreateSimpleLogRecordProcessor( + const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration *model) const; + + std::unique_ptr CreateExtensionLogRecordProcessor( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + const; + + std::unique_ptr CreateLogRecordProcessor( + const std::unique_ptr + &model) const; + + std::unique_ptr CreateLoggerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + void SetResourceAttribute( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name, + const opentelemetry::sdk::configuration::AttributeValueConfiguration *model) const; + + void SetResource(opentelemetry::sdk::resource::Resource &resource, + const std::unique_ptr + &opt_model) const; + + std::unique_ptr CreateConfiguredSdk( + const std::unique_ptr &model) const; + +private: + std::shared_ptr registry_; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h b/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h new file mode 100644 index 0000000000..95da867b99 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include + +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class UnsupportedException : public std::runtime_error +{ +public: + UnsupportedException(const std::string &msg) : std::runtime_error(msg) {} + UnsupportedException(UnsupportedException &&) = default; + UnsupportedException(const UnsupportedException &) = default; + UnsupportedException &operator=(UnsupportedException &&) = default; + UnsupportedException &operator=(const UnsupportedException &other) = default; + ~UnsupportedException() override = default; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h b/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h index 7c47bdd1d3..248ff77578 100644 --- a/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h +++ b/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include #include "opentelemetry/sdk/configuration/instrument_type.h" diff --git a/sdk/src/configuration/configured_sdk.cc b/sdk/src/configuration/configured_sdk.cc new file mode 100644 index 0000000000..3eb81c9e48 --- /dev/null +++ b/sdk/src/configuration/configured_sdk.cc @@ -0,0 +1,114 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include "opentelemetry/context/propagation/global_propagator.h" +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/logs/logger_provider.h" +#include "opentelemetry/logs/provider.h" +#include "opentelemetry/metrics/meter_provider.h" +#include "opentelemetry/metrics/provider.h" +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/sdk_builder.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/trace/provider.h" +#include "opentelemetry/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +std::unique_ptr ConfiguredSdk::Create( + std::shared_ptr registry, + const std::unique_ptr &model) +{ + std::unique_ptr sdk; + + if (model) + { + try + { + SdkBuilder builder(std::move(registry)); + sdk = builder.CreateConfiguredSdk(model); + } + catch (const std::exception &e) + { + OTEL_INTERNAL_LOG_ERROR("[Configured Sdk] builder failed with exception: " << e.what()); + } + catch (...) + { + OTEL_INTERNAL_LOG_ERROR("[Configured Sdk] builder failed with unknown exception."); + } + } + + return sdk; +} + +void ConfiguredSdk::Install() +{ + if (propagator) + { + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator); + } + + if (tracer_provider) + { + std::shared_ptr api_tracer_provider = tracer_provider; + opentelemetry::trace::Provider::SetTracerProvider(api_tracer_provider); + } + + if (meter_provider) + { + std::shared_ptr api_meter_provider = meter_provider; + opentelemetry::metrics::Provider::SetMeterProvider(api_meter_provider); + } + + if (logger_provider) + { + std::shared_ptr api_logger_provider = logger_provider; + opentelemetry::logs::Provider::SetLoggerProvider(api_logger_provider); + } +} + +void ConfiguredSdk::UnInstall() +{ + if (propagator) + { + std::shared_ptr none; + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(none); + } + + if (tracer_provider) + { + std::shared_ptr none; + opentelemetry::trace::Provider::SetTracerProvider(none); + } + + if (meter_provider) + { + std::shared_ptr none; + opentelemetry::metrics::Provider::SetMeterProvider(none); + } + + if (logger_provider) + { + std::shared_ptr none; + opentelemetry::logs::Provider::SetLoggerProvider(none); + } +} + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/src/configuration/sdk_builder.cc b/sdk/src/configuration/sdk_builder.cc new file mode 100644 index 0000000000..593fb46ebb --- /dev/null +++ b/sdk/src/configuration/sdk_builder.cc @@ -0,0 +1,1766 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/kv_properties.h" +#include "opentelemetry/context/propagation/composite_propagator.h" +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/configuration/aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/aggregation_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/always_off_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/always_on_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/attribute_value_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/attributes_configuration.h" +#include "opentelemetry/sdk/configuration/base2_exponential_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/batch_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/batch_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/double_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/double_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/explicit_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_sampler_builder.h" +#include "opentelemetry/sdk/configuration/extension_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/include_exclude_configuration.h" +#include "opentelemetry/sdk/configuration/instrument_type.h" +#include "opentelemetry/sdk/configuration/integer_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/integer_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/jaeger_remote_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_processor_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/logger_provider_configuration.h" +#include "opentelemetry/sdk/configuration/meter_provider_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/parent_based_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/periodic_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/propagator_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/resource_configuration.h" +#include "opentelemetry/sdk/configuration/sampler_configuration.h" +#include "opentelemetry/sdk/configuration/sampler_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/sdk_builder.h" +#include "opentelemetry/sdk/configuration/simple_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/simple_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_processor_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/string_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/string_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/text_map_propagator_builder.h" +#include "opentelemetry/sdk/configuration/trace_id_ratio_based_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/tracer_provider_configuration.h" +#include "opentelemetry/sdk/configuration/unsupported_exception.h" +#include "opentelemetry/sdk/configuration/view_configuration.h" +#include "opentelemetry/sdk/configuration/view_selector_configuration.h" +#include "opentelemetry/sdk/configuration/view_stream_configuration.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_configuration.h" +#include "opentelemetry/sdk/logs/batch_log_record_processor_factory.h" +#include "opentelemetry/sdk/logs/batch_log_record_processor_options.h" +#include "opentelemetry/sdk/logs/exporter.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/logs/logger_provider_factory.h" +#include "opentelemetry/sdk/logs/processor.h" +#include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h" +#include "opentelemetry/sdk/metrics/aggregation/aggregation_config.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_factory.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_options.h" +#include "opentelemetry/sdk/metrics/instruments.h" +#include "opentelemetry/sdk/metrics/meter_context.h" +#include "opentelemetry/sdk/metrics/meter_context_factory.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider_factory.h" +#include "opentelemetry/sdk/metrics/metric_reader.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/sdk/metrics/view/attributes_processor.h" +#include "opentelemetry/sdk/metrics/view/instrument_selector.h" +#include "opentelemetry/sdk/metrics/view/meter_selector.h" +#include "opentelemetry/sdk/metrics/view/view.h" +#include "opentelemetry/sdk/metrics/view/view_registry.h" +#include "opentelemetry/sdk/metrics/view/view_registry_factory.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/batch_span_processor_factory.h" +#include "opentelemetry/sdk/trace/batch_span_processor_options.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/sampler.h" +#include "opentelemetry/sdk/trace/samplers/always_off_factory.h" +#include "opentelemetry/sdk/trace/samplers/always_on_factory.h" +#include "opentelemetry/sdk/trace/samplers/parent_factory.h" +#include "opentelemetry/sdk/trace/samplers/trace_id_ratio_factory.h" +#include "opentelemetry/sdk/trace/simple_processor_factory.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/sdk/trace/tracer_provider_factory.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class ResourceAttributeValueSetter + : public opentelemetry::sdk::configuration::AttributeValueConfigurationVisitor +{ +public: + ResourceAttributeValueSetter( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name) + : resource_attributes_(resource_attributes), name_(name) + {} + ResourceAttributeValueSetter(ResourceAttributeValueSetter &&) = delete; + ResourceAttributeValueSetter(const ResourceAttributeValueSetter &) = delete; + ResourceAttributeValueSetter &operator=(ResourceAttributeValueSetter &&) = delete; + ResourceAttributeValueSetter &operator=(const ResourceAttributeValueSetter &other) = delete; + ~ResourceAttributeValueSetter() override = default; + + void VisitString( + const opentelemetry::sdk::configuration::StringAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitInteger( + const opentelemetry::sdk::configuration::IntegerAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitDouble( + const opentelemetry::sdk::configuration::DoubleAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitBoolean( + const opentelemetry::sdk::configuration::BooleanAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitStringArray( + const opentelemetry::sdk::configuration::StringArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + std::vector string_view_array(length); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + string_view_array[i] = model->value[i]; + } + + nostd::span span(string_view_array.data(), string_view_array.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitIntegerArray( + const opentelemetry::sdk::configuration::IntegerArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + std::vector int_array(length); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + int_array[i] = model->value[i]; + } + + nostd::span span(int_array.data(), int_array.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitDoubleArray( + const opentelemetry::sdk::configuration::DoubleArrayAttributeValueConfiguration *model) + override + { + // We have: std::vector + // We need: nostd::span + // so no data conversion needed + + nostd::span span(model->value.data(), model->value.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitBooleanArray( + const opentelemetry::sdk::configuration::BooleanArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + + // Can not use std::vector, + // it has no data() to convert it to a span + std::unique_ptr bool_array(new bool[length]); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + bool_array[i] = model->value[i]; + } + + nostd::span span(&bool_array[0], length); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + opentelemetry::common::AttributeValue attribute_value; + +private: + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes_; + std::string name_; +}; + +class SamplerBuilder : public opentelemetry::sdk::configuration::SamplerConfigurationVisitor +{ +public: + SamplerBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SamplerBuilder(SamplerBuilder &&) = delete; + SamplerBuilder(const SamplerBuilder &) = delete; + SamplerBuilder &operator=(SamplerBuilder &&) = delete; + SamplerBuilder &operator=(const SamplerBuilder &other) = delete; + ~SamplerBuilder() override = default; + + void VisitAlwaysOff( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateAlwaysOffSampler(model); + } + + void VisitAlwaysOn( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateAlwaysOnSampler(model); + } + + void VisitJaegerRemote( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateJaegerRemoteSampler(model); + } + + void VisitParentBased( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateParentBasedSampler(model); + } + + void VisitTraceIdRatioBased( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) + override + { + sampler = sdk_builder_->CreateTraceIdRatioBasedSampler(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateExtensionSampler(model); + } + + std::unique_ptr sampler; + +private: + const SdkBuilder *sdk_builder_; +}; + +class SpanProcessorBuilder + : public opentelemetry::sdk::configuration::SpanProcessorConfigurationVisitor +{ +public: + SpanProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SpanProcessorBuilder(SpanProcessorBuilder &&) = delete; + SpanProcessorBuilder(const SpanProcessorBuilder &) = delete; + SpanProcessorBuilder &operator=(SpanProcessorBuilder &&) = delete; + SpanProcessorBuilder &operator=(const SpanProcessorBuilder &other) = delete; + ~SpanProcessorBuilder() override = default; + + void VisitBatch( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateBatchSpanProcessor(model); + } + + void VisitSimple( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateSimpleSpanProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateExtensionSpanProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *sdk_builder_; +}; + +class SpanExporterBuilder + : public opentelemetry::sdk::configuration::SpanExporterConfigurationVisitor +{ +public: + SpanExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SpanExporterBuilder(SpanExporterBuilder &&) = delete; + SpanExporterBuilder(const SpanExporterBuilder &) = delete; + SpanExporterBuilder &operator=(SpanExporterBuilder &&) = delete; + SpanExporterBuilder &operator=(const SpanExporterBuilder &other) = delete; + ~SpanExporterBuilder() override = default; + + void VisitOtlpHttp( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpHttpSpanExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpGrpcSpanExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpFileSpanExporter(model); + } + + void VisitConsole( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateConsoleSpanExporter(model); + } + + void VisitZipkin( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateZipkinSpanExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateExtensionSpanExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class MetricReaderBuilder + : public opentelemetry::sdk::configuration::MetricReaderConfigurationVisitor +{ +public: + MetricReaderBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + MetricReaderBuilder(MetricReaderBuilder &&) = delete; + MetricReaderBuilder(const MetricReaderBuilder &) = delete; + MetricReaderBuilder &operator=(MetricReaderBuilder &&) = delete; + MetricReaderBuilder &operator=(const MetricReaderBuilder &other) = delete; + ~MetricReaderBuilder() override = default; + + void VisitPeriodic( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) override + { + metric_reader = sdk_builder_->CreatePeriodicMetricReader(model); + } + + void VisitPull( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) override + { + metric_reader = sdk_builder_->CreatePullMetricReader(model); + } + + std::unique_ptr metric_reader; + +private: + const SdkBuilder *sdk_builder_; +}; + +class PushMetricExporterBuilder + : public opentelemetry::sdk::configuration::PushMetricExporterConfigurationVisitor +{ +public: + PushMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + PushMetricExporterBuilder(PushMetricExporterBuilder &&) = delete; + PushMetricExporterBuilder(const PushMetricExporterBuilder &) = delete; + PushMetricExporterBuilder &operator=(PushMetricExporterBuilder &&) = delete; + PushMetricExporterBuilder &operator=(const PushMetricExporterBuilder &other) = delete; + ~PushMetricExporterBuilder() override = default; + + void VisitOtlpHttp( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpHttpPushMetricExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpGrpcPushMetricExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpFilePushMetricExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateConsolePushMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionPushMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class PullMetricExporterBuilder + : public opentelemetry::sdk::configuration::PullMetricExporterConfigurationVisitor +{ +public: + PullMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + PullMetricExporterBuilder(PullMetricExporterBuilder &&) = delete; + PullMetricExporterBuilder(const PullMetricExporterBuilder &) = delete; + PullMetricExporterBuilder &operator=(PullMetricExporterBuilder &&) = delete; + PullMetricExporterBuilder &operator=(const PullMetricExporterBuilder &other) = delete; + ~PullMetricExporterBuilder() override = default; + + void VisitPrometheus( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreatePrometheusPullMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionPullMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class AggregationConfigBuilder + : public opentelemetry::sdk::configuration::AggregationConfigurationVisitor +{ +public: + AggregationConfigBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + AggregationConfigBuilder(AggregationConfigBuilder &&) = delete; + AggregationConfigBuilder(const AggregationConfigBuilder &) = delete; + AggregationConfigBuilder &operator=(AggregationConfigBuilder &&) = delete; + AggregationConfigBuilder &operator=(const AggregationConfigBuilder &other) = delete; + ~AggregationConfigBuilder() override = default; + + void VisitBase2ExponentialBucketHistogram( + const opentelemetry::sdk::configuration:: + Base2ExponentialBucketHistogramAggregationConfiguration *model) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kBase2ExponentialHistogram; + aggregation_config = sdk_builder_->CreateBase2ExponentialBucketHistogramAggregation(model); + } + + void VisitDefault(const opentelemetry::sdk::configuration::DefaultAggregationConfiguration + * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kDefault; + } + + void VisitDrop( + const opentelemetry::sdk::configuration::DropAggregationConfiguration * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kDrop; + } + + void VisitExplicitBucketHistogram( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration + *model) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kHistogram; + aggregation_config = sdk_builder_->CreateExplicitBucketHistogramAggregation(model); + } + + void VisitLastValue(const opentelemetry::sdk::configuration::LastValueAggregationConfiguration + * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kLastValue; + } + + void VisitSum( + const opentelemetry::sdk::configuration::SumAggregationConfiguration * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kSum; + } + + opentelemetry::sdk::metrics::AggregationType aggregation_type; + std::unique_ptr aggregation_config; + +private: + const SdkBuilder *sdk_builder_; +}; + +class LogRecordProcessorBuilder + : public opentelemetry::sdk::configuration::LogRecordProcessorConfigurationVisitor +{ +public: + LogRecordProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + LogRecordProcessorBuilder(LogRecordProcessorBuilder &&) = delete; + LogRecordProcessorBuilder(const LogRecordProcessorBuilder &) = delete; + LogRecordProcessorBuilder &operator=(LogRecordProcessorBuilder &&) = delete; + LogRecordProcessorBuilder &operator=(const LogRecordProcessorBuilder &other) = delete; + ~LogRecordProcessorBuilder() override = default; + + void VisitBatch( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateBatchLogRecordProcessor(model); + } + + void VisitSimple(const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration + *model) override + { + processor = sdk_builder_->CreateSimpleLogRecordProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + override + { + processor = sdk_builder_->CreateExtensionLogRecordProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *sdk_builder_; +}; + +class LogRecordExporterBuilder + : public opentelemetry::sdk::configuration::LogRecordExporterConfigurationVisitor +{ +public: + LogRecordExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + LogRecordExporterBuilder(LogRecordExporterBuilder &&) = delete; + LogRecordExporterBuilder(const LogRecordExporterBuilder &) = delete; + LogRecordExporterBuilder &operator=(LogRecordExporterBuilder &&) = delete; + LogRecordExporterBuilder &operator=(const LogRecordExporterBuilder &other) = delete; + ~LogRecordExporterBuilder() override = default; + + void VisitOtlpHttp(const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpHttpLogRecordExporter(model); + } + + void VisitOtlpGrpc(const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpGrpcLogRecordExporter(model); + } + + void VisitOtlpFile(const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpFileLogRecordExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateConsoleLogRecordExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionLogRecordExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +std::unique_ptr SdkBuilder::CreateAlwaysOffSampler( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateAlwaysOnSampler( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateJaegerRemoteSampler( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + static const std::string die("JaegerRemoteSampler not supported"); + throw UnsupportedException(die); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateParentBasedSampler( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + std::unique_ptr remote_parent_sampled_sdk; + std::unique_ptr remote_parent_not_sampled_sdk; + std::unique_ptr local_parent_sampled_sdk; + std::unique_ptr local_parent_not_sampled_sdk; + + auto root_sdk = SdkBuilder::CreateSampler(model->root); + + if (model->remote_parent_sampled != nullptr) + { + remote_parent_sampled_sdk = SdkBuilder::CreateSampler(model->remote_parent_sampled); + } + else + { + remote_parent_sampled_sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + } + + if (model->remote_parent_not_sampled != nullptr) + { + remote_parent_not_sampled_sdk = SdkBuilder::CreateSampler(model->remote_parent_not_sampled); + } + else + { + remote_parent_not_sampled_sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + } + + if (model->local_parent_sampled != nullptr) + { + local_parent_sampled_sdk = SdkBuilder::CreateSampler(model->local_parent_sampled); + } + else + { + local_parent_sampled_sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + } + + if (model->local_parent_not_sampled != nullptr) + { + local_parent_not_sampled_sdk = SdkBuilder::CreateSampler(model->local_parent_not_sampled); + } + else + { + local_parent_not_sampled_sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + } + + std::shared_ptr shared_root = std::move(root_sdk); + std::shared_ptr shared_remote_parent_sampled = + std::move(remote_parent_sampled_sdk); + std::shared_ptr shared_remote_parent_not_sampled = + std::move(remote_parent_not_sampled_sdk); + std::shared_ptr shared_local_parent_sampled = + std::move(local_parent_sampled_sdk); + std::shared_ptr shared_local_parent_not_sampled = + std::move(local_parent_not_sampled_sdk); + + sdk = opentelemetry::sdk::trace::ParentBasedSamplerFactory::Create( + shared_root, shared_remote_parent_sampled, shared_remote_parent_not_sampled, + shared_local_parent_sampled, shared_local_parent_not_sampled); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateTraceIdRatioBasedSampler( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::TraceIdRatioBasedSamplerFactory::Create(model->ratio); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateExtensionSampler( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSamplerBuilder *builder = registry_->GetExtensionSamplerBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSampler() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSampler() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSampler( + const std::unique_ptr &model) const +{ + std::unique_ptr sdk; + + SamplerBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.sampler); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateOtlpHttpSpanExporter( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpSpanExporterBuilder *builder; + + builder = registry_->GetOtlpHttpSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpSpanExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpHttpSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateOtlpGrpcSpanExporter( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcSpanExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcSpanExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for OtlpGrpcSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateOtlpFileSpanExporter( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFileSpanExporterBuilder *builder; + + builder = registry_->GetOtlpFileSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFileSpanExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for OtlpFileSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateConsoleSpanExporter( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ConsoleSpanExporterBuilder *builder = registry_->GetConsoleSpanBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsoleSpanExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsoleSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateZipkinSpanExporter( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ZipkinSpanExporterBuilder *builder = registry_->GetZipkinSpanBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateZipkinSpanExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ZipkinSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateExtensionSpanExporter( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSpanExporterBuilder *builder = registry_->GetExtensionSpanExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSpanExporter() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSpanExporter() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSpanExporter( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + SpanExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateBatchSpanProcessor( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + opentelemetry::sdk::trace::BatchSpanProcessorOptions options; + + options.schedule_delay_millis = std::chrono::milliseconds(model->schedule_delay); + +#ifdef LATER + options.xxx = model->export_timeout; +#endif + + options.max_queue_size = model->max_queue_size; + options.max_export_batch_size = model->max_export_batch_size; + + auto exporter_sdk = CreateSpanExporter(model->exporter); + + sdk = opentelemetry::sdk::trace::BatchSpanProcessorFactory::Create(std::move(exporter_sdk), + options); + return sdk; +} + +std::unique_ptr SdkBuilder::CreateSimpleSpanProcessor( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + + auto exporter_sdk = CreateSpanExporter(model->exporter); + + sdk = opentelemetry::sdk::trace::SimpleSpanProcessorFactory::Create(std::move(exporter_sdk)); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateExtensionSpanProcessor( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSpanProcessorBuilder *builder = registry_->GetExtensionSpanProcessorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSpanProcessor() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSpanProcessor() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSpanProcessor( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + SpanProcessorBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.processor); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateTracerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + // FIXME-CONFIG: https://github.com/open-telemetry/opentelemetry-configuration/issues/70 + // FIXME-CONFIG: Add support for IdGenerator + + std::unique_ptr sampler; + + if (model->sampler) + { + sampler = CreateSampler(model->sampler); + } + + std::vector> sdk_processors; + + for (const auto &processor_model : model->processors) + { + sdk_processors.push_back(CreateSpanProcessor(processor_model)); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: use limits, id_generator, ... + sdk = opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(sdk_processors), + resource, std::move(sampler)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateTextMapPropagator(const std::string &name) const +{ + std::unique_ptr sdk; + + const TextMapPropagatorBuilder *builder = registry_->GetTextMapPropagatorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateTextMapPropagator() using registered builder " << name); + sdk = builder->Build(); + return sdk; + } + + std::string die("CreateTextMapPropagator() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePropagator( + const std::unique_ptr &model) const +{ + std::vector> propagators; + std::unique_ptr propagator; + + for (const auto &name : model->composite) + { + propagator = CreateTextMapPropagator(name); + propagators.push_back(std::move(propagator)); + } + + auto sdk = std::make_unique( + std::move(propagators)); + + return sdk; +} + +static opentelemetry::sdk::metrics::InstrumentType ConvertInstrumentType( + enum opentelemetry::sdk::configuration::InstrumentType config) +{ + opentelemetry::sdk::metrics::InstrumentType sdk; + + switch (config) + { + case opentelemetry::sdk::configuration::InstrumentType::none: + case opentelemetry::sdk::configuration::InstrumentType::counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::histogram: + sdk = opentelemetry::sdk::metrics::InstrumentType::kHistogram; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_gauge: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableGauge; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_up_down_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableUpDownCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::up_down_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kUpDownCounter; + break; + } + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateOtlpHttpPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpPushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpHttpPushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpPushMetricExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpGrpcPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcPushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcPushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcPushMetricExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No grpc builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpFilePushMetricExporter( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFilePushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpFilePushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFilePushMetricExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No file builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateConsolePushMetricExporter( + const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + + const ConsolePushMetricExporterBuilder *builder = + registry_->GetConsolePushMetricExporterBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsolePushMetricExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsolePushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionPushMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionPushMetricExporterBuilder *builder = + registry_->GetExtensionPushMetricExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionPushMetricExporter() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("No builder for ExtensionPushMetricExporter "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePrometheusPullMetricExporter( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + + const PrometheusPullMetricExporterBuilder *builder = + registry_->GetPrometheusPullMetricExporterBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreatePrometheusPullMetricExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for PrometheusMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionPullMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionPullMetricExporterBuilder *builder = + registry_->GetExtensionPullMetricExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionPullMetricExporter() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("No builder for ExtensionPullMetricExporter "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePushMetricExporter( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + PushMetricExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePullMetricExporter( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + PullMetricExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePeriodicMetricReader( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) const +{ + std::unique_ptr sdk; + + opentelemetry::sdk::metrics::PeriodicExportingMetricReaderOptions options; + + options.export_interval_millis = std::chrono::milliseconds(model->interval); + options.export_timeout_millis = std::chrono::milliseconds(model->timeout); + + auto exporter_sdk = CreatePushMetricExporter(model->exporter); + + sdk = opentelemetry::sdk::metrics::PeriodicExportingMetricReaderFactory::Create( + std::move(exporter_sdk), options); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePullMetricReader( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) const +{ + std::unique_ptr sdk; + + sdk = CreatePullMetricExporter(model->exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateMetricReader( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + MetricReaderBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.metric_reader); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateBase2ExponentialBucketHistogramAggregation( + const opentelemetry::sdk::configuration::Base2ExponentialBucketHistogramAggregationConfiguration + *model) const +{ + auto sdk = + std::make_unique(); + + sdk->max_buckets_ = model->max_size; + sdk->max_scale_ = static_cast(model->max_scale); + sdk->record_min_max_ = model->record_min_max; + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateExplicitBucketHistogramAggregation( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration *model) + const +{ + auto sdk = std::make_unique(); + + sdk->boundaries_ = model->boundaries; + sdk->record_min_max_ = model->record_min_max; + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateAggregationConfig( + const std::unique_ptr &model, + opentelemetry::sdk::metrics::AggregationType &aggregation_type) const +{ + std::unique_ptr sdk; + + AggregationConfigBuilder builder(this); + model->Accept(&builder); + aggregation_type = builder.aggregation_type; + sdk = std::move(builder.aggregation_config); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateAttributesProcessor( + const std::unique_ptr + & /* model */) const +{ + std::unique_ptr sdk; + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3546 + // FIXME-SDK: Need a subclass of AttributesProcessor for IncludeExclude + OTEL_INTERNAL_LOG_WARN("IncludeExclude attribute processor not supported, ignoring"); + + return sdk; +} + +void SdkBuilder::AddView( + opentelemetry::sdk::metrics::ViewRegistry *view_registry, + const std::unique_ptr &model) const +{ + auto *selector = model->selector.get(); + + if (selector->instrument_type == opentelemetry::sdk::configuration::InstrumentType::none) + { + std::string die("Runtime does not support instrument_type: null"); + throw UnsupportedException(die); + } + + auto sdk_instrument_type = ConvertInstrumentType(selector->instrument_type); + + auto sdk_instrument_selector = std::make_unique( + sdk_instrument_type, selector->instrument_name, selector->unit); + + auto sdk_meter_selector = std::make_unique( + selector->meter_name, selector->meter_version, selector->meter_schema_url); + + auto *stream = model->stream.get(); + + opentelemetry::sdk::metrics::AggregationType sdk_aggregation_type = + opentelemetry::sdk::metrics::AggregationType::kDefault; + + std::shared_ptr sdk_aggregation_config; + + sdk_aggregation_config = CreateAggregationConfig(stream->aggregation, sdk_aggregation_type); + + std::unique_ptr sdk_attribute_processor; + + if (stream->attribute_keys != nullptr) + { + sdk_attribute_processor = CreateAttributesProcessor(stream->attribute_keys); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3547 + // FIXME-SDK: unit is unused in class View, should be removed. + std::string unit("FIXME-SDK"); + + auto sdk_view = std::make_unique( + stream->name, stream->description, unit, sdk_aggregation_type, sdk_aggregation_config, + std::move(sdk_attribute_processor)); + + view_registry->AddView(std::move(sdk_instrument_selector), std::move(sdk_meter_selector), + std::move(sdk_view)); +} + +std::unique_ptr SdkBuilder::CreateMeterProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + auto view_registry = opentelemetry::sdk::metrics::ViewRegistryFactory::Create(); + + for (const auto &view_configuration : model->views) + { + AddView(view_registry.get(), view_configuration); + } + + auto meter_context = + opentelemetry::sdk::metrics::MeterContextFactory::Create(std::move(view_registry), resource); + + for (const auto &reader_configuration : model->readers) + { + std::shared_ptr metric_reader; + metric_reader = CreateMetricReader(reader_configuration); + meter_context->AddMetricReader(metric_reader); + } + + sdk = opentelemetry::sdk::metrics::MeterProviderFactory::Create(std::move(meter_context)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateOtlpHttpLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpHttpLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpLogRecordExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpGrpcLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcLogRecordExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No grpc builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpFileLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFileLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpFileLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFileLogRecordExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No file builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateConsoleLogRecordExporter( + const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ConsoleLogRecordExporterBuilder *builder = registry_->GetConsoleLogRecordBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsoleLogRecordExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsoleLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionLogRecordExporter( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionLogRecordExporterBuilder *builder = + registry_->GetExtensionLogRecordExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionLogRecordExporter() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionLogRecordExporter() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateLogRecordExporter( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + LogRecordExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateBatchLogRecordProcessor( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + opentelemetry::sdk::logs::BatchLogRecordProcessorOptions options; + + options.schedule_delay_millis = std::chrono::milliseconds(model->schedule_delay); + options.max_queue_size = model->max_queue_size; + options.max_export_batch_size = model->max_export_batch_size; + + auto exporter_sdk = CreateLogRecordExporter(model->exporter); + + sdk = opentelemetry::sdk::logs::BatchLogRecordProcessorFactory::Create(std::move(exporter_sdk), + options); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateSimpleLogRecordProcessor( + const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + + auto exporter_sdk = CreateLogRecordExporter(model->exporter); + + sdk = opentelemetry::sdk::logs::SimpleLogRecordProcessorFactory::Create(std::move(exporter_sdk)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateExtensionLogRecordProcessor( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionLogRecordProcessorBuilder *builder = + registry_->GetExtensionLogRecordProcessorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionLogRecordProcessor() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionLogRecordProcessor() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateLogRecordProcessor( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + LogRecordProcessorBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.processor); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateLoggerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + std::vector> sdk_processors; + + for (const auto &processor_model : model->processors) + { + sdk_processors.push_back(CreateLogRecordProcessor(processor_model)); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: use limits + sdk = + opentelemetry::sdk::logs::LoggerProviderFactory::Create(std::move(sdk_processors), resource); + + return sdk; +} + +void SdkBuilder::SetResourceAttribute( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name, + const opentelemetry::sdk::configuration::AttributeValueConfiguration *model) const +{ + ResourceAttributeValueSetter setter(resource_attributes, name); + // Invokes resource_attributes.SetAttribute(name, ) + model->Accept(&setter); +} + +void SdkBuilder::SetResource( + opentelemetry::sdk::resource::Resource &resource, + const std::unique_ptr &opt_model) + const +{ + if (opt_model) + { + opentelemetry::sdk::resource::ResourceAttributes sdk_attributes; + + // First, scan attributes_list, which has low priority. + if (opt_model->attributes_list.size() != 0) + { + opentelemetry::common::KeyValueStringTokenizer tokenizer{opt_model->attributes_list}; + + opentelemetry::nostd::string_view attribute_key; + opentelemetry::nostd::string_view attribute_value; + bool attribute_valid = true; + + while (tokenizer.next(attribute_valid, attribute_key, attribute_value)) + { + if (attribute_valid) + { + opentelemetry::common::AttributeValue wrapped_attribute_value(attribute_value); + sdk_attributes.SetAttribute(attribute_key, wrapped_attribute_value); + } + else + { + OTEL_INTERNAL_LOG_WARN("Found invalid key/value pair in attributes_list"); + } + } + } + + // Second, scan attributes, which has high priority. + if (opt_model->attributes) + { + for (const auto &kv : opt_model->attributes->kv_map) + { + SetResourceAttribute(sdk_attributes, kv.first, kv.second.get()); + } + } + + if (opt_model->detectors != nullptr) + { + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3548 + // FIXME-SDK: Implement resource detectors + OTEL_INTERNAL_LOG_WARN("resource detectors not supported, ignoring"); + } + + auto sdk_resource = + opentelemetry::sdk::resource::Resource::Create(sdk_attributes, opt_model->schema_url); + resource = resource.Merge(sdk_resource); + } + else + { + resource = opentelemetry::sdk::resource::Resource::GetDefault(); + } +} + +std::unique_ptr SdkBuilder::CreateConfiguredSdk( + const std::unique_ptr &model) const +{ + auto sdk = std::make_unique(); + + if (!model->disabled) + { + SetResource(sdk->resource, model->resource); + + if (model->attribute_limits) + { + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: Implement attribute limits + OTEL_INTERNAL_LOG_WARN("attribute_limits not supported, ignoring"); + } + + if (model->tracer_provider) + { + sdk->tracer_provider = CreateTracerProvider(model->tracer_provider, sdk->resource); + } + + if (model->propagator) + { + sdk->propagator = CreatePropagator(model->propagator); + } + + if (model->meter_provider) + { + sdk->meter_provider = CreateMeterProvider(model->meter_provider, sdk->resource); + } + + if (model->logger_provider) + { + sdk->logger_provider = CreateLoggerProvider(model->logger_provider, sdk->resource); + } + } + + return sdk; +} + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE