= core: rename UserMetrics to SimpleMetrics.

6 files changed, 75 insertions, 75 deletions

diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala
index 231fc530..cf492125 100644
--- a/kamon-core/src/main/scala/kamon/Kamon.scala
+++ b/kamon-core/src/main/scala/kamon/Kamon.scala
@@ -26,7 +26,7 @@ object Kamon {
   private case class KamonCoreComponents(
     metrics: MetricsExtension,
     tracer: TracerExtension,
-    userMetrics: UserMetricsExtension)
+    simpleMetrics: SimpleMetricsExtension)
 
   @volatile private var _system: ActorSystem = _
   @volatile private var _coreComponents: Option[KamonCoreComponents] = None
@@ -43,7 +43,7 @@ object Kamon {
 
     if (_coreComponents.isEmpty) {
       val metrics = MetricsExtensionImpl(config)
-      val simpleMetrics = UserMetricsExtensionImpl(metrics)
+      val simpleMetrics = SimpleMetricsExtensionImpl(metrics)
       val tracer = TracerExtensionImpl(metrics, config)
 
       _coreComponents = Some(KamonCoreComponents(metrics, tracer, simpleMetrics))
@@ -70,8 +70,8 @@ object Kamon {
   def tracer: TracerExtension =
     ifStarted(_.tracer)
 
-  def userMetrics: UserMetricsExtension =
-    ifStarted(_.userMetrics)
+  def simpleMetrics: SimpleMetricsExtension =
+    ifStarted(_.simpleMetrics)
 
   def apply[T <: Kamon.Extension](key: ExtensionId[T]): T =
     ifStarted { _ ⇒
diff --git a/kamon-core/src/main/scala/kamon/metric/UserMetrics.scala b/kamon-core/src/main/scala/kamon/metric/SimpleMetrics.scala
index e0818292..b8dc54df 100644
--- a/kamon-core/src/main/scala/kamon/metric/UserMetrics.scala
+++ b/kamon-core/src/main/scala/kamon/metric/SimpleMetrics.scala
@@ -22,7 +22,7 @@ import kamon.metric.instrument._
 
 import scala.concurrent.duration.FiniteDuration
 
-trait UserMetricsExtension {
+trait SimpleMetricsExtension {
   def histogram(name: String): Histogram
   def histogram(name: String, dynamicRange: DynamicRange): Histogram
   def histogram(name: String, unitOfMeasurement: UnitOfMeasurement): Histogram
@@ -69,7 +69,7 @@ trait UserMetricsExtension {
 
 }
 
-private[kamon] class UserMetricsExtensionImpl(instrumentFactory: InstrumentFactory) extends GenericEntityRecorder(instrumentFactory) with UserMetricsExtension {
+private[kamon] class SimpleMetricsExtensionImpl(instrumentFactory: InstrumentFactory) extends GenericEntityRecorder(instrumentFactory) with SimpleMetricsExtension {
   override def histogram(name: String): Histogram =
     super.histogram(name)
 
@@ -191,14 +191,14 @@ private[kamon] class UserMetricsExtensionImpl(instrumentFactory: InstrumentFacto
     super.removeCounter(key)
 }
 
-private[kamon] object UserMetricsExtensionImpl {
-  val UserMetricEntity = Entity("user-metric", "user-metric")
+private[kamon] object SimpleMetricsExtensionImpl {
+  val SimpleMetricsEntity = Entity("simple-metric", "simple-metric")
 
-  def apply(metricsExtension: MetricsExtension): UserMetricsExtensionImpl = {
-    val instrumentFactory = metricsExtension.instrumentFactory(UserMetricEntity.category)
-    val userMetricsExtension = new UserMetricsExtensionImpl(instrumentFactory)
+  def apply(metricsExtension: MetricsExtension): SimpleMetricsExtensionImpl = {
+    val instrumentFactory = metricsExtension.instrumentFactory(SimpleMetricsEntity.category)
+    val simpleMetricsExtension = new SimpleMetricsExtensionImpl(instrumentFactory)
 
-    metricsExtension.register(UserMetricEntity, userMetricsExtension).recorder
+    metricsExtension.register(SimpleMetricsEntity, simpleMetricsExtension).recorder
   }
 
 }
\ No newline at end of file
diff --git a/kamon-core/src/test/scala/kamon/metric/UserMetricsSpec.scala b/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala
index 455518f8..60ba9a0e 100644
--- a/kamon-core/src/test/scala/kamon/metric/UserMetricsSpec.scala
+++ b/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala
@@ -22,7 +22,7 @@ import kamon.metric.instrument.Histogram.DynamicRange
 import kamon.testkit.BaseKamonSpec
 import scala.concurrent.duration._
 
-class UserMetricsSpec extends BaseKamonSpec("user-metrics-spec") {
+class SimpleMetricsSpec extends BaseKamonSpec("simple-metrics-spec") {
   override lazy val config =
     ConfigFactory.parseString(
       """
@@ -32,57 +32,57 @@ class UserMetricsSpec extends BaseKamonSpec("user-metrics-spec") {
         |}
       """.stripMargin)
 
-  "the UserMetrics extension" should {
+  "the SimpleMetrics extension" should {
 
     "allow registering a fully configured Histogram and get the same Histogram if registering again" in {
-      val histogramA = Kamon.userMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
-      val histogramB = Kamon.userMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
+      val histogramA = Kamon.simpleMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
+      val histogramB = Kamon.simpleMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
 
       histogramA shouldBe theSameInstanceAs(histogramB)
     }
 
     "return the original Histogram when registering a fully configured Histogram for second time but with different settings" in {
-      val histogramA = Kamon.userMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
-      val histogramB = Kamon.userMetrics.histogram("histogram-with-settings", DynamicRange(1, 50000, 2))
+      val histogramA = Kamon.simpleMetrics.histogram("histogram-with-settings", DynamicRange(1, 10000, 2))
+      val histogramB = Kamon.simpleMetrics.histogram("histogram-with-settings", DynamicRange(1, 50000, 2))
 
       histogramA shouldBe theSameInstanceAs(histogramB)
     }
 
     "allow registering a Histogram that takes the default configuration from the kamon.metrics.precision settings" in {
-      Kamon.userMetrics.histogram("histogram-with-default-configuration")
+      Kamon.simpleMetrics.histogram("histogram-with-default-configuration")
     }
 
     "allow registering a Counter and get the same Counter if registering again" in {
-      val counterA = Kamon.userMetrics.counter("counter")
-      val counterB = Kamon.userMetrics.counter("counter")
+      val counterA = Kamon.simpleMetrics.counter("counter")
+      val counterB = Kamon.simpleMetrics.counter("counter")
 
       counterA shouldBe theSameInstanceAs(counterB)
     }
 
     "allow registering a fully configured MinMaxCounter and get the same MinMaxCounter if registering again" in {
-      val minMaxCounterA = Kamon.userMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
-      val minMaxCounterB = Kamon.userMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
+      val minMaxCounterA = Kamon.simpleMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
+      val minMaxCounterB = Kamon.simpleMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
 
       minMaxCounterA shouldBe theSameInstanceAs(minMaxCounterB)
     }
 
     "return the original MinMaxCounter when registering a fully configured MinMaxCounter for second time but with different settings" in {
-      val minMaxCounterA = Kamon.userMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
-      val minMaxCounterB = Kamon.userMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 50000, 2), 1 second)
+      val minMaxCounterA = Kamon.simpleMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 10000, 2), 1 second)
+      val minMaxCounterB = Kamon.simpleMetrics.minMaxCounter("min-max-counter-with-settings", DynamicRange(1, 50000, 2), 1 second)
 
       minMaxCounterA shouldBe theSameInstanceAs(minMaxCounterB)
     }
 
     "allow registering a MinMaxCounter that takes the default configuration from the kamon.metrics.precision settings" in {
-      Kamon.userMetrics.minMaxCounter("min-max-counter-with-default-configuration")
+      Kamon.simpleMetrics.minMaxCounter("min-max-counter-with-default-configuration")
     }
 
     "allow registering a fully configured Gauge and get the same Gauge if registering again" in {
-      val gaugeA = Kamon.userMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
+      val gaugeA = Kamon.simpleMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
         () ⇒ 1L
       })
 
-      val gaugeB = Kamon.userMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
+      val gaugeB = Kamon.simpleMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
         () ⇒ 1L
       })
 
@@ -90,11 +90,11 @@ class UserMetricsSpec extends BaseKamonSpec("user-metrics-spec") {
     }
 
     "return the original Gauge when registering a fully configured Gauge for second time but with different settings" in {
-      val gaugeA = Kamon.userMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
+      val gaugeA = Kamon.simpleMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
         () ⇒ 1L
       })
 
-      val gaugeB = Kamon.userMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
+      val gaugeB = Kamon.simpleMetrics.gauge("gauge-with-settings", DynamicRange(1, 10000, 2), 1 second, {
         () ⇒ 1L
       })
 
@@ -102,26 +102,26 @@ class UserMetricsSpec extends BaseKamonSpec("user-metrics-spec") {
     }
 
     "allow registering a Gauge that takes the default configuration from the kamon.metrics.precision settings" in {
-      Kamon.userMetrics.gauge("gauge-with-default-configuration", {
+      Kamon.simpleMetrics.gauge("gauge-with-default-configuration", {
         () ⇒ 2L
       })
     }
 
     "allow un-registering user metrics" in {
-      val counter = Kamon.userMetrics.counter("counter-for-remove")
-      val histogram = Kamon.userMetrics.histogram("histogram-for-remove")
-      val minMaxCounter = Kamon.userMetrics.minMaxCounter("min-max-counter-for-remove")
-      val gauge = Kamon.userMetrics.gauge("gauge-for-remove", { () ⇒ 2L })
-
-      Kamon.userMetrics.removeCounter("counter-for-remove")
-      Kamon.userMetrics.removeHistogram("histogram-for-remove")
-      Kamon.userMetrics.removeMinMaxCounter("min-max-counter-for-remove")
-      Kamon.userMetrics.removeGauge("gauge-for-remove")
-
-      counter should not be (theSameInstanceAs(Kamon.userMetrics.counter("counter-for-remove")))
-      histogram should not be (theSameInstanceAs(Kamon.userMetrics.histogram("histogram-for-remove")))
-      minMaxCounter should not be (theSameInstanceAs(Kamon.userMetrics.minMaxCounter("min-max-counter-for-remove")))
-      gauge should not be (theSameInstanceAs(Kamon.userMetrics.gauge("gauge-for-remove", { () ⇒ 2L })))
+      val counter = Kamon.simpleMetrics.counter("counter-for-remove")
+      val histogram = Kamon.simpleMetrics.histogram("histogram-for-remove")
+      val minMaxCounter = Kamon.simpleMetrics.minMaxCounter("min-max-counter-for-remove")
+      val gauge = Kamon.simpleMetrics.gauge("gauge-for-remove", { () ⇒ 2L })
+
+      Kamon.simpleMetrics.removeCounter("counter-for-remove")
+      Kamon.simpleMetrics.removeHistogram("histogram-for-remove")
+      Kamon.simpleMetrics.removeMinMaxCounter("min-max-counter-for-remove")
+      Kamon.simpleMetrics.removeGauge("gauge-for-remove")
+
+      counter should not be (theSameInstanceAs(Kamon.simpleMetrics.counter("counter-for-remove")))
+      histogram should not be (theSameInstanceAs(Kamon.simpleMetrics.histogram("histogram-for-remove")))
+      minMaxCounter should not be (theSameInstanceAs(Kamon.simpleMetrics.minMaxCounter("min-max-counter-for-remove")))
+      gauge should not be (theSameInstanceAs(Kamon.simpleMetrics.gauge("gauge-for-remove", { () ⇒ 2L })))
     }
   }
 }
diff --git a/kamon-log-reporter/src/main/scala/kamon/logreporter/LogReporter.scala b/kamon-log-reporter/src/main/scala/kamon/logreporter/LogReporter.scala
index d5b07f6d..fc1f0faf 100644
--- a/kamon-log-reporter/src/main/scala/kamon/logreporter/LogReporter.scala
+++ b/kamon-log-reporter/src/main/scala/kamon/logreporter/LogReporter.scala
@@ -57,7 +57,7 @@ class LogReporterSubscriber extends Actor with ActorLogging {
     tick.metrics foreach {
       case (entity, snapshot) if entity.category == "actor"         ⇒ logActorMetrics(entity.name, snapshot)
       case (entity, snapshot) if entity.category == "trace"         ⇒ logTraceMetrics(entity.name, snapshot)
-      case (entity, snapshot) if entity.category == "user-metric"   ⇒ logUserMetrics(snapshot)
+      case (entity, snapshot) if entity.category == "simple-metric" ⇒ logSimpleMetrics(snapshot)
       case (entity, snapshot) if entity.category == "system-metric" ⇒ logSystemMetrics(entity.name, snapshot)
       case ignoreEverythingElse                                     ⇒
     }
@@ -253,59 +253,59 @@ class LogReporterSubscriber extends Actor with ActorLogging {
     }
   }
 
-  def logUserMetrics(userMetrics: EntitySnapshot): Unit = {
-    val histograms = userMetrics.histograms
-    val minMaxCounters = userMetrics.minMaxCounters
-    val gauges = userMetrics.gauges
-    val counters = userMetrics.counters
+  def logSimpleMetrics(simpleMetrics: EntitySnapshot): Unit = {
+    val histograms = simpleMetrics.histograms
+    val minMaxCounters = simpleMetrics.minMaxCounters
+    val gauges = simpleMetrics.gauges
+    val counters = simpleMetrics.counters
 
     if (histograms.isEmpty && counters.isEmpty && minMaxCounters.isEmpty && gauges.isEmpty) {
       log.info("No user metrics reported")
       return
     }
 
-    val userMetricsData = StringBuilder.newBuilder
+    val simpleMetricsData = StringBuilder.newBuilder
 
-    userMetricsData.append(
+    simpleMetricsData.append(
       """
         |+--------------------------------------------------------------------------------------------------+
         ||                                                                                                  |
-        ||                                       User Counters                                              |
+        ||                                      Simple Counters                                             |
         ||                                       -------------                                              |
         |""".stripMargin)
 
     counters.toList.sortBy(_._1.name.toLowerCase).foreach {
-      case (counter, snapshot) ⇒ userMetricsData.append(userCounterString(counter.name, snapshot))
+      case (counter, snapshot) ⇒ simpleMetricsData.append(userCounterString(counter.name, snapshot))
     }
 
-    userMetricsData.append(
+    simpleMetricsData.append(
       """||                                                                                                  |
         ||                                                                                                  |
-        ||                                      User Histograms                                             |
+        ||                                     Simple Histograms                                            |
         ||                                      ---------------                                             |
         |""".stripMargin)
 
     histograms.foreach {
       case (histogram, snapshot) ⇒
-        userMetricsData.append("|  %-40s                                                        |\n".format(histogram.name))
-        userMetricsData.append(compactHistogramView(snapshot))
-        userMetricsData.append("\n|                                                                                                  |\n")
+        simpleMetricsData.append("|  %-40s                                                        |\n".format(histogram.name))
+        simpleMetricsData.append(compactHistogramView(snapshot))
+        simpleMetricsData.append("\n|                                                                                                  |\n")
     }
 
-    userMetricsData.append(
+    simpleMetricsData.append(
       """||                                                                                                  |
-        ||                                    User MinMaxCounters                                           |
+        ||                                   Simple MinMaxCounters                                           |
         ||                                    -------------------                                           |
         |""".stripMargin)
 
     minMaxCounters.foreach {
       case (minMaxCounter, snapshot) ⇒
-        userMetricsData.append("|  %-40s                                                        |\n".format(minMaxCounter.name))
-        userMetricsData.append(simpleHistogramView(snapshot))
-        userMetricsData.append("\n|                                                                                                  |\n")
+        simpleMetricsData.append("|  %-40s                                                        |\n".format(minMaxCounter.name))
+        simpleMetricsData.append(simpleHistogramView(snapshot))
+        simpleMetricsData.append("\n|                                                                                                  |\n")
     }
 
-    userMetricsData.append(
+    simpleMetricsData.append(
       """||                                                                                                  |
         ||                                        User Gauges                                               |
         ||                                        -----------                                               |
@@ -314,17 +314,17 @@ class LogReporterSubscriber extends Actor with ActorLogging {
 
     gauges.foreach {
       case (gauge, snapshot) ⇒
-        userMetricsData.append("|  %-40s                                                        |\n".format(gauge.name))
-        userMetricsData.append(simpleHistogramView(snapshot))
-        userMetricsData.append("\n|                                                                                                  |\n")
+        simpleMetricsData.append("|  %-40s                                                        |\n".format(gauge.name))
+        simpleMetricsData.append(simpleHistogramView(snapshot))
+        simpleMetricsData.append("\n|                                                                                                  |\n")
     }
 
-    userMetricsData.append(
+    simpleMetricsData.append(
       """||                                                                                                  |
         |+--------------------------------------------------------------------------------------------------+"""
         .stripMargin)
 
-    log.info(userMetricsData.toString())
+    log.info(simpleMetricsData.toString())
   }
 
   def userCounterString(counterName: String, snapshot: Counter.Snapshot): String = {
diff --git a/kamon-newrelic/src/main/scala/kamon/newrelic/CustomMetricExtractor.scala b/kamon-newrelic/src/main/scala/kamon/newrelic/CustomMetricExtractor.scala
index 3b1b8cb3..26afc9e2 100644
--- a/kamon-newrelic/src/main/scala/kamon/newrelic/CustomMetricExtractor.scala
+++ b/kamon-newrelic/src/main/scala/kamon/newrelic/CustomMetricExtractor.scala
@@ -16,14 +16,14 @@
 
 package kamon.newrelic
 
-import kamon.metric.{ UserMetricsExtensionImpl, EntitySnapshot, Entity }
+import kamon.metric.{ SimpleMetricsExtensionImpl, EntitySnapshot, Entity }
 import kamon.metric.instrument.CollectionContext
 
 object CustomMetricExtractor extends MetricExtractor {
 
   def extract(settings: AgentSettings, collectionContext: CollectionContext, metrics: Map[Entity, EntitySnapshot]): Map[MetricID, MetricData] = {
-    metrics.get(UserMetricsExtensionImpl.UserMetricEntity).map { allUserMetrics ⇒
-      allUserMetrics.metrics.map {
+    metrics.get(SimpleMetricsExtensionImpl.SimpleMetricsEntity).map { allSimpleMetrics ⇒
+      allSimpleMetrics.metrics.map {
         case (key, snapshot) ⇒ Metric(snapshot, key.unitOfMeasurement, s"Custom/${key.name}", None)
       }
 
diff --git a/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala b/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
index 86f0c93e..fb68b60d 100644
--- a/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
+++ b/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
@@ -49,7 +49,7 @@ object SimpleRequestProcessor extends App with SimpleRoutingApp with RequestBuil
 
   implicit val timeout = Timeout(30 seconds)
 
-  val counter = Kamon.userMetrics.counter("requests")
+  val counter = Kamon.simpleMetrics.counter("requests")
   val pipeline = sendReceive
   val replier = system.actorOf(Props[Replier].withRouter(RoundRobinPool(nrOfInstances = 4)), "replier")