feat(configuration): add sampler parsing

experimental/CHANGELOG.md

@@ -13,6 +13,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 
 ### :rocket: Features
 
+* feat(configuration): add sampler configuration parsing support [#6409](https://github.com/open-telemetry/opentelemetry-js/pull/6409) @MikeGoldsmith
 * feat(configuration): add resource detection parsing [#6435](https://github.com/open-telemetry/opentelemetry-js/pull/6435) @MikeGoldsmith
 * feat(configuration): export interfaces required in other packages [#6462](https://github.com/open-telemetry/opentelemetry-js/pull/6462) @maryliag
 

experimental/packages/configuration/src/EnvironmentConfigFactory.ts

@@ -164,6 +164,55 @@ export function setPropagators(config: ConfigurationModel): void {
   }
 }
 
+export function setSampler(config: ConfigurationModel): void {
+  const sampler = getStringFromEnv('OTEL_TRACES_SAMPLER');
+  const arg = getStringFromEnv('OTEL_TRACES_SAMPLER_ARG');
+
+  if (!sampler || !config.tracer_provider) {
+    return;
+  }
+
+  const ratio = arg ? parseFloat(arg) : 1.0;
+
+  switch (sampler) {
+    case 'always_on':
+      config.tracer_provider.sampler = { always_on: {} };
+      break;
+
+    case 'always_off':
+      config.tracer_provider.sampler = { always_off: {} };
+      break;
+
+    case 'traceidratio':
+      config.tracer_provider.sampler = {
+        trace_id_ratio_based: { ratio },
+      };
+      break;
+
+    case 'parentbased_always_on':
+      config.tracer_provider.sampler = {
+        parent_based: { root: { always_on: {} } },
+      };
+      break;
+
+    case 'parentbased_always_off':
+      config.tracer_provider.sampler = {
+        parent_based: { root: { always_off: {} } },
+      };
+      break;
+
+    case 'parentbased_traceidratio':
+      config.tracer_provider.sampler = {
+        parent_based: { root: { trace_id_ratio_based: { ratio } } },
+      };
+      break;
+
+    default:
+      diag.warn(`Unknown sampler type: ${sampler}`);
+      break;
+  }
+}
+
 export function setTracerProvider(config: ConfigurationModel): void {
   const exportersType = Array.from(
     new Set(getStringListFromEnv('OTEL_TRACES_EXPORTER'))
@@ -178,6 +227,7 @@ export function setTracerProvider(config: ConfigurationModel): void {
     return;
   }
   config.tracer_provider = initializeDefaultTracerProviderConfiguration();
+  setSampler(config);
 
   const attributeValueLengthLimit = getNumberFromEnv(
     'OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'

experimental/packages/configuration/src/FileConfigFactory.ts

@@ -26,6 +26,8 @@ import {
 import type { NameStringValuePair } from './models/commonModel';
 import { OtlpHttpEncoding, SeverityNumber } from './models/commonModel';
 import type {
+  ExperimentalComposableSampler,
+  Sampler,
   SpanExporter,
   SpanProcessor,
   TracerProvider,
@@ -339,6 +341,137 @@ export function setPropagator(
   }
 }
 
+function parseComposableSampler(
+  sampler: ExperimentalComposableSampler
+): ExperimentalComposableSampler {
+  const samplerType = Object.keys(sampler)[0];
+  let parsedSampler: ExperimentalComposableSampler = {};
+
+  switch (samplerType) {
+    case 'always_on':
+      parsedSampler = { always_on: sampler['always_on'] ?? undefined };
+      break;
+
+    case 'always_off':
+      parsedSampler = { always_off: sampler['always_off'] ?? undefined };
+      break;
+
+    case 'parent_threshold': {
+      const s = sampler['parent_threshold'];
+      if (s?.root) {
+        parsedSampler = {
+          parent_threshold: { root: parseComposableSampler(s.root) },
+        };
+      }
+      break;
+    }
+
+    case 'probability': {
+      const s = sampler['probability'];
+      parsedSampler = {
+        probability: {
+          ratio: getNumberFromConfigFile(s?.ratio) ?? 1.0,
+        },
+      };
+      break;
+    }
+
+    case 'rule_based': {
+      const rb = sampler['rule_based'];
+      if (rb) {
+        parsedSampler = { rule_based: {} };
+        if (rb.rules) {
+          parsedSampler.rule_based!.rules = rb.rules.map(rule => ({
+            ...rule,
+            sampler: rule.sampler ? parseComposableSampler(rule.sampler) : {},
+          }));
+        }
+      }
+      break;
+    }
+  }
+
+  return parsedSampler;
+}
+
+function parseSampler(sampler: Sampler): Sampler {
+  const samplerType = Object.keys(sampler)[0];
+  let parsedSampler: Sampler = {};
+
+  switch (samplerType) {
+    case 'always_on':
+      parsedSampler = { always_on: sampler['always_on'] ?? undefined };
+      break;
+
+    case 'always_off':
+      parsedSampler = { always_off: sampler['always_off'] ?? undefined };
+      break;
+
+    case 'trace_id_ratio_based': {
+      const s = sampler['trace_id_ratio_based'];
+      parsedSampler = {
+        trace_id_ratio_based: {
+          ratio: getNumberFromConfigFile(s?.ratio) ?? 1.0,
+        },
+      };
+      break;
+    }
+
+    case 'parent_based': {
+      const s = sampler['parent_based'];
+      if (s) {
+        parsedSampler = { parent_based: {} };
+        if (s.root) {
+          parsedSampler.parent_based!.root = parseSampler(s.root);
+        }
+        if (s.remote_parent_sampled) {
+          parsedSampler.parent_based!.remote_parent_sampled = parseSampler(
+            s.remote_parent_sampled
+          );
+        }
+        if (s.remote_parent_not_sampled) {
+          parsedSampler.parent_based!.remote_parent_not_sampled = parseSampler(
+            s.remote_parent_not_sampled
+          );
+        }
+        if (s.local_parent_sampled) {
+          parsedSampler.parent_based!.local_parent_sampled = parseSampler(
+            s.local_parent_sampled
+          );
+        }
+        if (s.local_parent_not_sampled) {
+          parsedSampler.parent_based!.local_parent_not_sampled = parseSampler(
+            s.local_parent_not_sampled
+          );
+        }
+      }
+      break;
+    }
+
+    case 'probability/development': {
+      const s = sampler['probability/development'];
+      parsedSampler = {
+        'probability/development': {
+          ratio: getNumberFromConfigFile(s?.ratio) ?? 1.0,
+        },
+      };
+      break;
+    }
+
+    case 'composite/development': {
+      const s = sampler['composite/development'];
+      if (s) {
+        parsedSampler = {
+          'composite/development': parseComposableSampler(s),
+        };
+      }
+      break;
+    }
+  }
+
+  return parsedSampler;
+}
+
 function getConfigHeaders(
   h?: NameStringValuePair[]
 ): NameStringValuePair[] | null {
@@ -552,6 +685,11 @@ export function setTracerProvider(
       }
     }
 
+    // Sampler
+    if (tracerProvider['sampler']) {
+      config.tracer_provider.sampler = parseSampler(tracerProvider['sampler']);
+    }
+
     // Processors
     for (let i = 0; i < tracerProvider['processors'].length; i++) {
       const processorType = Object.keys(tracerProvider['processors'][i])[0];

experimental/packages/configuration/src/models/tracerProviderModel.ts

@@ -103,6 +103,16 @@ export interface Sampler {
    * Configure sampler to be trace_id_ratio_based.
    */
   trace_id_ratio_based?: TraceIdRatioBasedSampler;
+
+  /**
+   * Configure sampler to be probability/development.
+   */
+  'probability/development'?: ExperimentalProbabilitySampler;
+
+  /**
+   * Configure sampler to be composite/development.
+   */
+  'composite/development'?: ExperimentalComposableSampler;
 }
 
 export interface ParentBasedSampler {
@@ -140,10 +150,98 @@ export interface ParentBasedSampler {
 export interface TraceIdRatioBasedSampler {
   /**
    * Configure trace_id_ratio.
+   * If omitted or null, 1.0 is used.
+   */
+  ratio?: number;
+}
+
+export interface ExperimentalProbabilitySampler {
+  /**
+   * Configure probability ratio.
+   * If omitted or null, 1.0 is used.
+   */
+  ratio?: number;
+}
+
+export interface ExperimentalComposableSampler {
+  /**
+   * Configure composable sampler to be always_off.
+   */
+  always_off?: object;
+
+  /**
+   * Configure composable sampler to be always_on.
+   */
+  always_on?: object;
+
+  /**
+   * Configure composable sampler to be parent_threshold.
+   */
+  parent_threshold?: ExperimentalComposableParentThresholdSampler;
+
+  /**
+   * Configure composable sampler to be probability.
+   */
+  probability?: ExperimentalComposableProbabilitySampler;
+
+  /**
+   * Configure composable sampler to be rule_based.
+   */
+  rule_based?: ExperimentalComposableRuleBasedSampler;
+}
+
+export interface ExperimentalComposableParentThresholdSampler {
+  /**
+   * Sampler to use when there is no parent.
+   */
+  root: ExperimentalComposableSampler;
+}
+
+export interface ExperimentalComposableProbabilitySampler {
+  /**
+   * Configure probability ratio.
+   * If omitted or null, 1.0 is used.
    */
   ratio?: number;
 }
 
+export interface ExperimentalComposableRuleBasedSampler {
+  /**
+   * The rules for the sampler, matched in order.
+   */
+  rules?: ExperimentalComposableRuleBasedSamplerRule[];
+}
+
+export interface ExperimentalComposableRuleBasedSamplerRule {
+  /**
+   * Values to match against a single attribute.
+   */
+  attribute_values?: {
+    key: string;
+    values: string[];
+  };
+  /**
+   * Patterns to match against a single attribute.
+   */
+  attribute_patterns?: {
+    key: string;
+    included?: string[];
+    excluded?: string[];
+  };
+  /**
+   * The span kinds to match.
+   */
+  span_kinds?: string[];
+  /**
+   * The parent span types to match.
+   */
+  parent?: string[];
+  /**
+   * The sampler to use for matching spans.
+   */
+  sampler: ExperimentalComposableSampler;
+}
+
 export interface SimpleSpanProcessor {
   /**
    * Configure exporter.