Adding a test for low-resolution clock.

Author: PeterF778

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

@@ -187,23 +187,26 @@ private static double determineProbabilitySmoothingFactor(
   }
 
   private State updateState(State oldState, long currentNanoTime, double delegateProbability) {
-    if (currentNanoTime <= oldState.lastNanoTime) {
+    double currentAverageProbability =
+        oldState.effectiveDelegateProbability * (1.0 - probabilitySmoothingFactor)
+            + delegateProbability * probabilitySmoothingFactor;
+
+    long nanoTimeDelta = currentNanoTime - oldState.lastNanoTime;
+    if (nanoTimeDelta <= 0.0) {
+      // Low clock resolution or clock jumping backwards.
+      // Assume time delta equal to zero.
       return new State(
           oldState.effectiveWindowCount + 1,
           oldState.effectiveWindowNanos,
           oldState.lastNanoTime,
-          oldState.effectiveDelegateProbability);
+          currentAverageProbability);
     }
-    long nanoTimeDelta = currentNanoTime - oldState.lastNanoTime;
+
     double decayFactor = Math.exp(-nanoTimeDelta * inverseAdaptationTimeNanos);
     double currentEffectiveWindowCount = oldState.effectiveWindowCount * decayFactor + 1;
     double currentEffectiveWindowNanos =
         oldState.effectiveWindowNanos * decayFactor + nanoTimeDelta;
 
-    double currentAverageProbability =
-        oldState.effectiveDelegateProbability * (1.0 - probabilitySmoothingFactor)
-            + delegateProbability * probabilitySmoothingFactor;
-
     return new State(
         currentEffectiveWindowCount,
         currentEffectiveWindowNanos,

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

@@ -29,6 +29,7 @@ class ConsistentRateLimitingSamplerTest {
 
   private long[] nanoTime;
   private LongSupplier nanoTimeSupplier;
+  private LongSupplier lowResolutionTimeSupplier;
   private Context parentContext;
   private String name;
   private SpanKind spanKind;
@@ -40,6 +41,7 @@ class ConsistentRateLimitingSamplerTest {
   void init() {
     nanoTime = new long[] {0L};
     nanoTimeSupplier = () -> nanoTime[0];
+    lowResolutionTimeSupplier = () -> (nanoTime[0] / 1000000) * 1000000; // 1ms resolution
     parentContext = Context.root();
     name = "name";
     spanKind = SpanKind.SERVER;
@@ -97,6 +99,47 @@ void testConstantRate() {
         .isCloseTo(targetSpansPerSecondLimit, Percentage.withPercentage(5));
   }
 
+  @Test
+  void testConstantRateLowResolution() {
+
+    double targetSpansPerSecondLimit = 1000;
+    double adaptationTimeSeconds = 5;
+
+    ComposableSampler delegate =
+        new CoinFlipSampler(ConsistentSampler.alwaysOff(), ConsistentSampler.probabilityBased(0.8));
+    ConsistentSampler sampler =
+        ConsistentSampler.rateLimited(
+            delegate, targetSpansPerSecondLimit, adaptationTimeSeconds, lowResolutionTimeSupplier);
+
+    long nanosBetweenSpans = TimeUnit.MICROSECONDS.toNanos(100);
+    int numSpans = 1000000;
+
+    List<Long> spanSampledNanos = new ArrayList<>();
+
+    for (int i = 0; i < numSpans; ++i) {
+      advanceTime(nanosBetweenSpans);
+      SamplingResult samplingResult =
+          sampler.shouldSample(
+              parentContext,
+              generateRandomTraceId(random),
+              name,
+              spanKind,
+              attributes,
+              parentLinks);
+      if (SamplingDecision.RECORD_AND_SAMPLE.equals(samplingResult.getDecision())) {
+        spanSampledNanos.add(getCurrentTimeNanos());
+      }
+    }
+
+    long numSampledSpansInLast5Seconds =
+        spanSampledNanos.stream()
+            .filter(x -> x > TimeUnit.SECONDS.toNanos(95) && x <= TimeUnit.SECONDS.toNanos(100))
+            .count();
+
+    assertThat(numSampledSpansInLast5Seconds / 5.)
+        .isCloseTo(targetSpansPerSecondLimit, Percentage.withPercentage(5));
+  }
+
   @Test
   void testRateIncrease() {