feat: add YAML parsing support for Composable Samplers

CHANGELOG.md

@@ -15,6 +15,9 @@ Increment the:
 
 ## [Unreleased]
 
+* [CONFIGURATION] Add YAML parsing support for Composable Samplers
+  [#3914](https://github.com/open-telemetry/opentelemetry-cpp/issues/3914)
+
 * [SDK] Move inline implementation from SDK headers to .cc files.
   Note: `GetEmptyAttributes()` now requires linking `opentelemetry_common`.
   [#3887](https://github.com/open-telemetry/opentelemetry-cpp/pull/3887)

sdk/include/opentelemetry/sdk/configuration/composable_always_off_sampler_configuration.h

@@ -0,0 +1,26 @@
+// 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
+{
+
+class ComposableAlwaysOffSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableAlwaysOffSamplerConfiguration() = default;
+
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_always_on_sampler_configuration.h

@@ -0,0 +1,26 @@
+// 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
+{
+
+class ComposableAlwaysOnSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableAlwaysOnSamplerConfiguration() = default;
+
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_parent_threshold_sampler_configuration.h

@@ -0,0 +1,24 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include <memory>
+#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
+{
+class ComposableParentThresholdSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableParentThresholdSamplerConfiguration() = default;
+  std::unique_ptr<SamplerConfiguration> root;
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_probability_sampler_configuration.h

@@ -0,0 +1,26 @@
+// 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
+{
+
+class ComposableProbabilitySamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableProbabilitySamplerConfiguration() = default;
+  double ratio{1.0};
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_rule_based_sampler_configuration.h

@@ -0,0 +1,28 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include <memory>
+#include <vector>
+#include "opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_configuration.h"
+#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
+{
+
+class ComposableRuleBasedSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableRuleBasedSamplerConfiguration() = default;
+  std::vector<std::unique_ptr<ComposableRuleBasedSamplerRuleConfiguration>> rules;
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_attribute_patterns_configuration.h

@@ -0,0 +1,22 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <string>
+#include <vector>
+#include "opentelemetry/version.h"
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+class ComposableRuleBasedSamplerRuleAttributePatternsConfiguration
+{
+public:
+  ComposableRuleBasedSamplerRuleAttributePatternsConfiguration() = default;
+  std::string key;
+  std::vector<std::string> included;
+  std::vector<std::string> excluded;
+};
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_attribute_values_configuration.h

@@ -0,0 +1,21 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <string>
+#include <vector>
+#include "opentelemetry/version.h"
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+class ComposableRuleBasedSamplerRuleAttributeValuesConfiguration
+{
+public:
+  ComposableRuleBasedSamplerRuleAttributeValuesConfiguration() = default;
+  std::string key;
+  std::vector<std::string> values;
+};
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_configuration.h

@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <memory>
+#include <string>
+#include <vector>
+#include "opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_attribute_patterns_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_rule_based_sampler_rule_attribute_values_configuration.h"
+#include "opentelemetry/sdk/configuration/sampler_configuration.h"
+#include "opentelemetry/version.h"
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+class ComposableRuleBasedSamplerRuleConfiguration
+{
+public:
+  ComposableRuleBasedSamplerRuleConfiguration() = default;
+  std::unique_ptr<ComposableRuleBasedSamplerRuleAttributeValuesConfiguration> attribute_values;
+  std::unique_ptr<ComposableRuleBasedSamplerRuleAttributePatternsConfiguration> attribute_patterns;
+
+  bool match_parent_none{false};
+  bool match_parent_remote{false};
+  bool match_parent_local{false};
+
+  bool match_span_kind_internal{false};
+  bool match_span_kind_server{false};
+  bool match_span_kind_client{false};
+  bool match_span_kind_producer{false};
+  bool match_span_kind_consumer{false};
+
+  std::unique_ptr<SamplerConfiguration> sampler;
+};
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/composable_sampler_configuration.h

@@ -0,0 +1,22 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <memory>
+#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
+{
+class ComposableSamplerConfiguration : public SamplerConfiguration
+{
+public:
+  ComposableSamplerConfiguration() = default;
+  std::unique_ptr<SamplerConfiguration> inner;
+  void Accept(SamplerConfigurationVisitor *visitor) const override;
+};
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

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

@@ -17,6 +17,12 @@
 #include "opentelemetry/sdk/configuration/boolean_array_attribute_value_configuration.h"
 #include "opentelemetry/sdk/configuration/boolean_attribute_value_configuration.h"
 #include "opentelemetry/sdk/configuration/cardinality_limits_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_always_off_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_always_on_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_parent_threshold_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_probability_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_rule_based_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/composable_sampler_configuration.h"
 #include "opentelemetry/sdk/configuration/configuration.h"
 #include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h"
 #include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h"
@@ -313,6 +319,42 @@ class ConfigurationParser
       const std::unique_ptr<DocumentNode> &node,
       size_t depth) const;
 
+  std::unique_ptr<ComposableAlwaysOffSamplerConfiguration>
+  ParseComposableAlwaysOffSamplerConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                               size_t depth) const;
+
+  std::unique_ptr<ComposableAlwaysOnSamplerConfiguration>
+  ParseComposableAlwaysOnSamplerConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                              size_t depth) const;
+
+  std::unique_ptr<ComposableProbabilitySamplerConfiguration>
+  ParseComposableProbabilitySamplerConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                                 size_t depth) const;
+
+  std::unique_ptr<ComposableParentThresholdSamplerConfiguration>
+  ParseComposableParentThresholdSamplerConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                                     size_t depth) const;
+
+  std::unique_ptr<ComposableRuleBasedSamplerRuleAttributeValuesConfiguration>
+  ParseComposableRuleBasedSamplerRuleAttributeValuesConfiguration(
+      const std::unique_ptr<DocumentNode> &node) const;
+
+  std::unique_ptr<ComposableRuleBasedSamplerRuleAttributePatternsConfiguration>
+  ParseComposableRuleBasedSamplerRuleAttributePatternsConfiguration(
+      const std::unique_ptr<DocumentNode> &node) const;
+
+  std::unique_ptr<ComposableRuleBasedSamplerRuleConfiguration>
+  ParseComposableRuleBasedSamplerRuleConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                                   size_t depth) const;
+
+  std::unique_ptr<ComposableRuleBasedSamplerConfiguration>
+  ParseComposableRuleBasedSamplerConfiguration(const std::unique_ptr<DocumentNode> &node,
+                                               size_t depth) const;
+
+  std::unique_ptr<SamplerConfiguration> ParseComposableSamplerConfiguration(
+      const std::unique_ptr<DocumentNode> &node,
+      size_t depth) const;
+
   std::unique_ptr<ExtensionSamplerConfiguration> ParseSamplerExtensionConfiguration(
       const std::string &name,
       std::unique_ptr<DocumentNode> node,

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

@@ -17,6 +17,12 @@ class JaegerRemoteSamplerConfiguration;
 class ParentBasedSamplerConfiguration;
 class TraceIdRatioBasedSamplerConfiguration;
 class ExtensionSamplerConfiguration;
+class ComposableAlwaysOffSamplerConfiguration;
+class ComposableAlwaysOnSamplerConfiguration;
+class ComposableProbabilitySamplerConfiguration;
+class ComposableParentThresholdSamplerConfiguration;
+class ComposableRuleBasedSamplerConfiguration;
+class ComposableSamplerConfiguration;
 
 class SamplerConfigurationVisitor
 {
@@ -34,6 +40,18 @@ class SamplerConfigurationVisitor
   virtual void VisitParentBased(const ParentBasedSamplerConfiguration *model)             = 0;
   virtual void VisitTraceIdRatioBased(const TraceIdRatioBasedSamplerConfiguration *model) = 0;
   virtual void VisitExtension(const ExtensionSamplerConfiguration *model)                 = 0;
+  virtual void VisitComposableAlwaysOff(const ComposableAlwaysOffSamplerConfiguration * /*model*/)
+  {}
+  virtual void VisitComposableAlwaysOn(const ComposableAlwaysOnSamplerConfiguration * /*model*/) {}
+  virtual void VisitComposableProbability(
+      const ComposableProbabilitySamplerConfiguration * /*model*/)
+  {}
+  virtual void VisitComposableParentThreshold(
+      const ComposableParentThresholdSamplerConfiguration * /*model*/)
+  {}
+  virtual void VisitComposableRuleBased(const ComposableRuleBasedSamplerConfiguration * /*model*/)
+  {}
+  virtual void VisitComposable(const ComposableSamplerConfiguration * /*model*/) {}
 };
 
 }  // namespace configuration

sdk/src/configuration/CMakeLists.txt

@@ -10,7 +10,13 @@ add_library(
   ryml_document_node.cc
   configured_sdk.cc
   sdk_builder.cc
-  registry.cc)
+  registry.cc
+  composable_always_off_sampler_configuration.cc
+  composable_always_on_sampler_configuration.cc
+  composable_probability_sampler_configuration.cc
+  composable_parent_threshold_sampler_configuration.cc
+  composable_rule_based_sampler_configuration.cc
+  composable_sampler_configuration.cc)
 
 set_target_properties(opentelemetry_configuration PROPERTIES EXPORT_NAME
                                                              configuration)

sdk/src/configuration/composable_always_off_sampler_configuration.cc

@@ -0,0 +1,16 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#include "opentelemetry/sdk/configuration/composable_always_off_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/sampler_configuration_visitor.h"
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+void ComposableAlwaysOffSamplerConfiguration::Accept(SamplerConfigurationVisitor *visitor) const
+{
+  visitor->VisitComposableAlwaysOff(this);
+}
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/src/configuration/composable_always_on_sampler_configuration.cc

@@ -0,0 +1,16 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#include "opentelemetry/sdk/configuration/composable_always_on_sampler_configuration.h"
+#include "opentelemetry/sdk/configuration/sampler_configuration_visitor.h"
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+void ComposableAlwaysOnSamplerConfiguration::Accept(SamplerConfigurationVisitor *visitor) const
+{
+  visitor->VisitComposableAlwaysOn(this);
+}
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE