metrics

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. class LoggerSender extends MetricSender

    

30. class LoggerSenderActor extends Actor with ActorLogging with MetricsLogger

    

    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

    

    Configuration class for the metric reporter

    Configuration class for the metric reporter

    metricSender

    A MetricSender instance that the reporter will use to send metrics

    globalTags

    filters

    frequency

    includeHostInGlobalTags

46. trait MetricSender extends AnyRef

    

47. type MetricSet = Set[Metric]

    

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

    

    The MetricSystem is a set of actors which handle the background operations of dealing with metrics.

    The MetricSystem is a set of actors which handle the background operations of dealing with metrics. In most cases, you only want to have one MetricSystem per application.

    Metrics are generated periodically by a Tick message published on the global event bus. By default this happens once per second, but it can be configured to any time interval. So while events are being collected as they occur, compiled metrics (such as rates and histogram percentiles) are generated once per tick.

    id

    The ID of the metrics system

    namespace

    the base of the url describing the location of metrics within the system

    clock

    an actor which serves as the clock for the metric system

    database

    an actor which serves as the database of the metric system

    snapshot

    tickPeriod

    The frequency of the tick message

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

    

50. case class MetricSystemId(id: Long) extends Product with Serializable

    

51. type MetricValue = Long

    

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

    

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

    

54. class OpenTsdbSenderActor extends Actor with ActorLogging with MetricsLogger

    

55. 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

56. trait Rate extends EventCollector

    

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

    

58. implicit final class RichMetricMap extends AnyVal

    

59. implicit final class RichMetricset extends AnyVal

    

60. implicit final class RichTagMap extends AnyVal

    

61. implicit final class RichValueMap extends AnyVal

    

62. 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

63. 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.

64. class SharedCounter extends Counter with SharedLocality[Counter]

    

65. class SharedGauge extends Gauge with SharedLocality[Gauge]

    

66. class SharedHistogram extends Histogram with SharedLocality[Histogram]

    

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

    

68. 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

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

    

70. class SystemMetricsCollector extends AnyRef

    

71. trait TagGenerator extends AnyRef

    

72. type TagMap = Map[String, String]

    

73. 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"

74. class TaggedHistogram extends AnyRef

    

75. class TickTracker extends AnyRef

    

76. trait TickedCollector extends EventCollector

    

77. trait TickedMetric extends AnyRef

    

    Any metric that needs to be ticked by the external clock

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

    

79. class TimeSeriesBuilder extends AnyRef

    

80. type Timestamp = Long

    

81. type ValueMap = Map[TagMap, MetricValue]

    

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