Addressing code review suggestions.

Author: PeterF778

consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent56/ConsistentAnyOf.java

@@ -15,6 +15,9 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.trace.data.LinkData;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
 /**
@@ -41,7 +44,10 @@ final class ConsistentAnyOf extends ConsistentSampler {
 
     this.delegates = delegates;
 
-    this.description = Stream.of(delegates).map(Object::toString).collect(Collectors.joining(",", "ConsistentAnyOf{", "}"));
+    this.description =
+        Stream.of(delegates)
+            .map(Object::toString)
+            .collect(Collectors.joining(",", "ConsistentAnyOf{", "}"));
   }
 
   @Override

consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent56/ConsistentRateLimitingSampler.java

@@ -157,12 +157,35 @@ public State(
     this.inverseAdaptationTimeNanos = NANOS_IN_SECONDS / adaptationTimeSeconds;
     this.targetSpansPerNanosecondLimit = NANOS_IN_SECONDS * targetSpansPerSecondLimit;
 
-    double t = 1.0 / (targetSpansPerSecondLimit * adaptationTimeSeconds);
-    this.probabilitySmoothingFactor = t / (1.0 + t);
+    this.probabilitySmoothingFactor =
+        determineProbabilitySmoothingFactor(targetSpansPerSecondLimit, adaptationTimeSeconds);
 
     this.state = new AtomicReference<>(new State(0, 0, nanoTimeSupplier.getAsLong(), 1.0));
   }
 
+  private static double determineProbabilitySmoothingFactor(
+      double targetSpansPerSecondLimit, double adaptationTimeSeconds) {
+    // The probability smoothing factor alpha will be the weight for the newly observed
+    // probability P, while (1-alpha) will be the weight for the cumulative average probability
+    // observed so far (newC = P * alpha + oldC * (1 - alpha)). Any smoothing factor
+    // alpha from the interval (0.0, 1.0) is mathematically acceptable.
+    // However, we'd like the weight associated with the newly observed data point to be inversely
+    // proportional to the adaptation time (larger adaptation time will allow longer time for the
+    // cumulative probability to stabilize) and inversely proportional to the order of magnitude of
+    // the data points arriving within a given time unit (because with a lot of data points we can
+    // afford to give a smaller weight to each single one). We do not know the true rate of Spans
+    // coming in to get sampled, but we optimistically assume that the user knows what they are
+    // doing and that the targetSpansPerSecondLimit will be of similar order of magnitude.
+
+    // First approximation of the probability smoothing factor alpha.
+    double t = 1.0 / (targetSpansPerSecondLimit * adaptationTimeSeconds);
+
+    // We expect that t is a small number, but we have to make sure that alpha is smaller than 1.
+    // Therefore we apply a "bending" transformation which almost preserves small values, but makes
+    // sure that the result is within the expected interval.
+    return t / (1.0 + t);
+  }
+
   private State updateState(State oldState, long currentNanoTime, double delegateProbability) {
     if (currentNanoTime <= oldState.lastNanoTime) {
       return new State(

consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent56/ConsistentRuleBasedSampler.java

@@ -12,6 +12,8 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.trace.data.LinkData;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
@@ -28,11 +30,15 @@ final class ConsistentRuleBasedSampler extends ConsistentSampler {
 
   private final String description;
 
-  ConsistentRuleBasedSampler(@Nullable SpanKind spanKindToMatch, @Nullable PredicatedSampler... samplers) {
+  ConsistentRuleBasedSampler(
+      @Nullable SpanKind spanKindToMatch, @Nullable PredicatedSampler... samplers) {
     this.spanKindToMatch = spanKindToMatch;
-    this.samplers = (samplers != null)?samplers:new PredicatedSampler[0];
+    this.samplers = (samplers != null) ? samplers : new PredicatedSampler[0];
 
-    this.description = Stream.of(samplers).collect(Collectors.joining(",", "ConsistentRuleBasedSampler{", "}"));
+    this.description =
+        Stream.of(samplers)
+            .map((s) -> s.getSampler().getDescription())
+            .collect(Collectors.joining(",", "ConsistentRuleBasedSampler{", "}"));
   }
 
   @Override

consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent56/CoinFlipSampler.java

@@ -12,7 +12,7 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.trace.data.LinkData;
 import java.util.List;
-import java.util.Random;
+import java.util.SplittableRandom;
 import javax.annotation.concurrent.Immutable;
 
 /**
@@ -22,7 +22,7 @@
 @Immutable
 final class CoinFlipSampler extends ConsistentSampler {
 
-  private static final SplittableRandomrandom = new SplittableRandom(0x160a50a2073e17e6L);
+  private static final SplittableRandom random = new SplittableRandom(0x160a50a2073e17e6L);
 
   private final ComposableSampler samplerA;
   private final ComposableSampler samplerB;