diff options
Diffstat (limited to 'kamon-core/src/main/scala')
14 files changed, 235 insertions, 82 deletions
diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala index e6b93459..b5ea0c28 100644 --- a/kamon-core/src/main/scala/kamon/Kamon.scala +++ b/kamon-core/src/main/scala/kamon/Kamon.scala @@ -16,13 +16,14 @@ package kamon import _root_.akka.actor import _root_.akka.actor._ +import _root_.scala.util.{ Success, Failure, Try } import com.typesafe.config.{ Config, ConfigFactory } import kamon.metric._ import kamon.trace.TracerModuleImpl import kamon.util.logger.LazyLogger object Kamon { - private val log = LazyLogger(getClass) + private val log = LazyLogger("Kamon") trait Extension extends actor.Extension @@ -40,6 +41,8 @@ object Kamon { log.info("Initializing Kamon...") + tryLoadAutoweaveModule() + ActorSystem("kamon", patchedConfig) } @@ -52,10 +55,22 @@ object Kamon { def start(): Unit = _start def shutdown(): Unit = { - // TODO: Define what a proper shutdown should be like. _system.shutdown() } + private def tryLoadAutoweaveModule(): Unit = { + val color = (msg: String) ⇒ s"""\u001B[32m${msg}\u001B[0m""" + + log.info("Trying to load kamon-autoweave...") + + Try(Class.forName("kamon.autoweave.Autoweave$")) match { + case Success(_) ⇒ + log.info(color("Kamon-autoweave has been successfully loaded.")) + log.info(color("The AspectJ loadtime weaving agent is now attached to the JVM (you don't need to use -javaagent).")) + case Failure(reason) ⇒ log.debug(s"Kamon-autoweave failed to load. Reason: we have not found the ${reason.getMessage} class in the classpath.") + } + } + private def resolveConfiguration: Config = { val defaultConfig = ConfigFactory.load() diff --git a/kamon-core/src/main/scala/kamon/ModuleLoader.scala b/kamon-core/src/main/scala/kamon/ModuleLoader.scala index 55874a33..b594d4cf 100644 --- a/kamon-core/src/main/scala/kamon/ModuleLoader.scala +++ b/kamon-core/src/main/scala/kamon/ModuleLoader.scala @@ -20,7 +20,7 @@ import _root_.akka.actor import _root_.akka.actor._ import kamon.util.logger.LazyLogger import org.aspectj.lang.ProceedingJoinPoint -import org.aspectj.lang.annotation.{Around, Aspect, Pointcut} +import org.aspectj.lang.annotation.{ Around, Aspect, Pointcut } private[kamon] object ModuleLoader extends ExtensionId[ModuleLoaderExtension] with ExtensionIdProvider { def lookup(): ExtensionId[_ <: actor.Extension] = ModuleLoader diff --git a/kamon-core/src/main/scala/kamon/metric/EntityRecorder.scala b/kamon-core/src/main/scala/kamon/metric/EntityRecorder.scala index e1e89b79..c1392d4d 100644 --- a/kamon-core/src/main/scala/kamon/metric/EntityRecorder.scala +++ b/kamon-core/src/main/scala/kamon/metric/EntityRecorder.scala @@ -95,7 +95,7 @@ case class GaugeRecorder(key: MetricKey, instrument: Gauge) extends SingleInstru /** * Base class with plenty of utility methods to facilitate the creation of [[EntityRecorder]] implementations. - * It is not required to use this base class for defining custom a custom [[EntityRecorder]], but it is certainly + * It is not required to use this base class for defining a custom [[EntityRecorder]], but it is certainly * the most convenient way to do it and the preferred approach throughout the Kamon codebase. */ abstract class GenericEntityRecorder(instrumentFactory: InstrumentFactory) extends EntityRecorder { diff --git a/kamon-core/src/main/scala/kamon/metric/MetricScaleDecorator.scala b/kamon-core/src/main/scala/kamon/metric/MetricScaleDecorator.scala new file mode 100644 index 00000000..e096429d --- /dev/null +++ b/kamon-core/src/main/scala/kamon/metric/MetricScaleDecorator.scala @@ -0,0 +1,55 @@ +/* + * ========================================================================================= + * 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 + +import akka.actor.{ Actor, ActorRef, Props } +import kamon.metric.SubscriptionsDispatcher.TickMetricSnapshot +import kamon.metric.instrument._ + +/** + * Can be used as a decorator to scale TickMetricSnapshot messages to given `timeUnits` and/or `memoryUnits` + * before forwarding to original receiver + * @param timeUnits Optional time units to scale time metrics to + * @param memoryUnits Optional memory units to scale memory metrics to + * @param receiver Receiver of scaled metrics snapshot, usually a backend sender + */ +class MetricScaleDecorator(timeUnits: Option[Time], memoryUnits: Option[Memory], receiver: ActorRef) extends Actor { + require(timeUnits.isDefined || memoryUnits.isDefined, + "Use MetricScaleDecorator only when any of units is defined") + + override def receive: Receive = { + case tick: TickMetricSnapshot ⇒ + val scaled = tick.copy(metrics = tick.metrics.mapValues { entitySnapshot ⇒ + new DefaultEntitySnapshot(entitySnapshot.metrics.map { + case (metricKey, metricSnapshot) ⇒ + val scaledSnapshot = (metricKey.unitOfMeasurement, timeUnits, memoryUnits) match { + case (time: Time, Some(to), _) ⇒ metricSnapshot.scale(time, to) + case (memory: Memory, _, Some(to)) ⇒ metricSnapshot.scale(memory, to) + case _ ⇒ metricSnapshot + } + metricKey -> scaledSnapshot + }) + }) + receiver forward scaled + } +} + +object MetricScaleDecorator { + def props(timeUnits: Option[Time], memoryUnits: Option[Memory], receiver: ActorRef): Props = + Props(new MetricScaleDecorator(timeUnits, memoryUnits, receiver)) +} + diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/Counter.scala b/kamon-core/src/main/scala/kamon/metric/instrument/Counter.scala index c1b69cbe..349a12bd 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/Counter.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/Counter.scala @@ -33,6 +33,7 @@ object Counter { trait Snapshot extends InstrumentSnapshot { def count: Long def merge(that: InstrumentSnapshot, context: CollectionContext): Counter.Snapshot + def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Counter.Snapshot } } @@ -57,4 +58,8 @@ case class CounterSnapshot(count: Long) extends Counter.Snapshot { case CounterSnapshot(thatCount) ⇒ CounterSnapshot(count + thatCount) case other ⇒ sys.error(s"Cannot merge a CounterSnapshot with the incompatible [${other.getClass.getName}] type.") } + + override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Counter.Snapshot = + CounterSnapshot(from.tryScale(to)(count).toLong) + }
\ No newline at end of file diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/Histogram.scala b/kamon-core/src/main/scala/kamon/metric/instrument/Histogram.scala index 5c4c7f71..dc9a4bbf 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/Histogram.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/Histogram.scala @@ -17,9 +17,9 @@ package kamon.metric.instrument import java.nio.LongBuffer -import org.HdrHistogram.AtomicHistogramFieldsAccessor -import kamon.metric.instrument.Histogram.{ Snapshot, DynamicRange } -import org.HdrHistogram.AtomicHistogram + +import kamon.metric.instrument.Histogram.{ DynamicRange, Snapshot } +import org.HdrHistogram.ModifiedAtomicHistogram trait Histogram extends Instrument { type SnapshotType = Histogram.Snapshot @@ -54,11 +54,9 @@ object Histogram { * @param lowestDiscernibleValue * The lowest value that can be discerned (distinguished from 0) by the histogram.Must be a positive integer that * is >= 1. May be internally rounded down to nearest power of 2. - * * @param highestTrackableValue * The highest value to be tracked by the histogram. Must be a positive integer that is >= (2 * lowestDiscernibleValue). * Must not be larger than (Long.MAX_VALUE/2). - * * @param precision * The number of significant decimal digits to which the histogram will maintain value resolution and separation. * Must be a non-negative integer between 1 and 3. @@ -87,6 +85,39 @@ object Histogram { def recordsIterator: Iterator[Record] def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot def merge(that: Histogram.Snapshot, context: CollectionContext): Histogram.Snapshot + + override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot = + new ScaledSnapshot(from, to, this) + } + + class ScaledSnapshot(from: UnitOfMeasurement, to: UnitOfMeasurement, snapshot: Snapshot) extends Snapshot { + private def doScale(v: Long) = from.tryScale(to)(v).toLong + override def numberOfMeasurements: Long = snapshot.numberOfMeasurements + + override def max: Long = doScale(snapshot.max) + + override def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot = snapshot.merge(that, context) + + override def merge(that: Snapshot, context: CollectionContext): Snapshot = snapshot.merge(that, context) + + override def percentile(percentile: Double): Long = doScale(snapshot.percentile(percentile)) + + override def min: Long = doScale(snapshot.min) + + override def sum: Long = doScale(snapshot.sum) + + override def recordsIterator: Iterator[Record] = { + snapshot.recordsIterator.map(record ⇒ new Record { + override def count: Long = record.count + + override def level: Long = doScale(record.level) + + override private[kamon] def rawCompactRecord: Long = record.rawCompactRecord + }) + } + + override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot = + if (this.from == from && this.to == to) this else super.scale(from, to) } object Snapshot { @@ -99,6 +130,7 @@ object Histogram { override def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot = that override def merge(that: Histogram.Snapshot, context: CollectionContext): Histogram.Snapshot = that override def numberOfMeasurements: Long = 0L + override def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): Histogram.Snapshot = this } } } @@ -108,9 +140,8 @@ object Histogram { * The collect(..) operation extracts all the recorded values from the histogram and resets the counts, but still * leave it in a consistent state even in the case of concurrent modification while the snapshot is being taken. */ -class HdrHistogram(dynamicRange: DynamicRange) extends AtomicHistogram(dynamicRange.lowestDiscernibleValue, - dynamicRange.highestTrackableValue, dynamicRange.precision) with Histogram with AtomicHistogramFieldsAccessor { - import AtomicHistogramFieldsAccessor.totalCountUpdater +class HdrHistogram(dynamicRange: DynamicRange) extends ModifiedAtomicHistogram(dynamicRange.lowestDiscernibleValue, + dynamicRange.highestTrackableValue, dynamicRange.precision) with Histogram { def record(value: Long): Unit = recordValue(value) @@ -125,7 +156,7 @@ class HdrHistogram(dynamicRange: DynamicRange) extends AtomicHistogram(dynamicRa val measurementsArray = Array.ofDim[Long](buffer.limit()) buffer.get(measurementsArray, 0, measurementsArray.length) - new CompactHdrSnapshot(nrOfMeasurements, measurementsArray, unitMagnitude(), subBucketHalfCount(), subBucketHalfCountMagnitude()) + new CompactHdrSnapshot(nrOfMeasurements, measurementsArray, protectedUnitMagnitude(), protectedSubBucketHalfCount(), protectedSubBucketHalfCountMagnitude()) } def getCounts = countsArray().length() @@ -148,22 +179,8 @@ class HdrHistogram(dynamicRange: DynamicRange) extends AtomicHistogram(dynamicRa index += 1 } - - reestablishTotalCount(nrOfMeasurements) nrOfMeasurements } - - private def reestablishTotalCount(diff: Long): Unit = { - def tryUpdateTotalCount: Boolean = { - val previousTotalCount = totalCountUpdater.get(this) - val newTotalCount = previousTotalCount - diff - - totalCountUpdater.compareAndSet(this, previousTotalCount, newTotalCount) - } - - while (!tryUpdateTotalCount) {} - } - } case class CompactHdrSnapshot(val numberOfMeasurements: Long, compactRecords: Array[Long], unitMagnitude: Int, diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/Instrument.scala b/kamon-core/src/main/scala/kamon/metric/instrument/Instrument.scala index 089dbeec..2c4b4319 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/Instrument.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/Instrument.scala @@ -18,10 +18,6 @@ package kamon.metric.instrument import java.nio.LongBuffer -import akka.actor.{ Scheduler, Cancellable } -import akka.dispatch.MessageDispatcher -import scala.concurrent.duration.FiniteDuration - private[kamon] trait Instrument { type SnapshotType <: InstrumentSnapshot @@ -31,6 +27,8 @@ private[kamon] trait Instrument { trait InstrumentSnapshot { def merge(that: InstrumentSnapshot, context: CollectionContext): InstrumentSnapshot + + def scale(from: UnitOfMeasurement, to: UnitOfMeasurement): InstrumentSnapshot } trait CollectionContext { diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSettings.scala b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSettings.scala index 4423964a..f7516262 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSettings.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/InstrumentSettings.scala @@ -1,7 +1,5 @@ package kamon.metric.instrument -import java.util.concurrent.TimeUnit - import com.typesafe.config.Config import kamon.metric.instrument.Histogram.DynamicRange diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/AtomicHistogramFieldsAccessor.scala b/kamon-core/src/main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala index e79090a8..eb01d114 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/AtomicHistogramFieldsAccessor.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/ModifiedAtomicHistogram.scala @@ -16,20 +16,16 @@ package org.HdrHistogram -import java.util.concurrent.atomic.{ AtomicLongArray, AtomicLongFieldUpdater } +import java.util.concurrent.atomic.AtomicLongArray -trait AtomicHistogramFieldsAccessor { - self: AtomicHistogram ⇒ +abstract class ModifiedAtomicHistogram(low: Long, high: Long, precision: Int) + extends AtomicHistogram(low, high, precision) { self ⇒ - def countsArray(): AtomicLongArray = self.counts + override def incrementTotalCount(): Unit = {} + override def addToTotalCount(value: Long): Unit = {} - def unitMagnitude(): Int = self.unitMagnitude - - def subBucketHalfCount(): Int = self.subBucketHalfCount - - def subBucketHalfCountMagnitude(): Int = self.subBucketHalfCountMagnitude -} - -object AtomicHistogramFieldsAccessor { - def totalCountUpdater(): AtomicLongFieldUpdater[AtomicHistogram] = AtomicHistogram.totalCountUpdater -} + def countsArray(): AtomicLongArray = counts + def protectedUnitMagnitude(): Int = unitMagnitude + def protectedSubBucketHalfCount(): Int = subBucketHalfCount + def protectedSubBucketHalfCountMagnitude(): Int = subBucketHalfCountMagnitude +}
\ No newline at end of file diff --git a/kamon-core/src/main/scala/kamon/metric/instrument/UnitOfMeasurement.scala b/kamon-core/src/main/scala/kamon/metric/instrument/UnitOfMeasurement.scala index c5a1b81a..5952b906 100644 --- a/kamon-core/src/main/scala/kamon/metric/instrument/UnitOfMeasurement.scala +++ b/kamon-core/src/main/scala/kamon/metric/instrument/UnitOfMeasurement.scala @@ -22,14 +22,27 @@ package kamon.metric.instrument * recorders and might be used to scale certain kinds of measurements in metric backends. */ trait UnitOfMeasurement { + type U <: UnitOfMeasurement + def name: String def label: String + def scale(toUnit: U)(value: Double): Double = value + + def tryScale(toUnit: UnitOfMeasurement)(value: Double): Double = + if (canScale(toUnit)) scale(toUnit.asInstanceOf[U])(value) + else throw new IllegalArgumentException(s"Can't scale different types of units `$name` and `${toUnit.name}`") + + protected def canScale(toUnit: UnitOfMeasurement): Boolean + } object UnitOfMeasurement { case object Unknown extends UnitOfMeasurement { + override type U = Unknown.type val name = "unknown" val label = "unknown" + + override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isUnknown(toUnit) } def isUnknown(uom: UnitOfMeasurement): Boolean = @@ -47,10 +60,13 @@ object UnitOfMeasurement { * UnitOfMeasurement representing time. */ case class Time(factor: Double, label: String) extends UnitOfMeasurement { + override type U = Time val name = "time" - def scale(toUnit: Time)(value: Double): Double = + override def scale(toUnit: Time)(value: Double): Double = (value * factor) / toUnit.factor + + override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isTime(toUnit) } object Time { @@ -58,22 +74,36 @@ object Time { val Microseconds = Time(1E-6, "µs") val Milliseconds = Time(1E-3, "ms") val Seconds = Time(1, "s") + + val units = List(Nanoseconds, Microseconds, Milliseconds, Seconds) + + def apply(time: String): Time = units.find(_.label.toLowerCase == time.toLowerCase) getOrElse { + throw new IllegalArgumentException(s"Can't recognize time unit '$time'") + } } /** * UnitOfMeasurement representing computer memory space. */ case class Memory(factor: Double, label: String) extends UnitOfMeasurement { + override type U = Memory val name = "bytes" - def scale(toUnit: Memory)(value: Double): Double = + override def scale(toUnit: Memory)(value: Double): Double = (value * factor) / toUnit.factor + + override protected def canScale(toUnit: UnitOfMeasurement): Boolean = UnitOfMeasurement.isMemory(toUnit) } object Memory { val Bytes = Memory(1, "b") val KiloBytes = Memory(1024, "Kb") - val MegaBytes = Memory(1024E2, "Mb") - val GigaBytes = Memory(1024E3, "Gb") -} + val MegaBytes = Memory(1024 * 1024, "Mb") + val GigaBytes = Memory(1024 * 1024 * 1024, "Gb") + val units = List(Bytes, KiloBytes, MegaBytes, GigaBytes) + + def apply(memory: String): Memory = units.find(_.label.toLowerCase == memory.toLowerCase) getOrElse { + throw new IllegalArgumentException(s"Can't recognize memory unit '$memory'") + } +} diff --git a/kamon-core/src/main/scala/kamon/trace/MetricsOnlyContext.scala b/kamon-core/src/main/scala/kamon/trace/MetricsOnlyContext.scala index 869bcc12..c044719c 100644 --- a/kamon-core/src/main/scala/kamon/trace/MetricsOnlyContext.scala +++ b/kamon-core/src/main/scala/kamon/trace/MetricsOnlyContext.scala @@ -52,7 +52,8 @@ private[kamon] class MetricsOnlyContext(traceName: String, val token: String, iz val traceElapsedTime = NanoInterval.since(startTimestamp) _elapsedTime = traceElapsedTime - Kamon.metrics.entity(TraceMetrics, name).elapsedTime.record(traceElapsedTime.nanos) + if (Kamon.metrics.shouldTrack(name, TraceMetrics.category)) + Kamon.metrics.entity(TraceMetrics, name).elapsedTime.record(traceElapsedTime.nanos) drainFinishedSegments() } @@ -67,7 +68,8 @@ private[kamon] class MetricsOnlyContext(traceName: String, val token: String, iz "category" -> segment.category, "library" -> segment.library) - Kamon.metrics.entity(SegmentMetrics, segment.name, segmentTags).elapsedTime.record(segment.duration.nanos) + if (Kamon.metrics.shouldTrack(segment.name, SegmentMetrics.category)) + Kamon.metrics.entity(SegmentMetrics, segment.name, segmentTags).elapsedTime.record(segment.duration.nanos) drainFinishedSegments() } } diff --git a/kamon-core/src/main/scala/kamon/util/ConfigTools.scala b/kamon-core/src/main/scala/kamon/util/ConfigTools.scala index bcec22c3..d0665764 100644 --- a/kamon-core/src/main/scala/kamon/util/ConfigTools.scala +++ b/kamon-core/src/main/scala/kamon/util/ConfigTools.scala @@ -22,6 +22,8 @@ import com.typesafe.config.Config import scala.concurrent.duration.FiniteDuration +import kamon.metric.instrument.{ Memory, Time } + object ConfigTools { implicit class Syntax(val config: Config) extends AnyVal { // We are using the deprecated .getNanoseconds option to keep Kamon source code compatible with @@ -37,6 +39,10 @@ object ConfigTools { case entry ⇒ entry.getKey.takeWhile(_ != '.') } toSet } + + def time(path: String): Time = Time(config.getString(path)) + + def memory(path: String): Memory = Memory(config.getString(path)) } } diff --git a/kamon-core/src/main/scala/kamon/util/NeedToScale.scala b/kamon-core/src/main/scala/kamon/util/NeedToScale.scala new file mode 100644 index 00000000..19e1ae06 --- /dev/null +++ b/kamon-core/src/main/scala/kamon/util/NeedToScale.scala @@ -0,0 +1,37 @@ +/* + * ========================================================================================= + * 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.util + +import com.typesafe.config.Config +import kamon.metric.instrument.{ Memory, Time } +import kamon.util.ConfigTools._ + +object NeedToScale { + val TimeUnits = "time-units" + val MemoryUnits = "memory-units" + + def unapply(config: Config): Option[(Option[Time], Option[Memory])] = { + val scaleTimeTo: Option[Time] = + if (config.hasPath(TimeUnits)) Some(config.time(TimeUnits)) else None + + val scaleMemoryTo: Option[Memory] = + if (config.hasPath(MemoryUnits)) Some(config.memory(MemoryUnits)) else None + if (scaleTimeTo.isDefined || scaleMemoryTo.isDefined) Some(scaleTimeTo -> scaleMemoryTo) + else None + } +} + diff --git a/kamon-core/src/main/scala/kamon/util/executors/ExecutorServiceMetrics.scala b/kamon-core/src/main/scala/kamon/util/executors/ExecutorServiceMetrics.scala index 7a87163f..98d2ea0c 100644 --- a/kamon-core/src/main/scala/kamon/util/executors/ExecutorServiceMetrics.scala +++ b/kamon-core/src/main/scala/kamon/util/executors/ExecutorServiceMetrics.scala @@ -16,10 +16,10 @@ package kamon.util.executors +import java.util.concurrent.{ ExecutorService, ForkJoinPool ⇒ JavaForkJoinPool, ThreadPoolExecutor } + import kamon.Kamon import kamon.metric.Entity -import java.util.concurrent.{ ForkJoinPool ⇒ JavaForkJoinPool } -import java.util.concurrent.{ ExecutorService, ThreadPoolExecutor } import scala.concurrent.forkjoin.ForkJoinPool import scala.util.control.NoStackTrace @@ -48,8 +48,10 @@ object ExecutorServiceMetrics { * @param threadPool The intance of the [[ThreadPoolExecutor]] * @param tags The tags associated to the [[ThreadPoolExecutor]] */ - private def registerThreadPool(name: String, threadPool: ThreadPoolExecutor, tags: Map[String, String]): Unit = { - Kamon.metrics.entity(ThreadPoolExecutorMetrics.factory(threadPool, Category), Entity(name, Category, tags)) + @inline private def registerThreadPool(name: String, threadPool: ThreadPoolExecutor, tags: Map[String, String]): Entity = { + val threadPoolEntity = Entity(name, Category, tags + ("executor-type" -> "thread-pool-executor")) + Kamon.metrics.entity(ThreadPoolExecutorMetrics.factory(threadPool, Category), threadPoolEntity) + threadPoolEntity } /** @@ -60,8 +62,10 @@ object ExecutorServiceMetrics { * @param forkJoinPool The instance of the [[ForkJoinPool]] * @param tags The tags associated to the [[ForkJoinPool]] */ - private def registerScalaForkJoin(name: String, forkJoinPool: ForkJoinPool, tags: Map[String, String] = Map.empty): Unit = { - Kamon.metrics.entity(ForkJoinPoolMetrics.factory(forkJoinPool, Category), Entity(name, Category, tags)) + @inline private def registerScalaForkJoin(name: String, forkJoinPool: ForkJoinPool, tags: Map[String, String]): Entity = { + val forkJoinEntity = Entity(name, Category, tags + ("executor-type" -> "fork-join-pool")) + Kamon.metrics.entity(ForkJoinPoolMetrics.factory(forkJoinPool, Category), forkJoinEntity) + forkJoinEntity } /** @@ -72,8 +76,10 @@ object ExecutorServiceMetrics { * @param forkJoinPool The instance of the [[JavaForkJoinPool]] * @param tags The tags associated to the [[JavaForkJoinPool]] */ - private def registerJavaForkJoin(name: String, forkJoinPool: JavaForkJoinPool, tags: Map[String, String] = Map.empty): Unit = { - Kamon.metrics.entity(ForkJoinPoolMetrics.factory(forkJoinPool, Category), Entity(name, Category, tags)) + @inline private def registerJavaForkJoin(name: String, forkJoinPool: JavaForkJoinPool, tags: Map[String, String]): Entity = { + val forkJoinEntity = Entity(name, Category, tags + ("executor-type" -> "fork-join-pool")) + Kamon.metrics.entity(ForkJoinPoolMetrics.factory(forkJoinPool, Category), forkJoinEntity) + forkJoinEntity } /** @@ -84,7 +90,7 @@ object ExecutorServiceMetrics { * @param executorService The instance of the [[ExecutorService]] * @param tags The tags associated to the [[ExecutorService]] */ - def register(name: String, executorService: ExecutorService, tags: Map[String, String]): Unit = executorService match { + def register(name: String, executorService: ExecutorService, tags: Map[String, String]): Entity = executorService match { case threadPoolExecutor: ThreadPoolExecutor ⇒ registerThreadPool(name, threadPoolExecutor, tags) case scalaForkJoinPool: ForkJoinPool if scalaForkJoinPool.getClass.isAssignableFrom(ScalaForkJoinPool) ⇒ registerScalaForkJoin(name, scalaForkJoinPool, tags) case javaForkJoinPool: JavaForkJoinPool if javaForkJoinPool.getClass.isAssignableFrom(JavaForkJoinPool) ⇒ registerJavaForkJoin(name, javaForkJoinPool, tags) @@ -94,36 +100,24 @@ object ExecutorServiceMetrics { case other ⇒ throw new NotSupportedException(s"The ExecutorService $name is not supported.") } - //Java variants - def register(name: String, executorService: ExecutorService): Unit = { - register(name, executorService, Map.empty[String, String]) - } - - def register(name: String, executorService: ExecutorService, tags: java.util.Map[String, String]): Unit = { + //Java variant + def register(name: String, executorService: ExecutorService, tags: java.util.Map[String, String]): Entity = { import scala.collection.JavaConverters._ register(name, executorService, tags.asScala.toMap) } /** * - * Remove the [[https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html ExecutorService]] to Monitor. + * Register the [[https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html ExecutorService]] to Monitor. * * @param name The name of the [[ExecutorService]] - * @param tags The tags associated to the [[ExecutorService]] + * @param executorService The instance of the [[ExecutorService]] */ - def remove(name: String, tags: Map[String, String]): Unit = { - Kamon.metrics.removeEntity(name, Category, tags) - } - - //Java variants - def remove(name: String): Unit = { - remove(name, Map.empty[String, String]) + def register(name: String, executorService: ExecutorService): Entity = { + register(name, executorService, Map.empty[String, String]) } - def remove(name: String, tags: java.util.Map[String, String]): Unit = { - import scala.collection.JavaConverters._ - remove(name, tags.asScala.toMap) - } + def remove(entity: Entity): Unit = Kamon.metrics.removeEntity(entity) /** * INTERNAL USAGE ONLY |