From 4d828e1a3195e55365c865aa3a78af9668742643 Mon Sep 17 00:00:00 2001
From: Ivan Topolnjak <ivantopo@gmail.com>
Date: Mon, 24 Apr 2017 13:54:40 +0200
Subject: Prepare for the major cleanup

Moved all the original files from src/main to src/legacy-main, same with test files. Also
removed the autoweave module, examples and bench as I'm planning to have them in separate
repositories.
---
 .../scala/kamon/metric/instrument/Counter.scala    |  65 ++++
 .../scala/kamon/metric/instrument/Gauge.scala      | 120 ++++++++
 .../scala/kamon/metric/instrument/Histogram.scala  | 331 +++++++++++++++++++++
 .../scala/kamon/metric/instrument/Instrument.scala |  51 ++++
 .../metric/instrument/InstrumentFactory.scala      |  51 ++++
 .../metric/instrument/InstrumentSettings.scala     |  73 +++++
 .../kamon/metric/instrument/MinMaxCounter.scala    | 105 +++++++
 .../instrument/ModifiedAtomicHistogram.scala       |  31 ++
 .../kamon/metric/instrument/RefreshScheduler.scala | 115 +++++++
 .../metric/instrument/UnitOfMeasurement.scala      | 109 +++++++
 10 files changed, 1051 insertions(+)
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/Counter.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/Gauge.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/Histogram.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/Instrument.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentFactory.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentSettings.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/MinMaxCounter.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/RefreshScheduler.scala
 create mode 100644 kamon-core/src/legacy-main/scala/kamon/metric/instrument/UnitOfMeasurement.scala

(limited to 'kamon-core/src/legacy-main/scala/kamon/metric/instrument')

diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Counter.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Counter.scala
new file mode 100644
index 00000000..b7ab60de
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Counter.scala
@@ -0,0 +1,65 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2014 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import kamon.jsr166.LongAdder
+
+trait Counter extends Instrument {
+  type SnapshotType = Counter.Snapshot
+
+  def increment(): Unit
+  def increment(times: Long): Unit
+}
+
+object Counter {
+
+  def apply(): Counter = new LongAdderCounter
+  def create(): Counter = apply()
+
+  trait Snapshot extends InstrumentSnapshot {
+    def count: Long
+    def merge(that: InstrumentSnapshot, context: CollectionContext): Counter.Snapshot
+    def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Counter.Snapshot
+  }
+}
+
+class LongAdderCounter extends Counter {
+  private val counter = new LongAdder
+
+  def increment(): Unit = counter.increment()
+
+  def increment(times: Long): Unit = {
+    if (times < 0)
+      throw new UnsupportedOperationException("Counters cannot be decremented")
+    counter.add(times)
+  }
+
+  def collect(context: CollectionContext): Counter.Snapshot = CounterSnapshot(counter.sumAndReset())
+
+  def cleanup: Unit = {}
+}
+
+case class CounterSnapshot(count: Long) extends Counter.Snapshot {
+  def merge(that: InstrumentSnapshot, context: CollectionContext): Counter.Snapshot = that match {
+    case CounterSnapshot(thatCount) ⇒ CounterSnapshot(count + thatCount)
+    case other                      ⇒ sys.error(s"Cannot merge a CounterSnapshot with the incompatible [${other.getClass.getName}] type.")
+  }
+
+  override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Counter.Snapshot =
+    CounterSnapshot(from.tryScale(to)(count).toLong)
+
+}
\ No newline at end of file
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Gauge.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Gauge.scala
new file mode 100644
index 00000000..39571d3d
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Gauge.scala
@@ -0,0 +1,120 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2015 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import java.util.concurrent.atomic.{AtomicLong, AtomicLongFieldUpdater, AtomicReference}
+
+import akka.actor.Cancellable
+import kamon.metric.instrument.Gauge.CurrentValueCollector
+import kamon.metric.instrument.Histogram.DynamicRange
+
+import scala.concurrent.duration.FiniteDuration
+
+trait Gauge extends Instrument {
+  type SnapshotType = Histogram.Snapshot
+
+  def record(value: Long): Unit
+  def record(value: Long, count: Long): Unit
+  def refreshValue(): Unit
+}
+
+object Gauge {
+
+  def apply(dynamicRange: DynamicRange, refreshInterval: FiniteDuration, scheduler: RefreshScheduler, valueCollector: CurrentValueCollector): Gauge = {
+    val underlyingHistogram = Histogram(dynamicRange)
+    val gauge = new HistogramBackedGauge(underlyingHistogram, valueCollector)
+    val refreshValuesSchedule = scheduler.schedule(refreshInterval, () ⇒ {
+      gauge.refreshValue()
+    })
+
+    gauge.automaticValueCollectorSchedule.set(refreshValuesSchedule)
+    gauge
+  }
+
+  def create(dynamicRange: DynamicRange, refreshInterval: FiniteDuration, scheduler: RefreshScheduler, valueCollector: CurrentValueCollector): Gauge =
+    apply(dynamicRange, refreshInterval, scheduler, valueCollector)
+
+  trait CurrentValueCollector {
+    def currentValue: Long
+  }
+
+  implicit def functionZeroAsCurrentValueCollector(f: () ⇒ Long): CurrentValueCollector = new CurrentValueCollector {
+    def currentValue: Long = f.apply()
+  }
+
+  implicit def callByNameLongAsCurrentValueCollector(f: ⇒ Long): CurrentValueCollector = new CurrentValueCollector {
+    def currentValue: Long = f
+  }
+}
+
+/**
+ *  Helper for cases in which a gauge shouldn't store the current value of a observed value but the difference between
+ *  the current observed value and the previously observed value. Should only be used if the observed value is always
+ *  increasing or staying steady, but is never able to decrease.
+ *
+ *  Note: The first time a value is collected, this wrapper will always return zero, afterwards, the difference between
+ *        the current value and the last value will be returned.
+ */
+class DifferentialValueCollector(wrappedValueCollector: CurrentValueCollector) extends CurrentValueCollector {
+  @volatile private var _readAtLeastOnce = false
+  private val _lastObservedValue = new AtomicLong(0)
+
+  def currentValue: Long = {
+    if (_readAtLeastOnce) {
+      val wrappedCurrent = wrappedValueCollector.currentValue
+      val diff = wrappedCurrent - _lastObservedValue.getAndSet(wrappedCurrent)
+
+      if (diff >= 0) diff else 0L
+
+    } else {
+      _lastObservedValue.set(wrappedValueCollector.currentValue)
+      _readAtLeastOnce = true
+      0L
+    }
+
+  }
+}
+
+object DifferentialValueCollector {
+  def apply(wrappedValueCollector: CurrentValueCollector): CurrentValueCollector =
+    new DifferentialValueCollector(wrappedValueCollector)
+
+  def apply(wrappedValueCollector: ⇒ Long): CurrentValueCollector =
+    new DifferentialValueCollector(new CurrentValueCollector {
+      def currentValue: Long = wrappedValueCollector
+    })
+}
+
+class HistogramBackedGauge(underlyingHistogram: Histogram, currentValueCollector: Gauge.CurrentValueCollector) extends Gauge {
+  private[kamon] val automaticValueCollectorSchedule = new AtomicReference[Cancellable]()
+
+  def record(value: Long): Unit = underlyingHistogram.record(value)
+
+  def record(value: Long, count: Long): Unit = underlyingHistogram.record(value, count)
+
+  def collect(context: CollectionContext): Histogram.Snapshot = underlyingHistogram.collect(context)
+
+  def cleanup: Unit = {
+    if (automaticValueCollectorSchedule.get() != null)
+      automaticValueCollectorSchedule.get().cancel()
+  }
+
+  def refreshValue(): Unit =
+    underlyingHistogram.record(currentValueCollector.currentValue)
+
+}
+
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Histogram.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Histogram.scala
new file mode 100644
index 00000000..399f0880
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Histogram.scala
@@ -0,0 +1,331 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import java.nio.LongBuffer
+
+import kamon.metric.instrument.Histogram.{DynamicRange, Snapshot}
+import kamon.util.logger.LazyLogger
+import org.HdrHistogram.ModifiedAtomicHistogram
+
+trait Histogram extends Instrument {
+  type SnapshotType = Histogram.Snapshot
+
+  def record(value: Long): Unit
+  def record(value: Long, count: Long): Unit
+}
+
+object Histogram {
+
+  /**
+   *  Scala API:
+   *
+   *  Create a new High Dynamic Range Histogram ([[kamon.metric.instrument.HdrHistogram]]) using the given
+   *  [[kamon.metric.instrument.Histogram.DynamicRange]].
+   */
+  def apply(dynamicRange: DynamicRange): Histogram = new HdrHistogram(dynamicRange)
+
+  /**
+   *  Java API:
+   *
+   *  Create a new High Dynamic Range Histogram ([[kamon.metric.instrument.HdrHistogram]]) using the given
+   *  [[kamon.metric.instrument.Histogram.DynamicRange]].
+   */
+  def create(dynamicRange: DynamicRange): Histogram = apply(dynamicRange)
+
+  /**
+   *  DynamicRange is a configuration object used to supply range and precision configuration to a
+   *  [[kamon.metric.instrument.HdrHistogram]]. See the [[http://hdrhistogram.github.io/HdrHistogram/ HdrHistogram website]]
+   *  for more details on how it works and the effects of these configuration values.
+   *
+   * @param lowestDiscernibleValue
+   *    The lowest value that can be discerned (distinguished from 0) by the histogram.Must be a positive integer that
+   *    is >= 1. May be internally rounded down to nearest power of 2.
+   * @param highestTrackableValue
+   *    The highest value to be tracked by the histogram. Must be a positive integer that is >= (2 * lowestDiscernibleValue).
+   *    Must not be larger than (Long.MAX_VALUE/2).
+   * @param precision
+   *    The number of significant decimal digits to which the histogram will maintain value resolution and separation.
+   *    Must be a non-negative integer between 1 and 3.
+   */
+  case class DynamicRange(lowestDiscernibleValue: Long, highestTrackableValue: Long, precision: Int)
+
+  trait Record {
+    def level: Long
+    def count: Long
+
+    private[kamon] def rawCompactRecord: Long
+  }
+
+  case class MutableRecord(var level: Long, var count: Long) extends Record {
+    var rawCompactRecord: Long = 0L
+  }
+
+  trait Snapshot extends InstrumentSnapshot {
+
+    def isEmpty: Boolean = numberOfMeasurements == 0
+    def numberOfMeasurements: Long
+    def min: Long
+    def max: Long
+    def sum: Long
+    def percentile(percentile: Double): Long
+    def recordsIterator: Iterator[Record]
+    def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot
+    def merge(that: Histogram.Snapshot, context: CollectionContext): Histogram.Snapshot
+
+    override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot =
+      new ScaledSnapshot(from, to, this)
+  }
+
+  class ScaledSnapshot(from: UnitOfMeasurement, to: UnitOfMeasurement, snapshot: Snapshot) extends Snapshot {
+    private def doScale(v: Long) = from.tryScale(to)(v).toLong
+    override def numberOfMeasurements: Long = snapshot.numberOfMeasurements
+
+    override def max: Long = doScale(snapshot.max)
+
+    override def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot = snapshot.merge(that, context)
+
+    override def merge(that: Snapshot, context: CollectionContext): Snapshot = snapshot.merge(that, context)
+
+    override def percentile(percentile: Double): Long = doScale(snapshot.percentile(percentile))
+
+    override def min: Long = doScale(snapshot.min)
+
+    override def sum: Long = doScale(snapshot.sum)
+
+    override def recordsIterator: Iterator[Record] = {
+      snapshot.recordsIterator.map(record ⇒ new Record {
+        override def count: Long = record.count
+
+        override def level: Long = doScale(record.level)
+
+        override private[kamon] def rawCompactRecord: Long = record.rawCompactRecord
+      })
+    }
+
+    override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot =
+      if (this.from == from && this.to == to) this else super.scale(from, to)
+  }
+
+  object Snapshot {
+    val empty = new Snapshot {
+      override def min: Long = 0L
+      override def max: Long = 0L
+      override def sum: Long = 0L
+      override def percentile(percentile: Double): Long = 0L
+      override def recordsIterator: Iterator[Record] = Iterator.empty
+      override def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot = that
+      override def merge(that: Histogram.Snapshot, context: CollectionContext): Histogram.Snapshot = that
+      override def numberOfMeasurements: Long = 0L
+      override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot = this
+    }
+  }
+}
+
+object HdrHistogram {
+  private val log = LazyLogger(classOf[HdrHistogram])
+}
+
+/**
+ *  This implementation is meant to be used for real time data collection where data snapshots are taken often over time.
+ *  The collect(..) operation extracts all the recorded values from the histogram and resets the counts, but still
+ *  leave it in a consistent state even in the case of concurrent modification while the snapshot is being taken.
+ */
+class HdrHistogram(dynamicRange: DynamicRange) extends ModifiedAtomicHistogram(
+  dynamicRange.lowestDiscernibleValue,
+  dynamicRange.highestTrackableValue, dynamicRange.precision
+) with Histogram {
+  import HdrHistogram.log
+
+  def record(value: Long): Unit = tryRecord(value, 1L)
+
+  def record(value: Long, count: Long): Unit = tryRecord(value, count)
+
+  private def tryRecord(value: Long, count: Long): Unit = {
+    try {
+      recordValueWithCount(value, count)
+    } catch {
+      case anyException: Throwable ⇒
+        log.warn(s"Failed to store value $value in HdrHistogram, please review your range configuration.", anyException)
+    }
+  }
+
+  def collect(context: CollectionContext): Histogram.Snapshot = {
+    import context.buffer
+    buffer.clear()
+    val nrOfMeasurements = writeSnapshotTo(buffer)
+
+    buffer.flip()
+
+    val measurementsArray = Array.ofDim[Long](buffer.limit())
+    buffer.get(measurementsArray, 0, measurementsArray.length)
+    new CompactHdrSnapshot(nrOfMeasurements, measurementsArray, protectedUnitMagnitude(), protectedSubBucketHalfCount(), protectedSubBucketHalfCountMagnitude())
+  }
+
+  def getCounts = countsArray().length()
+
+  def cleanup: Unit = {}
+
+  private def writeSnapshotTo(buffer: LongBuffer): Long = {
+    val counts = countsArray()
+    val countsLength = counts.length()
+
+    var nrOfMeasurements = 0L
+    var index = 0L
+    while (index < countsLength) {
+      val countAtIndex = counts.getAndSet(index.toInt, 0L)
+
+      if (countAtIndex > 0) {
+        buffer.put(CompactHdrSnapshot.compactRecord(index, countAtIndex))
+        nrOfMeasurements += countAtIndex
+      }
+
+      index += 1
+    }
+    nrOfMeasurements
+  }
+}
+
+case class CompactHdrSnapshot(numberOfMeasurements: Long, compactRecords: Array[Long], unitMagnitude: Int,
+    subBucketHalfCount: Int, subBucketHalfCountMagnitude: Int) extends Histogram.Snapshot {
+
+  def min: Long = if (compactRecords.length == 0) 0 else levelFromCompactRecord(compactRecords(0))
+  def max: Long = if (compactRecords.length == 0) 0 else levelFromCompactRecord(compactRecords(compactRecords.length - 1))
+  def sum: Long = recordsIterator.foldLeft(0L)((a, r) ⇒ a + (r.count * r.level))
+
+  def percentile(p: Double): Long = {
+    val records = recordsIterator
+    val threshold = numberOfMeasurements * (p / 100D)
+    var countToCurrentLevel = 0L
+    var percentileLevel = 0L
+
+    while (countToCurrentLevel < threshold && records.hasNext) {
+      val record = records.next()
+      countToCurrentLevel += record.count
+      percentileLevel = record.level
+    }
+
+    percentileLevel
+  }
+
+  def merge(that: Histogram.Snapshot, context: CollectionContext): Snapshot =
+    merge(that.asInstanceOf[InstrumentSnapshot], context)
+
+  def merge(that: InstrumentSnapshot, context: CollectionContext): Histogram.Snapshot = that match {
+    case thatSnapshot: CompactHdrSnapshot ⇒
+      if (thatSnapshot.isEmpty) this else if (this.isEmpty) thatSnapshot else {
+        import context.buffer
+        buffer.clear()
+
+        val selfIterator = recordsIterator
+        val thatIterator = thatSnapshot.recordsIterator
+        var thatCurrentRecord: Histogram.Record = null
+        var mergedNumberOfMeasurements = 0L
+
+        def nextOrNull(iterator: Iterator[Histogram.Record]): Histogram.Record = if (iterator.hasNext) iterator.next() else null
+        def addToBuffer(compactRecord: Long): Unit = {
+          mergedNumberOfMeasurements += countFromCompactRecord(compactRecord)
+          buffer.put(compactRecord)
+        }
+
+        while (selfIterator.hasNext) {
+          val selfCurrentRecord = selfIterator.next()
+
+          // Advance that to no further than the level of selfCurrentRecord
+          thatCurrentRecord = if (thatCurrentRecord == null) nextOrNull(thatIterator) else thatCurrentRecord
+          while (thatCurrentRecord != null && thatCurrentRecord.level < selfCurrentRecord.level) {
+            addToBuffer(thatCurrentRecord.rawCompactRecord)
+            thatCurrentRecord = nextOrNull(thatIterator)
+          }
+
+          // Include the current record of self and optionally merge if has the same level as thatCurrentRecord
+          if (thatCurrentRecord != null && thatCurrentRecord.level == selfCurrentRecord.level) {
+            addToBuffer(mergeCompactRecords(thatCurrentRecord.rawCompactRecord, selfCurrentRecord.rawCompactRecord))
+            thatCurrentRecord = nextOrNull(thatIterator)
+          } else {
+            addToBuffer(selfCurrentRecord.rawCompactRecord)
+          }
+        }
+
+        // Include everything that might have been left from that
+        if (thatCurrentRecord != null) addToBuffer(thatCurrentRecord.rawCompactRecord)
+        while (thatIterator.hasNext) {
+          addToBuffer(thatIterator.next().rawCompactRecord)
+        }
+
+        buffer.flip()
+        val compactRecords = Array.ofDim[Long](buffer.limit())
+        buffer.get(compactRecords)
+
+        new CompactHdrSnapshot(mergedNumberOfMeasurements, compactRecords, unitMagnitude, subBucketHalfCount, subBucketHalfCountMagnitude)
+      }
+
+    case other ⇒
+      sys.error(s"Cannot merge a CompactHdrSnapshot with the incompatible [${other.getClass.getName}] type.")
+
+  }
+
+  @inline private def mergeCompactRecords(left: Long, right: Long): Long = {
+    val index = left >> 48
+    val leftCount = countFromCompactRecord(left)
+    val rightCount = countFromCompactRecord(right)
+
+    CompactHdrSnapshot.compactRecord(index, leftCount + rightCount)
+  }
+
+  @inline private def levelFromCompactRecord(compactRecord: Long): Long = {
+    val countsArrayIndex = (compactRecord >> 48).toInt
+    var bucketIndex: Int = (countsArrayIndex >> subBucketHalfCountMagnitude) - 1
+    var subBucketIndex: Int = (countsArrayIndex & (subBucketHalfCount - 1)) + subBucketHalfCount
+    if (bucketIndex < 0) {
+      subBucketIndex -= subBucketHalfCount
+      bucketIndex = 0
+    }
+
+    subBucketIndex.toLong << (bucketIndex + unitMagnitude)
+  }
+
+  @inline private def countFromCompactRecord(compactRecord: Long): Long =
+    compactRecord & CompactHdrSnapshot.CompactRecordCountMask
+
+  def recordsIterator: Iterator[Histogram.Record] = new Iterator[Histogram.Record] {
+    var currentIndex = 0
+    val mutableRecord = Histogram.MutableRecord(0, 0)
+
+    override def hasNext: Boolean = currentIndex < compactRecords.length
+
+    override def next(): Histogram.Record = {
+      if (hasNext) {
+        val measurement = compactRecords(currentIndex)
+        mutableRecord.rawCompactRecord = measurement
+        mutableRecord.level = levelFromCompactRecord(measurement)
+        mutableRecord.count = countFromCompactRecord(measurement)
+        currentIndex += 1
+
+        mutableRecord
+      } else {
+        throw new IllegalStateException("The iterator has already been consumed.")
+      }
+    }
+  }
+}
+
+object CompactHdrSnapshot {
+  val CompactRecordCountMask = 0xFFFFFFFFFFFFL
+
+  def compactRecord(index: Long, count: Long): Long = (index << 48) | count
+}
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Instrument.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Instrument.scala
new file mode 100644
index 00000000..2c4b4319
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/Instrument.scala
@@ -0,0 +1,51 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2015 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import java.nio.LongBuffer
+
+private[kamon] trait Instrument {
+  type SnapshotType <: InstrumentSnapshot
+
+  def collect(context: CollectionContext): SnapshotType
+  def cleanup: Unit
+}
+
+trait InstrumentSnapshot {
+  def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot
+
+  def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): InstrumentSnapshot
+}
+
+trait CollectionContext {
+  def buffer: LongBuffer
+}
+
+object CollectionContext {
+  def apply(longBufferSize: Int): CollectionContext = new CollectionContext {
+    val buffer: LongBuffer = LongBuffer.allocate(longBufferSize)
+  }
+}
+
+sealed trait InstrumentType
+
+object InstrumentTypes {
+  case object Histogram extends InstrumentType
+  case object MinMaxCounter extends InstrumentType
+  case object Gauge extends InstrumentType
+  case object Counter extends InstrumentType
+}
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentFactory.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentFactory.scala
new file mode 100644
index 00000000..7c0201f7
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentFactory.scala
@@ -0,0 +1,51 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2015 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import kamon.metric.instrument.Gauge.CurrentValueCollector
+import kamon.metric.instrument.Histogram.DynamicRange
+
+import scala.concurrent.duration.FiniteDuration
+
+case class InstrumentFactory(configurations: Map[String, InstrumentCustomSettings], defaults: DefaultInstrumentSettings, scheduler: RefreshScheduler) {
+
+  private def resolveSettings(instrumentName: String, codeSettings: Option[InstrumentSettings], default: InstrumentSettings): InstrumentSettings = {
+    configurations.get(instrumentName).flatMap { customSettings ⇒
+      codeSettings.map(cs ⇒ customSettings.combine(cs)) orElse (Some(customSettings.combine(default)))
+
+    } getOrElse (codeSettings.getOrElse(default))
+  }
+
+  def createHistogram(name: String, dynamicRange: Option[DynamicRange] = None): Histogram = {
+    val settings = resolveSettings(name, dynamicRange.map(dr ⇒ InstrumentSettings(dr, None)), defaults.histogram)
+    Histogram(settings.dynamicRange)
+  }
+
+  def createMinMaxCounter(name: String, dynamicRange: Option[DynamicRange] = None, refreshInterval: Option[FiniteDuration] = None): MinMaxCounter = {
+    val settings = resolveSettings(name, dynamicRange.map(dr ⇒ InstrumentSettings(dr, refreshInterval)), defaults.minMaxCounter)
+    MinMaxCounter(settings.dynamicRange, settings.refreshInterval.get, scheduler)
+  }
+
+  def createGauge(name: String, dynamicRange: Option[DynamicRange] = None, refreshInterval: Option[FiniteDuration] = None,
+    valueCollector: CurrentValueCollector): Gauge = {
+
+    val settings = resolveSettings(name, dynamicRange.map(dr ⇒ InstrumentSettings(dr, refreshInterval)), defaults.gauge)
+    Gauge(settings.dynamicRange, settings.refreshInterval.get, scheduler, valueCollector)
+  }
+
+  def createCounter(): Counter = Counter()
+}
\ No newline at end of file
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentSettings.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentSettings.scala
new file mode 100644
index 00000000..e4d6f547
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/InstrumentSettings.scala
@@ -0,0 +1,73 @@
+package kamon.metric.instrument
+
+import com.typesafe.config.Config
+import kamon.metric.instrument.Histogram.DynamicRange
+
+import scala.concurrent.duration.FiniteDuration
+
+case class InstrumentCustomSettings(lowestDiscernibleValue: Option[Long], highestTrackableValue: Option[Long],
+    precision: Option[Int], refreshInterval: Option[FiniteDuration]) {
+
+  def combine(that: InstrumentSettings): InstrumentSettings =
+    InstrumentSettings(
+      DynamicRange(
+        lowestDiscernibleValue.getOrElse(that.dynamicRange.lowestDiscernibleValue),
+        highestTrackableValue.getOrElse(that.dynamicRange.highestTrackableValue),
+        precision.getOrElse(that.dynamicRange.precision)
+      ),
+      refreshInterval.orElse(that.refreshInterval)
+    )
+}
+
+object InstrumentCustomSettings {
+  import kamon.util.ConfigTools.Syntax
+
+  def fromConfig(config: Config): InstrumentCustomSettings =
+    InstrumentCustomSettings(
+      if (config.hasPath("lowest-discernible-value")) Some(config.getLong("lowest-discernible-value")) else None,
+      if (config.hasPath("highest-trackable-value")) Some(config.getLong("highest-trackable-value")) else None,
+      if (config.hasPath("precision")) Some(InstrumentSettings.parsePrecision(config.getString("precision"))) else None,
+      if (config.hasPath("refresh-interval")) Some(config.getFiniteDuration("refresh-interval")) else None
+    )
+
+}
+
+case class InstrumentSettings(dynamicRange: DynamicRange, refreshInterval: Option[FiniteDuration])
+
+object InstrumentSettings {
+
+  def readDynamicRange(config: Config): DynamicRange =
+    DynamicRange(
+      config.getLong("lowest-discernible-value"),
+      config.getLong("highest-trackable-value"),
+      parsePrecision(config.getString("precision"))
+    )
+
+  def parsePrecision(stringValue: String): Int = stringValue match {
+    case "low"    ⇒ 1
+    case "normal" ⇒ 2
+    case "fine"   ⇒ 3
+    case other    ⇒ sys.error(s"Invalid precision configuration [$other] found, valid options are: [low|normal|fine].")
+  }
+}
+
+case class DefaultInstrumentSettings(histogram: InstrumentSettings, minMaxCounter: InstrumentSettings, gauge: InstrumentSettings)
+
+object DefaultInstrumentSettings {
+
+  def fromConfig(config: Config): DefaultInstrumentSettings = {
+    import kamon.util.ConfigTools.Syntax
+
+    val histogramSettings = InstrumentSettings(InstrumentSettings.readDynamicRange(config.getConfig("histogram")), None)
+    val minMaxCounterSettings = InstrumentSettings(
+      InstrumentSettings.readDynamicRange(config.getConfig("min-max-counter")),
+      Some(config.getFiniteDuration("min-max-counter.refresh-interval"))
+    )
+    val gaugeSettings = InstrumentSettings(
+      InstrumentSettings.readDynamicRange(config.getConfig("gauge")),
+      Some(config.getFiniteDuration("gauge.refresh-interval"))
+    )
+
+    DefaultInstrumentSettings(histogramSettings, minMaxCounterSettings, gaugeSettings)
+  }
+}
\ No newline at end of file
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/MinMaxCounter.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/MinMaxCounter.scala
new file mode 100644
index 00000000..76fc2c2a
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/MinMaxCounter.scala
@@ -0,0 +1,105 @@
+package kamon.metric.instrument
+
+/*
+ * =========================================================================================
+ * Copyright © 2013-2014 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+import java.lang.Math.abs
+import java.util.concurrent.atomic.AtomicReference
+import akka.actor.Cancellable
+import kamon.jsr166.LongMaxUpdater
+import kamon.metric.instrument.Histogram.DynamicRange
+import kamon.util.PaddedAtomicLong
+import scala.concurrent.duration.FiniteDuration
+
+trait MinMaxCounter extends Instrument {
+  override type SnapshotType = Histogram.Snapshot
+
+  def increment(): Unit
+  def increment(times: Long): Unit
+  def decrement(): Unit
+  def decrement(times: Long): Unit
+  def refreshValues(): Unit
+}
+
+object MinMaxCounter {
+
+  def apply(dynamicRange: DynamicRange, refreshInterval: FiniteDuration, scheduler: RefreshScheduler): MinMaxCounter = {
+    val underlyingHistogram = Histogram(dynamicRange)
+    val minMaxCounter = new PaddedMinMaxCounter(underlyingHistogram)
+    val refreshValuesSchedule = scheduler.schedule(refreshInterval, () ⇒ {
+      minMaxCounter.refreshValues()
+    })
+
+    minMaxCounter.refreshValuesSchedule.set(refreshValuesSchedule)
+    minMaxCounter
+  }
+
+  def create(dynamicRange: DynamicRange, refreshInterval: FiniteDuration, scheduler: RefreshScheduler): MinMaxCounter =
+    apply(dynamicRange, refreshInterval, scheduler)
+
+}
+
+class PaddedMinMaxCounter(underlyingHistogram: Histogram) extends MinMaxCounter {
+  private val min = new LongMaxUpdater(0L)
+  private val max = new LongMaxUpdater(0L)
+  private val sum = new PaddedAtomicLong
+  val refreshValuesSchedule = new AtomicReference[Cancellable]()
+
+  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 collect(context: CollectionContext): Histogram.Snapshot = {
+    refreshValues()
+    underlyingHistogram.collect(context)
+  }
+
+  def cleanup: Unit = {
+    if (refreshValuesSchedule.get() != null)
+      refreshValuesSchedule.get().cancel()
+  }
+
+  def refreshValues(): 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)
+  }
+}
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala
new file mode 100644
index 00000000..eb01d114
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala
@@ -0,0 +1,31 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2014 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package org.HdrHistogram
+
+import java.util.concurrent.atomic.AtomicLongArray
+
+abstract class ModifiedAtomicHistogram(low: Long, high: Long, precision: Int)
+    extends AtomicHistogram(low, high, precision) { self ⇒
+
+  override def incrementTotalCount(): Unit = {}
+  override def addToTotalCount(value: Long): Unit = {}
+
+  def countsArray(): AtomicLongArray = counts
+  def protectedUnitMagnitude(): Int = unitMagnitude
+  def protectedSubBucketHalfCount(): Int = subBucketHalfCount
+  def protectedSubBucketHalfCountMagnitude(): Int = subBucketHalfCountMagnitude
+}
\ No newline at end of file
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/RefreshScheduler.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/RefreshScheduler.scala
new file mode 100644
index 00000000..6bc02dc3
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/RefreshScheduler.scala
@@ -0,0 +1,115 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2015 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+import akka.actor.{Scheduler, Cancellable}
+import org.HdrHistogram.WriterReaderPhaser
+
+import scala.collection.concurrent.TrieMap
+import scala.concurrent.ExecutionContext
+import scala.concurrent.duration.FiniteDuration
+
+trait RefreshScheduler {
+  def schedule(interval: FiniteDuration, refresh: () ⇒ Unit): Cancellable
+}
+
+/**
+ *  Default implementation of RefreshScheduler that simply uses an [[akka.actor.Scheduler]] to schedule tasks to be run
+ *  in the provided ExecutionContext.
+ */
+class DefaultRefreshScheduler(scheduler: Scheduler, dispatcher: ExecutionContext) extends RefreshScheduler {
+  def schedule(interval: FiniteDuration, refresh: () ⇒ Unit): Cancellable =
+    scheduler.schedule(interval, interval)(refresh.apply())(dispatcher)
+}
+
+object DefaultRefreshScheduler {
+  def apply(scheduler: Scheduler, dispatcher: ExecutionContext): RefreshScheduler =
+    new DefaultRefreshScheduler(scheduler, dispatcher)
+
+  def create(scheduler: Scheduler, dispatcher: ExecutionContext): RefreshScheduler =
+    apply(scheduler, dispatcher)
+}
+
+/**
+ *  RefreshScheduler implementation that accumulates all the scheduled actions until it is pointed to another refresh
+ *  scheduler. Once it is pointed, all subsequent calls to `schedule` will immediately be scheduled in the pointed
+ *  scheduler.
+ */
+class LazyRefreshScheduler extends RefreshScheduler {
+  private val _schedulerPhaser = new WriterReaderPhaser
+  private val _backlog = new TrieMap[(FiniteDuration, () ⇒ Unit), RepointableCancellable]()
+  @volatile private var _target: Option[RefreshScheduler] = None
+
+  def schedule(interval: FiniteDuration, refresh: () ⇒ Unit): Cancellable = {
+    val criticalEnter = _schedulerPhaser.writerCriticalSectionEnter()
+    try {
+      _target.map { scheduler ⇒
+        scheduler.schedule(interval, refresh)
+
+      } getOrElse {
+        val entry = (interval, refresh)
+        val cancellable = new RepointableCancellable(entry)
+
+        _backlog.put(entry, cancellable)
+        cancellable
+      }
+
+    } finally {
+      _schedulerPhaser.writerCriticalSectionExit(criticalEnter)
+    }
+  }
+
+  def point(target: RefreshScheduler): Unit = try {
+    _schedulerPhaser.readerLock()
+
+    if (_target.isEmpty) {
+      _target = Some(target)
+      _schedulerPhaser.flipPhase(10000L)
+      _backlog.dropWhile {
+        case ((interval, refresh), repointableCancellable) ⇒
+          repointableCancellable.point(target.schedule(interval, refresh))
+          true
+      }
+    } else sys.error("A LazyRefreshScheduler cannot be pointed more than once.")
+  } finally { _schedulerPhaser.readerUnlock() }
+
+  class RepointableCancellable(entry: (FiniteDuration, () ⇒ Unit)) extends Cancellable {
+    private var _isCancelled = false
+    private var _cancellable: Option[Cancellable] = None
+
+    def isCancelled: Boolean = synchronized {
+      _cancellable.map(_.isCancelled).getOrElse(_isCancelled)
+    }
+
+    def cancel(): Boolean = synchronized {
+      _isCancelled = true
+      _cancellable.map(_.cancel()).getOrElse(_backlog.remove(entry).nonEmpty)
+    }
+
+    def point(cancellable: Cancellable): Unit = synchronized {
+      if (_cancellable.isEmpty) {
+        _cancellable = Some(cancellable)
+
+        if (_isCancelled)
+          cancellable.cancel()
+
+      } else sys.error("A RepointableCancellable cannot be pointed more than once.")
+
+    }
+  }
+}
+
diff --git a/kamon-core/src/legacy-main/scala/kamon/metric/instrument/UnitOfMeasurement.scala b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/UnitOfMeasurement.scala
new file mode 100644
index 00000000..5952b906
--- /dev/null
+++ b/kamon-core/src/legacy-main/scala/kamon/metric/instrument/UnitOfMeasurement.scala
@@ -0,0 +1,109 @@
+/*
+ * =========================================================================================
+ * Copyright © 2013-2015 the kamon project <http://kamon.io/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ * =========================================================================================
+ */
+
+package kamon.metric.instrument
+
+/**
+ *  A UnitOfMeasurement implementation describes the magnitude of a quantity being measured, such as Time and computer
+ *  Memory space. Kamon uses UnitOfMeasurement implementations just as a informative companion to metrics inside entity
+ *  recorders and might be used to scale certain kinds of measurements in metric backends.
+ */
+trait UnitOfMeasurement {
+  type U <: UnitOfMeasurement
+
+  def name: String
+  def label: String
+  def scale(toUnit: U)(value: Double): Double = value
+
+  def tryScale(toUnit: UnitOfMeasurement)(value: Double): Double =
+    if (canScale(toUnit)) scale(toUnit.asInstanceOf[U])(value)
+    else throw new IllegalArgumentException(s"Can't scale different types of units `$name` and `${toUnit.name}`")
+
+  protected def canScale(toUnit: UnitOfMeasurement): Boolean
+
+}
+
+object UnitOfMeasurement {
+  case object Unknown extends UnitOfMeasurement {
+    override type U = Unknown.type
+    val name = "unknown"
+    val label = "unknown"
+
+    override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isUnknown(toUnit)
+  }
+
+  def isUnknown(uom: UnitOfMeasurement): Boolean =
+    uom == Unknown
+
+  def isTime(uom: UnitOfMeasurement): Boolean =
+    uom.isInstanceOf[Time]
+
+  def isMemory(uom: UnitOfMeasurement): Boolean =
+    uom.isInstanceOf[Memory]
+
+}
+
+/**
+ *  UnitOfMeasurement representing time.
+ */
+case class Time(factor: Double, label: String) extends UnitOfMeasurement {
+  override type U = Time
+  val name = "time"
+
+  override def scale(toUnit: Time)(value: Double): Double =
+    (value * factor) / toUnit.factor
+
+  override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isTime(toUnit)
+}
+
+object Time {
+  val Nanoseconds = Time(1E-9, "n")
+  val Microseconds = Time(1E-6, "µs")
+  val Milliseconds = Time(1E-3, "ms")
+  val Seconds = Time(1, "s")
+
+  val units = List(Nanoseconds, Microseconds, Milliseconds, Seconds)
+
+  def apply(time: String): Time = units.find(_.label.toLowerCase == time.toLowerCase) getOrElse {
+    throw new IllegalArgumentException(s"Can't recognize time unit '$time'")
+  }
+}
+
+/**
+ *  UnitOfMeasurement representing computer memory space.
+ */
+case class Memory(factor: Double, label: String) extends UnitOfMeasurement {
+  override type U = Memory
+  val name = "bytes"
+
+  override def scale(toUnit: Memory)(value: Double): Double =
+    (value * factor) / toUnit.factor
+
+  override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isMemory(toUnit)
+}
+
+object Memory {
+  val Bytes = Memory(1, "b")
+  val KiloBytes = Memory(1024, "Kb")
+  val MegaBytes = Memory(1024 * 1024, "Mb")
+  val GigaBytes = Memory(1024 * 1024 * 1024, "Gb")
+
+  val units = List(Bytes, KiloBytes, MegaBytes, GigaBytes)
+
+  def apply(memory: String): Memory = units.find(_.label.toLowerCase == memory.toLowerCase) getOrElse {
+    throw new IllegalArgumentException(s"Can't recognize memory unit '$memory'")
+  }
+}
-- 
cgit v1.2.3