Allow direct initialization of `ScopeConfigurator` object

[michaelvanstraten]

The new ScopeConfiguration class added in #3137 is great, but it currently disallows direct initialization of the object:

opentelemetry-cpp/sdk/include/opentelemetry/sdk/instrumentationscope/scope_configurator.h

Lines 136 to 138 in fdee87f

	// Prevent direct initialization of ScopeConfigurator objects.
	explicit ScopeConfigurator(std::function<T(const InstrumentationScope &)> configurator)
	: configurator_(configurator)

This makes the class a bit awkward to use. For example, here’s how you’d configure it via the builder when working with environment variables:

auto config = ScopeConfigurator<TracerConfig>::Builder(TracerConfig::Enabled())
    .AddCondition(
        /* if TRACES_ENABLE is not set, disable traces */
        [](const InstrumentationScope&) {
          return !std::getenv("TRACES_ENABLE");
        },
        TracerConfig::Disabled())
    .AddCondition(
        /* if TRACES_<scope name>_DISABLED is set, disable traces for that scope */
        [](const InstrumentationScope& aScope) {
          return !std::getenv(
              ("TRACES_" + aScope.GetName() + "_DISABLED").c_str());
        },
        TracerConfig::Disabled())
    .Build();

With direct initialization, the same logic could be expressed far more concisely:

auto config = ScopeConfigurator<TracerConfig>(
    [](const InstrumentationScope& aScope) {
      // disable if global flag is unset, or per-scope disabled flag is set
      if (!std::getenv("TRACES_ENABLE") ||
          std::getenv(("TRACES_" + aScope.GetName() + "_DISABLED").c_str()))
      {
        return TracerConfig::Disabled();
      }
      return TracerConfig::Enabled();
    });

The direct‑init version is much more readable, especially when you only have a single configurator function.

Proposal:
Allow ScopeConfigurator to be constructed directly from a single callback (in addition to the existing Builder API).

If this restriction is intentional, could someone explain why direct construction should remain private?

[marcalff]

@michaelvanstraten

Thanks for the report.

The idea behind ScopeConfigurator is that the SDK configuration should be "pushed" towards the tracer provider, in a way which is trivial to consume at runtime.

For example, if there are 10 instrumentation scopes that should be disabled, then build a scope configuration by calling AddCondition 10 times, to disable these 10 scopes.

In the code posted, what is happening is the opposite: the tracer provider goes and "pull" its configuration at runtime, by inspecting environment variables to decide what to do : this should have been decided up front.

This is an anti pattern, to avoid.

If an application processes a million spans, the code should not call get_env a million times to decide what to do.

As for the constructor using a function callback for the condition, separate from the enabled/disabled flag, the point is to build a configurator with predicates, that can be chained.

For example:

If name match *foo-with-no-bar*, disable
Else if name match *bar*, enabled,
Else if name match *baz*, disabled,
otherwise enabled

so the predicate function (match a name) does not return enabled/disabled, it only says it the condition applies.

Representing a chain of predicates (based on known primitives like name matching) allows to represent the configuration with data, instead of code:

See tracer_configurator/development: in yaml

https://github.com/open-telemetry/opentelemetry-configuration/blob/c90dd946272e211514248ea8e47208387683711e/examples/kitchen-sink.yaml#L765-L780

tracer_configurator/development:
    # Configure the default tracer config used there is no matching entry in .tracer_configurator/development.tracers.
    default_config:
      # Configure if the tracer is enabled or not.
      disabled: true
    # Configure tracers.
    tracers:
      - # Configure tracer names to match, evaluated as follows:
        #
        #  * If the tracer name exactly matches.
        #  * If the tracer name matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none.
        name: io.opentelemetry.contrib.*
        # The tracer config.
        config:
          # Configure if the tracer is enabled or not.
          disabled: false