FanoutStatsCollection

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addGauge(name: String)(gauge: ⇒ Double): Unit

Add a gauge function, which is used to sample instantaneous values.

def addListener(listener: StatsListener): Unit

Attach a new StatsListener to this collection.

def addMetric(name: String, distribution: Distribution): Unit

Adds a set of values to a named metric.

def addMetric(name: String, value: Int): Unit

Adds a value to a named metric, which tracks min, max, mean, and a histogram.

final def asInstanceOf[T0]: T0

def clearAll(): Unit

Reset all collected stats and erase the history.

def clearGauge(name: String): Unit

Remove a gauge from the provided stats.

def clearLabel(name: String): Unit

Clear an existing label.

def clone(): AnyRef

val counterMap: ConcurrentHashMap[String, Counter]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fillInJvmCounters(out: Map[String, Long]): Unit

def fillInJvmGauges(out: Map[String, Double]): Unit

Use JMX (shudder) to fill in stats about the JVM into a mutable map.

def finalize(): Unit

val gaugeMap: ConcurrentHashMap[String, () ⇒ Double]

def get(): StatsSummary

Summarize all the counters, metrics, gauges, and labels in this collection.

final def getClass(): Class[_]

def getCounter(name: String): Counter

Get the Counter object representing a named counter.

def getCounters(): HashMap[String, Long]

Summarize all the counters in this collection.

def getGauge(name: String): Option[Double]

Get the current value of a named gauge.

def getGauges(): HashMap[String, Double]

Summarize all the gauges in this collection.

def getLabel(name: String): Option[String]

Get the current value of a named label, if it exists.

def getLabels(): Map[String, String]

Summarize all the labels in this collection.

def getMetric(name: String): Metric

Get the Metric object representing a named metric.

def getMetrics(): HashMap[String, Distribution]

Summarize all the metrics in this collection.

def hashCode(): Int

var includeJvmStats: Boolean

Set this to true to have the collection fill in a set of automatic gauges from the JVM.

def incr(name: String): Long

Increments a counter by one, returning the new value.

def incr(name: String, count: Int): Long

Increments a counter, returning the new value.

final def isInstanceOf[T0]: Boolean

val labelMap: ConcurrentHashMap[String, String]

val log: Logger

def makeCounter(name: String, atomic: AtomicLong): Counter

val metricMap: ConcurrentHashMap[String, Metric]

final def ne(arg0: AnyRef): Boolean

def newCounter(name: String): FanoutCounter

def newMetric(name: String): FanoutMetric

final def notify(): Unit

final def notifyAll(): Unit

def removeCounter(name: String): Unit

def removeMetric(name: String): Option[Metric]

def setGauge(name: String, value: Double): Unit

Set a gauge to a specific value.

def setLabel(name: String, value: String): Unit

Set a label to a string.

final def synchronized[T0](arg0: ⇒ T0): T0

def time[T](name: String)(f: ⇒ T): T

Runs the function f and logs that duration, in milliseconds, with the given name.

def timeFutureMicros[T](name: String)(f: Future[T]): Future[T]

Runs the function f and logs that duration until the future is satisfied, in microseconds, with the given name.

def timeFutureMillisLazy[T](name: String)(f: ⇒ Future[T]): Future[T]

Lazily runs the Future that f returns and measure the duration of Future creation and time until it is satisfied, in milliseconds, with the given name

def timeFutureNanos[T](name: String)(f: Future[T]): Future[T]

Runs the function f and logs that duration until the future is satisfied, in nanoseconds, with the given name.

def timeMicros[T](name: String)(f: ⇒ T): T

Runs the function f and logs that duration, in microseconds, with the given name.

def timeNanos[T](name: String)(f: ⇒ T): T

Runs the function f and logs that duration, in nanoseconds, with the given name.

def toJson(): String

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def timeFutureMillis[T](name: String)(f: Future[T]): Future[T]

Runs the function f and logs that duration until the future is satisfied, in milliseconds, with the given name.