Stats: Only include the simple class name in the error message for ViewData.check methods. (#1267)

* Stats: Only include the simple class name in the error message for ViewData.check methods.

* Copy checkArgument and lazily create error message.

* Rename help methods to avoid InconsistentOverloads.

* Improve error messages in the unit tests.

Author: songy23

api/src/main/java/io/opencensus/stats/ViewData.java

@@ -21,7 +21,6 @@
 import io.opencensus.common.Function;
 import io.opencensus.common.Functions;
 import io.opencensus.common.Timestamp;
-import io.opencensus.internal.Utils;
 import io.opencensus.stats.Aggregation.Count;
 import io.opencensus.stats.Aggregation.Distribution;
 import io.opencensus.stats.Aggregation.LastValue;
@@ -210,31 +209,36 @@ private static void checkWindow(
         new Function<View.AggregationWindow.Cumulative, Void>() {
           @Override
           public Void apply(View.AggregationWindow.Cumulative arg) {
-            Utils.checkArgument(
-                windowData instanceof AggregationWindowData.CumulativeData,
-                createErrorMessageForWindow(arg, windowData));
+            throwIfWindowMismatch(
+                windowData instanceof AggregationWindowData.CumulativeData, arg, windowData);
             return null;
           }
         },
         new Function<View.AggregationWindow.Interval, Void>() {
           @Override
           public Void apply(View.AggregationWindow.Interval arg) {
-            Utils.checkArgument(
-                windowData instanceof AggregationWindowData.IntervalData,
-                createErrorMessageForWindow(arg, windowData));
+            throwIfWindowMismatch(
+                windowData instanceof AggregationWindowData.IntervalData, arg, windowData);
             return null;
           }
         },
         Functions.</*@Nullable*/ Void>throwAssertionError());
   }
 
