Enabled custom sampler configuration via env vars

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased](https://github.com/open-telemetry/opentelemetry-python/compare/v1.13.0...HEAD)
 
+- Enabled custom samplers via entry points
+  ([#2972](https://github.com/open-telemetry/opentelemetry-python/pull/2972))
 - Update explicit histogram bucket boundaries
   ([#2947](https://github.com/open-telemetry/opentelemetry-python/pull/2947))
 - `exporter-otlp-proto-http`: add user agent string

opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py

@@ -23,7 +23,6 @@
 from os import environ
 from typing import Dict, Optional, Sequence, Tuple, Type
 
-from pkg_resources import iter_entry_points
 from typing_extensions import Literal
 
 from opentelemetry.environment_variables import (
@@ -55,6 +54,7 @@
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExporter
 from opentelemetry.sdk.trace.id_generator import IdGenerator
+from opentelemetry.sdk.util import _import_config_components
 from opentelemetry.semconv.resource import ResourceAttributes
 from opentelemetry.trace import set_tracer_provider
 
@@ -228,26 +228,6 @@ def _init_logging(
     logging.getLogger().addHandler(handler)
 
 
-def _import_config_components(
-    selected_components, entry_point_name
-) -> Sequence[Tuple[str, object]]:
-    component_entry_points = {
-        ep.name: ep for ep in iter_entry_points(entry_point_name)
-    }
-    component_impls = []
-    for selected_component in selected_components:
-        entry_point = component_entry_points.get(selected_component, None)
-        if not entry_point:
-            raise RuntimeError(
-                f"Requested component '{selected_component}' not found in entry points for '{entry_point_name}'"
-            )
-
-        component_impl = entry_point.load()
-        component_impls.append((selected_component, component_impl))
-
-    return component_impls
-
-
 def _import_exporters(
     trace_exporter_names: Sequence[str],
     metric_exporter_names: Sequence[str],

opentelemetry-sdk/src/opentelemetry/sdk/trace/sampling.py

@@ -64,7 +64,7 @@
         ...
 
 The tracer sampler can also be configured via environment variables ``OTEL_TRACES_SAMPLER`` and ``OTEL_TRACES_SAMPLER_ARG`` (only if applicable).
-The list of known values for ``OTEL_TRACES_SAMPLER`` are:
+The list of built-in values for ``OTEL_TRACES_SAMPLER`` are:
 
     * always_on - Sampler that always samples spans, regardless of the parent span's sampling decision.
     * always_off - Sampler that never samples spans, regardless of the parent span's sampling decision.
@@ -73,7 +73,34 @@
     * parentbased_always_off - Sampler that respects its parent span's sampling decision, but otherwise never samples.
     * parentbased_traceidratio - Sampler that respects its parent span's sampling decision, but otherwise samples probabalistically based on rate.
 
-Sampling probability can be set with ``OTEL_TRACES_SAMPLER_ARG`` if the sampler is traceidratio or parentbased_traceidratio, when not provided rate will be set to 1.0 (maximum rate possible).
+In order to configure a custom sampler via environment variables, create an entry point for the custom sampler factory method under the entry point group, ``opentelemtry_traces_sampler``. Then, set
+the ``OTEL_TRACES_SAMPLER`` environment variable to the key name of the entry point. The custom sampler factory method must take a single string argument. This input will come from
+``OTEL_TRACES_SAMPLER_ARG``. If ``OTEL_TRACES_SAMPLER_ARG`` is not configured, the input will be an empty string. For example, set ``OTEL_TRACES_SAMPLER=custom_sampler_name`` and
+``OTEL_TRACES_SAMPLER_ARG=0.5`` after creating the following entry point:
+
+.. code:: python
+
+    setup(
+        ...
+        entry_points={
+            ...
+            "opentelemtry_traces_sampler": [
+                "custom_sampler_name = path.to.sampler.factory.method:CustomSamplerFactory.get_sampler"
+            ]
+        }
+    )
+    ...
+    class CustomRatioSampler(Sampler):
+        def __init__(rate):
+            ...
+    ...
+    class CustomSamplerFactory:
+        get_sampler(sampler_argument_str):
+            rate = float(sampler_argument_str)
+            return CustomSampler(rate)
+
+Sampling probability can be set with ``OTEL_TRACES_SAMPLER_ARG`` if the sampler is a ``TraceIdRatioBased`` Sampler, such as ``traceidratio`` and ``parentbased_traceidratio``. When not provided rate
+will be set to 1.0 (maximum rate possible).
 
 
 Prev example but with environment variables. Please make sure to set the env ``OTEL_TRACES_SAMPLER=traceidratio`` and ``OTEL_TRACES_SAMPLER_ARG=0.001``.
@@ -111,6 +138,7 @@
     OTEL_TRACES_SAMPLER,
     OTEL_TRACES_SAMPLER_ARG,
 )
+from opentelemetry.sdk.util import _import_config_components
 from opentelemetry.trace import Link, SpanKind, get_current_span
 from opentelemetry.trace.span import TraceState
 from opentelemetry.util.types import Attributes
@@ -161,6 +189,9 @@ def __init__(
         self.trace_state = trace_state
 
 
+_OTEL_SAMPLER_ENTRY_POINT_GROUP = "opentelemtry_traces_sampler"
+
+
 class Sampler(abc.ABC):
     @abc.abstractmethod
     def should_sample(
@@ -390,8 +421,55 @@ def _get_from_env_or_default() -> Sampler:
     return _KNOWN_SAMPLERS[trace_sampler]
 
 
+def _get_from_env_or_default() -> Sampler:
+    trace_sampler_name = os.getenv(
+        OTEL_TRACES_SAMPLER, "parentbased_always_on"
+    ).lower()
+
+    if trace_sampler_name in _KNOWN_SAMPLERS:
+        if trace_sampler_name in ("traceidratio", "parentbased_traceidratio"):
+            try:
+                rate = float(os.getenv(OTEL_TRACES_SAMPLER_ARG))
+            except ValueError:
+                _logger.warning(
+                    "Could not convert TRACES_SAMPLER_ARG to float."
+                )
+                rate = 1.0
+            return _KNOWN_SAMPLERS[trace_sampler_name](rate)
+        return _KNOWN_SAMPLERS[trace_sampler_name]
+    else:
+        try:
+            trace_sampler_factory = _import_sampler_factory(trace_sampler_name)
+            sampler_arg = os.getenv(OTEL_TRACES_SAMPLER_ARG, "")
+            trace_sampler = trace_sampler_factory(sampler_arg)
+            _logger.warning("JEREVOSS: trace_sampler: %s" % trace_sampler)
+            if not issubclass(type(trace_sampler), Sampler):
+                message = (
+                    "Output of traces sampler factory, %s, was not a Sampler object."
+                    % trace_sampler_factory
+                )
+                _logger.warning(message)
+                raise ValueError(message)
+            return trace_sampler
+        except Exception as exc:
+            _logger.warning(
+                "Failed to initialize custom sampler, %s: %s",
+                trace_sampler_name,
+                exc,
+            )
+            return _KNOWN_SAMPLERS["parentbased_always_on"]
+
+
 def _get_parent_trace_state(parent_context) -> Optional["TraceState"]:
     parent_span_context = get_current_span(parent_context).get_span_context()
     if parent_span_context is None or not parent_span_context.is_valid:
         return None
     return parent_span_context.trace_state
+
+
+def _import_sampler_factory(sampler_name: str) -> Sampler:
+    # pylint: disable=unbalanced-tuple-unpacking
+    [(sampler_name, sampler_impl)] = _import_config_components(
+        [sampler_name.strip()], _OTEL_SAMPLER_ENTRY_POINT_GROUP
+    )
+    return sampler_impl

opentelemetry-sdk/src/opentelemetry/sdk/util/__init__.py

@@ -14,11 +14,11 @@
 
 import datetime
 import threading
-from collections import OrderedDict, deque
-from collections.abc import MutableMapping, Sequence
-from typing import Optional
+from collections import OrderedDict, abc, deque
+from typing import Optional, Sequence, Tuple
 
 from deprecated import deprecated
+from pkg_resources import iter_entry_points
 
 
 def ns_to_iso_str(nanoseconds):
@@ -41,7 +41,27 @@ def get_dict_as_key(labels):
     )
 
 
-class BoundedList(Sequence):
+def _import_config_components(
+    selected_components, entry_point_name
+) -> Sequence[Tuple[str, object]]:
+    component_entry_points = {
+        ep.name: ep for ep in iter_entry_points(entry_point_name)
+    }
+    component_impls = []
+    for selected_component in selected_components:
+        entry_point = component_entry_points.get(selected_component, None)
+        if not entry_point:
+            raise RuntimeError(
+                f"Requested component '{selected_component}' not found in entry points for '{entry_point_name}'"
+            )
+
+        component_impl = entry_point.load()
+        component_impls.append((selected_component, component_impl))
+
+    return component_impls
+
+
+class BoundedList(abc.Sequence):
     """An append only list with a fixed max size.
 
     Calls to `append` and `extend` will drop the oldest elements if there is
@@ -92,7 +112,7 @@ def from_seq(cls, maxlen, seq):
 
 
 @deprecated(version="1.4.0")  # type: ignore
-class BoundedDict(MutableMapping):
+class BoundedDict(abc.MutableMapping):
     """An ordered dict with a fixed max capacity.
 
     Oldest elements are dropped when the dict is full and a new element is

opentelemetry-sdk/tests/test_configurator.py

@@ -257,7 +257,7 @@ def test_trace_init_otlp(self):
 
     @patch.dict(environ, {OTEL_PYTHON_ID_GENERATOR: "custom_id_generator"})
     @patch("opentelemetry.sdk._configuration.IdGenerator", new=IdGenerator)
-    @patch("opentelemetry.sdk._configuration.iter_entry_points")
+    @patch("opentelemetry.sdk.util.iter_entry_points")
     def test_trace_init_custom_id_generator(self, mock_iter_entry_points):
         mock_iter_entry_points.configure_mock(
             return_value=[