includes/opentelemetry/sdk/instrumentationscope/scope_configurator.h

Go to the documentation of this file.

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
 
#pragma once
#include <functional>
 
#include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
#include "opentelemetry/version.h"
 
OPENTELEMETRY_BEGIN_NAMESPACE
namespace sdk
{
namespace instrumentationscope
{
template <typename T>
class ScopeConfigurator
{
public:
  class Builder
  {
  public:
    explicit Builder(T default_scope_config) noexcept : default_scope_config_(default_scope_config)
    {}
 
    Builder &AddCondition(std::function<bool(const InstrumentationScope &)> scope_matcher,
                          T scope_config)
    {
      conditions_.emplace_back(scope_matcher, scope_config);
      return *this;
    }
 
    Builder &AddConditionNameEquals(nostd::string_view scope_name, T scope_config)
    {
      std::function<bool(const InstrumentationScope &)> name_equals_matcher =
          [scope_name = std::string(scope_name)](const InstrumentationScope &scope_info) {
            return scope_info.GetName() == scope_name;
          };
      conditions_.emplace_back(name_equals_matcher, scope_config);
      return *this;
    }
 
    ScopeConfigurator<T> Build() const
    {
      if (conditions_.size() == 0)
      {
        return ScopeConfigurator<T>(
            [default_scope_config_ = this->default_scope_config_](const InstrumentationScope &) {
              return default_scope_config_;
            });
      }
 
      // Return a configurator that processes all the conditions
      return ScopeConfigurator<T>(
          [conditions_ = this->conditions_, default_scope_config_ = this->default_scope_config_](
              const InstrumentationScope &scope_info) {
            for (Condition condition : conditions_)
            {
              if (condition.scope_matcher(scope_info))
              {
                return condition.scope_config;
              }
            }
            return default_scope_config_;
          });
    }
 
  private:
    struct Condition
    {
      std::function<bool(const InstrumentationScope &)> scope_matcher;
      T scope_config;
 
      Condition(const std::function<bool(const InstrumentationScope &)> &matcher, const T &config)
          : scope_matcher(matcher), scope_config(config)
      {}
    };
 
    T default_scope_config_;
    std::vector<Condition> conditions_;
  };
 
  // Public methods for ScopeConfigurator
 
  T ComputeConfig(const InstrumentationScope &scope_info) const
  {
    return this->configurator_(scope_info);
  }
 
private:
  // Prevent direct initialization of ScopeConfigurator objects.
  explicit ScopeConfigurator(std::function<T(const InstrumentationScope &)> configurator)
      : configurator_(configurator)
  {}
 
  std::function<T(const InstrumentationScope &)> configurator_;
};
}  // namespace instrumentationscope
}  // namespace sdk
OPENTELEMETRY_END_NAMESPACE