Extract SummaryData interface for DoubleSummaryData (#4224)

* Extract SummaryData interface for DoubleSummaryData

* ValueAtQuantile too

* javadoc

exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingMetricExporterTest.java

@@ -13,12 +13,12 @@ import io.opentelemetry.internal.testing.slf4j.SuppressLogger;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
-import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -69,17 +69,17 @@ class LoggingMetricExporterTest {
                 "measureOne",
                 "A summarized test measure",
                 "ms",
-                DoubleSummaryData.create(
+                ImmutableSummaryData.create(
                     Collections.singletonList(
-                        DoubleSummaryPointData.create(
+                        ImmutableSummaryPointData.create(
                             nowEpochNanos,
                             nowEpochNanos + 245,
                             Attributes.of(stringKey("a"), "b", stringKey("c"), "d"),
                             1010,
                             50000,
                             Arrays.asList(
-                                ValueAtPercentile.create(0.0, 25),
+                                ImmutableValueAtPercentile.create(0.0, 25),
-                                ValueAtPercentile.create(100.0, 433)))))),
+                                ImmutableValueAtPercentile.create(100.0, 433)))))),
             MetricData.createLongSum(
                 resource,
                 instrumentationLibraryInfo,

exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricMarshaler.java

@@ -49,7 +49,7 @@ final class MetricMarshaler extends MarshalerWithSize {
         dataField = Metric.SUM;
         break;
       case SUMMARY:
-        dataMarshaler = SummaryMarshaler.create(metric.getDoubleSummaryData());
+        dataMarshaler = SummaryMarshaler.create(metric.getSummaryData());
         dataField = Metric.SUMMARY;
         break;
       case HISTOGRAM:

exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/SummaryDataPointMarshaler.java

@@ -10,7 +10,7 @@ import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize;
 import io.opentelemetry.exporter.internal.marshal.Serializer;
 import io.opentelemetry.exporter.internal.otlp.KeyValueMarshaler;
 import io.opentelemetry.proto.metrics.v1.internal.SummaryDataPoint;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import java.io.IOException;
 import java.util.Collection;
 
@@ -22,16 +22,16 @@ final class SummaryDataPointMarshaler extends MarshalerWithSize {
   private final ValueAtQuantileMarshaler[] quantileValues;
   private final KeyValueMarshaler[] attributes;
 
-  static SummaryDataPointMarshaler[] createRepeated(Collection<DoubleSummaryPointData> points) {
+  static SummaryDataPointMarshaler[] createRepeated(Collection<SummaryPointData> points) {
     SummaryDataPointMarshaler[] marshalers = new SummaryDataPointMarshaler[points.size()];
     int index = 0;
-    for (DoubleSummaryPointData point : points) {
+    for (SummaryPointData point : points) {
       marshalers[index++] = SummaryDataPointMarshaler.create(point);
     }
     return marshalers;
   }
 
-  static SummaryDataPointMarshaler create(DoubleSummaryPointData point) {
+  static SummaryDataPointMarshaler create(SummaryPointData point) {
     ValueAtQuantileMarshaler[] quantileMarshalers =
         ValueAtQuantileMarshaler.createRepeated(point.getPercentileValues());
     KeyValueMarshaler[] attributeMarshalers =

exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/SummaryMarshaler.java

@@ -9,13 +9,13 @@ import io.opentelemetry.exporter.internal.marshal.MarshalerUtil;
 import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize;
 import io.opentelemetry.exporter.internal.marshal.Serializer;
 import io.opentelemetry.proto.metrics.v1.internal.Summary;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
+import io.opentelemetry.sdk.metrics.data.SummaryData;
 import java.io.IOException;
 
 final class SummaryMarshaler extends MarshalerWithSize {
   private final SummaryDataPointMarshaler[] dataPoints;
 
-  static SummaryMarshaler create(DoubleSummaryData summary) {
+  static SummaryMarshaler create(SummaryData summary) {
     SummaryDataPointMarshaler[] dataPointMarshalers =
         SummaryDataPointMarshaler.createRepeated(summary.getPoints());
     return new SummaryMarshaler(dataPointMarshalers);

exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java

@@ -43,18 +43,19 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.HistogramPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.PointData;
-import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramBuckets;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramPointData;
@@ -271,13 +272,13 @@ class MetricsRequestMarshalerTest {
     assertThat(
             toSummaryDataPoints(
                 singletonList(
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         123,
                         456,
                         KV_ATTR,
                         5,
                         14.2,
-                        singletonList(ValueAtPercentile.create(0.0, 1.1))))))
+                        singletonList(ImmutableValueAtPercentile.create(0.0, 1.1))))))
         .containsExactly(
             SummaryDataPoint.newBuilder()
                 .setStartTimeUnixNano(123)
@@ -296,17 +297,17 @@ class MetricsRequestMarshalerTest {
     assertThat(
             toSummaryDataPoints(
                 ImmutableList.of(
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         123, 456, Attributes.empty(), 7, 15.3, Collections.emptyList()),
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         321,
                         654,
                         KV_ATTR,
                         9,
                         18.3,
                         ImmutableList.of(
-                            ValueAtPercentile.create(0.0, 1.1),
+                            ImmutableValueAtPercentile.create(0.0, 1.1),
-                            ValueAtPercentile.create(100.0, 20.3))))))
+                            ImmutableValueAtPercentile.create(100.0, 20.3))))))
         .containsExactly(
             SummaryDataPoint.newBuilder()
                 .setStartTimeUnixNano(123)
@@ -679,17 +680,17 @@ class MetricsRequestMarshalerTest {
                     "name",
                     "description",
                     "1",
-                    DoubleSummaryData.create(
+                    ImmutableSummaryData.create(
                         singletonList(
-                            DoubleSummaryPointData.create(
+                            ImmutableSummaryPointData.create(
                                 123,
                                 456,
                                 KV_ATTR,
                                 5,
                                 33d,
                                 ImmutableList.of(
-                                    ValueAtPercentile.create(0, 1.1),
+                                    ImmutableValueAtPercentile.create(0, 1.1),
-                                    ValueAtPercentile.create(100.0, 20.3))))))))
+                                    ImmutableValueAtPercentile.create(100.0, 20.3))))))))
         .isEqualTo(
             Metric.newBuilder()
                 .setName("name")
@@ -959,8 +960,7 @@ class MetricsRequestMarshalerTest {
         .collect(Collectors.toList());
   }
 
-  private static List<SummaryDataPoint> toSummaryDataPoints(
+  private static List<SummaryDataPoint> toSummaryDataPoints(Collection<SummaryPointData> points) {
-      Collection<DoubleSummaryPointData> points) {
     return points.stream()
         .map(
             point ->

exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java

@@ -12,7 +12,6 @@ import io.opentelemetry.api.trace.SpanContext;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ExemplarData;
 import io.opentelemetry.sdk.metrics.data.HistogramPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
@@ -21,6 +20,7 @@ import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.MetricDataType;
 import io.opentelemetry.sdk.metrics.data.PointData;
 import io.opentelemetry.sdk.metrics.data.SumData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
 import io.prometheus.client.Collector;
@@ -149,8 +149,7 @@ final class MetricAdapter {
                   longPoint.getEpochNanos()));
           break;
         case SUMMARY:
-          addSummarySamples(
+          addSummarySamples((SummaryPointData) pointData, name, labelNames, labelValues, samples);
-              (DoubleSummaryPointData) pointData, name, labelNames, labelValues, samples);
           break;
         case HISTOGRAM:
           addHistogramSamples(
@@ -164,7 +163,7 @@ final class MetricAdapter {
   }
 
   private static void addSummarySamples(
-      DoubleSummaryPointData doubleSummaryPoint,
+      SummaryPointData doubleSummaryPoint,
       String name,
       List<String> labelNames,
       List<String> labelValues,
@@ -291,7 +290,7 @@ final class MetricAdapter {
       case LONG_SUM:
         return metricData.getLongSumData().getPoints();
       case SUMMARY:
-        return metricData.getDoubleSummaryData().getPoints();
+        return metricData.getSummaryData().getPoints();
       case HISTOGRAM:
         return metricData.getHistogramData().getPoints();
       case EXPONENTIAL_HISTOGRAM:

exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java

@@ -26,7 +26,6 @@ import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanContext;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ExemplarData;
 import io.opentelemetry.sdk.metrics.data.HistogramPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
@@ -34,6 +33,7 @@ import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.MetricDataType;
 import io.opentelemetry.sdk.metrics.data.PointData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import java.io.BufferedWriter;
 import java.io.IOException;
@@ -152,7 +152,7 @@ abstract class Serializer {
           writeHistogram(writer, name, (HistogramPointData) point);
           break;
         case SUMMARY:
-          writeSummary(writer, name, (DoubleSummaryPointData) point);
+          writeSummary(writer, name, (SummaryPointData) point);
           break;
         case EXPONENTIAL_HISTOGRAM:
           throw new IllegalArgumentException("Can't happen");
@@ -188,8 +188,7 @@ abstract class Serializer {
     }
   }
 
-  private void writeSummary(Writer writer, String name, DoubleSummaryPointData point)
+  private void writeSummary(Writer writer, String name, SummaryPointData point) throws IOException {
-      throws IOException {
     writePoint(
         writer, name + "_count", point.getCount(), point.getAttributes(), point.getEpochNanos());
     writePoint(writer, name + "_sum", point.getSum(), point.getAttributes(), point.getEpochNanos());

exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java

@@ -16,17 +16,17 @@ import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.MetricDataType;
-import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import io.prometheus.client.Collector;
 import io.prometheus.client.Collector.MetricFamilySamples;
@@ -182,17 +182,17 @@ class MetricAdapterTest {
           "instrument.name",
           "description",
           "1",
-          DoubleSummaryData.create(
+          ImmutableSummaryData.create(
               Collections.singletonList(
-                  DoubleSummaryPointData.create(
+                  ImmutableSummaryPointData.create(
                       1633947011000000000L,
                       1633950672000000000L,
                       KP_VP_ATTR,
                       5,
                       7,
                       Arrays.asList(
-                          ValueAtPercentile.create(0.9, 0.1),
+                          ImmutableValueAtPercentile.create(0.9, 0.1),
-                          ValueAtPercentile.create(0.99, 0.3))))));
+                          ImmutableValueAtPercentile.create(0.99, 0.3))))));
   private static final MetricData HISTOGRAM =
       MetricData.createDoubleHistogram(
           Resource.create(Attributes.of(stringKey("kr"), "vr")),
@@ -430,13 +430,13 @@ class MetricAdapterTest {
                 "full_name",
                 MetricDataType.SUMMARY,
                 ImmutableList.of(
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         1633939689000000000L,
                         1633943350000000000L,
                         KP_VP_ATTR,
                         9,
                         18.3,
-                        ImmutableList.of(ValueAtPercentile.create(0.9, 1.1))))))
+                        ImmutableList.of(ImmutableValueAtPercentile.create(0.9, 1.1))))))
         .containsExactly(
             new Sample(
                 "full_name_count",
@@ -465,22 +465,22 @@ class MetricAdapterTest {
                 "full_name",
                 MetricDataType.SUMMARY,
                 ImmutableList.of(
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         1633947011000000000L,
                         1633950672000000000L,
                         Attributes.empty(),
                         7,
                         15.3,
                         Collections.emptyList()),
-                    DoubleSummaryPointData.create(
+                    ImmutableSummaryPointData.create(
                         1633939689000000000L,
                         1633943350000000000L,
                         KP_VP_ATTR,
                         9,
                         18.3,
                         ImmutableList.of(
-                            ValueAtPercentile.create(0.9, 1.1),
+                            ImmutableValueAtPercentile.create(0.9, 1.1),
-                            ValueAtPercentile.create(0.99, 12.3))))))
+                            ImmutableValueAtPercentile.create(0.99, 12.3))))))
         .containsExactly(
             new Sample(
                 "full_name_count",

exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java

@@ -15,16 +15,16 @@ import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
-import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -172,17 +172,17 @@ class SerializerTest {
           "instrument.name",
           "description",
           "1",
-          DoubleSummaryData.create(
+          ImmutableSummaryData.create(
               Collections.singletonList(
-                  DoubleSummaryPointData.create(
+                  ImmutableSummaryPointData.create(
                       1633947011000000000L,
                       1633950672000000000L,
                       KP_VP_ATTR,
                       5,
                       7,
                       Arrays.asList(
-                          ValueAtPercentile.create(0.9, 0.1),
+                          ImmutableValueAtPercentile.create(0.9, 0.1),
-                          ValueAtPercentile.create(0.99, 0.3))))));
+                          ImmutableValueAtPercentile.create(0.99, 0.3))))));
   private static final MetricData HISTOGRAM =
       MetricData.createDoubleHistogram(
           Resource.create(Attributes.of(stringKey("kr"), "vr")),

opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java

@@ -24,8 +24,6 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ExemplarData;
 import io.opentelemetry.sdk.metrics.data.GaugeData;
 import io.opentelemetry.sdk.metrics.data.HistogramData;
@@ -33,11 +31,16 @@ import io.opentelemetry.sdk.metrics.data.HistogramPointData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.SumData;
+import io.opentelemetry.sdk.metrics.data.SummaryData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -167,8 +170,8 @@ public final class MetricAdapter {
         AggregationTemporality.DELTA, convertHistogramPoints(censusMetric));
   }
 
