SDK metrics prototype

sdk-exporter/metrics/src/main/scala/org/typelevel/otel4s/sdk/exporter/otlp/metrics/MetricsProtoEncoder.scala

@@ -162,13 +162,67 @@ private object MetricsProtoEncoder {
         Proto.Gauge(gauge.points.toVector.map(ProtoEncoder.encode(_)))
       )
 
+    case summary: MetricPoints.Summary =>
+      Proto.Metric.Data.Summary(
+        Proto.Summary(
+          summary.points.toVector.map(p =>
+            Proto.SummaryDataPoint(
+              ProtoEncoder.encode(p.attributes),
+              p.timeWindow.start.toNanos,
+              p.timeWindow.end.toNanos,
+              p.count,
+              p.sum,
+              p.percentileValues.map { q =>
+                Proto.SummaryDataPoint
+                  .ValueAtQuantile(q.quantile, q.value)
+              }
+            )
+          )
+        )
+      )
+
     case histogram: MetricPoints.Histogram =>
       Proto.Metric.Data.Histogram(
         Proto.Histogram(
           histogram.points.toVector.map(ProtoEncoder.encode(_)),
           ProtoEncoder.encode(histogram.aggregationTemporality)
         )
       )
+
+    case exponentialHistogram: MetricPoints.ExponentialHistogram =>
+      Proto.Metric.Data.ExponentialHistogram(
+        Proto.ExponentialHistogram(
+          exponentialHistogram.points.toVector.map(p =>
+            Proto
+              .ExponentialHistogramDataPoint(
+                attributes = ProtoEncoder.encode(p.attributes),
+                startTimeUnixNano = p.timeWindow.start.toNanos,
+                timeUnixNano = p.timeWindow.end.toNanos,
+                count = p.count,
+                sum = Some(p.sum),
+                scale = 0, // todo scale
+                zeroCount = p.zeroCount,
+                positive = Some(
+                  Proto.ExponentialHistogramDataPoint.Buckets(
+                    p.positiveBuckets.offset,
+                    p.positiveBuckets.bucketCounts
+                  )
+                ),
+                negative = Some(
+                  Proto.ExponentialHistogramDataPoint.Buckets(
+                    p.negativeBuckets.offset,
+                    p.negativeBuckets.bucketCounts
+                  )
+                ),
+                exemplars = p.exemplars.map(ProtoEncoder.encode(_)),
+                min = p.min,
+                max = p.max,
+                // zeroThreshold = , // todo?
+              )
+          ),
+          ProtoEncoder.encode(exponentialHistogram.aggregationTemporality)
+        )
+      )
   }
 
   implicit val metricDataEncoder: ProtoEncoder[

sdk/metrics/src/main/scala/org/typelevel/otel4s/sdk/metrics/Aggregation.scala

@@ -93,6 +93,10 @@ object Aggregation {
     * Compatible instruments:
     *   - [[org.typelevel.otel4s.metrics.Counter Counter]]
     *   - [[org.typelevel.otel4s.metrics.Histogram Histogram]]
+    *
+    * @see
+    *   [[org.typelevel.otel4s.metrics.BucketBoundaries.default]] - default
+    *   bucket boundaries
     */
   def explicitBucketHistogram: Aggregation =
     ExplicitBucketHistogram(Defaults.Boundaries)
@@ -111,6 +115,37 @@ object Aggregation {
   def explicitBucketHistogram(boundaries: BucketBoundaries): Aggregation =
     ExplicitBucketHistogram(boundaries)
 
+  /** Aggregates measurements into a base-2
+    * [[org.typelevel.otel4s.sdk.metrics.data.MetricPoints.ExponentialHistogram MetricPoints.ExponentialHistogram]]
+    * using the default `maxBuckets` and `maxScale`.
+    *
+    * Compatible instruments:
+    *   - [[org.typelevel.otel4s.metrics.Counter Counter]]
+    *   - [[org.typelevel.otel4s.metrics.Histogram Histogram]]
+    */
+  def base2ExponentialBucketHistogram: Aggregation =
+    Base2ExponentialHistogram(160, 20) // todo: use const variables
+
+  /** Aggregates measurements into a base-2
+    * [[org.typelevel.otel4s.sdk.metrics.data.MetricPoints.ExponentialHistogram Data.ExponentialHistogram]]
+    * using the given `maxBuckets` and `maxScale`.
+    *
+    * Compatible instruments:
+    *   - [[org.typelevel.otel4s.metrics.Counter Counter]]
+    *   - [[org.typelevel.otel4s.metrics.Histogram Histogram]]
+    *
+    * @param maxBuckets
+    *   the max number of positive and negative buckets
+    *
+    * @param maxScale
+    *   the maximum and initial scale
+    */
+  def base2ExponentialBucketHistogram(
+      maxBuckets: Int,
+      maxScale: Int
+  ): Aggregation =
+    Base2ExponentialHistogram(maxBuckets, maxScale)
+
   implicit val aggregationHash: Hash[Aggregation] =
     Hash.fromUniversalHashCode
 
@@ -122,6 +157,8 @@ object Aggregation {
       case LastValue => "Aggregation.LastValue"
       case ExplicitBucketHistogram(boundaries) =>
         show"Aggregation.ExplicitBucketHistogram{boundaries=$boundaries}"
+      case Base2ExponentialHistogram(maxBuckets, maxScale) =>
+        show"Aggregation.Base2ExponentialHistogram{maxBuckets=$maxBuckets, maxScale=$maxScale}"
     }
 
   private[metrics] sealed trait Synchronous { self: Aggregation => }
@@ -149,6 +186,12 @@ object Aggregation {
   ) extends Aggregation(Compatability.ExplicitBucketHistogram)
       with Synchronous
 
+  private[metrics] final case class Base2ExponentialHistogram(
+      maxBuckets: Int,
+      maxScale: Int
+  ) extends Aggregation(Compatability.Base2ExponentialHistogram)
+      with Synchronous
+
   private object Compatability {
     val Drop: Set[InstrumentType] =
       InstrumentType.values
@@ -169,6 +212,9 @@ object Aggregation {
 
     val ExplicitBucketHistogram: Set[InstrumentType] =
       Set(InstrumentType.Counter, InstrumentType.Histogram)
+
+    val Base2ExponentialHistogram: Set[InstrumentType] =
+      Set(InstrumentType.Counter, InstrumentType.Histogram)
   }
 
 }

sdk/metrics/src/main/scala/org/typelevel/otel4s/sdk/metrics/aggregation/Aggregator.scala

@@ -246,6 +246,9 @@ private[metrics] object Aggregator {
 
       case Aggregation.ExplicitBucketHistogram(boundaries) =>
         histogram(boundaries)
+
+      case Aggregation.Base2ExponentialHistogram(_, _) =>
+        ???
     }
   }
 

sdk/metrics/src/main/scala/org/typelevel/otel4s/sdk/metrics/data/MetricPoints.scala

@@ -79,6 +79,10 @@ object MetricPoints {
     def points: NonEmptyVector[Point]
   }
 
+  sealed trait Summary extends MetricPoints {
+    def points: NonEmptyVector[PointData.Summary]
+  }
+
   /** Histogram represents the type of a metric that is calculated by
     * aggregating as a histogram of all reported double measurements over a time
     * interval.
@@ -94,6 +98,11 @@ object MetricPoints {
     def aggregationTemporality: AggregationTemporality
   }
 
+  sealed trait ExponentialHistogram extends MetricPoints {
+    def points: NonEmptyVector[PointData.ExponentialHistogram]
+    def aggregationTemporality: AggregationTemporality
+  }
+
   /** Creates a [[Sum]] with the given values.
     */
   def sum[A <: PointData.NumberPoint](
@@ -110,6 +119,11 @@ object MetricPoints {
   ): Gauge =
     GaugeImpl(points)
 
+  def summary(
+      points: NonEmptyVector[PointData.Summary]
+  ): Summary =
+    SummaryImpl(points)
+
   /** Creates a [[Histogram]] with the given values.
     */
   def histogram(
@@ -118,6 +132,12 @@ object MetricPoints {
   ): Histogram =
     HistogramImpl(points, aggregationTemporality)
 
+  def exponentialHistogram(
+      points: NonEmptyVector[PointData.ExponentialHistogram],
+      aggregationTemporality: AggregationTemporality
+  ): ExponentialHistogram =
+    ExponentialHistogramImpl(points, aggregationTemporality)
+
   implicit val metricPointsHash: Hash[MetricPoints] = {
     val sumHash: Hash[Sum] =
       Hash.by { s =>
@@ -187,9 +207,18 @@ object MetricPoints {
       points: NonEmptyVector[A]
   ) extends Gauge { type Point = A }
 
+  private final case class SummaryImpl(
+      points: NonEmptyVector[PointData.Summary]
+  ) extends Summary
+
   private final case class HistogramImpl(
       points: NonEmptyVector[PointData.Histogram],
       aggregationTemporality: AggregationTemporality
   ) extends Histogram
 
+  private final case class ExponentialHistogramImpl(
+      points: NonEmptyVector[PointData.ExponentialHistogram],
+      aggregationTemporality: AggregationTemporality
+  ) extends ExponentialHistogram
+
 }

sdk/metrics/src/main/scala/org/typelevel/otel4s/sdk/metrics/data/PointData.scala

@@ -172,6 +172,39 @@ object PointData {
 
   }
 
+  sealed trait Summary extends PointData {
+    def count: Long
+    def sum: Double
+    def percentileValues: Vector[Summary.ValueAtQuantile]
+  }
+
+  object Summary {
+    sealed trait ValueAtQuantile {
+      def quantile: Double
+      def value: Double
+    }
+  }
+
+  sealed trait ExponentialHistogram extends PointData {
+    def exemplars: Vector[ExemplarData.DoubleExemplar]
+    def sum: Double
+    def zeroCount: Long
+    def min: Option[Double]
+    def max: Option[Double]
+    val count: Long
+    def positiveBuckets: ExponentialHistogram.Buckets
+    def negativeBuckets: ExponentialHistogram.Buckets
+  }
+
+  object ExponentialHistogram {
+    sealed trait Buckets {
+      def scale: Int
+      def offset: Int
+      def bucketCounts: Vector[Long]
+      def totalCount: Long
+    }
+  }
+
   /** Creates a [[LongNumber]] with the given values.
     */
   def longNumber(
@@ -204,6 +237,44 @@ object PointData {
   ): Histogram =
     HistogramImpl(timeWindow, attributes, exemplars, stats, boundaries, counts)
 
+  def summary(
+      timeWindow: TimeWindow,
+      attributes: Attributes,
+      count: Long,
+      sum: Double,
+      percentileValues: Vector[Summary.ValueAtQuantile]
+  ): Summary =
+    SummaryImpl(
+      timeWindow,
+      attributes,
+      count,
+      sum,
+      percentileValues
+    )
+
+  def exponentialHistogram(
+      timeWindow: TimeWindow,
+      attributes: Attributes,
+      exemplars: Vector[ExemplarData.DoubleExemplar],
+      sum: Double,
+      zeroCount: Long,
+      min: Option[Double],
+      max: Option[Double],
+      positiveBuckets: ExponentialHistogram.Buckets,
+      negativeBuckets: ExponentialHistogram.Buckets
+  ): ExponentialHistogram =
+    ExponentialHistogramImpl(
+      timeWindow,
+      attributes,
+      exemplars,
+      sum,
+      zeroCount,
+      min,
+      max,
+      positiveBuckets,
+      negativeBuckets
+    )
+
   implicit val pointDataHash: Hash[PointData] = {
     val numberHash: Hash[NumberPoint] = {
       // a value can be either Long or Double. The universal hashcode is safe
@@ -298,4 +369,27 @@ object PointData {
       counts: Vector[Long]
   ) extends Histogram
 
+  private final case class SummaryImpl(
+      timeWindow: TimeWindow,
+      attributes: Attributes,
+      count: Long,
+      sum: Double,
+      percentileValues: Vector[Summary.ValueAtQuantile]
+  ) extends Summary
+
+  private final case class ExponentialHistogramImpl(
+      timeWindow: TimeWindow,
+      attributes: Attributes,
+      exemplars: Vector[ExemplarData.DoubleExemplar],
+      sum: Double,
+      zeroCount: Long,
+      min: Option[Double],
+      max: Option[Double],
+      positiveBuckets: ExponentialHistogram.Buckets,
+      negativeBuckets: ExponentialHistogram.Buckets
+  ) extends ExponentialHistogram {
+    val count: Long =
+      zeroCount + positiveBuckets.totalCount + negativeBuckets.totalCount
+  }
+
 }

sdk/metrics/src/main/scala/org/typelevel/otel4s/sdk/metrics/internal/Advice.scala

@@ -19,6 +19,7 @@ package org.typelevel.otel4s.sdk.metrics.internal
 import cats.Hash
 import cats.Show
 import cats.syntax.foldable._
+import org.typelevel.otel4s.AttributeKey
 import org.typelevel.otel4s.metrics.BucketBoundaries
 
 /** Advisory options influencing aggregation configuration parameters.
@@ -33,6 +34,10 @@ private[metrics] sealed trait Advice {
     */
   def explicitBucketBoundaries: Option[BucketBoundaries]
 
+  /** The list of the attribute keys to be used for the resulting instrument.
+   */
+  def attributeKeys: Option[Set[AttributeKey[_]]]
+
   override final def hashCode(): Int =
     Hash[Advice].hash(this)
 
@@ -55,20 +60,26 @@ private[metrics] object Advice {
     *   aggregation is `explicit bucket histogram`
     */
   def apply(bucketBoundaries: Option[BucketBoundaries]): Advice =
-    Impl(bucketBoundaries)
+    Impl(bucketBoundaries, None)
 
   implicit val adviceHash: Hash[Advice] =
-    Hash.by(_.explicitBucketBoundaries)
+    Hash.by(a => (a.explicitBucketBoundaries, a.attributeKeys))
 
   implicit val adviceShow: Show[Advice] =
     Show.show { advice =>
-      val boundaries = advice.explicitBucketBoundaries.foldMap { b =>
+      val boundaries = advice.explicitBucketBoundaries.map { b =>
         s"explicitBucketBoundaries=$b"
       }
-      s"Advice{$boundaries}"
+
+      val attributeKeys = advice.attributeKeys.map { k =>
+        s"attributeKeys=${k.mkString("[", ",", "]")}"
+      }
+
+      Vector(attributeKeys, boundaries).flatten.mkString("Advice{", ", ", "}")
     }
 
   private final case class Impl(
-      explicitBucketBoundaries: Option[BucketBoundaries]
+      explicitBucketBoundaries: Option[BucketBoundaries],
+      attributeKeys: Option[Set[AttributeKey[_]]]
   ) extends Advice
 }