From 1f5d9876dedb715ae1c31203ea4f15ebf031612c Mon Sep 17 00:00:00 2001 From: Ivan Topolnjak Date: Fri, 26 May 2017 15:29:41 +0200 Subject: on the crazy path to a better Kamon :D --- .../src/main/scala/kamon/metric/MetricLookup.scala | 59 ++++++ .../main/scala/kamon/metric/MetricRegistry.scala | 86 ++++++++ .../src/main/scala/kamon/metric/Registry.scala | 222 --------------------- .../src/main/scala/kamon/metric/TickSnapshot.scala | 13 +- 4 files changed, 152 insertions(+), 228 deletions(-) create mode 100644 kamon-core/src/main/scala/kamon/metric/MetricLookup.scala create mode 100644 kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala delete mode 100644 kamon-core/src/main/scala/kamon/metric/Registry.scala (limited to 'kamon-core/src/main/scala/kamon/metric') diff --git a/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala b/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala new file mode 100644 index 00000000..db33b83c --- /dev/null +++ b/kamon-core/src/main/scala/kamon/metric/MetricLookup.scala @@ -0,0 +1,59 @@ +package kamon +package metric + +import java.time.Duration + +import kamon.metric.instrument._ +import kamon.util.MeasurementUnit + +trait MetricLookup { + + def histogram(name: String): Histogram = + histogram(name, MeasurementUnit.none, Map.empty[String, String], None) + + def histogram(name: String, unit: MeasurementUnit): Histogram = + histogram(name, unit, Map.empty[String, String], None) + + def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String]): Histogram = + histogram(name, unit, tags, None) + + def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: DynamicRange): Histogram = + histogram(name, unit, tags, Some(dynamicRange)) + + def counter(name: String): Counter = + counter(name, MeasurementUnit.none, Map.empty[String, String]) + + def counter(name: String, unit: MeasurementUnit): Counter = + counter(name, unit, Map.empty[String, String]) + + def gauge(name: String): Gauge = + gauge(name, MeasurementUnit.none, Map.empty[String, String]) + + def gauge(name: String, unit: MeasurementUnit): Gauge = + gauge(name, unit, Map.empty[String, String]) + + def minMaxCounter(name: String): MinMaxCounter = + minMaxCounter(name, MeasurementUnit.none, Map.empty[String, String], None, None) + + def minMaxCounter(name: String, unit: MeasurementUnit): MinMaxCounter = + minMaxCounter(name, unit, Map.empty[String, String], None, None) + + def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String]): MinMaxCounter = + minMaxCounter(name, unit, tags, None, None) + + def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String], sampleInterval: Duration): MinMaxCounter = + minMaxCounter(name, unit, tags, Option(sampleInterval), None) + + def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String], sampleInterval: Duration, + dynamicRange: DynamicRange): MinMaxCounter = + minMaxCounter(name, unit, tags, Option(sampleInterval), Option(dynamicRange)) + + def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange]): Histogram + + def counter(name: String, unit: MeasurementUnit, tags: Map[String, String]): Counter + + def gauge(name: String, unit: MeasurementUnit, tags: Map[String, String]): Gauge + + def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String], sampleInterval: Option[Duration], + dynamicRange: Option[DynamicRange]): MinMaxCounter +} diff --git a/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala b/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala new file mode 100644 index 00000000..c6513f1a --- /dev/null +++ b/kamon-core/src/main/scala/kamon/metric/MetricRegistry.scala @@ -0,0 +1,86 @@ +package kamon +package metric + +import java.time.Duration +import java.util.concurrent.atomic.AtomicReference + +import com.typesafe.config.Config +import com.typesafe.scalalogging.Logger +import kamon.metric.instrument._ +import kamon.util.MeasurementUnit + +import scala.collection.concurrent.TrieMap + + +class MetricRegistry(initialConfig: Config) extends MetricsSnapshotGenerator { + private val logger = Logger(classOf[MetricRegistry]) + private val metrics = TrieMap.empty[String, MetricEntry] + private val instrumentFactory = new AtomicReference[InstrumentFactory]() + reconfigure(initialConfig) + + def reconfigure(config: Config): Unit = synchronized { + instrumentFactory.set(InstrumentFactory.fromConfig(config)) + } + + def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange]): Histogram = + lookupInstrument(name, unit, tags, InstrumentType.Histogram, instrumentFactory.get().buildHistogram(dynamicRange)) + + def counter(name: String, unit: MeasurementUnit, tags: Map[String, String]): Counter = + lookupInstrument(name, unit, tags, InstrumentType.Counter, instrumentFactory.get().buildCounter) + + def gauge(name: String, unit: MeasurementUnit, tags: Map[String, String]): Gauge = + lookupInstrument(name, unit, tags, InstrumentType.Gauge, instrumentFactory.get().buildGauge) + + def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration]): MinMaxCounter = + lookupInstrument(name, unit, tags, InstrumentType.MinMaxCounter, instrumentFactory.get().buildMinMaxCounter(dynamicRange, sampleInterval)) + + + override def snapshot(): MetricsSnapshot = synchronized { + var histograms = Seq.empty[DistributionSnapshot] + var mmCounters = Seq.empty[DistributionSnapshot] + var counters = Seq.empty[SingleValueSnapshot] + var gauges = Seq.empty[SingleValueSnapshot] + + for { + metricEntry <- metrics.values + instrument <- metricEntry.instruments.values + } { + metricEntry.instrumentType match { + case InstrumentType.Histogram => histograms = histograms :+ instrument.asInstanceOf[SnapshotableHistogram].snapshot() + case InstrumentType.MinMaxCounter => mmCounters = mmCounters :+ instrument.asInstanceOf[SnapshotableMinMaxCounter].snapshot() + case InstrumentType.Gauge => gauges = gauges :+ instrument.asInstanceOf[SnapshotableGauge].snapshot() + case InstrumentType.Counter => counters = counters :+ instrument.asInstanceOf[SnapshotableCounter].snapshot() + } + } + + MetricsSnapshot(histograms, mmCounters, gauges, counters) + } + + private def lookupInstrument[T](name: String, measurementUnit: MeasurementUnit, tags: Map[String, String], + instrumentType: InstrumentType, builder: (String, Map[String, String], MeasurementUnit) => T): T = { + + val entry = metrics.atomicGetOrElseUpdate(name, MetricEntry(instrumentType, measurementUnit, TrieMap.empty)) + if(entry.instrumentType != instrumentType) + sys.error(s"Tried to use metric [$name] as a [${instrumentType.name}] but it is already defined as [${entry.instrumentType.name}] ") + + if(entry.unit != measurementUnit) + logger.warn("Ignoring attempt to use measurement unit [{}] on metric [name={}, tags={}], the metric uses [{}]", + measurementUnit.magnitude.name, name, tags.prettyPrint(), entry.unit.magnitude.name) + + entry.instruments.getOrElseUpdate(tags, builder(name, tags, measurementUnit)).asInstanceOf[T] + } + + private case class InstrumentType(name: String) + private object InstrumentType { + val Histogram = InstrumentType("Histogram") + val MinMaxCounter = InstrumentType("MinMaxCounter") + val Counter = InstrumentType("Counter") + val Gauge = InstrumentType("Gauge") + } + + private case class MetricEntry(instrumentType: InstrumentType, unit: MeasurementUnit, instruments: TrieMap[Map[String, String], Any]) +} + +trait MetricsSnapshotGenerator { + def snapshot(): MetricsSnapshot +} diff --git a/kamon-core/src/main/scala/kamon/metric/Registry.scala b/kamon-core/src/main/scala/kamon/metric/Registry.scala deleted file mode 100644 index 3f549802..00000000 --- a/kamon-core/src/main/scala/kamon/metric/Registry.scala +++ /dev/null @@ -1,222 +0,0 @@ -package kamon -package metric - -import java.time.Duration -import java.util.concurrent.ScheduledThreadPoolExecutor -import java.util.concurrent.atomic.AtomicReference - -import com.typesafe.config.{Config, ConfigFactory} -import com.typesafe.scalalogging.Logger -import kamon.metric.instrument._ -import kamon.util.MeasurementUnit - -import scala.collection.concurrent.TrieMap -/* - - -Kamon.metrics.histogram("http.latency").withMeasurementUnit(Time.Microseconds) - - -Histogram.create("http.latency", Time.Milliseconds) - - - -val histogram = Histogram.builder("http.latency") - .tag("method", "get") - .build() - - -val actorMetrics = MetricGroup("method" -> "get") - - -val actorMetrics = MetricGroup.builder() - .tag("method", "get") - .build() - -actorMetrics.histogram( - -Options for a Histogram: - - MeasurementUnit - - Dynamic Range - -HistogramConfig.forLatency().inMicroseconds() - -Kamon.metrics.histogram("http.latency").withoutTags() -Kamon.metrics.histogram("http.latency").withTag("method", "get") - - - - -Kamon.metrics.histogram("http.latency", Tag.of("color", "blue"), Tag.of("color", "blue")) - -Kamon.histogram(named("http.latency").withTag("path", path)) -Kamon.counter(named("http.latency").withTag("path", path)) - - - - - - - - -val group = Kamon.metrics.group(tags = Map("path" -> "/my-system/user/test-actor")) -val processingTime = group.histogram("processing-time") - - - - def histogram(name: String): Histogram = - histogram(name, MeasurementUnit.none) - - def histogram(name: String, unit: MeasurementUnit): Histogram = - histogram(name, unit, Map.empty) - - def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String]): Histogram = - histogram(name, unit, tags, DynamicRange.Default) - - - - */ - -trait MetricLookup { - - def histogram(name: String): Histogram = - histogram(name, MeasurementUnit.none) - - def histogram(name: String, unit: MeasurementUnit): Histogram = - histogram(name, unit, Map.empty) - - def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String]): Histogram = - histogram(name, unit, tags, None) - - def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: DynamicRange): Histogram = - histogram(name, unit, tags, Some(dynamicRange)) - - def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange]): Histogram - -} - -class Registry(initialConfig: Config) extends RegistrySnapshotGenerator { - private val logger = Logger(classOf[Registry]) - private val metrics = TrieMap.empty[String, MetricEntry] - private val instrumentFactory = new AtomicReference[InstrumentFactory]() - reconfigure(initialConfig) - - def reconfigure(config: Config): Unit = synchronized { - instrumentFactory.set(InstrumentFactory.fromConfig(config)) - } - - def histogram(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange]): Histogram = - lookupInstrument(name, unit, tags, InstrumentType.Histogram, instrumentFactory.get().buildHistogram(dynamicRange)) - - def counter(name: String, unit: MeasurementUnit, tags: Map[String, String]): Counter = - lookupInstrument(name, unit, tags, InstrumentType.Counter, instrumentFactory.get().buildCounter) - - def gauge(name: String, unit: MeasurementUnit, tags: Map[String, String]): Gauge = - lookupInstrument(name, unit, tags, InstrumentType.Gauge, instrumentFactory.get().buildGauge) - - def minMaxCounter(name: String, unit: MeasurementUnit, tags: Map[String, String], dynamicRange: Option[DynamicRange], sampleInterval: Option[Duration]): MinMaxCounter = - lookupInstrument(name, unit, tags, InstrumentType.MinMaxCounter, instrumentFactory.get().buildMinMaxCounter(dynamicRange, sampleInterval)) - - - override def snapshot(): RegistrySnapshot = synchronized { - var histograms = Seq.empty[DistributionSnapshot] - var mmCounters = Seq.empty[DistributionSnapshot] - var counters = Seq.empty[SingleValueSnapshot] - var gauges = Seq.empty[SingleValueSnapshot] - - for { - metricEntry <- metrics.values - instrument <- metricEntry.instruments.values - } { - metricEntry.instrumentType match { - case InstrumentType.Histogram => histograms = histograms :+ instrument.asInstanceOf[SnapshotableHistogram].snapshot() - case InstrumentType.MinMaxCounter => mmCounters = mmCounters :+ instrument.asInstanceOf[SnapshotableMinMaxCounter].snapshot() - case InstrumentType.Gauge => gauges = gauges :+ instrument.asInstanceOf[SnapshotableGauge].snapshot() - case InstrumentType.Counter => counters = counters :+ instrument.asInstanceOf[SnapshotableCounter].snapshot() - } - } - - RegistrySnapshot(histograms, mmCounters, gauges, counters) - } - - private def lookupInstrument[T](name: String, measurementUnit: MeasurementUnit, tags: Map[String, String], - instrumentType: InstrumentType, builder: (String, Map[String, String], MeasurementUnit) => T): T = { - - val entry = metrics.atomicGetOrElseUpdate(name, MetricEntry(instrumentType, measurementUnit, TrieMap.empty)) - if(entry.instrumentType != instrumentType) - sys.error(s"Tried to use metric [$name] as a [${instrumentType.name}] but it is already defined as [${entry.instrumentType.name}] ") - - if(entry.unit != measurementUnit) - logger.warn("Ignoring attempt to use measurement unit [{}] on metric [name={}, tags={}], the metric uses [{}]", - measurementUnit.magnitude.name, name, tags.prettyPrint(), entry.unit.magnitude.name) - - entry.instruments.getOrElseUpdate(tags, builder(name, tags, measurementUnit)).asInstanceOf[T] - } - - private case class InstrumentType(name: String) - private object InstrumentType { - val Histogram = InstrumentType("Histogram") - val MinMaxCounter = InstrumentType("MinMaxCounter") - val Counter = InstrumentType("Counter") - val Gauge = InstrumentType("Gauge") - } - - private case class MetricEntry(instrumentType: InstrumentType, unit: MeasurementUnit, instruments: TrieMap[Map[String, String], Any]) -} - - - -// -// -//trait RecorderRegistry { -// def shouldTrack(entity: Entity): Boolean -// def getRecorder(entity: Entity): EntityRecorder -// def removeRecorder(entity: Entity): Boolean -//} -// -//class RecorderRegistryImpl(initialConfig: Config) extends RecorderRegistry { -// private val scheduler = new ScheduledThreadPoolExecutor(1, numberedThreadFactory("kamon.metric.refresh-scheduler")) -// private val instrumentFactory = new AtomicReference[InstrumentFactory]() -// private val entityFilter = new AtomicReference[Filter]() -// private val entities = TrieMap.empty[Entity, EntityRecorder with EntitySnapshotProducer] -// -// reconfigure(initialConfig) -// -// -// override def shouldTrack(entity: Entity): Boolean = -// entityFilter.get().accept(entity) -// -// override def getRecorder(entity: Entity): EntityRecorder = -// entities.atomicGetOrElseUpdate(entity, new DefaultEntityRecorder(entity, instrumentFactory.get(), scheduler)) -// -// override def removeRecorder(entity: Entity): Boolean = -// entities.remove(entity).nonEmpty -// -// private[kamon] def reconfigure(config: Config): Unit = synchronized { -// instrumentFactory.set(InstrumentFactory.fromConfig(config)) -// entityFilter.set(Filter.fromConfig(config)) -// -// val refreshSchedulerPoolSize = config.getInt("kamon.metric.refresh-scheduler-pool-size") -// scheduler.setCorePoolSize(refreshSchedulerPoolSize) -// } -// -// //private[kamon] def diagnosticData -//} -// -//case class RecorderRegistryDiagnostic(entities: Seq[Entity]) -// - - -object Test extends App { - val registry = new Registry(ConfigFactory.load()) - - println(registry.histogram("test-1", MeasurementUnit.none, Map.empty, Some(DynamicRange.Default)).dynamicRange) - println(registry.histogram("test-2", MeasurementUnit.none, Map.empty, Option(DynamicRange.Fine)).dynamicRange) - - println(Kamon.histogram("my-test")) -} - - - - - diff --git a/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala index fe027c91..b7cc349e 100644 --- a/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala +++ b/kamon-core/src/main/scala/kamon/metric/TickSnapshot.scala @@ -6,12 +6,13 @@ import kamon.metric.instrument.{DistributionSnapshot, SingleValueSnapshot} case class Interval(from: Instant, to: Instant) -case class RegistrySnapshot(histograms: Seq[DistributionSnapshot], minMaxCounters: Seq[DistributionSnapshot], - gauges: Seq[SingleValueSnapshot], counters: Seq[SingleValueSnapshot]) +case class MetricsSnapshot( + histograms: Seq[DistributionSnapshot], + minMaxCounters: Seq[DistributionSnapshot], + gauges: Seq[SingleValueSnapshot], + counters: Seq[SingleValueSnapshot] +) -case class TickSnapshot(interval: Interval, metrics: RegistrySnapshot) +case class TickSnapshot(interval: Interval, metrics: MetricsSnapshot) -trait RegistrySnapshotGenerator { - def snapshot(): RegistrySnapshot -} -- cgit v1.2.3