implement MinMaxCounter and Gauge, include them in the InstrumentFactory

6 files changed, 105 insertions, 31 deletions

diff --git a/kamon-core/src/main/scala/kamon/metric/snapshot/EntitySnapshot.scala b/kamon-core/src/main/scala/kamon/metric/EntitySnapshot.scala
index 41fde2c0..e51e80cc 100644
--- a/kamon-core/src/main/scala/kamon/metric/snapshot/EntitySnapshot.scala
+++ b/kamon-core/src/main/scala/kamon/metric/EntitySnapshot.scala
@@ -1,6 +1,5 @@
-package kamon.metric.snapshot
+package kamon.metric
 
-import kamon.metric.Entity
 import kamon.metric.instrument.{DistributionSnapshot, SingleValueSnapshot}
 
 trait EntitySnapshot {
diff --git a/kamon-core/src/main/scala/kamon/metric/snapshot/TickSnapshot.scala b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala
index a1bdd6b1..4248180c 100644
--- a/kamon-core/src/main/scala/kamon/metric/snapshot/TickSnapshot.scala
+++ b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala
@@ -1,4 +1,4 @@
-package kamon.metric.snapshot
+package kamon.metric
 
 import java.time.Instant
 
diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/Gauge.scala b/kamon-core/src/main/scala/kamon/metric/instrument/Gauge.scala
index bb31e30a..5263d258 100644
--- a/kamon-core/src/main/scala/kamon/metric/instrument/Gauge.scala
+++ b/kamon-core/src/main/scala/kamon/metric/instrument/Gauge.scala
@@ -1,5 +1,7 @@
 package kamon.metric.instrument
 
+import java.util.concurrent.atomic.AtomicLong
+
 import kamon.metric.Entity
 import kamon.util.MeasurementUnit
 
@@ -13,6 +15,27 @@ trait Gauge {
   def set(value: Long): Unit
 }
 
-object Gauge {
-  def apply(entity: Entity, name: String): Gauge = ???
+
+class AtomicLongGauge(entity: Entity, name: String, val measurementUnit: MeasurementUnit)
+  extends Gauge with SingleValueSnapshotInstrument  {
+
+  private val currentValue = new AtomicLong(0L)
+
+  def increment(): Unit =
+    currentValue.incrementAndGet()
+
+  def increment(times: Long): Unit =
+    currentValue.addAndGet(times)
+
+  def decrement(): Unit =
+    currentValue.decrementAndGet()
+
+  def decrement(times: Long): Unit =
+    currentValue.addAndGet(-times)
+
+  def set(value: Long): Unit =
+    currentValue.set(value)
+
+  def snapshot(): SingleValueSnapshot =
+    SingleValueSnapshot(name, measurementUnit, currentValue.get())
 }
diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentFactory.scala b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentFactory.scala
index 1ccd5899..fb6dfe27 100644
--- a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentFactory.scala
+++ b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentFactory.scala
@@ -16,7 +16,7 @@ private[metric] class InstrumentFactory private (
     customSettings: Map[(String, String), CustomInstrumentSettings]) {
 
   def buildHistogram(entity: Entity, name: String, dynamicRange: DynamicRange = defaultHistogramDynamicRange,
-      measurementUnit: MeasurementUnit = MeasurementUnit.none): Histogram = {
+      measurementUnit: MeasurementUnit = MeasurementUnit.none): Histogram with DistributionSnapshotInstrument = {
 
     new HdrHistogram(
       entity,
@@ -29,16 +29,17 @@ private[metric] class InstrumentFactory private (
   def buildMinMaxCounter(entity: Entity, name: String, dynamicRange: DynamicRange = defaultMMCounterDynamicRange,
       sampleInterval: Duration = defaultMMCounterSampleRate, measurementUnit: MeasurementUnit = MeasurementUnit.none): MinMaxCounter = {
 
-    MinMaxCounter(
+    val underlyingHistogram = buildHistogram(entity, name, dynamicRange, measurementUnit)
+    new PaddedMinMaxCounter(
       entity,
       name,
-      instrumentDynamicRange(entity, name, dynamicRange),
+      underlyingHistogram,
       instrumentSampleInterval(entity, name, sampleInterval)
     )
   }
 
-  def buildGauge(entity: Entity, name: String, measurementUnit: MeasurementUnit = MeasurementUnit.none): Gauge =
-    Gauge(entity, name)
+  def buildGauge(entity: Entity, name: String, measurementUnit: MeasurementUnit = MeasurementUnit.none): Gauge with SingleValueSnapshotInstrument =
+    new AtomicLongGauge(entity, name, measurementUnit)
 
   def buildCounter(entity: Entity, name: String, measurementUnit: MeasurementUnit = MeasurementUnit.none): Counter with SingleValueSnapshotInstrument =
     new LongAdderCounter(entity, name, measurementUnit)
diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSnapshot.scala b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSnapshot.scala
index 58e10c54..ffb00080 100644
--- a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSnapshot.scala
+++ b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSnapshot.scala
@@ -2,21 +2,18 @@ package kamon.metric.instrument
 
 import kamon.util.MeasurementUnit
 
-
+/**
+  * Snapshot for instruments that internally track a single value. Meant to be used for counters and gauges.
+  *
+  */
 case class SingleValueSnapshot(name: String, measurementUnit: MeasurementUnit, value: Long)
 
+/**
+  * Snapshot for instruments that internally the distribution of values in a defined dynamic range. Meant to be used
+  * with histograms and min max counters.
+  */
 case class DistributionSnapshot(name: String, measurementUnit: MeasurementUnit, dynamicRange: DynamicRange, distribution: Distribution)
 
-trait DistributionSnapshotInstrument {
-  def snapshot(): DistributionSnapshot
-}
-
-trait SingleValueSnapshotInstrument {
-  def snapshot(): SingleValueSnapshot
-}
-
-
-
 
 trait Distribution {
   def buckets: Seq[Bucket]
@@ -42,3 +39,12 @@ trait Percentile {
   def value: Long
   def countUnderQuantile: Long
 }
+
+
+trait DistributionSnapshotInstrument {
+  private[kamon] def snapshot(): DistributionSnapshot
+}
+
+trait SingleValueSnapshotInstrument {
+  private[kamon] def snapshot(): SingleValueSnapshot
+}
diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/MinMaxCounter.scala b/kamon-core/src/main/scala/kamon/metric/instrument/MinMaxCounter.scala
index 8a43865f..cddd8ed9 100644
--- a/kamon-core/src/main/scala/kamon/metric/instrument/MinMaxCounter.scala
+++ b/kamon-core/src/main/scala/kamon/metric/instrument/MinMaxCounter.scala
@@ -1,7 +1,10 @@
 package kamon.metric.instrument
 
+import java.lang.Math.abs
 import java.time.Duration
+import java.util.concurrent.atomic.{AtomicLong, AtomicReference}
 
+import kamon.jsr166.LongMaxUpdater
 import kamon.metric.Entity
 import kamon.util.MeasurementUnit
 
@@ -14,18 +17,60 @@ trait MinMaxCounter {
   def increment(times: Long): Unit
   def decrement(): Unit
   def decrement(times: Long): Unit
+  def sample(): Unit
 }
 
-object MinMaxCounter {
-  def apply(entity: Entity, name: String, dynamicRange2: DynamicRange, sampleInterval2: Duration): MinMaxCounter = new MinMaxCounter {
 
-    override def measurementUnit: MeasurementUnit = ???
+class PaddedMinMaxCounter(entity: Entity, name: String, underlyingHistogram: Histogram with DistributionSnapshotInstrument,
+    val sampleInterval: Duration) extends MinMaxCounter with DistributionSnapshotInstrument {
 
-    override def sampleInterval: Duration = sampleInterval2
-    override def increment(): Unit = ???
-    override def increment(times: Long): Unit = ???
-    override def decrement(): Unit = ???
-    override def decrement(times: Long): Unit = ???
-    override def dynamicRange: DynamicRange = dynamicRange2
+  private val min = new LongMaxUpdater(0L)
+  private val max = new LongMaxUpdater(0L)
+  private val sum = new AtomicLong()
+
+  def dynamicRange: DynamicRange =
+    underlyingHistogram.dynamicRange
+
+  def measurementUnit: MeasurementUnit =
+    underlyingHistogram.measurementUnit
+
+  private[kamon] def snapshot(): DistributionSnapshot =
+    underlyingHistogram.snapshot()
+
+  def increment(): Unit =
+    increment(1L)
+
+  def increment(times: Long): Unit = {
+    val currentValue = sum.addAndGet(times)
+    max.update(currentValue)
   }
-}
+
+  def decrement(): Unit =
+    decrement(1L)
+
+  def decrement(times: Long): Unit = {
+    val currentValue = sum.addAndGet(-times)
+    min.update(-currentValue)
+  }
+
+  def sample(): Unit = {
+    val currentValue = {
+      val value = sum.get()
+      if (value <= 0) 0 else value
+    }
+
+    val currentMin = {
+      val rawMin = min.maxThenReset(-currentValue)
+      if (rawMin >= 0)
+        0
+      else
+        abs(rawMin)
+    }
+
+    val currentMax = max.maxThenReset(currentValue)
+
+    underlyingHistogram.record(currentValue)
+    underlyingHistogram.record(currentMin)
+    underlyingHistogram.record(currentMax)
+  }
+}
\ No newline at end of file