-  static DoubleSummaryData convertSummary(Metric censusMetric) {
+  static SummaryData convertSummary(Metric censusMetric) {
-    return DoubleSummaryData.create(convertSummaryPoints(censusMetric));
+    return ImmutableSummaryData.create(convertSummaryPoints(censusMetric));
   }
 
   static Collection<LongPointData> convertLongPoints(Metric censusMetric) {
@@ -243,14 +246,14 @@ public final class MetricAdapter {
     return result;
   }
 
-  static Collection<DoubleSummaryPointData> convertSummaryPoints(Metric censusMetric) {
+  static Collection<SummaryPointData> convertSummaryPoints(Metric censusMetric) {
-    List<DoubleSummaryPointData> result = new ArrayList<>();
+    List<SummaryPointData> result = new ArrayList<>();
     for (TimeSeries ts : censusMetric.getTimeSeriesList()) {
       long startTimestamp = mapTimestamp(ts.getStartTimestamp());
       Attributes attributes =
           mapAttributes(censusMetric.getMetricDescriptor().getLabelKeys(), ts.getLabelValues());
       for (Point point : ts.getPoints()) {
-        DoubleSummaryPointData otelPoint =
+        SummaryPointData otelPoint =
             point
                 .getValue()
                 .match(
@@ -258,7 +261,7 @@ public final class MetricAdapter {
                     lv -> null,
                     distribution -> null,
                     summary ->
-                        DoubleSummaryPointData.create(
+                        ImmutableSummaryPointData.create(
                             startTimestamp,
                             mapTimestamp(point.getTimestamp()),
                             attributes,
@@ -369,7 +372,8 @@ public final class MetricAdapter {
       List<Summary.Snapshot.ValueAtPercentile> valueAtPercentiles) {
     List<ValueAtPercentile> result = new ArrayList<>(valueAtPercentiles.size());
     for (Summary.Snapshot.ValueAtPercentile censusValue : valueAtPercentiles) {
-      result.add(ValueAtPercentile.create(censusValue.getPercentile(), censusValue.getValue()));
+      result.add(
+          ImmutableValueAtPercentile.create(censusValue.getPercentile(), censusValue.getValue()));
     }
     return result;
   }

opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java

@@ -25,7 +25,7 @@ import io.opentelemetry.api.trace.SpanContext;
 import io.opentelemetry.api.trace.TraceFlags;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
-import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.Arrays;
 import java.util.Collections;
@@ -301,7 +301,7 @@ class MetricAdapterTest {
                     .hasAttributes(Attributes.of(AttributeKey.stringKey("key1"), "value1"))
                     .hasCount(10)
                     .hasSum(5)
-                    .hasPercentileValues(ValueAtPercentile.create(1.0, 200)));
+                    .hasPercentileValues(ImmutableValueAtPercentile.create(1.0, 200)));
   }
 
   @Test

sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleSummaryDataAssert.java

@@ -1,29 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.sdk.testing.assertj;
-
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
-import org.assertj.core.api.AbstractAssert;
-import org.assertj.core.api.AbstractIterableAssert;
-import org.assertj.core.api.Assertions;
-
-/** Assert on a {@link DoubleSummaryData} metric. */
-public class DoubleSummaryDataAssert
-    extends AbstractAssert<DoubleSummaryDataAssert, DoubleSummaryData> {
-
-  protected DoubleSummaryDataAssert(DoubleSummaryData actual) {
-    super(actual, DoubleSummaryDataAssert.class);
-  }
-
-  /** Returns convenience API to assert against the {@code points} field. */
-  public AbstractIterableAssert<
-          ?, ? extends Iterable<? extends DoubleSummaryPointData>, DoubleSummaryPointData, ?>
-      points() {
-    isNotNull();
-    return Assertions.assertThat(actual.getPoints());
-  }
-}

sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java

@@ -6,8 +6,6 @@
 package io.opentelemetry.sdk.testing.assertj;
 
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ExemplarData;
 import io.opentelemetry.sdk.metrics.data.GaugeData;
 import io.opentelemetry.sdk.metrics.data.HistogramData;
@@ -16,6 +14,8 @@ import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.data.PointData;
 import io.opentelemetry.sdk.metrics.data.SumData;
+import io.opentelemetry.sdk.metrics.data.SummaryData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramBuckets;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramPointData;
 import org.assertj.core.api.Assertions;
@@ -28,6 +28,9 @@ public final class MetricAssertions extends Assertions {
   }
 
   /** Returns an assertion for {@link GaugeData}. */
+  // There is no real use case for passing in a GaugeData that is a lambda, if for some reason it is
+  // desired a cast will still work.
+  @SuppressWarnings("FunctionalInterfaceClash")
   public static <T extends PointData> GaugeAssert<T> assertThat(GaugeData<T> metric) {
     return new GaugeAssert<>(metric);
   }
@@ -37,9 +40,9 @@ public final class MetricAssertions extends Assertions {
     return new HistogramAssert(metric);
   }
 
-  /** Returns an assertion for {@link DoubleSummaryData}. */
+  /** Returns an assertion for {@link SummaryData}. */
-  public static DoubleSummaryDataAssert assertThat(DoubleSummaryData metric) {
+  public static SummaryDataAssert assertThat(SummaryData metric) {
-    return new DoubleSummaryDataAssert(metric);
+    return new SummaryDataAssert(metric);
   }
 
   /** Returns an assertion for {@link HistogramPointData}. */
@@ -47,9 +50,9 @@ public final class MetricAssertions extends Assertions {
     return new HistogramPointDataAssert(point);
   }
 
-  /** Returns an assertion for {@link DoubleSummaryPointData}. */
+  /** Returns an assertion for {@link SummaryPointData}. */
-  public static DoubleSummaryPointDataAssert assertThat(DoubleSummaryPointData point) {
+  public static SummaryPointDataAssert assertThat(SummaryPointData point) {
-    return new DoubleSummaryPointDataAssert(point);
+    return new SummaryPointDataAssert(point);
   }
 
   /** Returns an assertion for {@link ExponentialHistogramPointData}. */

sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java

@@ -207,7 +207,7 @@ public class MetricDataAssert extends AbstractAssert<MetricDataAssert, MetricDat
    *
    * @return convenience API to assert against the {@code DoubleSummaryData}.
    */
-  public DoubleSummaryDataAssert hasDoubleSummary() {
+  public SummaryDataAssert hasDoubleSummary() {
     isNotNull();
     if (actual.getType() != MetricDataType.SUMMARY) {
       failWithActualExpectedAndMessage(
@@ -217,6 +217,6 @@ public class MetricDataAssert extends AbstractAssert<MetricDataAssert, MetricDat
           MetricDataType.SUMMARY,
           actual.getType());
     }
-    return new DoubleSummaryDataAssert(actual.getDoubleSummaryData());
+    return new SummaryDataAssert(actual.getSummaryData());
   }
 }

sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/SummaryDataAssert.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.testing.assertj;
+
+import io.opentelemetry.sdk.metrics.data.SummaryData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.AbstractIterableAssert;
+import org.assertj.core.api.Assertions;
+
+/** Assert on a {@link SummaryData} metric. */
+public class SummaryDataAssert extends AbstractAssert<SummaryDataAssert, SummaryData> {
+
+  protected SummaryDataAssert(SummaryData actual) {
+    super(actual, SummaryDataAssert.class);
+  }
+
+  /** Returns convenience API to assert against the {@code points} field. */
+  public AbstractIterableAssert<
+          ?, ? extends Iterable<? extends SummaryPointData>, SummaryPointData, ?>
+      points() {
+    isNotNull();
+    return Assertions.assertThat(actual.getPoints());
+  }
+}

sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/SummaryPointDataAssert.java

@@ -5,33 +5,33 @@
 
 package io.opentelemetry.sdk.testing.assertj;
 
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import org.assertj.core.api.Assertions;
 
 /** Asserts for (deprecated) Summary points. */
-public class DoubleSummaryPointDataAssert
+public class SummaryPointDataAssert
-    extends AbstractPointDataAssert<DoubleSummaryPointDataAssert, DoubleSummaryPointData> {
+    extends AbstractPointDataAssert<SummaryPointDataAssert, SummaryPointData> {
-  protected DoubleSummaryPointDataAssert(DoubleSummaryPointData actual) {
+  protected SummaryPointDataAssert(SummaryPointData actual) {
-    super(actual, DoubleSummaryPointDataAssert.class);
+    super(actual, SummaryPointDataAssert.class);
   }
 
   /** Ensure the summary has seen the expected count of measurements. */
-  public DoubleSummaryPointDataAssert hasCount(long expected) {
+  public SummaryPointDataAssert hasCount(long expected) {
     isNotNull();
     Assertions.assertThat(actual.getCount()).as("count").isEqualTo(expected);
     return this;
   }
 
   /** Ensure the summary has the expected sum across all observed measurements. */
-  public DoubleSummaryPointDataAssert hasSum(double expected) {
+  public SummaryPointDataAssert hasSum(double expected) {
     isNotNull();
     Assertions.assertThat(actual.getSum()).as("sum").isEqualTo(expected);
     return this;
   }
 
   /** Ensure the summary has exactly, in any order, the given percentile values. */
-  public DoubleSummaryPointDataAssert hasPercentileValues(ValueAtPercentile... percentiles) {
+  public SummaryPointDataAssert hasPercentileValues(ValueAtPercentile... percentiles) {
     isNotNull();
     Assertions.assertThat(actual.getPercentileValues()).containsExactlyInAnyOrder(percentiles);
     return this;

sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java

@@ -17,17 +17,19 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.DoubleExemplarData;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
-import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
 import io.opentelemetry.sdk.metrics.data.HistogramPointData;
 import io.opentelemetry.sdk.metrics.data.LongExemplarData;
 import io.opentelemetry.sdk.metrics.data.LongPointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.Arrays;
@@ -94,7 +96,7 @@ public class MetricAssertionsTest {
           /* name= */ "summary",
           /* description= */ "description",
           /* unit= */ "unit",
-          DoubleSummaryData.create(
+          ImmutableSummaryData.create(
               // Points
               Collections.emptyList()));
 
@@ -207,10 +209,10 @@ public class MetricAssertionsTest {
   private static final LongPointData LONG_POINT_DATA_WITH_EXEMPLAR =
       LongPointData.create(1, 2, Attributes.empty(), 3, Collections.singletonList(LONG_EXEMPLAR));
 
-  private static final ValueAtPercentile PERCENTILE_VALUE = ValueAtPercentile.create(0, 1);
+  private static final ValueAtPercentile PERCENTILE_VALUE = ImmutableValueAtPercentile.create(0, 1);
 
-  private static final DoubleSummaryPointData DOUBLE_SUMMARY_POINT_DATA =
+  private static final SummaryPointData DOUBLE_SUMMARY_POINT_DATA =
-      DoubleSummaryPointData.create(
+      ImmutableSummaryPointData.create(
           1, 2, Attributes.empty(), 1, 2, Collections.singletonList(PERCENTILE_VALUE));
 
   private static final HistogramPointData DOUBLE_HISTOGRAM_POINT_DATA =
@@ -476,7 +478,7 @@ public class MetricAssertionsTest {
     assertThatThrownBy(
             () ->
                 assertThat(DOUBLE_SUMMARY_POINT_DATA)
-                    .hasPercentileValues(ValueAtPercentile.create(1, 1)))
+                    .hasPercentileValues(ImmutableValueAtPercentile.create(1, 1)))
         .isInstanceOf(AssertionError.class);
   }
 

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java

@@ -9,6 +9,7 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
 import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
 import io.opentelemetry.sdk.resources.Resource;
 import javax.annotation.concurrent.Immutable;
@@ -119,7 +120,7 @@ public interface MetricData {
       String name,
       String description,
       String unit,
-      DoubleSummaryData data) {
+      SummaryData data) {
     return MetricDataImpl.create(
         resource,
         instrumentationLibraryInfo,
@@ -295,11 +296,11 @@ public interface MetricData {
    * @return the {@code DoubleSummaryData} if type is {@link MetricDataType#SUMMARY}, otherwise a
    *     default * empty data.
    */
-  default DoubleSummaryData getDoubleSummaryData() {
+  default SummaryData getSummaryData() {
     if (getType() == MetricDataType.SUMMARY) {
-      return (DoubleSummaryData) getData();
+      return (SummaryData) getData();
     }
-    return DoubleSummaryData.EMPTY;
+    return ImmutableSummaryData.empty();
   }
 
   /**

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/SummaryData.java

@@ -0,0 +1,14 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.metrics.data;
+
+/**
+ * A summary metric.
+ *
+ * <p>See:
+ * https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/datamodel.md#summary
+ */
+public interface SummaryData extends Data<SummaryPointData> {}

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/SummaryPointData.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.metrics.data;
+
+import java.util.List;
+
+/** A single data point that summarizes the values in a time series of numeric values. */
+public interface SummaryPointData extends PointData {
+  /**
+   * The number of values that are being summarized.
+   *
+   * @return the number of values that are being summarized.
+   */
+  long getCount();
+
+  /**
+   * The sum of all the values that are being summarized.
+   *
+   * @return the sum of the values that are being summarized.
+   */
+  double getSum();
+
+  /**
+   * Percentile values in the summarization. Note: a percentile 0.0 represents the minimum value in
+   * the distribution.
+   *
+   * @return the percentiles values.
+   */
+  List<ValueAtPercentile> getPercentileValues();
+}

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ValueAtPercentile.java

@@ -5,29 +5,19 @@
 
 package io.opentelemetry.sdk.metrics.data;
 
-import com.google.auto.value.AutoValue;
+/** A value within a summary. */
-import javax.annotation.concurrent.Immutable;
+public interface ValueAtPercentile {
-
-@Immutable
-@AutoValue
-public abstract class ValueAtPercentile {
-  public static ValueAtPercentile create(double percentile, double value) {
-    return new AutoValue_ValueAtPercentile(percentile, value);
-  }
-
-  ValueAtPercentile() {}
-
   /**
    * The percentile of a distribution. Must be in the interval [0.0, 100.0].
    *
    * @return the percentile.
    */
-  public abstract double getPercentile();
+  double getPercentile();
 
   /**
    * The value at the given percentile of a distribution.
    *
    * @return the value at the percentile.
    */
-  public abstract double getValue();
+  double getValue();
 }

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableSummaryData.java

@@ -3,9 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.sdk.metrics.data;
+package io.opentelemetry.sdk.metrics.internal.data;
 
 import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.metrics.data.SummaryData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
 import java.util.Collection;
 import java.util.Collections;
 import javax.annotation.concurrent.Immutable;
@@ -21,19 +23,24 @@ import javax.annotation.concurrent.Immutable;
  *
  * <p>Summary is considered a legacy metric type, and shouldn't be produced (by default) from
  * instruments.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time
  */
 @Immutable
 @AutoValue
-public abstract class DoubleSummaryData implements Data<DoubleSummaryPointData> {
+public abstract class ImmutableSummaryData implements SummaryData {
 
-  static final DoubleSummaryData EMPTY = DoubleSummaryData.create(Collections.emptyList());
+  private static final ImmutableSummaryData EMPTY =
+      ImmutableSummaryData.create(Collections.emptyList());
 
-  DoubleSummaryData() {}
+  public static ImmutableSummaryData empty() {
-
+    return EMPTY;
-  public static DoubleSummaryData create(Collection<DoubleSummaryPointData> points) {
-    return new AutoValue_DoubleSummaryData(points);
   }
 
-  @Override
+  ImmutableSummaryData() {}
-  public abstract Collection<DoubleSummaryPointData> getPoints();
+
+  public static ImmutableSummaryData create(Collection<SummaryPointData> points) {
+    return new AutoValue_ImmutableSummaryData(points);
+  }
 }

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableSummaryPointData.java

@@ -3,23 +3,27 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.sdk.metrics.data;
+package io.opentelemetry.sdk.metrics.internal.data;
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
+import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
 import java.util.Collections;
 import java.util.List;
 import javax.annotation.concurrent.Immutable;
 
 /**
- * SummaryPoint is a single data point that summarizes the values in a time series of numeric
+ * A single data point that summarizes the values in a time series of numeric values.
- * values.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time
  */
 @Immutable
 @AutoValue
-public abstract class DoubleSummaryPointData implements PointData {
+public abstract class ImmutableSummaryPointData implements SummaryPointData {
   /**
-   * Creates a {@link DoubleSummaryPointData}.
+   * Creates a {@link SummaryPointData}.
    *
    * @param startEpochNanos (optional) The starting time for the period where this point was
    *     sampled.
@@ -29,14 +33,14 @@ public abstract class DoubleSummaryPointData implements PointData {
    * @param sum The sum of measuremnts being sumarized.
    * @param percentileValues Calculations of percentile values from measurements.
    */
-  public static DoubleSummaryPointData create(
+  public static ImmutableSummaryPointData create(
       long startEpochNanos,
       long epochNanos,
       Attributes attributes,
       long count,
       double sum,
       List<ValueAtPercentile> percentileValues) {
-    return new AutoValue_DoubleSummaryPointData(
+    return new AutoValue_ImmutableSummaryPointData(
         startEpochNanos,
         epochNanos,
         attributes,
@@ -46,27 +50,5 @@ public abstract class DoubleSummaryPointData implements PointData {
         percentileValues);
   }
 
-  DoubleSummaryPointData() {}
+  ImmutableSummaryPointData() {}
-
-  /**
-   * The number of values that are being summarized.
-   *
-   * @return the number of values that are being summarized.
-   */
-  public abstract long getCount();
-
-  /**
-   * The sum of all the values that are being summarized.
-   *
-   * @return the sum of the values that are being summarized.
-   */
-  public abstract double getSum();
-
-  /**
-   * Percentile values in the summarization. Note: a percentile 0.0 represents the minimum value in
-   * the distribution.
-   *
-   * @return the percentiles values.
-   */
-  public abstract List<ValueAtPercentile> getPercentileValues();
 }

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableValueAtPercentile.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.metrics.internal.data;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * A summary metric value.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time
+ */
+@Immutable
+@AutoValue
+public abstract class ImmutableValueAtPercentile implements ValueAtPercentile {
+  public static ValueAtPercentile create(double percentile, double value) {
+    return new AutoValue_ImmutableValueAtPercentile(percentile, value);
+  }
+
+  ImmutableValueAtPercentile() {}
+}

sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java

@@ -16,6 +16,9 @@ import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
+import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.Arrays;
 import java.util.Collections;
@@ -30,24 +33,24 @@ class MetricDataImplTest {
   private static final double DOUBLE_VALUE = 1.234;
   private static final AttributeKey<String> KEY = AttributeKey.stringKey("key");
   private static final ValueAtPercentile MINIMUM_VALUE =
-      ValueAtPercentile.create(0.0, DOUBLE_VALUE);
+      ImmutableValueAtPercentile.create(0.0, DOUBLE_VALUE);
   private static final ValueAtPercentile MAXIMUM_VALUE =
-      ValueAtPercentile.create(100.0, DOUBLE_VALUE);
+      ImmutableValueAtPercentile.create(100.0, DOUBLE_VALUE);
   private static final LongPointData LONG_POINT =
       LongPointData.create(START_EPOCH_NANOS, EPOCH_NANOS, Attributes.of(KEY, "value"), LONG_VALUE);
   private static final DoublePointData DOUBLE_POINT =
       DoublePointData.create(
           START_EPOCH_NANOS, EPOCH_NANOS, Attributes.of(KEY, "value"), DOUBLE_VALUE);
-  private static final DoubleSummaryPointData SUMMARY_POINT =
+  private static final SummaryPointData SUMMARY_POINT =
-      DoubleSummaryPointData.create(
+      ImmutableSummaryPointData.create(
           START_EPOCH_NANOS,
           EPOCH_NANOS,
           Attributes.of(KEY, "value"),
           LONG_VALUE,
           DOUBLE_VALUE,
           Arrays.asList(
-              ValueAtPercentile.create(0.0, DOUBLE_VALUE),
+              ImmutableValueAtPercentile.create(0.0, DOUBLE_VALUE),
-              ValueAtPercentile.create(100, DOUBLE_VALUE)));
+              ImmutableValueAtPercentile.create(100, DOUBLE_VALUE)));
   private static final ImmutableHistogramPointData HISTOGRAM_POINT =
       ImmutableHistogramPointData.create(
           START_EPOCH_NANOS,
@@ -158,8 +161,8 @@ class MetricDataImplTest {
             "metric_name",
             "metric_description",
             "ms",
-            DoubleSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
+            ImmutableSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
-    assertThat(metricData.getDoubleSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
+    assertThat(metricData.getSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
   }
 
   @Test
@@ -220,13 +223,13 @@ class MetricDataImplTest {
             "metric_name",
             "metric_description",
             "ms",
-            DoubleSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
+            ImmutableSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
     assertThat(metricData.getDoubleGaugeData().getPoints()).isEmpty();
     assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
     assertThat(metricData.getDoubleSumData().getPoints()).isEmpty();
     assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
+    assertThat(metricData.getSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
     assertThat(metricData.getHistogramData().getPoints()).isEmpty();
-    assertThat(metricData.getDoubleSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
 
     metricData =
         MetricData.createDoubleGauge(
@@ -240,7 +243,7 @@ class MetricDataImplTest {
     assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
     assertThat(metricData.getDoubleSumData().getPoints()).isEmpty();
     assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
+    assertThat(metricData.getSummaryData().getPoints()).isEmpty();
     assertThat(metricData.getHistogramData().getPoints()).isEmpty();
-    assertThat(metricData.getDoubleSummaryData().getPoints()).isEmpty();
   }
 }