class Riemann::Event

Constants

RESERVED_FIELDS

Fields which are specially encoded in the Event protobuf–that is, they can’t be used as attributes.

VIRTUAL_FIELDS

Fields which don’t really exist in protobufs, but which are reserved and can’t be used as attributes.

Public Class Methods

average(states, init = Event.new) click to toggle source

Average a set of states together. Chooses the mean metric, the mode state, mode service, and the mean time. If init is provided, its values override (where present) the computed ones.

# File lib/riemann/event.rb, line 40
def self.average(states, init = Event.new)
  init = case init
         when Event
           init.dup
         else
           Event.new init
         end

  # Metric
  init.metric_f ||= states.inject(0.0) do |a, state|
    a + (state.metric || 0)
  end / states.size
  init.metric_f = 0.0 if init.metric_f.nan?

  # Event
  init.state ||= mode states.map(&:state)
  init.service ||= mode states.map(&:service)

  # Time
  init.time_micros = begin
    times = states.map(&:time_micros).compact
    (times.inject(:+) / times.size).to_i
  rescue ZeroDivisionError
    nil
  end
  init.time_micros ||= now

  init
end
max(states, init = Event.new) click to toggle source

Finds the maximum of a set of states. Metric is the maximum. Event is the highest, as defined by Dash.config.state_order. Time is the mean.

# File lib/riemann/event.rb, line 105
def self.max(states, init = Event.new)
  init = case init
         when Event
           init.dup
         else
           Event.new init
         end

  # Metric
  init.metric_f ||= states.inject(0.0) do |a, state|
    a + (state.metric || 0)
  end
  init.metric = 0.0 if init.metric.nan?

  # Event
  init.state ||= states.inject(nil) do |max, state|
    state.state if Dash.config[:state_order][state.state] > Dash.config[:state_order][max]
  end

  # Time
  init.time_micros = begin
    times = states.map(&:time_micros).compact
    (times.inject(:+) / times.size).to_i
  rescue ZeroDivisionError
    nil
  end
  init.time_micros ||= now

  init
end
mode(array) click to toggle source
# File lib/riemann/event.rb, line 136
def self.mode(array)
  array.each_with_object(Hash.new(0)) do |e, counts|
    counts[e] += 1
  end.max_by { |_e, count| count }.first # rubocop:disable Style/MultilineBlockChain
rescue StandardError
  nil
end
new(hash = nil) click to toggle source
Calls superclass method
# File lib/riemann/event.rb, line 172
def initialize(hash = nil)
  if hash
    super hash
    self.metric = hash[:metric] if hash[:metric]

    # Add extra attributes to the event as Attribute instances with values
    # converted to String
    self.attributes = hash.map do |key, _value|
      unless RESERVED_FIELDS.include? key.to_sym
        Attribute.new(key: key.to_s,
                      value: (hash[key] || hash[key.to_sym]).to_s)
      end
    end.compact
  else
    super()
  end

  @time_micros ||= self.class.now unless @time
end
now() click to toggle source
# File lib/riemann/event.rb, line 33
def self.now
  (Time.now.to_f * 1_000_000).to_i
end
partition(states, field) click to toggle source

Partition a list of states by a field Returns a hash of field_value => state

# File lib/riemann/event.rb, line 146
def self.partition(states, field)
  states.each_with_object({}) do |state, p|
    k = state.send field
    if p.include? k
      p[k] << state
    else
      p[k] = [state]
    end
  end
end
sort(states, field) click to toggle source

Sorts states by a field. nil values first.

# File lib/riemann/event.rb, line 158
def self.sort(states, field)
  states.sort do |a, b|
    a = a.send field
    b = b.send field
    if a.nil?
      -1
    elsif b.nil?
      1
    else
      a <=> b
    end
  end
end
sum(states, init = Event.new) click to toggle source

Sum a set of states together. Adds metrics, takes the mode state, mode service and the mean time. If init is provided, its values override (where present) the computed ones.

# File lib/riemann/event.rb, line 73
def self.sum(states, init = Event.new)
  init = case init
         when Event
           init.dup
         else
           Event.new init
         end

  # Metric
  init.metric_f ||= states.inject(0.0) do |a, state|
    a + (state.metric || 0)
  end
  init.metric_f = 0.0 if init.metric_f.nan?

  # Event
  init.state ||= mode states.map(&:state)
  init.service ||= mode states.map(&:service)

  # Time
  init.time_micros = begin
    times = states.map(&:time_micros).compact
    (times.inject(:+) / times.size).to_i
  rescue ZeroDivisionError
    nil
  end
  init.time_micros ||= now

  init
end

Public Instance Methods

[](key) click to toggle source

Look up attributes

Calls superclass method
# File lib/riemann/event.rb, line 209
def [](key)
  if RESERVED_FIELDS.include? key.to_sym
    super
  else
    attributes.find { |a| a.key.to_s == key.to_s }.value
  end
end
[]=(key, value) click to toggle source

Set attributes

Calls superclass method
# File lib/riemann/event.rb, line 218
def []=(key, value)
  if RESERVED_FIELDS.include? key.to_sym
    super
  else
    attr = attributes.find { |a| a.key == key.to_s }
    if attr
      attr.value = value.to_s
    else
      attributes << Attribute.new(key: key.to_s, value: value.to_s)
    end
  end
end
metric() click to toggle source
# File lib/riemann/event.rb, line 192
def metric
  metric_d ||
    metric_sint64 ||
    metric_f
end
metric=(value) click to toggle source
# File lib/riemann/event.rb, line 198
def metric=(value)
  if value.is_a?(Integer) && (-(2**63)...2**63).include?(value)
    # Long
    self.metric_sint64 = value
  else
    self.metric_d = value.to_f
  end
  self.metric_f = value.to_f
end