From e27bbf164afcc4d79e4b70cfa922431a72f7b5d4 Mon Sep 17 00:00:00 2001 From: Marc Alff Date: Fri, 18 Jul 2025 00:48:22 +0200 Subject: [PATCH 1/4] [CONFIGURATION] File configuration - sdk builder --- .../sdk/configuration/configured_sdk.h | 44 + .../sdk/configuration/sdk_builder.h | 271 +++ .../sdk/configuration/unsupported_exception.h | 30 + .../view_selector_configuration.h | 1 - sdk/src/configuration/configured_sdk.cc | 113 ++ sdk/src/configuration/sdk_builder.cc | 1750 +++++++++++++++++ 6 files changed, 2208 insertions(+), 1 deletion(-) create mode 100644 sdk/include/opentelemetry/sdk/configuration/configured_sdk.h create mode 100644 sdk/include/opentelemetry/sdk/configuration/sdk_builder.h create mode 100644 sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h create mode 100644 sdk/src/configuration/configured_sdk.cc create mode 100644 sdk/src/configuration/sdk_builder.cc 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..d3a05f2481 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h @@ -0,0 +1,44 @@ +// 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 +{ + +class ConfiguredSdk +{ +public: + static std::unique_ptr Create( + std::shared_ptr registry, + const std::unique_ptr &model); + + ConfiguredSdk() : resource(opentelemetry::sdk::resource::Resource::GetEmpty()) {} + + void Install(); + 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..6bb065e823 --- /dev/null +++ b/sdk/src/configuration/configured_sdk.cc @@ -0,0 +1,113 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include "opentelemetry/context/propagation/global_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..6fbe16f1ca --- /dev/null +++ b/sdk/src/configuration/sdk_builder.cc @@ -0,0 +1,1750 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/context/propagation/composite_propagator.h" +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/nostd/span.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 AttributeValueSetter + : public opentelemetry::sdk::configuration::AttributeValueConfigurationVisitor +{ +public: + AttributeValueSetter(const SdkBuilder *b, + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name) + : m_sdk_builder(b), resource_attributes_(resource_attributes), name_(name) + {} + AttributeValueSetter(AttributeValueSetter &&) = delete; + AttributeValueSetter(const AttributeValueSetter &) = delete; + AttributeValueSetter &operator=(AttributeValueSetter &&) = delete; + AttributeValueSetter &operator=(const AttributeValueSetter &other) = delete; + ~AttributeValueSetter() 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); + + for (int 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); + + for (int 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 + { + size_t length = model->value.size(); + std::vector double_array(length); + + for (int i = 0; i < length; i++) + { + double_array[i] = model->value[i]; + } + + nostd::span span(double_array.data(), double_array.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]); + + for (int 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: + const SdkBuilder *m_sdk_builder; + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes_; + std::string name_; +}; + +class SamplerBuilder : public opentelemetry::sdk::configuration::SamplerConfigurationVisitor +{ +public: + SamplerBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateAlwaysOffSampler(model); + } + + void VisitAlwaysOn( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) override + { + sampler = m_sdk_builder->CreateAlwaysOnSampler(model); + } + + void VisitJaegerRemote( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) override + { + sampler = m_sdk_builder->CreateJaegerRemoteSampler(model); + } + + void VisitParentBased( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) override + { + sampler = m_sdk_builder->CreateParentBasedSampler(model); + } + + void VisitTraceIdRatioBased( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) + override + { + sampler = m_sdk_builder->CreateTraceIdRatioBasedSampler(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) override + { + sampler = m_sdk_builder->CreateExtensionSampler(model); + } + + std::unique_ptr sampler; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class SpanProcessorBuilder + : public opentelemetry::sdk::configuration::SpanProcessorConfigurationVisitor +{ +public: + SpanProcessorBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateBatchSpanProcessor(model); + } + + void VisitSimple( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) override + { + processor = m_sdk_builder->CreateSimpleSpanProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) override + { + processor = m_sdk_builder->CreateExtensionSpanProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class SpanExporterBuilder + : public opentelemetry::sdk::configuration::SpanExporterConfigurationVisitor +{ +public: + SpanExporterBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateOtlpHttpSpanExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) override + { + exporter = m_sdk_builder->CreateOtlpGrpcSpanExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) override + { + exporter = m_sdk_builder->CreateOtlpFileSpanExporter(model); + } + + void VisitConsole( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) override + { + exporter = m_sdk_builder->CreateConsoleSpanExporter(model); + } + + void VisitZipkin( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) override + { + exporter = m_sdk_builder->CreateZipkinSpanExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) override + { + exporter = m_sdk_builder->CreateExtensionSpanExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class MetricReaderBuilder + : public opentelemetry::sdk::configuration::MetricReaderConfigurationVisitor +{ +public: + MetricReaderBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreatePeriodicMetricReader(model); + } + + void VisitPull( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) override + { + metric_reader = m_sdk_builder->CreatePullMetricReader(model); + } + + std::unique_ptr metric_reader; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class PushMetricExporterBuilder + : public opentelemetry::sdk::configuration::PushMetricExporterConfigurationVisitor +{ +public: + PushMetricExporterBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateOtlpHttpPushMetricExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) + override + { + exporter = m_sdk_builder->CreateOtlpGrpcPushMetricExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) + override + { + exporter = m_sdk_builder->CreateOtlpFilePushMetricExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration + *model) override + { + exporter = m_sdk_builder->CreateConsolePushMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + override + { + exporter = m_sdk_builder->CreateExtensionPushMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class PullMetricExporterBuilder + : public opentelemetry::sdk::configuration::PullMetricExporterConfigurationVisitor +{ +public: + PullMetricExporterBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreatePrometheusPullMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + override + { + exporter = m_sdk_builder->CreateExtensionPullMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class AggregationConfigBuilder + : public opentelemetry::sdk::configuration::AggregationConfigurationVisitor +{ +public: + AggregationConfigBuilder(const SdkBuilder *b) : m_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 = m_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 = m_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 *m_sdk_builder; +}; + +class LogRecordProcessorBuilder + : public opentelemetry::sdk::configuration::LogRecordProcessorConfigurationVisitor +{ +public: + LogRecordProcessorBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateBatchLogRecordProcessor(model); + } + + void VisitSimple(const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration + *model) override + { + processor = m_sdk_builder->CreateSimpleLogRecordProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + override + { + processor = m_sdk_builder->CreateExtensionLogRecordProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *m_sdk_builder; +}; + +class LogRecordExporterBuilder + : public opentelemetry::sdk::configuration::LogRecordExporterConfigurationVisitor +{ +public: + LogRecordExporterBuilder(const SdkBuilder *b) : m_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 = m_sdk_builder->CreateOtlpHttpLogRecordExporter(model); + } + + void VisitOtlpGrpc(const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration + *model) override + { + exporter = m_sdk_builder->CreateOtlpGrpcLogRecordExporter(model); + } + + void VisitOtlpFile(const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration + *model) override + { + exporter = m_sdk_builder->CreateOtlpFileLogRecordExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration + *model) override + { + exporter = m_sdk_builder->CreateConsoleLogRecordExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + override + { + exporter = m_sdk_builder->CreateExtensionLogRecordExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *m_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("JeagerRemoteSampler 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(); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3545 + OTEL_INTERNAL_LOG_ERROR("CreateParentBasedSampler: FIXME-SDK, missing param in parent factory"); + std::shared_ptr delegate_sampler = std::move(root_sdk); + sdk = opentelemetry::sdk::trace::ParentBasedSamplerFactory::Create(delegate_sampler); + + 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 + OTEL_INTERNAL_LOG_ERROR("CreateTracerProvider: FIXME-CONFIG (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_ERROR("CreateAttributesProcessor() FIXME-SDK IncludeExclude"); + + 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 +{ + AttributeValueSetter setter(this, 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_ERROR("SdkBuilder::SetResource: FIXME-SDK detectors"); + } + + 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 From 4559186a1622d2d922b1426b11c4b18875b55ee0 Mon Sep 17 00:00:00 2001 From: Marc Alff Date: Fri, 18 Jul 2025 02:49:40 +0200 Subject: [PATCH 2/4] Code cleanup --- sdk/src/configuration/configured_sdk.cc | 1 + sdk/src/configuration/sdk_builder.cc | 53 ++++++++++++++----------- 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/sdk/src/configuration/configured_sdk.cc b/sdk/src/configuration/configured_sdk.cc index 6bb065e823..3eb81c9e48 100644 --- a/sdk/src/configuration/configured_sdk.cc +++ b/sdk/src/configuration/configured_sdk.cc @@ -7,6 +7,7 @@ #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" diff --git a/sdk/src/configuration/sdk_builder.cc b/sdk/src/configuration/sdk_builder.cc index 6fbe16f1ca..10b8a5c3d9 100644 --- a/sdk/src/configuration/sdk_builder.cc +++ b/sdk/src/configuration/sdk_builder.cc @@ -1,6 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +#include #include #include #include @@ -11,9 +12,11 @@ #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" @@ -159,20 +162,20 @@ namespace sdk namespace configuration { -class AttributeValueSetter +class ResourceAttributeValueSetter : public opentelemetry::sdk::configuration::AttributeValueConfigurationVisitor { public: - AttributeValueSetter(const SdkBuilder *b, - opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, - const std::string &name) - : m_sdk_builder(b), resource_attributes_(resource_attributes), name_(name) + ResourceAttributeValueSetter( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name) + : resource_attributes_(resource_attributes), name_(name) {} - AttributeValueSetter(AttributeValueSetter &&) = delete; - AttributeValueSetter(const AttributeValueSetter &) = delete; - AttributeValueSetter &operator=(AttributeValueSetter &&) = delete; - AttributeValueSetter &operator=(const AttributeValueSetter &other) = delete; - ~AttributeValueSetter() override = default; + 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 @@ -209,7 +212,10 @@ class AttributeValueSetter size_t length = model->value.size(); std::vector string_view_array(length); - for (int i = 0; i < length; i++) + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) { string_view_array[i] = model->value[i]; } @@ -227,7 +233,10 @@ class AttributeValueSetter size_t length = model->value.size(); std::vector int_array(length); - for (int i = 0; i < length; i++) + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) { int_array[i] = model->value[i]; } @@ -242,15 +251,11 @@ class AttributeValueSetter const opentelemetry::sdk::configuration::DoubleArrayAttributeValueConfiguration *model) override { - size_t length = model->value.size(); - std::vector double_array(length); - - for (int i = 0; i < length; i++) - { - double_array[i] = model->value[i]; - } + // We have: std::vector + // We need: nostd::span + // so no data conversion needed - nostd::span span(double_array.data(), double_array.size()); + nostd::span span(model->value.data(), model->value.size()); opentelemetry::common::AttributeValue attribute_value(span); resource_attributes_.SetAttribute(name_, attribute_value); @@ -266,7 +271,10 @@ class AttributeValueSetter // it has no data() to convert it to a span std::unique_ptr bool_array(new bool[length]); - for (int i = 0; i < length; i++) + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) { bool_array[i] = model->value[i]; } @@ -280,7 +288,6 @@ class AttributeValueSetter opentelemetry::common::AttributeValue attribute_value; private: - const SdkBuilder *m_sdk_builder; opentelemetry::sdk::resource::ResourceAttributes &resource_attributes_; std::string name_; }; @@ -1642,7 +1649,7 @@ void SdkBuilder::SetResourceAttribute( const std::string &name, const opentelemetry::sdk::configuration::AttributeValueConfiguration *model) const { - AttributeValueSetter setter(this, resource_attributes, name); + ResourceAttributeValueSetter setter(resource_attributes, name); // Invokes resource_attributes.SetAttribute(name, ) model->Accept(&setter); } From 3707932911ca04830f10f1f4ab36fbbc821453a4 Mon Sep 17 00:00:00 2001 From: Marc Alff Date: Sun, 20 Jul 2025 00:42:47 +0200 Subject: [PATCH 3/4] Refresh code from PR #2518, to fix review comments. --- .../sdk/configuration/configured_sdk.h | 32 +++-- sdk/src/configuration/configured_sdk.cc | 28 ++-- sdk/src/configuration/sdk_builder.cc | 123 +++++++++--------- 3 files changed, 101 insertions(+), 82 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h index d3a05f2481..1bd64552be 100644 --- a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h +++ b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h @@ -27,16 +27,28 @@ class ConfiguredSdk std::shared_ptr registry, const std::unique_ptr &model); - ConfiguredSdk() : resource(opentelemetry::sdk::resource::Resource::GetEmpty()) {} - - void Install(); - 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; + ConfiguredSdk( + opentelemetry::sdk::resource::Resource &&resource, + const std::shared_ptr &tracer_provider, + const std::shared_ptr &propagator, + const std::shared_ptr &meter_provider, + const std::shared_ptr &logger_provider) + : resource_(std::move(resource)), + tracer_provider_(tracer_provider), + propagator_(propagator), + meter_provider_(meter_provider), + logger_provider_(logger_provider) + {} + + void Init(); + void Cleanup(); + +private: + 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 diff --git a/sdk/src/configuration/configured_sdk.cc b/sdk/src/configuration/configured_sdk.cc index 3eb81c9e48..ea370c7374 100644 --- a/sdk/src/configuration/configured_sdk.cc +++ b/sdk/src/configuration/configured_sdk.cc @@ -56,53 +56,53 @@ std::unique_ptr ConfiguredSdk::Create( return sdk; } -void ConfiguredSdk::Install() +void ConfiguredSdk::Init() { - if (propagator) + if (propagator_) { - opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator); + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator_); } - if (tracer_provider) + if (tracer_provider_) { - std::shared_ptr api_tracer_provider = tracer_provider; + std::shared_ptr api_tracer_provider = tracer_provider_; opentelemetry::trace::Provider::SetTracerProvider(api_tracer_provider); } - if (meter_provider) + if (meter_provider_) { - std::shared_ptr api_meter_provider = meter_provider; + std::shared_ptr api_meter_provider = meter_provider_; opentelemetry::metrics::Provider::SetMeterProvider(api_meter_provider); } - if (logger_provider) + if (logger_provider_) { - std::shared_ptr api_logger_provider = logger_provider; + std::shared_ptr api_logger_provider = logger_provider_; opentelemetry::logs::Provider::SetLoggerProvider(api_logger_provider); } } -void ConfiguredSdk::UnInstall() +void ConfiguredSdk::Cleanup() { - if (propagator) + if (propagator_) { std::shared_ptr none; opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(none); } - if (tracer_provider) + if (tracer_provider_) { std::shared_ptr none; opentelemetry::trace::Provider::SetTracerProvider(none); } - if (meter_provider) + if (meter_provider_) { std::shared_ptr none; opentelemetry::metrics::Provider::SetMeterProvider(none); } - if (logger_provider) + if (logger_provider_) { std::shared_ptr none; opentelemetry::logs::Provider::SetLoggerProvider(none); diff --git a/sdk/src/configuration/sdk_builder.cc b/sdk/src/configuration/sdk_builder.cc index 10b8a5c3d9..0f0fb67dd5 100644 --- a/sdk/src/configuration/sdk_builder.cc +++ b/sdk/src/configuration/sdk_builder.cc @@ -295,7 +295,7 @@ class ResourceAttributeValueSetter class SamplerBuilder : public opentelemetry::sdk::configuration::SamplerConfigurationVisitor { public: - SamplerBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + SamplerBuilder(const SdkBuilder *b) : sdk_builder_(b) {} SamplerBuilder(SamplerBuilder &&) = delete; SamplerBuilder(const SamplerBuilder &) = delete; SamplerBuilder &operator=(SamplerBuilder &&) = delete; @@ -305,51 +305,51 @@ class SamplerBuilder : public opentelemetry::sdk::configuration::SamplerConfigur void VisitAlwaysOff( const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateAlwaysOffSampler(model); + sampler = sdk_builder_->CreateAlwaysOffSampler(model); } void VisitAlwaysOn( const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateAlwaysOnSampler(model); + sampler = sdk_builder_->CreateAlwaysOnSampler(model); } void VisitJaegerRemote( const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateJaegerRemoteSampler(model); + sampler = sdk_builder_->CreateJaegerRemoteSampler(model); } void VisitParentBased( const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateParentBasedSampler(model); + sampler = sdk_builder_->CreateParentBasedSampler(model); } void VisitTraceIdRatioBased( const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateTraceIdRatioBasedSampler(model); + sampler = sdk_builder_->CreateTraceIdRatioBasedSampler(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) override { - sampler = m_sdk_builder->CreateExtensionSampler(model); + sampler = sdk_builder_->CreateExtensionSampler(model); } std::unique_ptr sampler; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class SpanProcessorBuilder : public opentelemetry::sdk::configuration::SpanProcessorConfigurationVisitor { public: - SpanProcessorBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + SpanProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} SpanProcessorBuilder(SpanProcessorBuilder &&) = delete; SpanProcessorBuilder(const SpanProcessorBuilder &) = delete; SpanProcessorBuilder &operator=(SpanProcessorBuilder &&) = delete; @@ -359,32 +359,32 @@ class SpanProcessorBuilder void VisitBatch( const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateBatchSpanProcessor(model); + processor = sdk_builder_->CreateBatchSpanProcessor(model); } void VisitSimple( const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateSimpleSpanProcessor(model); + processor = sdk_builder_->CreateSimpleSpanProcessor(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateExtensionSpanProcessor(model); + processor = sdk_builder_->CreateExtensionSpanProcessor(model); } std::unique_ptr processor; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class SpanExporterBuilder : public opentelemetry::sdk::configuration::SpanExporterConfigurationVisitor { public: - SpanExporterBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + SpanExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} SpanExporterBuilder(SpanExporterBuilder &&) = delete; SpanExporterBuilder(const SpanExporterBuilder &) = delete; SpanExporterBuilder &operator=(SpanExporterBuilder &&) = delete; @@ -394,50 +394,50 @@ class SpanExporterBuilder void VisitOtlpHttp( const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpHttpSpanExporter(model); + exporter = sdk_builder_->CreateOtlpHttpSpanExporter(model); } void VisitOtlpGrpc( const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpGrpcSpanExporter(model); + exporter = sdk_builder_->CreateOtlpGrpcSpanExporter(model); } void VisitOtlpFile( const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpFileSpanExporter(model); + exporter = sdk_builder_->CreateOtlpFileSpanExporter(model); } void VisitConsole( const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateConsoleSpanExporter(model); + exporter = sdk_builder_->CreateConsoleSpanExporter(model); } void VisitZipkin( const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateZipkinSpanExporter(model); + exporter = sdk_builder_->CreateZipkinSpanExporter(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateExtensionSpanExporter(model); + exporter = sdk_builder_->CreateExtensionSpanExporter(model); } std::unique_ptr exporter; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class MetricReaderBuilder : public opentelemetry::sdk::configuration::MetricReaderConfigurationVisitor { public: - MetricReaderBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + MetricReaderBuilder(const SdkBuilder *b) : sdk_builder_(b) {} MetricReaderBuilder(MetricReaderBuilder &&) = delete; MetricReaderBuilder(const MetricReaderBuilder &) = delete; MetricReaderBuilder &operator=(MetricReaderBuilder &&) = delete; @@ -447,26 +447,26 @@ class MetricReaderBuilder void VisitPeriodic( const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) override { - metric_reader = m_sdk_builder->CreatePeriodicMetricReader(model); + metric_reader = sdk_builder_->CreatePeriodicMetricReader(model); } void VisitPull( const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) override { - metric_reader = m_sdk_builder->CreatePullMetricReader(model); + metric_reader = sdk_builder_->CreatePullMetricReader(model); } std::unique_ptr metric_reader; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class PushMetricExporterBuilder : public opentelemetry::sdk::configuration::PushMetricExporterConfigurationVisitor { public: - PushMetricExporterBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + PushMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} PushMetricExporterBuilder(PushMetricExporterBuilder &&) = delete; PushMetricExporterBuilder(const PushMetricExporterBuilder &) = delete; PushMetricExporterBuilder &operator=(PushMetricExporterBuilder &&) = delete; @@ -477,47 +477,47 @@ class PushMetricExporterBuilder const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpHttpPushMetricExporter(model); + exporter = sdk_builder_->CreateOtlpHttpPushMetricExporter(model); } void VisitOtlpGrpc( const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpGrpcPushMetricExporter(model); + exporter = sdk_builder_->CreateOtlpGrpcPushMetricExporter(model); } void VisitOtlpFile( const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpFilePushMetricExporter(model); + exporter = sdk_builder_->CreateOtlpFilePushMetricExporter(model); } void VisitConsole(const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateConsolePushMetricExporter(model); + exporter = sdk_builder_->CreateConsolePushMetricExporter(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateExtensionPushMetricExporter(model); + exporter = sdk_builder_->CreateExtensionPushMetricExporter(model); } std::unique_ptr exporter; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class PullMetricExporterBuilder : public opentelemetry::sdk::configuration::PullMetricExporterConfigurationVisitor { public: - PullMetricExporterBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + PullMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} PullMetricExporterBuilder(PullMetricExporterBuilder &&) = delete; PullMetricExporterBuilder(const PullMetricExporterBuilder &) = delete; PullMetricExporterBuilder &operator=(PullMetricExporterBuilder &&) = delete; @@ -528,27 +528,27 @@ class PullMetricExporterBuilder const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreatePrometheusPullMetricExporter(model); + exporter = sdk_builder_->CreatePrometheusPullMetricExporter(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateExtensionPullMetricExporter(model); + exporter = sdk_builder_->CreateExtensionPullMetricExporter(model); } std::unique_ptr exporter; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class AggregationConfigBuilder : public opentelemetry::sdk::configuration::AggregationConfigurationVisitor { public: - AggregationConfigBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + AggregationConfigBuilder(const SdkBuilder *b) : sdk_builder_(b) {} AggregationConfigBuilder(AggregationConfigBuilder &&) = delete; AggregationConfigBuilder(const AggregationConfigBuilder &) = delete; AggregationConfigBuilder &operator=(AggregationConfigBuilder &&) = delete; @@ -560,7 +560,7 @@ class AggregationConfigBuilder Base2ExponentialBucketHistogramAggregationConfiguration *model) override { aggregation_type = opentelemetry::sdk::metrics::AggregationType::kBase2ExponentialHistogram; - aggregation_config = m_sdk_builder->CreateBase2ExponentialBucketHistogramAggregation(model); + aggregation_config = sdk_builder_->CreateBase2ExponentialBucketHistogramAggregation(model); } void VisitDefault(const opentelemetry::sdk::configuration::DefaultAggregationConfiguration @@ -580,7 +580,7 @@ class AggregationConfigBuilder *model) override { aggregation_type = opentelemetry::sdk::metrics::AggregationType::kHistogram; - aggregation_config = m_sdk_builder->CreateExplicitBucketHistogramAggregation(model); + aggregation_config = sdk_builder_->CreateExplicitBucketHistogramAggregation(model); } void VisitLastValue(const opentelemetry::sdk::configuration::LastValueAggregationConfiguration @@ -599,14 +599,14 @@ class AggregationConfigBuilder std::unique_ptr aggregation_config; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class LogRecordProcessorBuilder : public opentelemetry::sdk::configuration::LogRecordProcessorConfigurationVisitor { public: - LogRecordProcessorBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + LogRecordProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} LogRecordProcessorBuilder(LogRecordProcessorBuilder &&) = delete; LogRecordProcessorBuilder(const LogRecordProcessorBuilder &) = delete; LogRecordProcessorBuilder &operator=(LogRecordProcessorBuilder &&) = delete; @@ -616,33 +616,33 @@ class LogRecordProcessorBuilder void VisitBatch( const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateBatchLogRecordProcessor(model); + processor = sdk_builder_->CreateBatchLogRecordProcessor(model); } void VisitSimple(const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateSimpleLogRecordProcessor(model); + processor = sdk_builder_->CreateSimpleLogRecordProcessor(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) override { - processor = m_sdk_builder->CreateExtensionLogRecordProcessor(model); + processor = sdk_builder_->CreateExtensionLogRecordProcessor(model); } std::unique_ptr processor; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; class LogRecordExporterBuilder : public opentelemetry::sdk::configuration::LogRecordExporterConfigurationVisitor { public: - LogRecordExporterBuilder(const SdkBuilder *b) : m_sdk_builder(b) {} + LogRecordExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} LogRecordExporterBuilder(LogRecordExporterBuilder &&) = delete; LogRecordExporterBuilder(const LogRecordExporterBuilder &) = delete; LogRecordExporterBuilder &operator=(LogRecordExporterBuilder &&) = delete; @@ -652,38 +652,38 @@ class LogRecordExporterBuilder void VisitOtlpHttp(const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpHttpLogRecordExporter(model); + exporter = sdk_builder_->CreateOtlpHttpLogRecordExporter(model); } void VisitOtlpGrpc(const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpGrpcLogRecordExporter(model); + exporter = sdk_builder_->CreateOtlpGrpcLogRecordExporter(model); } void VisitOtlpFile(const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateOtlpFileLogRecordExporter(model); + exporter = sdk_builder_->CreateOtlpFileLogRecordExporter(model); } void VisitConsole(const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateConsoleLogRecordExporter(model); + exporter = sdk_builder_->CreateConsoleLogRecordExporter(model); } void VisitExtension( const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) override { - exporter = m_sdk_builder->CreateExtensionLogRecordExporter(model); + exporter = sdk_builder_->CreateExtensionLogRecordExporter(model); } std::unique_ptr exporter; private: - const SdkBuilder *m_sdk_builder; + const SdkBuilder *sdk_builder_; }; std::unique_ptr SdkBuilder::CreateAlwaysOffSampler( @@ -1715,11 +1715,16 @@ void SdkBuilder::SetResource( std::unique_ptr SdkBuilder::CreateConfiguredSdk( const std::unique_ptr &model) const { - auto sdk = std::make_unique(); + std::unique_ptr sdk; + auto resource = opentelemetry::sdk::resource::Resource::GetEmpty(); + std::shared_ptr tracer_provider; + std::shared_ptr propagator; + std::shared_ptr meter_provider; + std::shared_ptr logger_provider; if (!model->disabled) { - SetResource(sdk->resource, model->resource); + SetResource(resource, model->resource); if (model->attribute_limits) { @@ -1730,25 +1735,27 @@ std::unique_ptr SdkBuilder::CreateConfiguredSdk( if (model->tracer_provider) { - sdk->tracer_provider = CreateTracerProvider(model->tracer_provider, sdk->resource); + tracer_provider = CreateTracerProvider(model->tracer_provider, resource); } if (model->propagator) { - sdk->propagator = CreatePropagator(model->propagator); + propagator = CreatePropagator(model->propagator); } if (model->meter_provider) { - sdk->meter_provider = CreateMeterProvider(model->meter_provider, sdk->resource); + meter_provider = CreateMeterProvider(model->meter_provider, resource); } if (model->logger_provider) { - sdk->logger_provider = CreateLoggerProvider(model->logger_provider, sdk->resource); + logger_provider = CreateLoggerProvider(model->logger_provider, resource); } } + sdk = std::make_unique(std::move(resource), tracer_provider, propagator, + meter_provider, logger_provider); return sdk; } From 698d752e42cab44c6df9f85cfba12775122688f7 Mon Sep 17 00:00:00 2001 From: Marc Alff Date: Wed, 23 Jul 2025 00:21:08 +0200 Subject: [PATCH 4/4] Refresh code from PR #2518, to fix review comments. --- .../sdk/configuration/configured_sdk.h | 48 ++++++++++--------- sdk/src/configuration/configured_sdk.cc | 28 +++++------ sdk/src/configuration/sdk_builder.cc | 44 +++++++++-------- 3 files changed, 63 insertions(+), 57 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h index 1bd64552be..c2205a8be3 100644 --- a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h +++ b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h @@ -20,6 +20,11 @@ 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: @@ -27,28 +32,27 @@ class ConfiguredSdk std::shared_ptr registry, const std::unique_ptr &model); - ConfiguredSdk( - opentelemetry::sdk::resource::Resource &&resource, - const std::shared_ptr &tracer_provider, - const std::shared_ptr &propagator, - const std::shared_ptr &meter_provider, - const std::shared_ptr &logger_provider) - : resource_(std::move(resource)), - tracer_provider_(tracer_provider), - propagator_(propagator), - meter_provider_(meter_provider), - logger_provider_(logger_provider) - {} - - void Init(); - void Cleanup(); - -private: - opentelemetry::sdk::resource::Resource resource_; - std::shared_ptr tracer_provider_; - std::shared_ptr propagator_; - std::shared_ptr meter_provider_; - std::shared_ptr logger_provider_; + 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 diff --git a/sdk/src/configuration/configured_sdk.cc b/sdk/src/configuration/configured_sdk.cc index ea370c7374..3eb81c9e48 100644 --- a/sdk/src/configuration/configured_sdk.cc +++ b/sdk/src/configuration/configured_sdk.cc @@ -56,53 +56,53 @@ std::unique_ptr ConfiguredSdk::Create( return sdk; } -void ConfiguredSdk::Init() +void ConfiguredSdk::Install() { - if (propagator_) + if (propagator) { - opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator_); + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator); } - if (tracer_provider_) + if (tracer_provider) { - std::shared_ptr api_tracer_provider = tracer_provider_; + std::shared_ptr api_tracer_provider = tracer_provider; opentelemetry::trace::Provider::SetTracerProvider(api_tracer_provider); } - if (meter_provider_) + if (meter_provider) { - std::shared_ptr api_meter_provider = meter_provider_; + std::shared_ptr api_meter_provider = meter_provider; opentelemetry::metrics::Provider::SetMeterProvider(api_meter_provider); } - if (logger_provider_) + if (logger_provider) { - std::shared_ptr api_logger_provider = logger_provider_; + std::shared_ptr api_logger_provider = logger_provider; opentelemetry::logs::Provider::SetLoggerProvider(api_logger_provider); } } -void ConfiguredSdk::Cleanup() +void ConfiguredSdk::UnInstall() { - if (propagator_) + if (propagator) { std::shared_ptr none; opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(none); } - if (tracer_provider_) + if (tracer_provider) { std::shared_ptr none; opentelemetry::trace::Provider::SetTracerProvider(none); } - if (meter_provider_) + if (meter_provider) { std::shared_ptr none; opentelemetry::metrics::Provider::SetMeterProvider(none); } - if (logger_provider_) + if (logger_provider) { std::shared_ptr none; opentelemetry::logs::Provider::SetLoggerProvider(none); diff --git a/sdk/src/configuration/sdk_builder.cc b/sdk/src/configuration/sdk_builder.cc index 0f0fb67dd5..593fb46ebb 100644 --- a/sdk/src/configuration/sdk_builder.cc +++ b/sdk/src/configuration/sdk_builder.cc @@ -711,7 +711,7 @@ std::unique_ptr SdkBuilder::CreateJaegerRemo { std::unique_ptr sdk; - static const std::string die("JeagerRemoteSampler not supported"); + static const std::string die("JaegerRemoteSampler not supported"); throw UnsupportedException(die); return sdk; @@ -764,10 +764,19 @@ std::unique_ptr SdkBuilder::CreateParentBase local_parent_not_sampled_sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); } - // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3545 - OTEL_INTERNAL_LOG_ERROR("CreateParentBasedSampler: FIXME-SDK, missing param in parent factory"); - std::shared_ptr delegate_sampler = std::move(root_sdk); - sdk = opentelemetry::sdk::trace::ParentBasedSamplerFactory::Create(delegate_sampler); + 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; } @@ -1009,7 +1018,7 @@ std::unique_ptr SdkBuilder::CreateTra std::unique_ptr sdk; // FIXME-CONFIG: https://github.com/open-telemetry/opentelemetry-configuration/issues/70 - OTEL_INTERNAL_LOG_ERROR("CreateTracerProvider: FIXME-CONFIG (IdGenerator)"); + // FIXME-CONFIG: Add support for IdGenerator std::unique_ptr sampler; @@ -1364,7 +1373,7 @@ SdkBuilder::CreateAttributesProcessor( // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3546 // FIXME-SDK: Need a subclass of AttributesProcessor for IncludeExclude - OTEL_INTERNAL_LOG_ERROR("CreateAttributesProcessor() FIXME-SDK IncludeExclude"); + OTEL_INTERNAL_LOG_WARN("IncludeExclude attribute processor not supported, ignoring"); return sdk; } @@ -1699,7 +1708,7 @@ void SdkBuilder::SetResource( { // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3548 // FIXME-SDK: Implement resource detectors - OTEL_INTERNAL_LOG_ERROR("SdkBuilder::SetResource: FIXME-SDK detectors"); + OTEL_INTERNAL_LOG_WARN("resource detectors not supported, ignoring"); } auto sdk_resource = @@ -1715,16 +1724,11 @@ void SdkBuilder::SetResource( std::unique_ptr SdkBuilder::CreateConfiguredSdk( const std::unique_ptr &model) const { - std::unique_ptr sdk; - auto resource = opentelemetry::sdk::resource::Resource::GetEmpty(); - std::shared_ptr tracer_provider; - std::shared_ptr propagator; - std::shared_ptr meter_provider; - std::shared_ptr logger_provider; + auto sdk = std::make_unique(); if (!model->disabled) { - SetResource(resource, model->resource); + SetResource(sdk->resource, model->resource); if (model->attribute_limits) { @@ -1735,27 +1739,25 @@ std::unique_ptr SdkBuilder::CreateConfiguredSdk( if (model->tracer_provider) { - tracer_provider = CreateTracerProvider(model->tracer_provider, resource); + sdk->tracer_provider = CreateTracerProvider(model->tracer_provider, sdk->resource); } if (model->propagator) { - propagator = CreatePropagator(model->propagator); + sdk->propagator = CreatePropagator(model->propagator); } if (model->meter_provider) { - meter_provider = CreateMeterProvider(model->meter_provider, resource); + sdk->meter_provider = CreateMeterProvider(model->meter_provider, sdk->resource); } if (model->logger_provider) { - logger_provider = CreateLoggerProvider(model->logger_provider, resource); + sdk->logger_provider = CreateLoggerProvider(model->logger_provider, sdk->resource); } } - sdk = std::make_unique(std::move(resource), tracer_provider, propagator, - meter_provider, logger_provider); return sdk; }