Program Listing for File scope_configurator.h

↰ Return to documentation for file (/tmp/B.puc0r6hi/BUILD/opentelemetry-cpp-1.27.0-build/opentelemetry-cpp-1.27.0/sdk/include/opentelemetry/sdk/instrumentationscope/scope_configurator.h)

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

#pragma once
#include <functional>
#include <utility>

#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(std::move(scope_matcher), std::move(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(std::move(name_equals_matcher), std::move(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 (const 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(std::function<bool(const InstrumentationScope &)> matcher, T config)
          : scope_matcher(std::move(matcher)), scope_config(std::move(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_(std::move(configurator))
  {}

  std::function<T(const InstrumentationScope &)> configurator_;
};
}  // namespace instrumentationscope
}  // namespace sdk
OPENTELEMETRY_END_NAMESPACE