[CONFIGURATION] Upgrade to configuration model 1.2.0

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable.h

@@ -52,7 +52,8 @@ class OtlpRecordable final : public opentelemetry::sdk::trace::Recordable
       std::uint32_t max_attributes_per_event = (std::numeric_limits<std::uint32_t>::max)(),
       std::uint32_t max_attributes_per_link  = (std::numeric_limits<std::uint32_t>::max)())
       : span_limits_{max_attributes,
-                     (std::numeric_limits<std::size_t>::max)(),
+                     (std::numeric_limits<std::size_t>::max)(),  // attribute_value_length_limit
+                     (std::numeric_limits<std::size_t>::max)(),  // attribute_value_depth_limit
                      max_events,
                      max_links,
                      max_attributes_per_event,

exporters/otlp/src/otlp_recordable.cc

@@ -124,6 +124,7 @@ void OtlpRecordable::SetSpanLimits(const opentelemetry::sdk::trace::SpanLimits &
   span_limits_ = {
       (std::min)(span_limits_.attribute_count_limit, limits.attribute_count_limit),
       (std::min)(span_limits_.attribute_value_length_limit, limits.attribute_value_length_limit),
+      (std::min)(span_limits_.attribute_value_depth_limit, limits.attribute_value_depth_limit),
       (std::min)(span_limits_.event_count_limit, limits.event_count_limit),
       (std::min)(span_limits_.link_count_limit, limits.link_count_limit),
       (std::min)(span_limits_.event_attribute_count_limit, limits.event_attribute_count_limit),

sdk/include/opentelemetry/sdk/configuration/always_record_sampler_builder.h

@@ -0,0 +1,38 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/always_record_sampler_configuration.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace trace
+{
+class Sampler;
+}  // namespace trace
+
+namespace configuration
+{
+
+class AlwaysRecordSamplerBuilder
+{
+public:
+  AlwaysRecordSamplerBuilder()                                                   = default;
+  AlwaysRecordSamplerBuilder(AlwaysRecordSamplerBuilder &&)                      = default;
+  AlwaysRecordSamplerBuilder(const AlwaysRecordSamplerBuilder &)                 = default;
+  AlwaysRecordSamplerBuilder &operator=(AlwaysRecordSamplerBuilder &&)           = default;
+  AlwaysRecordSamplerBuilder &operator=(const AlwaysRecordSamplerBuilder &other) = default;
+  virtual ~AlwaysRecordSamplerBuilder()                                          = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::Sampler> Build(
+      const opentelemetry::sdk::configuration::AlwaysRecordSamplerConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/always_record_sampler_configuration.h

@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/sdk/configuration/sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/sampler_configuration_visitor.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+// YAML-SCHEMA: schema/tracer_provider.json
+// YAML-NODE: always_record
+class AlwaysRecordSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  void Accept(SamplerConfigurationVisitor *visitor) const override
+  {
+    visitor->VisitAlwaysRecord(this);
+  }
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/attribute_limits_configuration.h

@@ -22,9 +22,11 @@ class AttributeLimitsConfiguration
 public:
   static constexpr std::size_t kDefaultAttributeValueLengthLimit =
       (std::numeric_limits<std::size_t>::max)();
-  static constexpr std::size_t kDefaultAttributeCountLimit = 128;
+  static constexpr std::size_t kDefaultAttributeValueDepthLimit = 64;
+  static constexpr std::size_t kDefaultAttributeCountLimit      = 128;
 
   OptionalValue<std::size_t> attribute_value_length_limit;
+  OptionalValue<std::size_t> attribute_value_depth_limit;
   OptionalValue<std::size_t> attribute_count_limit;
 };
 

sdk/include/opentelemetry/sdk/configuration/configuration_parser.h

@@ -8,6 +8,7 @@
 #include "opentelemetry/sdk/configuration/aggregation_configuration.h"
 #include "opentelemetry/sdk/configuration/always_off_sampler_configuration.h"
 #include "opentelemetry/sdk/configuration/always_on_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/always_record_sampler_configuration.h"
 #include "opentelemetry/sdk/configuration/attribute_limits_configuration.h"
 #include "opentelemetry/sdk/configuration/attribute_value_configuration.h"
 #include "opentelemetry/sdk/configuration/attributes_configuration.h"
@@ -107,6 +108,7 @@
 #include "opentelemetry/sdk/configuration/tracer_provider_configuration.h"
 #include "opentelemetry/sdk/configuration/translation_strategy.h"
 #include "opentelemetry/sdk/configuration/view_configuration.h"
+#include "opentelemetry/sdk/configuration/view_matching_mode.h"
 #include "opentelemetry/sdk/configuration/view_selector_configuration.h"
 #include "opentelemetry/sdk/configuration/view_stream_configuration.h"
 #include "opentelemetry/version.h"
@@ -258,6 +260,9 @@ class ConfigurationParser
   ExemplarFilter ParseExemplarFilter(const std::unique_ptr<DocumentNode> &node,
                                      const std::string &name) const;
 
+  ViewMatchingMode ParseViewMatchingMode(const std::unique_ptr<DocumentNode> &node,
+                                         const std::string &name) const;
+
   std::unique_ptr<ViewSelectorConfiguration> ParseViewSelectorConfiguration(
       const std::unique_ptr<DocumentNode> &node) const;
 
@@ -316,6 +321,10 @@ class ConfigurationParser
       const std::unique_ptr<DocumentNode> &node,
       size_t depth) const;
 
+  std::unique_ptr<AlwaysRecordSamplerConfiguration> ParseAlwaysRecordSamplerConfiguration(
+      const std::unique_ptr<DocumentNode> &node,
+      size_t depth) const;
+
   std::unique_ptr<JaegerRemoteSamplerConfiguration> ParseJaegerRemoteSamplerConfiguration(
       const std::unique_ptr<DocumentNode> &node,
       size_t depth) const;

sdk/include/opentelemetry/sdk/configuration/log_record_limits_configuration.h

@@ -22,9 +22,11 @@ class LogRecordLimitsConfiguration
 public:
   static constexpr std::size_t kDefaultAttributeValueLengthLimit =
       (std::numeric_limits<std::size_t>::max)();
-  static constexpr std::size_t kDefaultAttributeCountLimit = 128;
+  static constexpr std::size_t kDefaultAttributeValueDepthLimit = 64;
+  static constexpr std::size_t kDefaultAttributeCountLimit      = 128;
 
   OptionalValue<std::size_t> attribute_value_length_limit;
+  OptionalValue<std::size_t> attribute_value_depth_limit;
   OptionalValue<std::size_t> attribute_count_limit;
 };
 

sdk/include/opentelemetry/sdk/configuration/meter_provider_configuration.h

@@ -10,6 +10,7 @@
 #include "opentelemetry/sdk/configuration/meter_configurator_configuration.h"
 #include "opentelemetry/sdk/configuration/metric_reader_configuration.h"
 #include "opentelemetry/sdk/configuration/view_configuration.h"
+#include "opentelemetry/sdk/configuration/view_matching_mode.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -27,6 +28,7 @@ class MeterProviderConfiguration
   std::vector<std::unique_ptr<ViewConfiguration>> views;
   ExemplarFilter exemplar_filter{ExemplarFilter::trace_based};
   std::unique_ptr<MeterConfiguratorConfiguration> meter_configurator;
+  ViewMatchingMode view_matching_mode{ViewMatchingMode::independent};
 };
 
 }  // namespace configuration

sdk/include/opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h

@@ -25,6 +25,8 @@ class OtlpGrpcLogRecordExporterConfiguration : public LogRecordExporterConfigura
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
 
   void Accept(LogRecordExporterConfigurationVisitor *visitor) const override
   {
@@ -36,6 +38,8 @@ class OtlpGrpcLogRecordExporterConfiguration : public LogRecordExporterConfigura
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
 };
 

sdk/include/opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h

@@ -27,6 +27,8 @@ class OtlpGrpcPushMetricExporterConfiguration : public PushMetricExporterConfigu
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
   static constexpr TemporalityPreference kDefaultTemporalityPreference =
       TemporalityPreference::cumulative;
   static constexpr DefaultHistogramAggregation kDefaultHistogramAggregation =
@@ -42,6 +44,8 @@ class OtlpGrpcPushMetricExporterConfiguration : public PushMetricExporterConfigu
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
   TemporalityPreference temporality_preference{kDefaultTemporalityPreference};
   DefaultHistogramAggregation default_histogram_aggregation{kDefaultHistogramAggregation};

sdk/include/opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h

@@ -25,6 +25,8 @@ class OtlpGrpcSpanExporterConfiguration : public SpanExporterConfiguration
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
 
   void Accept(SpanExporterConfigurationVisitor *visitor) const override
   {
@@ -36,6 +38,8 @@ class OtlpGrpcSpanExporterConfiguration : public SpanExporterConfiguration
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
 };
 

sdk/include/opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h

@@ -26,6 +26,8 @@ class OtlpHttpLogRecordExporterConfiguration : public LogRecordExporterConfigura
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
 
   void Accept(LogRecordExporterConfigurationVisitor *visitor) const override
   {
@@ -37,6 +39,8 @@ class OtlpHttpLogRecordExporterConfiguration : public LogRecordExporterConfigura
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
   OtlpHttpEncoding encoding{OtlpHttpEncoding::protobuf};
 };

sdk/include/opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h

@@ -28,6 +28,8 @@ class OtlpHttpPushMetricExporterConfiguration : public PushMetricExporterConfigu
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
   static constexpr TemporalityPreference kDefaultTemporalityPreference =
       TemporalityPreference::cumulative;
   static constexpr DefaultHistogramAggregation kDefaultHistogramAggregation =
@@ -43,6 +45,8 @@ class OtlpHttpPushMetricExporterConfiguration : public PushMetricExporterConfigu
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
   OtlpHttpEncoding encoding{OtlpHttpEncoding::protobuf};
   TemporalityPreference temporality_preference{kDefaultTemporalityPreference};

sdk/include/opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h

@@ -26,6 +26,8 @@ class OtlpHttpSpanExporterConfiguration : public SpanExporterConfiguration
 {
 public:
   static constexpr std::size_t kDefaultTimeoutMs = 10000;
+  static constexpr std::size_t kMaxRequestSize   = 64 * 1024 * 1024;  // 64 MiB
+  static constexpr std::size_t kMaxResponseSize  = 4 * 1024 * 1024;   // 4 MiB
 
   void Accept(SpanExporterConfigurationVisitor *visitor) const override
   {
@@ -37,6 +39,8 @@ class OtlpHttpSpanExporterConfiguration : public SpanExporterConfiguration
   std::unique_ptr<HeadersConfiguration> headers;
   std::string headers_list;
   std::string compression;
+  std::size_t max_request_size{kMaxRequestSize};
+  std::size_t max_response_size{kMaxResponseSize};
   std::size_t timeout{kDefaultTimeoutMs};
   OtlpHttpEncoding encoding{OtlpHttpEncoding::protobuf};
 };

sdk/include/opentelemetry/sdk/configuration/registry.h

@@ -18,6 +18,7 @@ namespace configuration
 // Forward declarations
 class AlwaysOffSamplerBuilder;
 class AlwaysOnSamplerBuilder;
+class AlwaysRecordSamplerBuilder;
 class BatchLogRecordProcessorBuilder;
 class BatchSpanProcessorBuilder;
 class ComposableAlwaysOffSamplerBuilder;
@@ -210,6 +211,13 @@ class OPENTELEMETRY_EXPORT Registry
 
   void SetAlwaysOnSamplerBuilder(std::unique_ptr<AlwaysOnSamplerBuilder> &&builder);
 
+  const AlwaysRecordSamplerBuilder *GetAlwaysRecordSamplerBuilder() const
+  {
+    return always_record_sampler_builder_.get();
+  }
+
+  void SetAlwaysRecordSamplerBuilder(std::unique_ptr<AlwaysRecordSamplerBuilder> &&builder);
+
   const AlwaysOffSamplerBuilder *GetAlwaysOffSamplerBuilder() const
   {
     return always_off_sampler_builder_.get();
@@ -495,6 +503,7 @@ class OPENTELEMETRY_EXPORT Registry
   std::unique_ptr<ConsoleLogRecordExporterBuilder> console_log_record_builder_;
 
   std::unique_ptr<AlwaysOnSamplerBuilder> always_on_sampler_builder_;
+  std::unique_ptr<AlwaysRecordSamplerBuilder> always_record_sampler_builder_;
   std::unique_ptr<AlwaysOffSamplerBuilder> always_off_sampler_builder_;
   std::unique_ptr<TraceIdRatioBasedSamplerBuilder> trace_id_ratio_based_sampler_builder_;
   std::unique_ptr<ProbabilitySamplerBuilder> probability_sampler_builder_;

sdk/include/opentelemetry/sdk/configuration/sampler_configuration_visitor.h

@@ -13,6 +13,7 @@ namespace configuration
 
 class AlwaysOffSamplerConfiguration;
 class AlwaysOnSamplerConfiguration;
+class AlwaysRecordSamplerConfiguration;
 class JaegerRemoteSamplerConfiguration;
 class ParentBasedSamplerConfiguration;
 class ProbabilitySamplerConfiguration;
@@ -32,6 +33,7 @@ class SamplerConfigurationVisitor
 
   virtual void VisitAlwaysOff(const AlwaysOffSamplerConfiguration *model)                 = 0;
   virtual void VisitAlwaysOn(const AlwaysOnSamplerConfiguration *model)                   = 0;
+  virtual void VisitAlwaysRecord(const AlwaysRecordSamplerConfiguration *model)           = 0;
   virtual void VisitJaegerRemote(const JaegerRemoteSamplerConfiguration *model)           = 0;
   virtual void VisitParentBased(const ParentBasedSamplerConfiguration *model)             = 0;
   virtual void VisitProbability(const ProbabilitySamplerConfiguration *model)             = 0;

sdk/include/opentelemetry/sdk/configuration/span_limits_configuration.h

@@ -23,13 +23,15 @@ class SpanLimitsConfiguration
 public:
   static constexpr std::size_t kDefaultAttributeValueLengthLimit =
       (std::numeric_limits<std::size_t>::max)();
+  static constexpr std::size_t kDefaultAttributeValueDepthLimit   = 64;
   static constexpr std::uint32_t kDefaultAttributeCountLimit      = 128;
   static constexpr std::uint32_t kDefaultEventCountLimit          = 128;
   static constexpr std::uint32_t kDefaultLinkCountLimit           = 128;
   static constexpr std::uint32_t kDefaultEventAttributeCountLimit = 128;
   static constexpr std::uint32_t kDefaultLinkAttributeCountLimit  = 128;
 
   OptionalValue<std::size_t> attribute_value_length_limit;
+  OptionalValue<std::size_t> attribute_value_depth_limit;
   OptionalValue<std::uint32_t> attribute_count_limit;
   OptionalValue<std::uint32_t> event_count_limit;
   OptionalValue<std::uint32_t> link_count_limit;

sdk/include/opentelemetry/sdk/configuration/view_matching_mode.h

@@ -0,0 +1,26 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+// YAML-SCHEMA: schema/meter_provider.yaml
+// YAML-NODE: ViewMatchingMode
+enum class ViewMatchingMode : std::uint8_t
+{
+  independent,
+  composable
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/logs/log_record_limits.h

@@ -27,9 +27,11 @@ struct LogRecordLimits
   static constexpr std::size_t kDefaultAttributeCountLimit = 128;
   static constexpr std::size_t kDefaultAttributeValueLengthLimit =
       (std::numeric_limits<std::size_t>::max)();
+  static constexpr std::size_t kDefaultAttributeValueDepthLimit = 64;
 
   std::size_t attribute_count_limit        = kDefaultAttributeCountLimit;
   std::size_t attribute_value_length_limit = kDefaultAttributeValueLengthLimit;
+  std::size_t attribute_value_depth_limit  = kDefaultAttributeValueDepthLimit;
 
   /**
    * Limits that impose no cap. A recordable uses these until a LoggerProvider
@@ -39,6 +41,7 @@ struct LogRecordLimits
   static constexpr LogRecordLimits NoLimits() noexcept
   {
     return LogRecordLimits{(std::numeric_limits<std::size_t>::max)(),
+                           (std::numeric_limits<std::size_t>::max)(),
                            (std::numeric_limits<std::size_t>::max)()};
   }
 };