colossus

metrics

package metrics

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. metrics
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. trait ActorMetrics extends Actor with ActorLogging

  2. sealed trait AggregationType extends AnyRef

  3. class BaseHistogram extends AnyRef

    This is the actual histogram data structure.

    This is the actual histogram data structure. It knows nothing of tags or metrics

  4. class BasicCounter extends AnyRef

  5. class BasicGauge extends AnyRef

  6. class BasicRate extends AnyRef

  7. final case class BucketList(buckets: Vector[Int]) extends AnyVal with Product with Serializable

  8. trait Collection[L[_] <: Locality[_]] extends AnyRef

  9. case class CollectionContext(globalTags: TagMap) extends Product with Serializable

  10. class Collector extends Actor with ActorMetrics

  11. class ConcreteGauge extends Gauge with LocalLocality[Gauge] with TickedCollector

  12. class ConcreteRate extends Rate with LocalLocality[Rate] with TickedCollector

  13. trait Counter extends EventCollector

  14. case class CounterParams(address: MetricAddress) extends MetricParams[Counter, CounterParams] with Product with Serializable

  15. class DuplicateMetricException extends Exception

  16. trait EventCollector extends AnyRef

  17. trait EventLocality[E <: EventCollector] extends AnyRef

  18. case class Frame(timestamp: Long, metrics: MetricMap) extends Product with Serializable

  19. trait Gauge extends EventCollector

  20. case class GaugeParams(address: MetricAddress, expireAfter: Duration = 1.hour, expireTo: Option[Long] = None) extends MetricParams[Gauge, GaugeParams] with Product with Serializable

  21. trait Generator[L[_] <: Locality[_], C <: EventCollector, P] extends AnyRef

    This is a typeclass that is basically just an EventCollector factory.

    This is a typeclass that is basically just an EventCollector factory.

    Note - we may be able to get rid of the Locality type-param since as of now it looks like we only need generators for local collectors, but we'll leave it for now since it's fully hidden from users anyway

  22. case class GroupBy(tags: Set[String], aggregationType: AggregationType) extends Product with Serializable

  23. trait Histogram extends EventCollector

  24. case class HistogramParams(address: MetricAddress, bucketRanges: BucketList = Histogram.defaultBucketRanges, periods: List[FiniteDuration] = List(1.second, 1.minute), percentiles: List[Double] = Histogram.defaultPercentiles, tagPrecision: FiniteDuration = 1.second, sampleRate: Double = 1.0) extends MetricParams[Histogram, HistogramParams] with Product with Serializable

  25. class LocalCollection extends Collection[LocalLocality]

    A Local collection is designed only to be used inside an actor or otherwise thread-safe environment.

    A Local collection is designed only to be used inside an actor or otherwise thread-safe environment. Notice that even though the collection we're storing the event collectors is thread-safe, the collectors themselves are not. The collector actor must be the actor receiving events for metrics in the map

    note - this is not intended to be directly constructed by users

  26. class LocalCounter extends BasicCounter with Counter with LocalLocality[Counter]

  27. trait LocalLocality[+T] extends Locality[T] with MetricProducer

  28. sealed trait Locality[+T] extends AnyRef

  29. case class LoggerSender(verbose: Boolean = false) extends MetricSender with Product with Serializable

  30. class LoggerSenderActor extends Actor with ActorLogging

    Simple sender that just prints the stats to the log

  31. case class Metric(address: MetricAddress, values: ValueMap) extends Product with Serializable

  32. case class MetricAddress(components: List[String]) extends Product with Serializable

  33. class MetricClock extends Actor with ActorLogging

  34. class MetricDatabase extends Actor with ActorLogging

  35. trait MetricEvent extends AnyRef

  36. case class MetricFilter(address: MetricAddress, valueFilter: MetricValueFilter, alias: Option[MetricAddress] = None) extends Product with Serializable

    A metric filter is essentially a selector for a metric along with a filter for processing/aggregating the values

  37. trait MetricFormatter[T] extends AnyRef

  38. case class MetricFragment(address: MetricAddress, tags: TagMap, value: MetricValue) extends Product with Serializable

  39. type MetricMap = Map[MetricAddress, ValueMap]

  40. class MetricMapBuilder extends AnyRef

  41. trait MetricParams[E <: EventCollector, T] extends AnyRef

    Since we are basically requiring every EventCollector to be constructed with a single parameter (which should be a case class), this trait is required to be extended by that parameter.

    Since we are basically requiring every EventCollector to be constructed with a single parameter (which should be a case class), this trait is required to be extended by that parameter. The type parameter exists solely for the purpose of type inference, so we can do getOrAdd(Rate(...)), and simply by supplying the Rate (which returns a RateParams, which extends MetricParams[Rate]), the method can infer that it should be returning a Rate

  42. trait MetricProducer extends AnyRef

    Anything that eventually expands to a set of raw stats extends this

  43. case class MetricReport(globalTags: TagMap, metrics: SerializedMetricMap, reportingFreqMillis: Int, timestamp: Long) extends Product with Serializable

  44. class MetricReporter extends Actor with ActorLogging

  45. case class MetricReporterConfig(metricSender: MetricSender, globalTags: Option[TagGenerator] = None, filters: Option[Seq[MetricFilter]] = None, frequency: FiniteDuration = 60.seconds, includeHostInGlobalTags: Boolean = true) extends Product with Serializable

  46. trait MetricSender extends AnyRef

  47. type MetricSet = Set[Metric]

  48. case class MetricSystem(namespace: MetricAddress, clock: ActorRef, database: ActorRef, snapshot: Agent[MetricMap], tickPeriod: FiniteDuration) extends Product with Serializable

  49. case class MetricSystemConfig(tickPeriod: FiniteDuration = 1.second) extends Product with Serializable

  50. type MetricValue = Long

  51. case class MetricValueFilter(filter: Option[TagSelector], aggregate: Option[GroupBy]) extends Product with Serializable

  52. case class OpenTsdbSender(host: String, port: Int) extends MetricSender with Product with Serializable

  53. class OpenTsdbSenderActor extends Actor with ActorLogging

  54. class PeriodicHistogram extends Histogram with TickedCollector with LocalLocality[Histogram]

    A periodic histogram multiplexes a histogram into several with different periods of resetting

    A periodic histogram multiplexes a histogram into several with different periods of resetting

    Ticks are controlled externally so we can ensure that we get a complete set of data before resetting the hists

  55. trait Rate extends EventCollector

  56. case class RateParams(address: MetricAddress, periods: List[FiniteDuration], tagPrecision: FiniteDuration = 1.second) extends MetricParams[Rate, RateParams] with Product with Serializable

  57. implicit final class RichMetricMap extends AnyVal

  58. implicit final class RichMetricset extends AnyVal

  59. implicit final class RichTagMap extends AnyVal

  60. implicit final class RichValueMap extends AnyVal

  61. trait SemiTypedActorRef[M] extends AnyRef

    STAR's are purely for maintaining sanity when actors are being passed all over the place and are intended to help detect at compile time when we're sending a message to the wrong actor.

    STAR's are purely for maintaining sanity when actors are being passed all over the place and are intended to help detect at compile time when we're sending a message to the wrong actor. eg, no more "foo: ActorRef" in parameters

    It is not intended to ensure an actor can handle the messages that are sent to it. Perhaps we will switch to typed channels when those are more stable

  62. class SharedCollection extends Collection[SharedLocality]

    A Shared collection is a collection where every metric it returns is completely thread-safe.

    A Shared collection is a collection where every metric it returns is completely thread-safe. A Shared collection is useful if you want to pass one collection to many actors, but be aware that since every event is sent as a separate actor message (as opposed to local collections which collect events just as function calls), this should not be used for very-high frequency events.

  63. class SharedCounter extends Counter with SharedLocality[Counter]

  64. class SharedGauge extends Gauge with SharedLocality[Gauge]

  65. class SharedHistogram extends Histogram with SharedLocality[Histogram]

  66. trait SharedLocality[+T] extends Locality[T]

  67. class SharedRate extends Rate with SharedLocality[Rate]

    Notice - the SharedRate is just a front for sending actor messages.

    Notice - the SharedRate is just a front for sending actor messages. The collector must be the actor that actually has access to the concrete rate, where is should call it's "event" method when it receives this message

  68. case class Snapshot(min: Int, max: Int, count: Int, percentiles: Map[Double, Int]) extends Product with Serializable

  69. class SystemMetricsCollector extends AnyRef

  70. trait TagGenerator extends AnyRef

  71. type TagMap = Map[String, String]

  72. case class TagSelector(tags: Map[String, Seq[String]]) extends Product with Serializable

    Used to select one or more values on one or more tags

    Used to select one or more values on one or more tags

    eg. Suppose we have a metric "foo" with a tag named "bar" with values "A", "B", "C". We can pass a selector "foo" -> ["A", "B"] to indicate we wish to select values on the metric where "foo" is "A" or "B"

  73. class TaggedHistogram extends AnyRef

  74. class TickTracker extends AnyRef

  75. trait TickedCollector extends EventCollector

  76. trait TickedMetric extends AnyRef

    Any metric that needs to be ticked by the external clock

  77. case class TimeSeries(address: MetricAddress, tags: TagMap, data: Seq[(Long, Long)]) extends Product with Serializable

  78. class TimeSeriesBuilder extends AnyRef

  79. type Timestamp = Long

  80. type ValueMap = Map[TagMap, MetricValue]

  81. case class Window(frames: Seq[Frame]) extends Product with Serializable

Value Members

  1. object AggregationType

  2. object Collection

  3. object Counter

  4. object EventLocality

  5. object Frame extends Serializable

  6. object Gauge

  7. object Histogram

    A Basic log-scale histogram, mainly designed to measure latency

    A Basic log-scale histogram, mainly designed to measure latency

    Each bucket handles an increasingly large range of values from 0 to MAX_INT.

  8. object LocalCollection

  9. object Metric extends Serializable

  10. object MetricAddress extends Serializable

  11. object MetricClock

  12. object MetricDatabase

  13. object MetricFilter extends Serializable

  14. object MetricFilterParser extends RegexParsers

  15. object MetricFilters

  16. object MetricMap

  17. object MetricReporter

  18. object MetricSender

  19. object MetricSystem extends Serializable

  20. object MetricValueFilter extends Serializable

  21. object OpenTsdbFormatter extends MetricFormatter[String]

  22. object PeriodicHistogram

  23. object Rate

  24. object SharedCollection

  25. object Snapshot extends Serializable

  26. object TagMap

  27. object TagSelector extends Serializable

  28. object TickTracker

  29. object Timestamp

  30. object ValueMap

Inherited from AnyRef

Inherited from Any

Ungrouped