diff options
Diffstat (limited to 'kamon-core/src/main/scala/kamon/metric/Registry.scala')
-rw-r--r-- | kamon-core/src/main/scala/kamon/metric/Registry.scala | 222 |
1 files changed, 222 insertions, 0 deletions
diff --git a/kamon-core/src/main/scala/kamon/metric/Registry.scala b/kamon-core/src/main/scala/kamon/metric/Registry.scala new file mode 100644 index 00000000..3f549802 --- /dev/null +++ b/kamon-core/src/main/scala/kamon/metric/Registry.scala @@ -0,0 +1,222 @@ +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")) +} + + + + + |