Merge pull request #489 from kamon-io/refineWithJMap

Metric::refine with java.util.Map

5 files changed, 54 insertions, 22 deletions

diff --git a/kamon-core-tests/src/test/scala/kamon/metric/MetricLookupSpec.scala b/kamon-core-tests/src/test/scala/kamon/metric/MetricLookupSpec.scala
index 64ae1514..4df2397b 100644
--- a/kamon-core-tests/src/test/scala/kamon/metric/MetricLookupSpec.scala
+++ b/kamon-core-tests/src/test/scala/kamon/metric/MetricLookupSpec.scala
@@ -15,6 +15,8 @@
 
 package kamon.metric
 
+import java.util.Collections.{singletonMap => javaMap}
+
 import kamon.Kamon
 import org.scalatest.{Matchers, WordSpec}
 
@@ -51,27 +53,38 @@ class MetricLookupSpec extends WordSpec with Matchers {
       "always return the same histogram for a set of tags" in {
         val histogramOne = Kamon.histogram("histogram-lookup").refine("tag" -> "value")
         val histogramTwo = Kamon.histogram("histogram-lookup").refine("tag" -> "value")
+        val histogramThree = Kamon.histogram("histogram-lookup").refine(javaMap("tag", "value"))
+
         histogramOne shouldBe theSameInstanceAs(histogramTwo)
+        histogramOne shouldBe theSameInstanceAs(histogramThree)
       }
 
       "always return the same counter for a set of tags" in {
         val counterOne = Kamon.counter("counter-lookup").refine("tag" -> "value")
         val counterTwo = Kamon.counter("counter-lookup").refine("tag" -> "value")
+        val counterThree = Kamon.counter("counter-lookup").refine(javaMap("tag", "value"))
+
         counterOne shouldBe theSameInstanceAs(counterTwo)
+        counterOne shouldBe theSameInstanceAs(counterThree)
       }
 
       "always return the same gauge for a set of tags" in {
         val gaugeOne = Kamon.gauge("gauge-lookup").refine("tag" -> "value")
         val gaugeTwo = Kamon.gauge("gauge-lookup").refine("tag" -> "value")
+        val gaugeThree = Kamon.gauge("gauge-lookup").refine(javaMap("tag", "value"))
+
         gaugeOne shouldBe theSameInstanceAs(gaugeTwo)
+        gaugeOne shouldBe theSameInstanceAs(gaugeThree)
       }
 
       "always return the same min-max-counter for a set of tags" in {
         val minMaxCounterOne = Kamon.minMaxCounter("min-max-counter-lookup").refine("tag" -> "value")
         val minMaxCounterTwo = Kamon.minMaxCounter("min-max-counter-lookup").refine("tag" -> "value")
+        val minMaxCounterThree = Kamon.minMaxCounter("min-max-counter-lookup").refine(javaMap("tag", "value"))
+
         minMaxCounterOne shouldBe theSameInstanceAs(minMaxCounterTwo)
+        minMaxCounterOne shouldBe theSameInstanceAs(minMaxCounterThree)
       }
     }
   }
-
 }
diff --git a/kamon-core-tests/src/test/scala/kamon/metric/TimerSpec.scala b/kamon-core-tests/src/test/scala/kamon/metric/TimerSpec.scala
index 1d439b3a..834c38e5 100644
--- a/kamon-core-tests/src/test/scala/kamon/metric/TimerSpec.scala
+++ b/kamon-core-tests/src/test/scala/kamon/metric/TimerSpec.scala
@@ -29,7 +29,7 @@ class TimerSpec extends WordSpec with Matchers {
       timer.start().stop()
       timer.start().stop()
 
-      timer.distribution().count shouldBe(3)
+      timer.distribution().count shouldBe 3
     }
 
     "ensure that a started timer can only be stopped once" in {
@@ -39,7 +39,7 @@ class TimerSpec extends WordSpec with Matchers {
       startedTimer.stop()
       startedTimer.stop()
 
-      timer.distribution().count shouldBe(1)
+      timer.distribution().count shouldBe 1
     }
 
 
@@ -50,20 +50,20 @@ class TimerSpec extends WordSpec with Matchers {
       timer.record(200)
 
       val distribution = timer.distribution()
-      distribution.min shouldBe(100)
-      distribution.max shouldBe(200)
-      distribution.count shouldBe(1000)
+      distribution.min shouldBe 100
+      distribution.max shouldBe 200
+      distribution.count shouldBe 1000
       distribution.buckets.length shouldBe 3
       distribution.buckets.map(b => (b.value, b.frequency)) should contain.allOf(
-        (100 -> 1),
-        (150 -> 998),
-        (200 -> 1)
+        100 -> 1,
+        150 -> 998,
+        200 -> 1
       )
 
       val emptyDistribution = timer.distribution()
-      emptyDistribution.min shouldBe(0)
-      emptyDistribution.max shouldBe(0)
-      emptyDistribution.count shouldBe(0)
+      emptyDistribution.min shouldBe 0
+      emptyDistribution.max shouldBe 0
+      emptyDistribution.count shouldBe 0
       emptyDistribution.buckets.length shouldBe 0
     }
   }
