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.

5 files changed, 553 insertions, 0 deletions

diff --git a/kamon-core/src/legacy-test/scala/kamon/metric/instrument/CounterSpec.scala b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/CounterSpec.scala
new file mode 100644
index 00000000..d5d651e5
--- /dev/null
+++ b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/CounterSpec.scala
@@ -0,0 +1,79 @@
+/*
+ * =========================================================================================
+ * 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
+
+import org.scalatest.{Matchers, WordSpec}
+
+class CounterSpec extends WordSpec with Matchers {
+
+  "a Counter" should {
+    "allow increment only operations" in new CounterFixture {
+      counter.increment()
+      counter.increment(10)
+
+      intercept[UnsupportedOperationException] {
+        counter.increment(-10)
+      }
+    }
+
+    "reset to zero when a snapshot is taken" in new CounterFixture {
+      counter.increment(100)
+      takeSnapshotFrom(counter).count should be(100)
+      takeSnapshotFrom(counter).count should be(0)
+      takeSnapshotFrom(counter).count should be(0)
+
+      counter.increment(50)
+      takeSnapshotFrom(counter).count should be(50)
+      takeSnapshotFrom(counter).count should be(0)
+    }
+
+    "produce a snapshot that can be merged with others" in new CounterFixture {
+      val counterA = Counter()
+      val counterB = Counter()
+      counterA.increment(100)
+      counterB.increment(200)
+
+      val counterASnapshot = takeSnapshotFrom(counterA)
+      val counterBSnapshot = takeSnapshotFrom(counterB)
+
+      counterASnapshot.merge(counterBSnapshot, collectionContext).count should be(300)
+      counterBSnapshot.merge(counterASnapshot, collectionContext).count should be(300)
+    }
+
+    "produce a snapshot that can be scaled" in new CounterFixture {
+      counter.increment(100)
+
+      val counterSnapshot = takeSnapshotFrom(counter)
+
+      val scaledSnapshot = counterSnapshot.scale(Time.Milliseconds, Time.Microseconds)
+      scaledSnapshot.count should be(100000)
+    }
+
+  }
+
+  trait CounterFixture {
+    val counter = Counter()
+
+    val collectionContext = new CollectionContext {
+      val buffer: LongBuffer = LongBuffer.allocate(1)
+    }
+
+    def takeSnapshotFrom(counter: Counter): Counter.Snapshot = counter.collect(collectionContext)
+  }
+}
diff --git a/kamon-core/src/legacy-test/scala/kamon/metric/instrument/GaugeSpec.scala b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/GaugeSpec.scala
new file mode 100644
index 00000000..ec07d66c
--- /dev/null
+++ b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/GaugeSpec.scala
@@ -0,0 +1,79 @@
+/*
+ * =========================================================================================
+ * 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
+import kamon.Kamon
+import kamon.metric.instrument.Histogram.DynamicRange
+import kamon.testkit.BaseKamonSpec
+import scala.concurrent.duration._
+
+class GaugeSpec extends BaseKamonSpec("gauge-spec") {
+
+  "a Gauge" should {
+    "automatically record the current value using the configured refresh-interval" in new GaugeFixture {
+      val (numberOfValuesRecorded, gauge) = createGauge()
+      Thread.sleep(1.second.toMillis)
+
+      numberOfValuesRecorded.get() should be(10L +- 1L)
+      gauge.cleanup
+    }
+
+    "stop automatically recording after a call to cleanup" in new GaugeFixture {
+      val (numberOfValuesRecorded, gauge) = createGauge()
+      Thread.sleep(1.second.toMillis)
+
+      gauge.cleanup
+      numberOfValuesRecorded.get() should be(10L +- 1L)
+      Thread.sleep(1.second.toMillis)
+
+      numberOfValuesRecorded.get() should be(10L +- 1L)
+    }
+
+    "produce a Histogram snapshot including all the recorded values" in new GaugeFixture {
+      val (numberOfValuesRecorded, gauge) = createGauge()
+
+      Thread.sleep(1.second.toMillis)
+      gauge.cleanup
+      val snapshot = gauge.collect(Kamon.metrics.buildDefaultCollectionContext)
+
+      snapshot.numberOfMeasurements should be(10L +- 1L)
+      snapshot.min should be(1)
+      snapshot.max should be(10L +- 1L)
+    }
+
+    "not record the current value when doing a collection" in new GaugeFixture {
+      val (numberOfValuesRecorded, gauge) = createGauge(10 seconds)
+
+      val snapshot = gauge.collect(Kamon.metrics.buildDefaultCollectionContext)
+      snapshot.numberOfMeasurements should be(0)
+      numberOfValuesRecorded.get() should be(0)
+    }
+  }
+
+  trait GaugeFixture {
+    def createGauge(refreshInterval: FiniteDuration = 100 millis): (AtomicLong, Gauge) = {
+      val recordedValuesCounter = new AtomicLong(0)
+      val gauge = Gauge(DynamicRange(1, 100, 2), refreshInterval, Kamon.metrics.settings.refreshScheduler, {
+        () ⇒ recordedValuesCounter.addAndGet(1)
+      })
+
+      (recordedValuesCounter, gauge)
+    }
+
+  }
+}
diff --git a/kamon-core/src/legacy-test/scala/kamon/metric/instrument/HistogramSpec.scala b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/HistogramSpec.scala
new file mode 100644
index 00000000..9551c6ea
--- /dev/null
+++ b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/HistogramSpec.scala
@@ -0,0 +1,157 @@
+/*
+ * =========================================================================================
+ * 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
+import org.scalatest.{Matchers, WordSpec}
+
+import scala.util.Random
+
+class HistogramSpec extends WordSpec with Matchers {
+
+  "a Histogram" should {
+    "allow record values within the configured range" in new HistogramFixture {
+      histogram.record(1000)
+      histogram.record(5000, count = 100)
+      histogram.record(10000)
+    }
+
+    "not fail when recording values higher than the highest trackable value" in new HistogramFixture {
+      histogram.record(Long.MaxValue)
+    }
+
+    "reset all recorded levels to zero after a snapshot collection" in new HistogramFixture {
+      histogram.record(100)
+      histogram.record(200)
+      histogram.record(300)
+
+      takeSnapshot().numberOfMeasurements should be(3)
+      takeSnapshot().numberOfMeasurements should be(0)
+    }
+
+    "produce a snapshot" which {
+      "supports min, max, percentile, sum, numberOfMeasurements and recordsIterator operations" in new HistogramFixture {
+        histogram.record(100)
+        histogram.record(200, count = 200)
+        histogram.record(300)
+        histogram.record(900)
+
+        val snapshot = takeSnapshot()
+
+        snapshot.min should equal(100L +- 1L)
+        snapshot.max should equal(900L +- 9L)
+        snapshot.percentile(50.0D) should be(200)
+        snapshot.percentile(99.5D) should be(300)
+        snapshot.percentile(99.9D) should be(900)
+        snapshot.sum should be(41300)
+        snapshot.numberOfMeasurements should be(203)
+
+        val records = snapshot.recordsIterator.map(r ⇒ r.level → r.count).toSeq
+        records.size should be(4)
+        records(0) should be(100 → 1)
+        records(1) should be(200 → 200)
+        records(2) should be(300 → 1)
+        records(3) should be(900 → 1)
+      }
+
+      "can be scaled" in new HistogramFixture {
+        histogram.record(100)
+        histogram.record(200, count = 200)
+        histogram.record(300)
+        histogram.record(900)
+
+        val snapshot = takeSnapshot().scale(Time.Seconds, Time.Milliseconds)
+
+        snapshot.min should equal(100000L +- 1000L)
+        snapshot.max should equal(900000L +- 9000L)
+        snapshot.percentile(50.0D) should be(200000)
+        snapshot.percentile(99.5D) should be(300000)
+        snapshot.percentile(99.9D) should be(900000)
+        snapshot.sum should be(41300000)
+        snapshot.numberOfMeasurements should be(203)
+
+        val records = snapshot.recordsIterator.map(r ⇒ r.level → r.count).toSeq
+        records.size should be(4)
+        records(0) should be(100000 → 1)
+        records(1) should be(200000 → 200)
+        records(2) should be(300000 → 1)
+        records(3) should be(900000 → 1)
+      }
+
+      "can be merged with another snapshot" in new MultipleHistogramFixture {
+        val random = new Random(System.nanoTime())
+
+        for (repetitions ← 1 to 1000) {
+          // Put some values on A and Control
+          for (_ ← 1 to 1000) {
+            val newRecording = random.nextInt(100000)
+            controlHistogram.record(newRecording)
+            histogramA.record(newRecording)
+          }
+
+          // Put some values on B and Control
+          for (_ ← 1 to 2000) {
+            val newRecording = random.nextInt(100000)
+            controlHistogram.record(newRecording)
+            histogramB.record(newRecording)
+          }
+
+          val controlSnapshot = takeSnapshotFrom(controlHistogram)
+          val histogramASnapshot = takeSnapshotFrom(histogramA)
+          val histogramBSnapshot = takeSnapshotFrom(histogramB)
+
+          assertEquals(controlSnapshot, histogramASnapshot.merge(histogramBSnapshot, collectionContext))
+          assertEquals(controlSnapshot, histogramBSnapshot.merge(histogramASnapshot, collectionContext))
+        }
+      }
+    }
+  }
+
+  trait HistogramFixture {
+    val collectionContext = new CollectionContext {
+      val buffer: LongBuffer = LongBuffer.allocate(10000)
+    }
+
+    val histogram = Histogram(DynamicRange(1, 100000, 2))
+
+    def takeSnapshot(): Histogram.Snapshot = histogram.collect(collectionContext)
+  }
+
+  trait MultipleHistogramFixture {
+    val collectionContext = new CollectionContext {
+      val buffer: LongBuffer = LongBuffer.allocate(10000)
+    }
+
+    val controlHistogram = Histogram(DynamicRange(1, 100000, 2))
+    val histogramA = Histogram(DynamicRange(1, 100000, 2))
+    val histogramB = Histogram(DynamicRange(1, 100000, 2))
+
+    def takeSnapshotFrom(histogram: Histogram): InstrumentSnapshot = histogram.collect(collectionContext)
+
+    def assertEquals(left: InstrumentSnapshot, right: InstrumentSnapshot): Unit = {
+      val leftSnapshot = left.asInstanceOf[Histogram.Snapshot]
+      val rightSnapshot = right.asInstanceOf[Histogram.Snapshot]
+
+      leftSnapshot.numberOfMeasurements should equal(rightSnapshot.numberOfMeasurements)
+      leftSnapshot.min should equal(rightSnapshot.min)
+      leftSnapshot.max should equal(rightSnapshot.max)
+      leftSnapshot.recordsIterator.toStream should contain theSameElementsAs (rightSnapshot.recordsIterator.toStream)
+    }
+  }
+}
diff --git a/kamon-core/src/legacy-test/scala/kamon/metric/instrument/MinMaxCounterSpec.scala b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/MinMaxCounterSpec.scala
new file mode 100644
index 00000000..d007d4cd
--- /dev/null
+++ b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/MinMaxCounterSpec.scala
@@ -0,0 +1,140 @@
+/* =========================================================================================
+ * 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 java.nio.LongBuffer
+
+import akka.actor._
+import akka.testkit.TestProbe
+import kamon.Kamon
+import kamon.metric.instrument.Histogram.{DynamicRange, MutableRecord}
+import kamon.testkit.BaseKamonSpec
+import scala.concurrent.duration._
+
+class MinMaxCounterSpec extends BaseKamonSpec("min-max-counter-spec") {
+
+  "the MinMaxCounter" should {
+    "track ascending tendencies" in new MinMaxCounterFixture {
+      mmCounter.increment()
+      mmCounter.increment(3)
+      mmCounter.increment()
+
+      val snapshot = collectCounterSnapshot()
+
+      snapshot.min should be(0)
+      snapshot.max should be(5)
+      snapshot.recordsIterator.toStream should contain allOf (
+        MutableRecord(0, 1), // min
+        MutableRecord(5, 2)
+      ) // max and current
+    }
+
+    "track descending tendencies" in new MinMaxCounterFixture {
+      mmCounter.increment(5)
+      mmCounter.decrement()
+      mmCounter.decrement(3)
+      mmCounter.decrement()
+
+      val snapshot = collectCounterSnapshot()
+
+      snapshot.min should be(0)
+      snapshot.max should be(5)
+      snapshot.recordsIterator.toStream should contain allOf (
+        MutableRecord(0, 2), // min and current
+        MutableRecord(5, 1)
+      ) // max
+    }
+
+    "reset the min and max to the current value after taking a snapshot" in new MinMaxCounterFixture {
+      mmCounter.increment(5)
+      mmCounter.decrement(3)
+
+      val firstSnapshot = collectCounterSnapshot()
+
+      firstSnapshot.min should be(0)
+      firstSnapshot.max should be(5)
+      firstSnapshot.recordsIterator.toStream should contain allOf (
+        MutableRecord(0, 1), // min
+        MutableRecord(2, 1), // current
+        MutableRecord(5, 1)
+      ) // max
+
+      val secondSnapshot = collectCounterSnapshot()
+
+      secondSnapshot.min should be(2)
+      secondSnapshot.max should be(2)
+      secondSnapshot.recordsIterator.toStream should contain(
+        MutableRecord(2, 3)
+      ) // min, max and current
+    }
+
+    "report zero as the min and current values if the current value fell bellow zero" in new MinMaxCounterFixture {
+      mmCounter.decrement(3)
+
+      val snapshot = collectCounterSnapshot()
+
+      snapshot.min should be(0)
+      snapshot.max should be(0)
+      snapshot.recordsIterator.toStream should contain(
+        MutableRecord(0, 3)
+      ) // min, max and current (even while current really is -3
+    }
+
+    "never record values bellow zero in very busy situations" in new MinMaxCounterFixture {
+      val monitor = TestProbe()
+      val workers = for (workers ← 1 to 50) yield {
+        system.actorOf(Props(new MinMaxCounterUpdateActor(mmCounter, monitor.ref)))
+      }
+
+      workers foreach (_ ! "increment")
+      for (refresh ← 1 to 1000) {
+        collectCounterSnapshot()
+        Thread.sleep(1)
+      }
+
+      monitor.expectNoMsg()
+      workers foreach (_ ! PoisonPill)
+    }
+  }
+
+  trait MinMaxCounterFixture {
+    val collectionContext = new CollectionContext {
+      val buffer: LongBuffer = LongBuffer.allocate(64)
+    }
+
+    val mmCounter = MinMaxCounter(DynamicRange(1, 1000, 2), 1 hour, Kamon.metrics.settings.refreshScheduler)
+    mmCounter.cleanup // cancel the refresh schedule
+
+    def collectCounterSnapshot(): Histogram.Snapshot = mmCounter.collect(collectionContext)
+  }
+}
+
+class MinMaxCounterUpdateActor(mmc: MinMaxCounter, monitor: ActorRef) extends Actor {
+  val x = Array.ofDim[Int](4)
+  def receive = {
+    case "increment" ⇒
+      mmc.increment()
+      self ! "decrement"
+    case "decrement" ⇒
+      mmc.decrement()
+      self ! "increment"
+      try {
+        mmc.refreshValues()
+      } catch {
+        case _: IndexOutOfBoundsException ⇒ monitor ! "failed"
+      }
+  }
+}
\ No newline at end of file
diff --git a/kamon-core/src/legacy-test/scala/kamon/metric/instrument/UnitOfMeasurementSpec.scala b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/UnitOfMeasurementSpec.scala
new file mode 100644
index 00000000..7133579e
--- /dev/null
+++ b/kamon-core/src/legacy-test/scala/kamon/metric/instrument/UnitOfMeasurementSpec.scala
@@ -0,0 +1,98 @@
+/*
+ * =========================================================================================
+ * 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.UnitOfMeasurement.Unknown
+import org.scalatest.{Matchers, WordSpec}
+
+class UnitOfMeasurementSpec extends WordSpec with Matchers {
+
+  "Time unit" should {
+    "resolve Time Unit by valid name" in {
+      Time("s") should be(Time.Seconds)
+      Time("n") should be(Time.Nanoseconds)
+      Time("ms") should be(Time.Milliseconds)
+      Time("µs") should be(Time.Microseconds)
+    }
+    "fail to resolve Time Unit by invalid name" in {
+      val ex = intercept[IllegalArgumentException](Time("boo"))
+      ex.getMessage should be("Can't recognize time unit 'boo'")
+    }
+    "scale time properly" in {
+      val epsilon = 0.0001
+
+      Time.Nanoseconds.scale(Time.Nanoseconds)(1000000D) should be(1000000D +- epsilon)
+      Time.Nanoseconds.scale(Time.Microseconds)(1000000D) should be(1000D +- epsilon)
+      Time.Nanoseconds.scale(Time.Milliseconds)(1000000D) should be(1D +- epsilon)
+      Time.Nanoseconds.scale(Time.Seconds)(1000000D) should be(0.001D +- epsilon)
+      Time.Seconds.scale(Time.Nanoseconds)(1D) should be(1000000000D +- epsilon)
+    }
+    "allow scale only time" in {
+      intercept[IllegalArgumentException](Time.Nanoseconds.tryScale(Unknown)(100))
+        .getMessage should be("Can't scale different types of units `time` and `unknown`")
+      intercept[IllegalArgumentException](Time.Nanoseconds.tryScale(Memory.Bytes)(100))
+        .getMessage should be("Can't scale different types of units `time` and `bytes`")
+      val epsilon = 0.0001
+
+      Time.Nanoseconds.tryScale(Time.Nanoseconds)(100D) should be(100D +- epsilon)
+    }
+  }
+
+  "Memory unit" should {
+    "resolve Memory Unit by valid name" in {
+      Memory("b") should be(Memory.Bytes)
+      Memory("Kb") should be(Memory.KiloBytes)
+      Memory("Mb") should be(Memory.MegaBytes)
+      Memory("Gb") should be(Memory.GigaBytes)
+    }
+    "fail to resolve Memory Unit by invalid name" in {
+      val ex = intercept[IllegalArgumentException](Memory("boo"))
+      ex.getMessage should be("Can't recognize memory unit 'boo'")
+    }
+    "scale memory properly" in {
+      val epsilon = 0.0001
+
+      Memory.Bytes.scale(Memory.Bytes)(1000000D) should be(1000000D +- epsilon)
+      Memory.Bytes.scale(Memory.KiloBytes)(1000000D) should be(976.5625D +- epsilon)
+      Memory.Bytes.scale(Memory.MegaBytes)(1000000D) should be(0.9536D +- epsilon)
+      Memory.Bytes.scale(Memory.GigaBytes)(1000000D) should be(9.3132E-4D +- epsilon)
+      Memory.MegaBytes.scale(Memory.Bytes)(1D) should be(1048576D +- epsilon)
+    }
+    "allow scale only memory" in {
+      intercept[IllegalArgumentException](Memory.Bytes.tryScale(Unknown)(100))
+        .getMessage should be("Can't scale different types of units `bytes` and `unknown`")
+      intercept[IllegalArgumentException](Memory.Bytes.tryScale(Time.Nanoseconds)(100))
+        .getMessage should be("Can't scale different types of units `bytes` and `time`")
+      val epsilon = 0.0001
+
+      Memory.Bytes.tryScale(Memory.Bytes)(100D) should be(100D +- epsilon)
+    }
+
+  }
+
+  "Unknown unit" should {
+    "allow scale only Unknown" in {
+      intercept[IllegalArgumentException](Unknown.tryScale(Memory.Bytes)(100))
+        .getMessage should be("Can't scale different types of units `unknown` and `bytes`")
+      intercept[IllegalArgumentException](Unknown.tryScale(Time.Nanoseconds)(100))
+        .getMessage should be("Can't scale different types of units `unknown` and `time`")
+
+      Unknown.scale(Unknown)(100D) should be(100D)
+    }
+
+  }
+}