+  private static void throwIfWindowMismatch(
+      boolean isValid, View.AggregationWindow window, AggregationWindowData windowData) {
+    if (!isValid) {
+      throw new IllegalArgumentException(createErrorMessageForWindow(window, windowData));
+    }
+  }
+
   private static String createErrorMessageForWindow(
       View.AggregationWindow window, AggregationWindowData windowData) {
     return "AggregationWindow and AggregationWindowData types mismatch. "
         + "AggregationWindow: "
-        + window
+        + window.getClass().getSimpleName()
         + " AggregationWindowData: "
-        + windowData;
+        + windowData.getClass().getSimpleName();
   }
 
   private static void checkAggregation(
@@ -247,18 +251,16 @@ public Void apply(Sum arg) {
                 new Function<MeasureDouble, Void>() {
                   @Override
                   public Void apply(MeasureDouble arg) {
-                    Utils.checkArgument(
-                        aggregationData instanceof SumDataDouble,
-                        createErrorMessageForAggregation(aggregation, aggregationData));
+                    throwIfAggregationMismatch(
+                        aggregationData instanceof SumDataDouble, aggregation, aggregationData);
                     return null;
                   }
                 },
                 new Function<MeasureLong, Void>() {
                   @Override
                   public Void apply(MeasureLong arg) {
-                    Utils.checkArgument(
-                        aggregationData instanceof SumDataLong,
-                        createErrorMessageForAggregation(aggregation, aggregationData));
+                    throwIfAggregationMismatch(
+                        aggregationData instanceof SumDataLong, aggregation, aggregationData);
                     return null;
                   }
                 },
@@ -269,18 +271,16 @@ public Void apply(MeasureLong arg) {
         new Function<Count, Void>() {
           @Override
           public Void apply(Count arg) {
-            Utils.checkArgument(
-                aggregationData instanceof CountData,
-                createErrorMessageForAggregation(aggregation, aggregationData));
+            throwIfAggregationMismatch(
+                aggregationData instanceof CountData, aggregation, aggregationData);
             return null;
           }
         },
         new Function<Distribution, Void>() {
           @Override
           public Void apply(Distribution arg) {
-            Utils.checkArgument(
-                aggregationData instanceof DistributionData,
-                createErrorMessageForAggregation(aggregation, aggregationData));
+            throwIfAggregationMismatch(
+                aggregationData instanceof DistributionData, aggregation, aggregationData);
             return null;
           }
         },
@@ -291,18 +291,18 @@ public Void apply(LastValue arg) {
                 new Function<MeasureDouble, Void>() {
                   @Override
                   public Void apply(MeasureDouble arg) {
-                    Utils.checkArgument(
+                    throwIfAggregationMismatch(
                         aggregationData instanceof LastValueDataDouble,
-                        createErrorMessageForAggregation(aggregation, aggregationData));
+                        aggregation,
+                        aggregationData);
                     return null;
                   }
                 },
                 new Function<MeasureLong, Void>() {
                   @Override
                   public Void apply(MeasureLong arg) {
-                    Utils.checkArgument(
-                        aggregationData instanceof LastValueDataLong,
-                        createErrorMessageForAggregation(aggregation, aggregationData));
+                    throwIfAggregationMismatch(
+                        aggregationData instanceof LastValueDataLong, aggregation, aggregationData);
                     return null;
                   }
                 },
@@ -317,23 +317,32 @@ public Void apply(Aggregation arg) {
             // we need to continue supporting Mean, since it could still be used by users and some
             // deprecated RPC views.
             if (arg instanceof Aggregation.Mean) {
-              Utils.checkArgument(
+              throwIfAggregationMismatch(
                   aggregationData instanceof AggregationData.MeanData,
-                  createErrorMessageForAggregation(aggregation, aggregationData));
+                  aggregation,
+                  aggregationData);
               return null;
             }
             throw new AssertionError();
           }
         });
   }
 
+  private static void throwIfAggregationMismatch(
+      boolean isValid, Aggregation aggregation, AggregationData aggregationData) {
+    if (!isValid) {
+      throw new IllegalArgumentException(
+          createErrorMessageForAggregation(aggregation, aggregationData));
+    }
+  }
+
   private static String createErrorMessageForAggregation(
       Aggregation aggregation, AggregationData aggregationData) {
     return "Aggregation and AggregationData types mismatch. "
         + "Aggregation: "
-        + aggregation
+        + aggregation.getClass().getSimpleName()
         + " AggregationData: "
-        + aggregationData;
+        + aggregationData.getClass().getSimpleName();
   }
 
   /**

api/src/test/java/io/opencensus/stats/ViewDataTest.java

@@ -160,12 +160,19 @@ public Void apply(IntervalData windowData) {
 
   @Test
   public void preventWindowAndAggregationWindowDataMismatch() {
+    CumulativeData cumulativeData =
+        CumulativeData.create(Timestamp.fromMillis(1000), Timestamp.fromMillis(2000));
     thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("AggregationWindow and AggregationWindowData types mismatch. ");
+    thrown.expectMessage(
+        "AggregationWindow and AggregationWindowData types mismatch. "
+            + "AggregationWindow: "
+            + INTERVAL_HOUR.getClass().getSimpleName()
+            + " AggregationWindowData: "
+            + cumulativeData.getClass().getSimpleName());
     ViewData.create(
         View.create(NAME, DESCRIPTION, MEASURE_DOUBLE, DISTRIBUTION, TAG_KEYS, INTERVAL_HOUR),
         ENTRIES,
-        CumulativeData.create(Timestamp.fromMillis(1000), Timestamp.fromMillis(2000)));
+        cumulativeData);
   }
 
   @Test
@@ -213,12 +220,7 @@ public void preventAggregationAndAggregationDataMismatch_Mean_Distribution() {
   @Test
   public void preventAggregationAndAggregationDataMismatch_Distribution_Count() {
     aggregationAndAggregationDataMismatch(
-        createView(DISTRIBUTION),
-        ImmutableMap.of(
-            Arrays.asList(V1, V2),
-            DistributionData.create(1, 1, 1, 1, 0, Arrays.asList(0L, 1L, 0L)),
-            Arrays.asList(V10, V20),
-            CountData.create(100)));
+        createView(DISTRIBUTION), ImmutableMap.of(Arrays.asList(V10, V20), CountData.create(100)));
   }
 
   @Test
@@ -249,8 +251,15 @@ private void aggregationAndAggregationDataMismatch(
       View view, Map<List<TagValue>, ? extends AggregationData> entries) {
     CumulativeData cumulativeData =
         CumulativeData.create(Timestamp.fromMillis(1000), Timestamp.fromMillis(2000));
+    Aggregation aggregation = view.getAggregation();
+    AggregationData aggregationData = entries.values().iterator().next();
     thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Aggregation and AggregationData types mismatch. ");
+    thrown.expectMessage(
+        "Aggregation and AggregationData types mismatch. "
+            + "Aggregation: "
+            + aggregation.getClass().getSimpleName()
+            + " AggregationData: "
+            + aggregationData.getClass().getSimpleName());
     ViewData.create(view, entries, cumulativeData);
   }