diff --git a/kamon-core/src/main/scala/kamon/metric/Metric.scala b/kamon-core/src/main/scala/kamon/metric/Metric.scala
index 90e5ede7..db5ff9c0 100644
--- a/kamon-core/src/main/scala/kamon/metric/Metric.scala
+++ b/kamon-core/src/main/scala/kamon/metric/Metric.scala
@@ -16,29 +16,29 @@
 package kamon
 package metric
 
+import java.time.Duration
 import java.util.concurrent.atomic.AtomicReference
+import java.util.concurrent.{ScheduledExecutorService, ScheduledFuture, TimeUnit}
 
 import kamon.metric.InstrumentFactory.InstrumentType
 import kamon.metric.InstrumentFactory.InstrumentTypes._
-
-import scala.collection.concurrent.TrieMap
-import java.time.Duration
-import java.util.concurrent.{ScheduledExecutorService, ScheduledFuture, TimeUnit}
-
 import org.slf4j.LoggerFactory
 
+import scala.collection.JavaConverters._
+import scala.collection.concurrent.TrieMap
 import scala.util.Try
 
 
-
 trait Metric[T] {
   def name: String
   def unit: MeasurementUnit
 
+  def refine(tags: JTags): T
   def refine(tags: Tags): T
   def refine(tags: (String, String)*): T
   def refine(tag: String, value: String): T
 
+  def remove(tags: JTags): Boolean
   def remove(tags: Tags): Boolean
   def remove(tags: (String, String)*): Boolean
   def remove(tag: String, value: String): Boolean
@@ -55,17 +55,23 @@ private[kamon] abstract sealed class BaseMetric[T, S](val instrumentType: Instru
   private[kamon] val instruments = TrieMap.empty[Tags, T]
   protected lazy val baseInstrument: T = instruments.atomicGetOrElseUpdate(Map.empty, createInstrument(Map.empty))
 
+  override def refine(tags: JTags):T =
+    refine(tags.asScala.toMap)
+
+  override def refine(tags: Map[String, String]): T =
+    instruments.atomicGetOrElseUpdate(tags, createInstrument(tags))
+
   override def refine(tag: String, value: String): T = {
     val instrumentTags = Map(tag -> value)
     instruments.atomicGetOrElseUpdate(instrumentTags, createInstrument(instrumentTags))
   }
 
-  override def refine(tags: Map[String, String]): T =
-    instruments.atomicGetOrElseUpdate(tags, createInstrument(tags))
-
   override def refine(tags: (String, String)*): T =
     refine(tags.toMap)
 
+  override def remove(tags: JTags):Boolean =
+    remove(tags.asScala.toMap)
+
   override def remove(tags: Tags): Boolean =
     if(tags.nonEmpty) instruments.remove(tags).nonEmpty else false
 
@@ -141,6 +147,9 @@ private[kamon] final class MinMaxCounterMetricImpl(val name: String, val unit: M
     mmCounter
   }
 
+  override def remove(tags: JTags): Boolean =
+    removeAndStopSampler(tags.asScala.toMap)
+
   override def remove(tags: Tags): Boolean =
     removeAndStopSampler(tags)
 
diff --git a/kamon-core/src/main/scala/kamon/metric/Timer.scala b/kamon-core/src/main/scala/kamon/metric/Timer.scala
index d3ccb840..74d203a9 100644
--- a/kamon-core/src/main/scala/kamon/metric/Timer.scala
+++ b/kamon-core/src/main/scala/kamon/metric/Timer.scala
@@ -15,7 +15,7 @@
 
 package kamon.metric
 
-import kamon.Tags
+import kamon.{JTags, Tags}
 
 trait Timer extends Histogram {
   def start(): StartedTimer
@@ -61,6 +61,9 @@ private[kamon] final class TimerImpl(val histogram: Histogram) extends Timer {
 
 private[kamon] final class TimerMetricImpl(val underlyingHistogram: HistogramMetric) extends TimerMetric {
 
+  import scala.collection.JavaConverters._
+
+
   override def unit: MeasurementUnit =
     underlyingHistogram.unit
 
@@ -76,6 +79,9 @@ private[kamon] final class TimerMetricImpl(val underlyingHistogram: HistogramMet
   override def name: String =
     underlyingHistogram.name
 
+  override def refine(tags: JTags): Timer =
+    refine(tags.asScala.toMap)
+
   override def refine(tags: Tags): Timer =
     new TimerImpl(underlyingHistogram.refine(tags))
 
@@ -85,6 +91,9 @@ private[kamon] final class TimerMetricImpl(val underlyingHistogram: HistogramMet
   override def refine(tag: String, value: String): Timer =
     new TimerImpl(underlyingHistogram.refine(Map(tag -> value)))
 
+  override def remove(tags: JTags): Boolean =
+    remove(tags.asScala.toMap)
+
   override def remove(tags: Tags): Boolean =
     underlyingHistogram.remove(tags)
 
diff --git a/kamon-core/src/main/scala/kamon/package.scala b/kamon-core/src/main/scala/kamon/package.scala
index 274f43f8..c746efa1 100644
--- a/kamon-core/src/main/scala/kamon/package.scala
+++ b/kamon-core/src/main/scala/kamon/package.scala
@@ -24,6 +24,7 @@ import scala.collection.concurrent.TrieMap
 package object kamon {
 
   type Tags = Map[String, String]
+  type JTags = java.util.Map[String, String]
 
 
   /**