Add a Fibonacci fitter for metrics bucketing

A Fibonacci fitter is useful in situations where you want more precision on the
low end than an ExponentialFitter with exponent base 2 provides without the
hassle of dealing with non-integer boundaries, such as would be created by an
exponential fitter with a base of less than 2. Fibonacci fitters are ideal for
integer metrics that are bounded across a certain range, e.g. integers between 1
and 1,000.

This also cleans up some unit test comments.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=156773367

java/google/registry/monitoring/metrics/FibonacciFitter.java

@@ -0,0 +1,64 @@
+// Copyright 2017 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.monitoring.metrics;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableSortedSet;
+
+/**
+ * A {@link DistributionFitter} with intervals of increasing size using the Fibonacci sequence.
+ *
+ * <p>A Fibonacci fitter is useful in situations where you want more precision on the low end than
+ * an {@link ExponentialFitter} with exponent base 2 would provide without the hassle of dealing
+ * with non-integer boundaries, such as would be created by an exponential fitter with a base of
+ * less than 2. Fibonacci fitters are ideal for integer metrics that are bounded across a certain
+ * range, e.g. integers between 1 and 1,000.
+ *
+ * <p>The interval boundaries are chosen as {@code (-inf, 0), [0, 1), [1, 2), [2, 3), [3, 5), [5,
+ * 8), [8, 13)}, etc., up to {@code [fibonacciFloor(maxBucketSize), inf)}.
+ */
+@AutoValue
+public abstract class FibonacciFitter implements DistributionFitter {
+
+  /**
+   * Returns a new {@link FibonacciFitter}.
+   *
+   * @param maxBucketSize the maximum bucket size to create (rounded down to the nearest Fibonacci
+   *     number)
+   * @throws IllegalArgumentException if {@code maxBucketSize <= 0}
+   */
+  public static FibonacciFitter create(long maxBucketSize) {
+    checkArgument(maxBucketSize > 0, "maxBucketSize must be greater than 0");
+
+    ImmutableSortedSet.Builder<Double> boundaries = ImmutableSortedSet.naturalOrder();
+    boundaries.add(Double.valueOf(0));
+    long i = 1;
+    long j = 2;
+    long k = 3;
+    while (i <= maxBucketSize) {
+      boundaries.add(Double.valueOf(i));
+      i = j;
+      j = k;
+      k = i + j;
+    }
+
+    return new AutoValue_FibonacciFitter(boundaries.build());
+  }
+
+  @Override
+  public abstract ImmutableSortedSet<Double> boundaries();
+}

javatests/google/registry/monitoring/metrics/ExponentialFitterTest.java

@@ -22,7 +22,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Tests for implementations of {@link DistributionFitter}. */
+/** Unit tests for {@link ExponentialFitter}. */
 @RunWith(JUnit4.class)
 public class ExponentialFitterTest {
 

javatests/google/registry/monitoring/metrics/FibonacciFitterTest.java

@@ -0,0 +1,83 @@
+// Copyright 2017 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.monitoring.metrics;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link FibonacciFitter}. */
+@RunWith(JUnit4.class)
+public class FibonacciFitterTest {
+
+  @Test
+  public void testCreate_maxBucketSizeNegative_throwsException() {
+    try {
+      FibonacciFitter.create(-1);
+      fail("Expected exception");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("maxBucketSize must be greater than 0");
+    }
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeZero_throwsException() {
+    try {
+      FibonacciFitter.create(0);
+      fail("Expected exception");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("maxBucketSize must be greater than 0");
+    }
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeOne_createsTwoBoundaries() {
+    assertThat(FibonacciFitter.create(1).boundaries()).containsExactly(0.0, 1.0).inOrder();
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeTwo_createsThreeBoundaries() {
+    assertThat(FibonacciFitter.create(2).boundaries()).containsExactly(0.0, 1.0, 2.0).inOrder();
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeThree_createsFourBoundaries() {
+    assertThat(FibonacciFitter.create(3).boundaries())
+        .containsExactly(0.0, 1.0, 2.0, 3.0)
+        .inOrder();
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeFour_createsFourBoundaries() {
+    assertThat(FibonacciFitter.create(4).boundaries())
+        .containsExactly(0.0, 1.0, 2.0, 3.0)
+        .inOrder();
+  }
+
+  @Test
+  public void testCreate_maxBucketSizeLarge_createsFibonacciSequenceBoundaries() {
+    ImmutableList<Double> expectedBoundaries =
+        ImmutableList.of(
+            0.0, 1.0, 2.0, 3.0, 5.0, 8.0, 13.0, 21.0, 34.0, 55.0, 89.0, 144.0, 233.0, 377.0, 610.0,
+            987.0);
+    assertThat(FibonacciFitter.create(1000).boundaries())
+        .containsExactlyElementsIn(expectedBoundaries)
+        .inOrder();
+  }
+}

javatests/google/registry/monitoring/metrics/LinearFitterTest.java

@@ -22,7 +22,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Tests for {@link LinearFitter}. */
+/** Unit tests for {@link LinearFitter}. */
 @RunWith(JUnit4.class)
 public class LinearFitterTest {