rename MinMaxCounter to RangeSampler

8 files changed, 52 insertions, 52 deletions

diff --git a/kamon-core/src/main/resources/reference.conf b/kamon-core/src/main/resources/reference.conf
index a779ad02..af767f60 100644
--- a/kamon-core/src/main/resources/reference.conf
+++ b/kamon-core/src/main/resources/reference.conf
@@ -18,7 +18,7 @@ kamon {
   # Example: `reporters = ["kamon.statsd.StatsD", "kamon.zipkin.Zipkin"]`.
   reporters = [ ]
 
-  # Pool size for the executor service that will run sampling on MinMaxCounter instruments. This scheduler is accesible
+  # Pool size for the executor service that will run sampling on RangeSampler instruments. This scheduler is accesible
   # through Kamon.scheduler()
   scheduler-pool-size = 2
 
@@ -36,7 +36,7 @@ kamon {
     optimistic-tick-alignment = yes
 
     # Thread pool size used by the metrics refresh scheduler. This pool is only used to periodically sampling
-    # min-max-counter values.
+    # range-sampler values.
     refresh-scheduler-pool-size = 2
 
     instrument-factory {
@@ -56,7 +56,7 @@ kamon {
           significant-value-digits = 2
         }
 
-        min-max-counter {
+        range-sampler {
           lowest-discernible-value = 1
           highest-trackable-value = 3600000000000
           significant-value-digits = 2
diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala
index 1a9dbe95..c9a2e415 100644
--- a/kamon-core/src/main/scala/kamon/Kamon.scala
+++ b/kamon-core/src/main/scala/kamon/Kamon.scala
@@ -83,9 +83,9 @@ object Kamon extends MetricLookup with ReporterRegistry with Tracer {
   override def gauge(name: String, unit: MeasurementUnit): GaugeMetric =
     _metrics.gauge(name, unit)
 
-  override def minMaxCounter(name: String, unit: MeasurementUnit, sampleInterval: Option[Duration],
-      dynamicRange: Option[DynamicRange]): MinMaxCounterMetric =
-    _metrics.minMaxCounter(name, unit, dynamicRange, sampleInterval)
+  override def rangeSampler(name: String, unit: MeasurementUnit, sampleInterval: Option[Duration],
+      dynamicRange: Option[DynamicRange]): RangeSamplerMetric =
+    _metrics.rangeSampler(name, unit, dynamicRange, sampleInterval)
 
   override def timer(name: String, dynamicRange: Option[DynamicRange]): TimerMetric =
     _metrics.timer(name, dynamicRange)
diff --git a/kamon-core/src/main/scala/kamon/metric/InstrumentFactory.scala b/kamon-core/src/main/scala/kamon/metric/InstrumentFactory.scala
index abab1207..7ae9b66c 100644
--- a/kamon-core/src/main/scala/kamon/metric/InstrumentFactory.scala
+++ b/kamon-core/src/main/scala/kamon/metric/InstrumentFactory.scala
@@ -24,19 +24,19 @@ import kamon.metric.InstrumentFactory.CustomInstrumentSettings
 import java.time.Duration
 
 
-private[kamon] class InstrumentFactory private (defaultHistogramDynamicRange: DynamicRange, defaultMMCounterDynamicRange: DynamicRange,
-    defaultMMCounterSampleInterval: Duration, customSettings: Map[String, CustomInstrumentSettings]) {
+private[kamon] class InstrumentFactory private (defaultHistogramDynamicRange: DynamicRange, defaultRangeSamplerDynamicRange: DynamicRange,
+    defaultRangeSamplerSampleInterval: Duration, customSettings: Map[String, CustomInstrumentSettings]) {
 
   def buildHistogram(dynamicRange: Option[DynamicRange])(name: String, tags: Map[String, String], unit: MeasurementUnit): AtomicHdrHistogram =
     new AtomicHdrHistogram(name, tags, unit, instrumentDynamicRange(name, dynamicRange.getOrElse(defaultHistogramDynamicRange)))
 
-  def buildMinMaxCounter(dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration])
-      (name: String, tags: Map[String, String], unit: MeasurementUnit): SimpleMinMaxCounter =
-    new SimpleMinMaxCounter(
+  def buildRangeSampler(dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration])
+      (name: String, tags: Map[String, String], unit: MeasurementUnit): SimpleRangeSampler =
+    new SimpleRangeSampler(
       name,
       tags,
-      buildHistogram(dynamicRange.orElse(Some(defaultMMCounterDynamicRange)))(name, tags, unit),
-      instrumentSampleInterval(name, sampleInterval.getOrElse(defaultMMCounterSampleInterval)))
+      buildHistogram(dynamicRange.orElse(Some(defaultRangeSamplerDynamicRange)))(name, tags, unit),
+      instrumentSampleInterval(name, sampleInterval.getOrElse(defaultRangeSamplerSampleInterval)))
 
   def buildGauge(name: String, tags: Map[String, String], unit: MeasurementUnit): AtomicLongGauge =
     new AtomicLongGauge(name, tags, unit)
@@ -68,24 +68,24 @@ object InstrumentFactory {
   case class InstrumentType(name: String)
 
   object InstrumentTypes {
-    val Histogram     = InstrumentType("Histogram")
-    val MinMaxCounter = InstrumentType("MinMaxCounter")
-    val Counter       = InstrumentType("Counter")
-    val Gauge         = InstrumentType("Gauge")
+    val Histogram    = InstrumentType("Histogram")
+    val RangeSampler = InstrumentType("RangeSampler")
+    val Counter      = InstrumentType("Counter")
+    val Gauge        = InstrumentType("Gauge")
   }
 
   def fromConfig(config: Config): InstrumentFactory = {
     val factoryConfig = config.getConfig("kamon.metric.instrument-factory")
     val histogramDynamicRange = readDynamicRange(factoryConfig.getConfig("default-settings.histogram"))
-    val mmCounterDynamicRange = readDynamicRange(factoryConfig.getConfig("default-settings.min-max-counter"))
-    val mmCounterSampleInterval = factoryConfig.getDuration("default-settings.min-max-counter.sample-interval")
+    val rangeSamplerDynamicRange = readDynamicRange(factoryConfig.getConfig("default-settings.range-sampler"))
+    val rangeSamplerSampleInterval = factoryConfig.getDuration("default-settings.range-sampler.sample-interval")
 
     val customSettings = factoryConfig.getConfig("custom-settings")
       .configurations
       .filter(nonEmptySection)
       .map(readCustomInstrumentSettings)
 
-    new InstrumentFactory(histogramDynamicRange, mmCounterDynamicRange, mmCounterSampleInterval, customSettings)
+    new InstrumentFactory(histogramDynamicRange, rangeSamplerDynamicRange, rangeSamplerSampleInterval, customSettings)
   }
 
   private def nonEmptySection(entry: (String, Config)): Boolean = entry match {
diff --git a/kamon-core/src/main/scala/kamon/metric/Metric.scala b/kamon-core/src/main/scala/kamon/metric/Metric.scala
index db5ff9c0..f63e3d07 100644
--- a/kamon-core/src/main/scala/kamon/metric/Metric.scala
+++ b/kamon-core/src/main/scala/kamon/metric/Metric.scala
@@ -46,7 +46,7 @@ trait Metric[T] {
 
 trait HistogramMetric extends Metric[Histogram] with Histogram
 trait TimerMetric extends Metric[Timer] with Timer
-trait MinMaxCounterMetric extends Metric[MinMaxCounter] with MinMaxCounter
+trait RangeSamplerMetric extends Metric[RangeSampler] with RangeSampler
 trait GaugeMetric extends Metric[Gauge] with Gauge
 trait CounterMetric extends Metric[Counter] with Counter
 
@@ -110,11 +110,11 @@ private[kamon] final class HistogramMetricImpl(val name: String, val unit: Measu
     instrument.asInstanceOf[AtomicHdrHistogram].snapshot(resetState = true)
 }
 
-private[kamon] final class MinMaxCounterMetricImpl(val name: String, val unit: MeasurementUnit, customDynamicRange: Option[DynamicRange],
+private[kamon] final class RangeSamplerMetricImpl(val name: String, val unit: MeasurementUnit, customDynamicRange: Option[DynamicRange],
     customSampleInterval: Option[Duration], factory: AtomicReference[InstrumentFactory], scheduler: ScheduledExecutorService)
-    extends BaseMetric[MinMaxCounter, MetricDistribution](MinMaxCounter) with MinMaxCounterMetric {
+    extends BaseMetric[RangeSampler, MetricDistribution](RangeSampler) with RangeSamplerMetric {
 
-  private val logger = LoggerFactory.getLogger(classOf[MinMaxCounterMetric])
+  private val logger = LoggerFactory.getLogger(classOf[RangeSamplerMetric])
   private val scheduledSamplers = TrieMap.empty[Tags, ScheduledFuture[_]]
 
   def dynamicRange: DynamicRange =
@@ -138,13 +138,13 @@ private[kamon] final class MinMaxCounterMetricImpl(val name: String, val unit: M
   override def sample(): Unit =
     baseInstrument.sample()
 
-  override protected def createInstrument(tags: Tags): MinMaxCounter = {
-    val mmCounter = factory.get().buildMinMaxCounter(customDynamicRange, customSampleInterval)(name, tags, unit)
-    val sampleInterval = mmCounter.sampleInterval.toMillis
-    val scheduledFuture = scheduler.scheduleAtFixedRate(scheduledSampler(mmCounter), sampleInterval, sampleInterval, TimeUnit.MILLISECONDS)
+  override protected def createInstrument(tags: Tags): RangeSampler = {
+    val rangeSampler = factory.get().buildRangeSampler(customDynamicRange, customSampleInterval)(name, tags, unit)
+    val sampleInterval = rangeSampler.sampleInterval.toMillis
+    val scheduledFuture = scheduler.scheduleAtFixedRate(scheduledSampler(rangeSampler), sampleInterval, sampleInterval, TimeUnit.MILLISECONDS)
     scheduledSamplers.put(tags, scheduledFuture)
 
-    mmCounter
+    rangeSampler
   }
 
   override def remove(tags: JTags): Boolean =
@@ -163,17 +163,17 @@ private[kamon] final class MinMaxCounterMetricImpl(val name: String, val unit: M
     val removed = super.remove(tags)
     if(removed)
       scheduledSamplers.get(tags).foreach(sf => {
-        Try(sf.cancel(false)).failed.foreach(_ => logger.error("Failed to cancel scheduled sampling for MinMaxCounter []", tags.prettyPrint()))
+        Try(sf.cancel(false)).failed.foreach(_ => logger.error("Failed to cancel scheduled sampling for RangeSampler []", tags.prettyPrint()))
       })
     removed
   }
 
-  override protected def createSnapshot(instrument: MinMaxCounter): MetricDistribution =
-    instrument.asInstanceOf[SimpleMinMaxCounter].snapshot(resetState = true)
+  override protected def createSnapshot(instrument: RangeSampler): MetricDistribution =
+    instrument.asInstanceOf[SimpleRangeSampler].snapshot(resetState = true)
 
 
-  private def scheduledSampler(mmCounter: MinMaxCounter): Runnable = new Runnable {
-    override def run(): Unit = mmCounter.sample()
+  private def scheduledSampler(rangeSampler: RangeSampler): Runnable = new Runnable {
+    override def run(): Unit = rangeSampler.sample()
   }
 }
 
diff --git a/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala b/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala
index fcca04bd..c8984015 100644
--- a/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala
+++ b/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala
@@ -45,17 +45,17 @@ trait MetricLookup {
     gauge(name, MeasurementUnit.none)
 
 
-  def minMaxCounter(name: String): MinMaxCounterMetric =
-    minMaxCounter(name, MeasurementUnit.none, None, None)
+  def rangeSampler(name: String): RangeSamplerMetric =
+    rangeSampler(name, MeasurementUnit.none, None, None)
 
-  def minMaxCounter(name: String, unit: MeasurementUnit): MinMaxCounterMetric =
-    minMaxCounter(name, unit, None, None)
+  def rangeSampler(name: String, unit: MeasurementUnit): RangeSamplerMetric =
+    rangeSampler(name, unit, None, None)
 
-  def minMaxCounter(name: String, unit: MeasurementUnit, sampleInterval: Duration): MinMaxCounterMetric =
-    minMaxCounter(name, unit, Option(sampleInterval), None)
+  def rangeSampler(name: String, unit: MeasurementUnit, sampleInterval: Duration): RangeSamplerMetric =
+    rangeSampler(name, unit, Option(sampleInterval), None)
 
-  def minMaxCounter(name: String, unit: MeasurementUnit, sampleInterval: Duration, dynamicRange: DynamicRange): MinMaxCounterMetric =
-    minMaxCounter(name, unit, Option(sampleInterval), Option(dynamicRange))
+  def rangeSampler(name: String, unit: MeasurementUnit, sampleInterval: Duration, dynamicRange: DynamicRange): RangeSamplerMetric =
+    rangeSampler(name, unit, Option(sampleInterval), Option(dynamicRange))
 
 
   def histogram(name: String, unit: MeasurementUnit, dynamicRange: Option[DynamicRange]): HistogramMetric
@@ -66,5 +66,5 @@ trait MetricLookup {
 
   def gauge(name: String, unit: MeasurementUnit): GaugeMetric
 
-  def minMaxCounter(name: String, unit: MeasurementUnit, sampleInterval: Option[Duration], dynamicRange: Option[DynamicRange]): MinMaxCounterMetric
+  def rangeSampler(name: String, unit: MeasurementUnit, sampleInterval: Option[Duration], dynamicRange: Option[DynamicRange]): RangeSamplerMetric
 }
diff --git a/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala b/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala
index ebc17834..cc111d95 100644
--- a/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala
+++ b/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala
@@ -50,8 +50,8 @@ class MetricRegistry(initialConfig: Config, scheduler: ScheduledExecutorService)
   def gauge(name: String, unit: MeasurementUnit): GaugeMetric =
     lookupMetric(name, unit, InstrumentTypes.Gauge)(new GaugeMetricImpl(name, unit, instrumentFactory))
 
-  def minMaxCounter(name: String, unit: MeasurementUnit, dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration]): MinMaxCounterMetric =
-    lookupMetric(name, unit, InstrumentTypes.MinMaxCounter)(new MinMaxCounterMetricImpl(name, unit, dynamicRange, sampleInterval, instrumentFactory, scheduler))
+  def rangeSampler(name: String, unit: MeasurementUnit, dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration]): RangeSamplerMetric =
+    lookupMetric(name, unit, InstrumentTypes.RangeSampler)(new RangeSamplerMetricImpl(name, unit, dynamicRange, sampleInterval, instrumentFactory, scheduler))
 
   def timer(name: String, dynamicRange: Option[DynamicRange]): TimerMetric =
     new TimerMetricImpl(histogram(name, time.nanoseconds, dynamicRange))
@@ -59,21 +59,21 @@ class MetricRegistry(initialConfig: Config, scheduler: ScheduledExecutorService)
 
   override def snapshot(): MetricsSnapshot = synchronized {
     var histograms = Seq.empty[MetricDistribution]
-    var mmCounters = Seq.empty[MetricDistribution]
+    var rangeSamplers = Seq.empty[MetricDistribution]
     var counters = Seq.empty[MetricValue]
     var gauges = Seq.empty[MetricValue]
 
     for(metricEntry <- metrics.values) {
       metricEntry.instrumentType match {
         case InstrumentTypes.Histogram     => histograms = histograms ++ metricEntry.snapshot().asInstanceOf[Seq[MetricDistribution]]
-        case InstrumentTypes.MinMaxCounter => mmCounters = mmCounters ++ metricEntry.snapshot().asInstanceOf[Seq[MetricDistribution]]
+        case InstrumentTypes.RangeSampler => rangeSamplers = rangeSamplers ++ metricEntry.snapshot().asInstanceOf[Seq[MetricDistribution]]
         case InstrumentTypes.Gauge         => gauges = gauges ++ metricEntry.snapshot().asInstanceOf[Seq[MetricValue]]
         case InstrumentTypes.Counter       => counters = counters ++ metricEntry.snapshot().asInstanceOf[Seq[MetricValue]]
         case other                        => logger.warn("Unexpected instrument type [{}] found in the registry", other )
       }
     }
 
-    MetricsSnapshot(histograms, mmCounters, gauges, counters)
+    MetricsSnapshot(histograms, rangeSamplers, gauges, counters)
   }
 
   private def lookupMetric[T <: BaseMetric[_, _]](name: String, unit: MeasurementUnit, instrumentType: InstrumentType)(metricBuilder: => T): T = {
diff --git a/kamon-core/src/main/scala/kamon/metric/MinMaxCounter.scala b/kamon-core/src/main/scala/kamon/metric/RangeSampler.scala
index cdcf3ee9..2adecf45 100644
--- a/kamon-core/src/main/scala/kamon/metric/MinMaxCounter.scala
+++ b/kamon-core/src/main/scala/kamon/metric/RangeSampler.scala
@@ -19,7 +19,7 @@ import java.lang.Math.abs
 import java.time.Duration
 import java.util.concurrent.atomic.AtomicLong
 
-trait MinMaxCounter {
+trait RangeSampler {
   def unit: MeasurementUnit
   def dynamicRange: DynamicRange
   def sampleInterval: Duration
@@ -31,8 +31,8 @@ trait MinMaxCounter {
   def sample(): Unit
 }
 
-class SimpleMinMaxCounter(name: String, tags: Map[String, String], underlyingHistogram: AtomicHdrHistogram,
-    val sampleInterval: Duration) extends MinMaxCounter {
+class SimpleRangeSampler(name: String, tags: Map[String, String], underlyingHistogram: AtomicHdrHistogram,
+    val sampleInterval: Duration) extends RangeSampler {
 
   private val min = AtomicLongMaxUpdater()
   private val max = AtomicLongMaxUpdater()
diff --git a/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala
index 83176d4f..45666de1 100644
--- a/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala
+++ b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala
@@ -28,7 +28,7 @@ case class Interval(from: Long, to: Long)
 
 case class MetricsSnapshot(
   histograms: Seq[MetricDistribution],
-  minMaxCounters: Seq[MetricDistribution],
+  rangeSamplers: Seq[MetricDistribution],
   gauges: Seq[MetricValue],
   counters: Seq[MetricValue]
 )