diff --git a/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h new file mode 100644 index 0000000000..c2205a8be3 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/configured_sdk.h @@ -0,0 +1,60 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +/** + * This class represents a fully configured SDK. + * A SDK contains various objects, like propagators and providers for each + * signals, that collectively describe the opentelemetry configuration. + */ +class ConfiguredSdk +{ +public: + static std::unique_ptr Create( + std::shared_ptr registry, + const std::unique_ptr &model); + + ConfiguredSdk() : resource(opentelemetry::sdk::resource::Resource::GetEmpty()) {} + + /** + * Install the SDK, so that an instrumented application can make calls + * to it. + * This methods sets the global provider singletons to point to the SDK. + */ + void Install(); + + /** + * Uninstall the SDK, so that an instrumented application no longer makes + * calls to it. + * This method clears the global provider singletons. + */ + void UnInstall(); + + opentelemetry::sdk::resource::Resource resource; + std::shared_ptr tracer_provider; + std::shared_ptr propagator; + std::shared_ptr meter_provider; + std::shared_ptr logger_provider; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h b/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h new file mode 100644 index 0000000000..9f31ba68e0 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/sdk_builder.h @@ -0,0 +1,271 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/always_off_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/base2_exponential_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/batch_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/batch_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/double_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/double_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/explicit_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/integer_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/integer_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/periodic_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/simple_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/string_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/string_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_configuration.h" +#include "opentelemetry/sdk/logs/exporter.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/sampler.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class SdkBuilder +{ +public: + SdkBuilder(std::shared_ptr registry) : registry_(std::move(registry)) {} + SdkBuilder(SdkBuilder &&) = default; + SdkBuilder(const SdkBuilder &) = default; + SdkBuilder &operator=(SdkBuilder &&) = default; + SdkBuilder &operator=(const SdkBuilder &other) = default; + ~SdkBuilder() = default; + + std::unique_ptr CreateAlwaysOffSampler( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration *model) const; + + std::unique_ptr CreateAlwaysOnSampler( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) const; + + std::unique_ptr CreateJaegerRemoteSampler( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) const; + + std::unique_ptr CreateParentBasedSampler( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) const; + + std::unique_ptr CreateTraceIdRatioBasedSampler( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) const; + + std::unique_ptr CreateExtensionSampler( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const; + + std::unique_ptr CreateSampler( + const std::unique_ptr &model) const; + + std::unique_ptr CreateOtlpHttpSpanExporter( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpGrpcSpanExporter( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpFileSpanExporter( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) const; + + std::unique_ptr CreateConsoleSpanExporter( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) const; + + std::unique_ptr CreateZipkinSpanExporter( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) const; + + std::unique_ptr CreateExtensionSpanExporter( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const; + + std::unique_ptr CreateSpanExporter( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateBatchSpanProcessor( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateSimpleSpanProcessor( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateExtensionSpanProcessor( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) const; + + std::unique_ptr CreateSpanProcessor( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateTracerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + std::unique_ptr CreateTextMapPropagator( + const std::string &name) const; + + std::unique_ptr CreatePropagator( + const std::unique_ptr &model) + const; + + std::unique_ptr CreateOtlpHttpPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateOtlpGrpcPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateOtlpFilePushMetricExporter( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateConsolePushMetricExporter( + const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model) const; + + std::unique_ptr + CreateExtensionPushMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + const; + + std::unique_ptr CreatePrometheusPullMetricExporter( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) + const; + + std::unique_ptr CreateExtensionPullMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + const; + + std::unique_ptr CreatePushMetricExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreatePullMetricExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreatePeriodicMetricReader( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) const; + + std::unique_ptr CreatePullMetricReader( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) const; + + std::unique_ptr CreateMetricReader( + const std::unique_ptr &model) + const; + + std::unique_ptr + CreateBase2ExponentialBucketHistogramAggregation( + const opentelemetry::sdk::configuration:: + Base2ExponentialBucketHistogramAggregationConfiguration *model) const; + + std::unique_ptr + CreateExplicitBucketHistogramAggregation( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration + *model) const; + + std::unique_ptr CreateAggregationConfig( + const std::unique_ptr &model, + opentelemetry::sdk::metrics::AggregationType &aggregation_type) const; + + std::unique_ptr CreateAttributesProcessor( + const std::unique_ptr &model) + const; + + void AddView( + opentelemetry::sdk::metrics::ViewRegistry *view_registry, + const std::unique_ptr &model) const; + + std::unique_ptr CreateMeterProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + std::unique_ptr CreateOtlpHttpLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpGrpcLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateOtlpFileLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateConsoleLogRecordExporter( + const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model) const; + + std::unique_ptr CreateExtensionLogRecordExporter( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + const; + + std::unique_ptr CreateLogRecordExporter( + const std::unique_ptr + &model) const; + + std::unique_ptr CreateBatchLogRecordProcessor( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) const; + + std::unique_ptr CreateSimpleLogRecordProcessor( + const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration *model) const; + + std::unique_ptr CreateExtensionLogRecordProcessor( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + const; + + std::unique_ptr CreateLogRecordProcessor( + const std::unique_ptr + &model) const; + + std::unique_ptr CreateLoggerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const; + + void SetResourceAttribute( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name, + const opentelemetry::sdk::configuration::AttributeValueConfiguration *model) const; + + void SetResource(opentelemetry::sdk::resource::Resource &resource, + const std::unique_ptr + &opt_model) const; + + std::unique_ptr CreateConfiguredSdk( + const std::unique_ptr &model) const; + +private: + std::shared_ptr registry_; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h b/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h new file mode 100644 index 0000000000..95da867b99 --- /dev/null +++ b/sdk/include/opentelemetry/sdk/configuration/unsupported_exception.h @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include + +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class UnsupportedException : public std::runtime_error +{ +public: + UnsupportedException(const std::string &msg) : std::runtime_error(msg) {} + UnsupportedException(UnsupportedException &&) = default; + UnsupportedException(const UnsupportedException &) = default; + UnsupportedException &operator=(UnsupportedException &&) = default; + UnsupportedException &operator=(const UnsupportedException &other) = default; + ~UnsupportedException() override = default; +}; + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h b/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h index 7c47bdd1d3..248ff77578 100644 --- a/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h +++ b/sdk/include/opentelemetry/sdk/configuration/view_selector_configuration.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include #include "opentelemetry/sdk/configuration/instrument_type.h" diff --git a/sdk/src/configuration/configured_sdk.cc b/sdk/src/configuration/configured_sdk.cc new file mode 100644 index 0000000000..3eb81c9e48 --- /dev/null +++ b/sdk/src/configuration/configured_sdk.cc @@ -0,0 +1,114 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include "opentelemetry/context/propagation/global_propagator.h" +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/logs/logger_provider.h" +#include "opentelemetry/logs/provider.h" +#include "opentelemetry/metrics/meter_provider.h" +#include "opentelemetry/metrics/provider.h" +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/sdk_builder.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/trace/provider.h" +#include "opentelemetry/trace/tracer_provider.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +std::unique_ptr ConfiguredSdk::Create( + std::shared_ptr registry, + const std::unique_ptr &model) +{ + std::unique_ptr sdk; + + if (model) + { + try + { + SdkBuilder builder(std::move(registry)); + sdk = builder.CreateConfiguredSdk(model); + } + catch (const std::exception &e) + { + OTEL_INTERNAL_LOG_ERROR("[Configured Sdk] builder failed with exception: " << e.what()); + } + catch (...) + { + OTEL_INTERNAL_LOG_ERROR("[Configured Sdk] builder failed with unknown exception."); + } + } + + return sdk; +} + +void ConfiguredSdk::Install() +{ + if (propagator) + { + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(propagator); + } + + if (tracer_provider) + { + std::shared_ptr api_tracer_provider = tracer_provider; + opentelemetry::trace::Provider::SetTracerProvider(api_tracer_provider); + } + + if (meter_provider) + { + std::shared_ptr api_meter_provider = meter_provider; + opentelemetry::metrics::Provider::SetMeterProvider(api_meter_provider); + } + + if (logger_provider) + { + std::shared_ptr api_logger_provider = logger_provider; + opentelemetry::logs::Provider::SetLoggerProvider(api_logger_provider); + } +} + +void ConfiguredSdk::UnInstall() +{ + if (propagator) + { + std::shared_ptr none; + opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(none); + } + + if (tracer_provider) + { + std::shared_ptr none; + opentelemetry::trace::Provider::SetTracerProvider(none); + } + + if (meter_provider) + { + std::shared_ptr none; + opentelemetry::metrics::Provider::SetMeterProvider(none); + } + + if (logger_provider) + { + std::shared_ptr none; + opentelemetry::logs::Provider::SetLoggerProvider(none); + } +} + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/src/configuration/sdk_builder.cc b/sdk/src/configuration/sdk_builder.cc new file mode 100644 index 0000000000..593fb46ebb --- /dev/null +++ b/sdk/src/configuration/sdk_builder.cc @@ -0,0 +1,1766 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "opentelemetry/common/attribute_value.h" +#include "opentelemetry/common/kv_properties.h" +#include "opentelemetry/context/propagation/composite_propagator.h" +#include "opentelemetry/context/propagation/text_map_propagator.h" +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/configuration/aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/aggregation_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/always_off_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/always_on_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/attribute_value_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/attributes_configuration.h" +#include "opentelemetry/sdk/configuration/base2_exponential_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/batch_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/batch_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/boolean_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/console_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/console_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/double_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/double_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/explicit_bucket_histogram_aggregation_configuration.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_sampler_builder.h" +#include "opentelemetry/sdk/configuration/extension_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/include_exclude_configuration.h" +#include "opentelemetry/sdk/configuration/instrument_type.h" +#include "opentelemetry/sdk/configuration/integer_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/integer_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/jaeger_remote_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/log_record_processor_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/logger_provider_configuration.h" +#include "opentelemetry/sdk/configuration/meter_provider_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/metric_reader_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/parent_based_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/periodic_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/propagator_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/pull_metric_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/resource_configuration.h" +#include "opentelemetry/sdk/configuration/sampler_configuration.h" +#include "opentelemetry/sdk/configuration/sampler_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/sdk_builder.h" +#include "opentelemetry/sdk/configuration/simple_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/simple_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/span_exporter_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/span_processor_configuration_visitor.h" +#include "opentelemetry/sdk/configuration/string_array_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/string_attribute_value_configuration.h" +#include "opentelemetry/sdk/configuration/text_map_propagator_builder.h" +#include "opentelemetry/sdk/configuration/trace_id_ratio_based_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/tracer_provider_configuration.h" +#include "opentelemetry/sdk/configuration/unsupported_exception.h" +#include "opentelemetry/sdk/configuration/view_configuration.h" +#include "opentelemetry/sdk/configuration/view_selector_configuration.h" +#include "opentelemetry/sdk/configuration/view_stream_configuration.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/zipkin_span_exporter_configuration.h" +#include "opentelemetry/sdk/logs/batch_log_record_processor_factory.h" +#include "opentelemetry/sdk/logs/batch_log_record_processor_options.h" +#include "opentelemetry/sdk/logs/exporter.h" +#include "opentelemetry/sdk/logs/logger_provider.h" +#include "opentelemetry/sdk/logs/logger_provider_factory.h" +#include "opentelemetry/sdk/logs/processor.h" +#include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h" +#include "opentelemetry/sdk/metrics/aggregation/aggregation_config.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_factory.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_options.h" +#include "opentelemetry/sdk/metrics/instruments.h" +#include "opentelemetry/sdk/metrics/meter_context.h" +#include "opentelemetry/sdk/metrics/meter_context_factory.h" +#include "opentelemetry/sdk/metrics/meter_provider.h" +#include "opentelemetry/sdk/metrics/meter_provider_factory.h" +#include "opentelemetry/sdk/metrics/metric_reader.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/sdk/metrics/view/attributes_processor.h" +#include "opentelemetry/sdk/metrics/view/instrument_selector.h" +#include "opentelemetry/sdk/metrics/view/meter_selector.h" +#include "opentelemetry/sdk/metrics/view/view.h" +#include "opentelemetry/sdk/metrics/view/view_registry.h" +#include "opentelemetry/sdk/metrics/view/view_registry_factory.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/trace/batch_span_processor_factory.h" +#include "opentelemetry/sdk/trace/batch_span_processor_options.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/sampler.h" +#include "opentelemetry/sdk/trace/samplers/always_off_factory.h" +#include "opentelemetry/sdk/trace/samplers/always_on_factory.h" +#include "opentelemetry/sdk/trace/samplers/parent_factory.h" +#include "opentelemetry/sdk/trace/samplers/trace_id_ratio_factory.h" +#include "opentelemetry/sdk/trace/simple_processor_factory.h" +#include "opentelemetry/sdk/trace/tracer_provider.h" +#include "opentelemetry/sdk/trace/tracer_provider_factory.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace configuration +{ + +class ResourceAttributeValueSetter + : public opentelemetry::sdk::configuration::AttributeValueConfigurationVisitor +{ +public: + ResourceAttributeValueSetter( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name) + : resource_attributes_(resource_attributes), name_(name) + {} + ResourceAttributeValueSetter(ResourceAttributeValueSetter &&) = delete; + ResourceAttributeValueSetter(const ResourceAttributeValueSetter &) = delete; + ResourceAttributeValueSetter &operator=(ResourceAttributeValueSetter &&) = delete; + ResourceAttributeValueSetter &operator=(const ResourceAttributeValueSetter &other) = delete; + ~ResourceAttributeValueSetter() override = default; + + void VisitString( + const opentelemetry::sdk::configuration::StringAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitInteger( + const opentelemetry::sdk::configuration::IntegerAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitDouble( + const opentelemetry::sdk::configuration::DoubleAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitBoolean( + const opentelemetry::sdk::configuration::BooleanAttributeValueConfiguration *model) override + { + opentelemetry::common::AttributeValue attribute_value(model->value); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitStringArray( + const opentelemetry::sdk::configuration::StringArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + std::vector string_view_array(length); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + string_view_array[i] = model->value[i]; + } + + nostd::span span(string_view_array.data(), string_view_array.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitIntegerArray( + const opentelemetry::sdk::configuration::IntegerArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + std::vector int_array(length); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + int_array[i] = model->value[i]; + } + + nostd::span span(int_array.data(), int_array.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitDoubleArray( + const opentelemetry::sdk::configuration::DoubleArrayAttributeValueConfiguration *model) + override + { + // We have: std::vector + // We need: nostd::span + // so no data conversion needed + + nostd::span span(model->value.data(), model->value.size()); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + void VisitBooleanArray( + const opentelemetry::sdk::configuration::BooleanArrayAttributeValueConfiguration *model) + override + { + size_t length = model->value.size(); + + // Can not use std::vector, + // it has no data() to convert it to a span + std::unique_ptr bool_array(new bool[length]); + + // We have: std::vector + // We need: nostd::span + + for (size_t i = 0; i < length; i++) + { + bool_array[i] = model->value[i]; + } + + nostd::span span(&bool_array[0], length); + + opentelemetry::common::AttributeValue attribute_value(span); + resource_attributes_.SetAttribute(name_, attribute_value); + } + + opentelemetry::common::AttributeValue attribute_value; + +private: + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes_; + std::string name_; +}; + +class SamplerBuilder : public opentelemetry::sdk::configuration::SamplerConfigurationVisitor +{ +public: + SamplerBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SamplerBuilder(SamplerBuilder &&) = delete; + SamplerBuilder(const SamplerBuilder &) = delete; + SamplerBuilder &operator=(SamplerBuilder &&) = delete; + SamplerBuilder &operator=(const SamplerBuilder &other) = delete; + ~SamplerBuilder() override = default; + + void VisitAlwaysOff( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateAlwaysOffSampler(model); + } + + void VisitAlwaysOn( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateAlwaysOnSampler(model); + } + + void VisitJaegerRemote( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateJaegerRemoteSampler(model); + } + + void VisitParentBased( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateParentBasedSampler(model); + } + + void VisitTraceIdRatioBased( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) + override + { + sampler = sdk_builder_->CreateTraceIdRatioBasedSampler(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) override + { + sampler = sdk_builder_->CreateExtensionSampler(model); + } + + std::unique_ptr sampler; + +private: + const SdkBuilder *sdk_builder_; +}; + +class SpanProcessorBuilder + : public opentelemetry::sdk::configuration::SpanProcessorConfigurationVisitor +{ +public: + SpanProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SpanProcessorBuilder(SpanProcessorBuilder &&) = delete; + SpanProcessorBuilder(const SpanProcessorBuilder &) = delete; + SpanProcessorBuilder &operator=(SpanProcessorBuilder &&) = delete; + SpanProcessorBuilder &operator=(const SpanProcessorBuilder &other) = delete; + ~SpanProcessorBuilder() override = default; + + void VisitBatch( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateBatchSpanProcessor(model); + } + + void VisitSimple( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateSimpleSpanProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateExtensionSpanProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *sdk_builder_; +}; + +class SpanExporterBuilder + : public opentelemetry::sdk::configuration::SpanExporterConfigurationVisitor +{ +public: + SpanExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + SpanExporterBuilder(SpanExporterBuilder &&) = delete; + SpanExporterBuilder(const SpanExporterBuilder &) = delete; + SpanExporterBuilder &operator=(SpanExporterBuilder &&) = delete; + SpanExporterBuilder &operator=(const SpanExporterBuilder &other) = delete; + ~SpanExporterBuilder() override = default; + + void VisitOtlpHttp( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpHttpSpanExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpGrpcSpanExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateOtlpFileSpanExporter(model); + } + + void VisitConsole( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateConsoleSpanExporter(model); + } + + void VisitZipkin( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateZipkinSpanExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) override + { + exporter = sdk_builder_->CreateExtensionSpanExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class MetricReaderBuilder + : public opentelemetry::sdk::configuration::MetricReaderConfigurationVisitor +{ +public: + MetricReaderBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + MetricReaderBuilder(MetricReaderBuilder &&) = delete; + MetricReaderBuilder(const MetricReaderBuilder &) = delete; + MetricReaderBuilder &operator=(MetricReaderBuilder &&) = delete; + MetricReaderBuilder &operator=(const MetricReaderBuilder &other) = delete; + ~MetricReaderBuilder() override = default; + + void VisitPeriodic( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) override + { + metric_reader = sdk_builder_->CreatePeriodicMetricReader(model); + } + + void VisitPull( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) override + { + metric_reader = sdk_builder_->CreatePullMetricReader(model); + } + + std::unique_ptr metric_reader; + +private: + const SdkBuilder *sdk_builder_; +}; + +class PushMetricExporterBuilder + : public opentelemetry::sdk::configuration::PushMetricExporterConfigurationVisitor +{ +public: + PushMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + PushMetricExporterBuilder(PushMetricExporterBuilder &&) = delete; + PushMetricExporterBuilder(const PushMetricExporterBuilder &) = delete; + PushMetricExporterBuilder &operator=(PushMetricExporterBuilder &&) = delete; + PushMetricExporterBuilder &operator=(const PushMetricExporterBuilder &other) = delete; + ~PushMetricExporterBuilder() override = default; + + void VisitOtlpHttp( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpHttpPushMetricExporter(model); + } + + void VisitOtlpGrpc( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpGrpcPushMetricExporter(model); + } + + void VisitOtlpFile( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateOtlpFilePushMetricExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateConsolePushMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionPushMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class PullMetricExporterBuilder + : public opentelemetry::sdk::configuration::PullMetricExporterConfigurationVisitor +{ +public: + PullMetricExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + PullMetricExporterBuilder(PullMetricExporterBuilder &&) = delete; + PullMetricExporterBuilder(const PullMetricExporterBuilder &) = delete; + PullMetricExporterBuilder &operator=(PullMetricExporterBuilder &&) = delete; + PullMetricExporterBuilder &operator=(const PullMetricExporterBuilder &other) = delete; + ~PullMetricExporterBuilder() override = default; + + void VisitPrometheus( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreatePrometheusPullMetricExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionPullMetricExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +class AggregationConfigBuilder + : public opentelemetry::sdk::configuration::AggregationConfigurationVisitor +{ +public: + AggregationConfigBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + AggregationConfigBuilder(AggregationConfigBuilder &&) = delete; + AggregationConfigBuilder(const AggregationConfigBuilder &) = delete; + AggregationConfigBuilder &operator=(AggregationConfigBuilder &&) = delete; + AggregationConfigBuilder &operator=(const AggregationConfigBuilder &other) = delete; + ~AggregationConfigBuilder() override = default; + + void VisitBase2ExponentialBucketHistogram( + const opentelemetry::sdk::configuration:: + Base2ExponentialBucketHistogramAggregationConfiguration *model) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kBase2ExponentialHistogram; + aggregation_config = sdk_builder_->CreateBase2ExponentialBucketHistogramAggregation(model); + } + + void VisitDefault(const opentelemetry::sdk::configuration::DefaultAggregationConfiguration + * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kDefault; + } + + void VisitDrop( + const opentelemetry::sdk::configuration::DropAggregationConfiguration * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kDrop; + } + + void VisitExplicitBucketHistogram( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration + *model) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kHistogram; + aggregation_config = sdk_builder_->CreateExplicitBucketHistogramAggregation(model); + } + + void VisitLastValue(const opentelemetry::sdk::configuration::LastValueAggregationConfiguration + * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kLastValue; + } + + void VisitSum( + const opentelemetry::sdk::configuration::SumAggregationConfiguration * /* model */) override + { + aggregation_type = opentelemetry::sdk::metrics::AggregationType::kSum; + } + + opentelemetry::sdk::metrics::AggregationType aggregation_type; + std::unique_ptr aggregation_config; + +private: + const SdkBuilder *sdk_builder_; +}; + +class LogRecordProcessorBuilder + : public opentelemetry::sdk::configuration::LogRecordProcessorConfigurationVisitor +{ +public: + LogRecordProcessorBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + LogRecordProcessorBuilder(LogRecordProcessorBuilder &&) = delete; + LogRecordProcessorBuilder(const LogRecordProcessorBuilder &) = delete; + LogRecordProcessorBuilder &operator=(LogRecordProcessorBuilder &&) = delete; + LogRecordProcessorBuilder &operator=(const LogRecordProcessorBuilder &other) = delete; + ~LogRecordProcessorBuilder() override = default; + + void VisitBatch( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) override + { + processor = sdk_builder_->CreateBatchLogRecordProcessor(model); + } + + void VisitSimple(const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration + *model) override + { + processor = sdk_builder_->CreateSimpleLogRecordProcessor(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + override + { + processor = sdk_builder_->CreateExtensionLogRecordProcessor(model); + } + + std::unique_ptr processor; + +private: + const SdkBuilder *sdk_builder_; +}; + +class LogRecordExporterBuilder + : public opentelemetry::sdk::configuration::LogRecordExporterConfigurationVisitor +{ +public: + LogRecordExporterBuilder(const SdkBuilder *b) : sdk_builder_(b) {} + LogRecordExporterBuilder(LogRecordExporterBuilder &&) = delete; + LogRecordExporterBuilder(const LogRecordExporterBuilder &) = delete; + LogRecordExporterBuilder &operator=(LogRecordExporterBuilder &&) = delete; + LogRecordExporterBuilder &operator=(const LogRecordExporterBuilder &other) = delete; + ~LogRecordExporterBuilder() override = default; + + void VisitOtlpHttp(const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpHttpLogRecordExporter(model); + } + + void VisitOtlpGrpc(const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpGrpcLogRecordExporter(model); + } + + void VisitOtlpFile(const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateOtlpFileLogRecordExporter(model); + } + + void VisitConsole(const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration + *model) override + { + exporter = sdk_builder_->CreateConsoleLogRecordExporter(model); + } + + void VisitExtension( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + override + { + exporter = sdk_builder_->CreateExtensionLogRecordExporter(model); + } + + std::unique_ptr exporter; + +private: + const SdkBuilder *sdk_builder_; +}; + +std::unique_ptr SdkBuilder::CreateAlwaysOffSampler( + const opentelemetry::sdk::configuration::AlwaysOffSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateAlwaysOnSampler( + const opentelemetry::sdk::configuration::AlwaysOnSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateJaegerRemoteSampler( + const opentelemetry::sdk::configuration::JaegerRemoteSamplerConfiguration * /* model */) const +{ + std::unique_ptr sdk; + + static const std::string die("JaegerRemoteSampler not supported"); + throw UnsupportedException(die); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateParentBasedSampler( + const opentelemetry::sdk::configuration::ParentBasedSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + std::unique_ptr remote_parent_sampled_sdk; + std::unique_ptr remote_parent_not_sampled_sdk; + std::unique_ptr local_parent_sampled_sdk; + std::unique_ptr local_parent_not_sampled_sdk; + + auto root_sdk = SdkBuilder::CreateSampler(model->root); + + if (model->remote_parent_sampled != nullptr) + { + remote_parent_sampled_sdk = SdkBuilder::CreateSampler(model->remote_parent_sampled); + } + else + { + remote_parent_sampled_sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + } + + if (model->remote_parent_not_sampled != nullptr) + { + remote_parent_not_sampled_sdk = SdkBuilder::CreateSampler(model->remote_parent_not_sampled); + } + else + { + remote_parent_not_sampled_sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + } + + if (model->local_parent_sampled != nullptr) + { + local_parent_sampled_sdk = SdkBuilder::CreateSampler(model->local_parent_sampled); + } + else + { + local_parent_sampled_sdk = opentelemetry::sdk::trace::AlwaysOnSamplerFactory::Create(); + } + + if (model->local_parent_not_sampled != nullptr) + { + local_parent_not_sampled_sdk = SdkBuilder::CreateSampler(model->local_parent_not_sampled); + } + else + { + local_parent_not_sampled_sdk = opentelemetry::sdk::trace::AlwaysOffSamplerFactory::Create(); + } + + std::shared_ptr shared_root = std::move(root_sdk); + std::shared_ptr shared_remote_parent_sampled = + std::move(remote_parent_sampled_sdk); + std::shared_ptr shared_remote_parent_not_sampled = + std::move(remote_parent_not_sampled_sdk); + std::shared_ptr shared_local_parent_sampled = + std::move(local_parent_sampled_sdk); + std::shared_ptr shared_local_parent_not_sampled = + std::move(local_parent_not_sampled_sdk); + + sdk = opentelemetry::sdk::trace::ParentBasedSamplerFactory::Create( + shared_root, shared_remote_parent_sampled, shared_remote_parent_not_sampled, + shared_local_parent_sampled, shared_local_parent_not_sampled); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateTraceIdRatioBasedSampler( + const opentelemetry::sdk::configuration::TraceIdRatioBasedSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + + sdk = opentelemetry::sdk::trace::TraceIdRatioBasedSamplerFactory::Create(model->ratio); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateExtensionSampler( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSamplerBuilder *builder = registry_->GetExtensionSamplerBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSampler() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSampler() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSampler( + const std::unique_ptr &model) const +{ + std::unique_ptr sdk; + + SamplerBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.sampler); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateOtlpHttpSpanExporter( + const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpSpanExporterBuilder *builder; + + builder = registry_->GetOtlpHttpSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpSpanExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpHttpSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateOtlpGrpcSpanExporter( + const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcSpanExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcSpanExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for OtlpGrpcSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateOtlpFileSpanExporter( + const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFileSpanExporterBuilder *builder; + + builder = registry_->GetOtlpFileSpanBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFileSpanExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for OtlpFileSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateConsoleSpanExporter( + const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ConsoleSpanExporterBuilder *builder = registry_->GetConsoleSpanBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsoleSpanExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsoleSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateZipkinSpanExporter( + const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ZipkinSpanExporterBuilder *builder = registry_->GetZipkinSpanBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateZipkinSpanExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ZipkinSpanExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateExtensionSpanExporter( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSpanExporterBuilder *builder = registry_->GetExtensionSpanExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSpanExporter() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSpanExporter() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSpanExporter( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + SpanExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateBatchSpanProcessor( + const opentelemetry::sdk::configuration::BatchSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + opentelemetry::sdk::trace::BatchSpanProcessorOptions options; + + options.schedule_delay_millis = std::chrono::milliseconds(model->schedule_delay); + +#ifdef LATER + options.xxx = model->export_timeout; +#endif + + options.max_queue_size = model->max_queue_size; + options.max_export_batch_size = model->max_export_batch_size; + + auto exporter_sdk = CreateSpanExporter(model->exporter); + + sdk = opentelemetry::sdk::trace::BatchSpanProcessorFactory::Create(std::move(exporter_sdk), + options); + return sdk; +} + +std::unique_ptr SdkBuilder::CreateSimpleSpanProcessor( + const opentelemetry::sdk::configuration::SimpleSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + + auto exporter_sdk = CreateSpanExporter(model->exporter); + + sdk = opentelemetry::sdk::trace::SimpleSpanProcessorFactory::Create(std::move(exporter_sdk)); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateExtensionSpanProcessor( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionSpanProcessorBuilder *builder = registry_->GetExtensionSpanProcessorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionSpanProcessor() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionSpanProcessor() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateSpanProcessor( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + SpanProcessorBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.processor); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateTracerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + // FIXME-CONFIG: https://github.com/open-telemetry/opentelemetry-configuration/issues/70 + // FIXME-CONFIG: Add support for IdGenerator + + std::unique_ptr sampler; + + if (model->sampler) + { + sampler = CreateSampler(model->sampler); + } + + std::vector> sdk_processors; + + for (const auto &processor_model : model->processors) + { + sdk_processors.push_back(CreateSpanProcessor(processor_model)); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: use limits, id_generator, ... + sdk = opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(sdk_processors), + resource, std::move(sampler)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateTextMapPropagator(const std::string &name) const +{ + std::unique_ptr sdk; + + const TextMapPropagatorBuilder *builder = registry_->GetTextMapPropagatorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateTextMapPropagator() using registered builder " << name); + sdk = builder->Build(); + return sdk; + } + + std::string die("CreateTextMapPropagator() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePropagator( + const std::unique_ptr &model) const +{ + std::vector> propagators; + std::unique_ptr propagator; + + for (const auto &name : model->composite) + { + propagator = CreateTextMapPropagator(name); + propagators.push_back(std::move(propagator)); + } + + auto sdk = std::make_unique( + std::move(propagators)); + + return sdk; +} + +static opentelemetry::sdk::metrics::InstrumentType ConvertInstrumentType( + enum opentelemetry::sdk::configuration::InstrumentType config) +{ + opentelemetry::sdk::metrics::InstrumentType sdk; + + switch (config) + { + case opentelemetry::sdk::configuration::InstrumentType::none: + case opentelemetry::sdk::configuration::InstrumentType::counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::histogram: + sdk = opentelemetry::sdk::metrics::InstrumentType::kHistogram; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_gauge: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableGauge; + break; + case opentelemetry::sdk::configuration::InstrumentType::observable_up_down_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kObservableUpDownCounter; + break; + case opentelemetry::sdk::configuration::InstrumentType::up_down_counter: + sdk = opentelemetry::sdk::metrics::InstrumentType::kUpDownCounter; + break; + } + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateOtlpHttpPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpPushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpHttpPushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpPushMetricExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpGrpcPushMetricExporter( + const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcPushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcPushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcPushMetricExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No grpc builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpFilePushMetricExporter( + const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFilePushMetricExporterBuilder *builder; + + builder = registry_->GetOtlpFilePushMetricExporterBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFilePushMetricExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No file builder for OtlpPushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateConsolePushMetricExporter( + const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + + const ConsolePushMetricExporterBuilder *builder = + registry_->GetConsolePushMetricExporterBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsolePushMetricExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsolePushMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionPushMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionPushMetricExporterBuilder *builder = + registry_->GetExtensionPushMetricExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionPushMetricExporter() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("No builder for ExtensionPushMetricExporter "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePrometheusPullMetricExporter( + const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + + const PrometheusPullMetricExporterBuilder *builder = + registry_->GetPrometheusPullMetricExporterBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreatePrometheusPullMetricExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for PrometheusMetricExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionPullMetricExporter( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionPullMetricExporterBuilder *builder = + registry_->GetExtensionPullMetricExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionPullMetricExporter() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("No builder for ExtensionPullMetricExporter "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreatePushMetricExporter( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + PushMetricExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePullMetricExporter( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + PullMetricExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePeriodicMetricReader( + const opentelemetry::sdk::configuration::PeriodicMetricReaderConfiguration *model) const +{ + std::unique_ptr sdk; + + opentelemetry::sdk::metrics::PeriodicExportingMetricReaderOptions options; + + options.export_interval_millis = std::chrono::milliseconds(model->interval); + options.export_timeout_millis = std::chrono::milliseconds(model->timeout); + + auto exporter_sdk = CreatePushMetricExporter(model->exporter); + + sdk = opentelemetry::sdk::metrics::PeriodicExportingMetricReaderFactory::Create( + std::move(exporter_sdk), options); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreatePullMetricReader( + const opentelemetry::sdk::configuration::PullMetricReaderConfiguration *model) const +{ + std::unique_ptr sdk; + + sdk = CreatePullMetricExporter(model->exporter); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateMetricReader( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + MetricReaderBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.metric_reader); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateBase2ExponentialBucketHistogramAggregation( + const opentelemetry::sdk::configuration::Base2ExponentialBucketHistogramAggregationConfiguration + *model) const +{ + auto sdk = + std::make_unique(); + + sdk->max_buckets_ = model->max_size; + sdk->max_scale_ = static_cast(model->max_scale); + sdk->record_min_max_ = model->record_min_max; + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateExplicitBucketHistogramAggregation( + const opentelemetry::sdk::configuration::ExplicitBucketHistogramAggregationConfiguration *model) + const +{ + auto sdk = std::make_unique(); + + sdk->boundaries_ = model->boundaries; + sdk->record_min_max_ = model->record_min_max; + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateAggregationConfig( + const std::unique_ptr &model, + opentelemetry::sdk::metrics::AggregationType &aggregation_type) const +{ + std::unique_ptr sdk; + + AggregationConfigBuilder builder(this); + model->Accept(&builder); + aggregation_type = builder.aggregation_type; + sdk = std::move(builder.aggregation_config); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateAttributesProcessor( + const std::unique_ptr + & /* model */) const +{ + std::unique_ptr sdk; + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3546 + // FIXME-SDK: Need a subclass of AttributesProcessor for IncludeExclude + OTEL_INTERNAL_LOG_WARN("IncludeExclude attribute processor not supported, ignoring"); + + return sdk; +} + +void SdkBuilder::AddView( + opentelemetry::sdk::metrics::ViewRegistry *view_registry, + const std::unique_ptr &model) const +{ + auto *selector = model->selector.get(); + + if (selector->instrument_type == opentelemetry::sdk::configuration::InstrumentType::none) + { + std::string die("Runtime does not support instrument_type: null"); + throw UnsupportedException(die); + } + + auto sdk_instrument_type = ConvertInstrumentType(selector->instrument_type); + + auto sdk_instrument_selector = std::make_unique( + sdk_instrument_type, selector->instrument_name, selector->unit); + + auto sdk_meter_selector = std::make_unique( + selector->meter_name, selector->meter_version, selector->meter_schema_url); + + auto *stream = model->stream.get(); + + opentelemetry::sdk::metrics::AggregationType sdk_aggregation_type = + opentelemetry::sdk::metrics::AggregationType::kDefault; + + std::shared_ptr sdk_aggregation_config; + + sdk_aggregation_config = CreateAggregationConfig(stream->aggregation, sdk_aggregation_type); + + std::unique_ptr sdk_attribute_processor; + + if (stream->attribute_keys != nullptr) + { + sdk_attribute_processor = CreateAttributesProcessor(stream->attribute_keys); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3547 + // FIXME-SDK: unit is unused in class View, should be removed. + std::string unit("FIXME-SDK"); + + auto sdk_view = std::make_unique( + stream->name, stream->description, unit, sdk_aggregation_type, sdk_aggregation_config, + std::move(sdk_attribute_processor)); + + view_registry->AddView(std::move(sdk_instrument_selector), std::move(sdk_meter_selector), + std::move(sdk_view)); +} + +std::unique_ptr SdkBuilder::CreateMeterProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + auto view_registry = opentelemetry::sdk::metrics::ViewRegistryFactory::Create(); + + for (const auto &view_configuration : model->views) + { + AddView(view_registry.get(), view_configuration); + } + + auto meter_context = + opentelemetry::sdk::metrics::MeterContextFactory::Create(std::move(view_registry), resource); + + for (const auto &reader_configuration : model->readers) + { + std::shared_ptr metric_reader; + metric_reader = CreateMetricReader(reader_configuration); + meter_context->AddMetricReader(metric_reader); + } + + sdk = opentelemetry::sdk::metrics::MeterProviderFactory::Create(std::move(meter_context)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateOtlpHttpLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpHttpLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpHttpLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpHttpLogRecordExporter() using registered http builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No http builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpGrpcLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpGrpcLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpGrpcLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpGrpcLogRecordExporter() using registered grpc builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No grpc builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateOtlpFileLogRecordExporter( + const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const OtlpFileLogRecordExporterBuilder *builder; + + builder = registry_->GetOtlpFileLogRecordBuilder(); + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateOtlpFileLogRecordExporter() using registered file builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No file builder for OtlpLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateConsoleLogRecordExporter( + const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + const ConsoleLogRecordExporterBuilder *builder = registry_->GetConsoleLogRecordBuilder(); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateConsoleLogRecordExporter() using registered builder"); + sdk = builder->Build(model); + return sdk; + } + + static const std::string die("No builder for ConsoleLogRecordExporter"); + throw UnsupportedException(die); +} + +std::unique_ptr +SdkBuilder::CreateExtensionLogRecordExporter( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionLogRecordExporterBuilder *builder = + registry_->GetExtensionLogRecordExporterBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionLogRecordExporter() using registered builder " << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionLogRecordExporter() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateLogRecordExporter( + const std::unique_ptr &model) + const +{ + std::unique_ptr sdk; + + LogRecordExporterBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.exporter); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateBatchLogRecordProcessor( + const opentelemetry::sdk::configuration::BatchLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + opentelemetry::sdk::logs::BatchLogRecordProcessorOptions options; + + options.schedule_delay_millis = std::chrono::milliseconds(model->schedule_delay); + options.max_queue_size = model->max_queue_size; + options.max_export_batch_size = model->max_export_batch_size; + + auto exporter_sdk = CreateLogRecordExporter(model->exporter); + + sdk = opentelemetry::sdk::logs::BatchLogRecordProcessorFactory::Create(std::move(exporter_sdk), + options); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateSimpleLogRecordProcessor( + const opentelemetry::sdk::configuration::SimpleLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + + auto exporter_sdk = CreateLogRecordExporter(model->exporter); + + sdk = opentelemetry::sdk::logs::SimpleLogRecordProcessorFactory::Create(std::move(exporter_sdk)); + + return sdk; +} + +std::unique_ptr +SdkBuilder::CreateExtensionLogRecordProcessor( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) const +{ + std::unique_ptr sdk; + std::string name = model->name; + + const ExtensionLogRecordProcessorBuilder *builder = + registry_->GetExtensionLogRecordProcessorBuilder(name); + + if (builder != nullptr) + { + OTEL_INTERNAL_LOG_DEBUG("CreateExtensionLogRecordProcessor() using registered builder " + << name); + sdk = builder->Build(model); + return sdk; + } + + std::string die("CreateExtensionLogRecordProcessor() no builder for "); + die.append(name); + throw UnsupportedException(die); +} + +std::unique_ptr SdkBuilder::CreateLogRecordProcessor( + const std::unique_ptr + &model) const +{ + std::unique_ptr sdk; + + LogRecordProcessorBuilder builder(this); + model->Accept(&builder); + sdk = std::move(builder.processor); + + return sdk; +} + +std::unique_ptr SdkBuilder::CreateLoggerProvider( + const std::unique_ptr &model, + const opentelemetry::sdk::resource::Resource &resource) const +{ + std::unique_ptr sdk; + + std::vector> sdk_processors; + + for (const auto &processor_model : model->processors) + { + sdk_processors.push_back(CreateLogRecordProcessor(processor_model)); + } + + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: use limits + sdk = + opentelemetry::sdk::logs::LoggerProviderFactory::Create(std::move(sdk_processors), resource); + + return sdk; +} + +void SdkBuilder::SetResourceAttribute( + opentelemetry::sdk::resource::ResourceAttributes &resource_attributes, + const std::string &name, + const opentelemetry::sdk::configuration::AttributeValueConfiguration *model) const +{ + ResourceAttributeValueSetter setter(resource_attributes, name); + // Invokes resource_attributes.SetAttribute(name, ) + model->Accept(&setter); +} + +void SdkBuilder::SetResource( + opentelemetry::sdk::resource::Resource &resource, + const std::unique_ptr &opt_model) + const +{ + if (opt_model) + { + opentelemetry::sdk::resource::ResourceAttributes sdk_attributes; + + // First, scan attributes_list, which has low priority. + if (opt_model->attributes_list.size() != 0) + { + opentelemetry::common::KeyValueStringTokenizer tokenizer{opt_model->attributes_list}; + + opentelemetry::nostd::string_view attribute_key; + opentelemetry::nostd::string_view attribute_value; + bool attribute_valid = true; + + while (tokenizer.next(attribute_valid, attribute_key, attribute_value)) + { + if (attribute_valid) + { + opentelemetry::common::AttributeValue wrapped_attribute_value(attribute_value); + sdk_attributes.SetAttribute(attribute_key, wrapped_attribute_value); + } + else + { + OTEL_INTERNAL_LOG_WARN("Found invalid key/value pair in attributes_list"); + } + } + } + + // Second, scan attributes, which has high priority. + if (opt_model->attributes) + { + for (const auto &kv : opt_model->attributes->kv_map) + { + SetResourceAttribute(sdk_attributes, kv.first, kv.second.get()); + } + } + + if (opt_model->detectors != nullptr) + { + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3548 + // FIXME-SDK: Implement resource detectors + OTEL_INTERNAL_LOG_WARN("resource detectors not supported, ignoring"); + } + + auto sdk_resource = + opentelemetry::sdk::resource::Resource::Create(sdk_attributes, opt_model->schema_url); + resource = resource.Merge(sdk_resource); + } + else + { + resource = opentelemetry::sdk::resource::Resource::GetDefault(); + } +} + +std::unique_ptr SdkBuilder::CreateConfiguredSdk( + const std::unique_ptr &model) const +{ + auto sdk = std::make_unique(); + + if (!model->disabled) + { + SetResource(sdk->resource, model->resource); + + if (model->attribute_limits) + { + // FIXME-SDK: https://github.com/open-telemetry/opentelemetry-cpp/issues/3303 + // FIXME-SDK: Implement attribute limits + OTEL_INTERNAL_LOG_WARN("attribute_limits not supported, ignoring"); + } + + if (model->tracer_provider) + { + sdk->tracer_provider = CreateTracerProvider(model->tracer_provider, sdk->resource); + } + + if (model->propagator) + { + sdk->propagator = CreatePropagator(model->propagator); + } + + if (model->meter_provider) + { + sdk->meter_provider = CreateMeterProvider(model->meter_provider, sdk->resource); + } + + if (model->logger_provider) + { + sdk->logger_provider = CreateLoggerProvider(model->logger_provider, sdk->resource); + } + } + + return sdk; +} + +} // namespace configuration +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE