ustate-client 0.0.3 → 0.0.4

data/README.markdown

@@ -83,6 +83,7 @@ Email
 -----
 
 config.rb:
+
     # Email comes from this address (required):
     emailer.from = 'ustate@your.net'
 
@@ -93,10 +94,56 @@ config.rb:
     emailer.tell 'you@gmail.com', 'state = "error" or state = "critical"'
     emailer.tell 'you@gmail.com', 'service =~ "mysql%"'
 
+Aggregating states
+---
+
+UState can fold together states matching some criteria to provide a more
+general overview of a complex system. Folds are executed in a separate thread
+and polled from the index every aggregator.interval seconds.
+
+config.rb:
+
+    # Add together the metrics for all feed mergers on any host.
+    # The resulting state has service name 'feed merger', but no host.
+    aggregator.sum 'service = "feed merger" and host != null', host: nil
+ 
+    # Average latencies
+    aggregator.average 'service = "api latency"'
+
+    # You can also pass any block to aggregator.fold. The block will be called
+    # with an array of states matching your query.
+    aggregator.fold 'service = "custom"' do |states|
+      UState::State.new(
+        service: 'some crazy result',
+        metric_f: states.map(&:metric_f).max
+      )
+    end
+
+Graphite
+---
+
+UState can forward metrics to Graphite. Just specify a query matching states
+you'd like to forward. Forwarding is performed in a separate thread, and polled from the index every graphite.interval seconds.
+
+config.rb:
+
+    graphite.host = 'foo'
+    graphite.port = 12345
+
+    # Submit states every 5 seconds
+    graphite.interval = 5
+    
+    # Send everything without a host
+    graphite.graph 'host = null'
+
+    # And also include the disk use on all nodes
+    graphite.graph 'service = "disk"'
+    
 Custom hooks
 ------------
 
 config.rb:
+
     # Log all states received to console.
     index.on_state do |s|
       p s

data/lib/ustate/aggregator.rb

@@ -0,0 +1,69 @@
+module UState
+  class Aggregator
+    # Combines states periodically.
+
+    INTERVAL = 1
+
+    attr_accessor :interval
+    attr_accessor :folds
+    def initialize(index, opts = {})
+      @index = index
+
+      @folds = {}
+      @interval = opts[:interval] || INTERVAL
+
+      start
+    end
+
+    # Combines states matching query with State.average
+    def average(query, init = State.new)
+      fold query do |states|
+        State.average states, init
+      end
+    end
+
+    # Combines states matching query with the given block. The block
+    # receives an array of states which presently match.
+    # 
+    # Example:
+    #   fold 'service = "api % reqs/sec"' do |states|
+    #     states.inject(State.new(service: 'api reqs/sec')) do |combined, state|
+    #       combined.metric_f += state.metric_f
+    #       combined
+    #     end
+    #   end
+    def fold(query, &block)
+      @folds[block] = if existing = @folds[block]
+        "(#{existing}) or (#{q})"
+      else
+        query
+      end
+    end
+
+    # Polls index for states matching each fold, applies fold, and inserts into
+    # index.
+    def start
+      @runner = Thread.new do
+        loop do
+          interval = (@interval.to_f / @folds.size) rescue @interval
+          @folds.each do |f, query|
+            matching = @index.query(Query.new(string: query))
+            unless matching.empty?
+              if combined = f[matching]
+                @index << combined
+              end
+            end
+            sleep interval
+          end
+        end
+      end
+    end
+
+    # Combines states matching query with State.sum
+    def sum(query, init = State.new)
+      fold query do |states|
+        State.sum states, init
+      end
+    end
+  end
+end

data/lib/ustate/client.rb

@@ -89,7 +89,7 @@ class UState::Client
     @locket.synchronize do
       begin
         tries += 1
-          yield (@socket or connect)
+          yield (@socket || connect)
       rescue IOError => e
         raise if tries > 3
         connect and retry
@@ -102,6 +102,9 @@ class UState::Client
       rescue Errno::ECONNRESET => e
         raise if tries > 3
         connect and retry
+      rescue InvalidResponse => e
+        raise if tries > 3
+        connect and retry
       end
     end
   end

data/lib/ustate/dash/helper/renderer.rb

@@ -101,11 +101,17 @@ module UState
       #                  names have common prefixes removed.
       #   hosts: an array of hosts for rows. Default is every host present in
       #          states, sorted.
+      #   transpose: Hosts go across, services go down. Enables :global_maxima.
+      #   global_maximum: Compute default maxima for services globally,
+      #                  instead of a different maximum for each service.
       def state_chart(states, opts = {})
         o = {
           :maxima => {},
           :service_names => {}
         }.merge opts
+        if o[:transpose] and not o.include?(:global_maximum)
+          o[:global_maximum] = true
+        end
 
         # Get all services
         services = states.map { |s| s.service }.compact.uniq.sort
@@ -118,10 +124,18 @@ module UState
         end.merge o[:service_names]
 
         # Compute maximum for each service
-        maxima = states.inject(Hash.new(0)) do |m, s|
-          m[s.service] = [s.metric, m[s.service]].max
-          m
-        end.merge o[:maxima]
+        maxima = if o[:global_maximum]
+          max = states.map(&:metric).max
+          services.inject({}) do |m, s|
+            m[s] = max
+            m
+          end.merge o[:maxima]
+        else
+          states.inject(Hash.new(0)) do |m, s|
+            m[s.service] = [s.metric, m[s.service]].max
+            m
+          end.merge o[:maxima]
+        end
 
         # Compute union of all hosts for these states, if no
         # list of hosts explicitly given.
@@ -139,27 +153,51 @@ module UState
         # Title
         title = o[:title] || prefix.capitalize rescue 'Unknown'
 
-        h2(title) +
-        table(
-          tr(
-            th,
+        if o[:transpose]
+          h2(title) +
+          table(
+            tr(
+              th,
+              *hosts.map do |host|
+                th host
+              end
+            ),
             *services.map do |service|
-              th service_names[service]
-            end
-          ),
-          *hosts.map do |host|
+              tr(
+                th(service_names[service]),
+                *hosts.map do |host|
+                  s = by[[host, service]]
+                  td(
+                    s ? state_bar(s, max: maxima[service]) : nil
+                  )
+                end
+              )
+            end,
+            :class => 'chart'
+          )
+        else
+          h2(title) +
+          table(
             tr(
-              th(host),
+              th,
               *services.map do |service|
-                s = by[[host, service]]
-                td(
-                  s ? state_bar(s, max: maxima[service]) : nil
-                )
+                th service_names[service]
               end
-            )
-          end,
-          :class => 'chart'
-        )
+            ),
+            *hosts.map do |host|
+              tr(
+                th(host),
+                *services.map do |service|
+                  s = by[[host, service]]
+                  td(
+                    s ? state_bar(s, max: maxima[service]) : nil
+                  )
+                end
+              )
+            end,
+            :class => 'chart'
+          )
+        end
       end
 
       # Renders a state as a short tag.

data/lib/ustate/dash/views/index.erubis

@@ -1,3 +1,5 @@
 <div class="box"><%= state_list query 'state != "ok"' %></div>
 
 <div class="box"><%= state_chart query 'service = "cpu" or service = "memory" or service =~ "disk%" or service = "load"' %></div>
+
+<div class="box"><%= state_chart query('host = "host0"'), transpose: true %></div>

data/lib/ustate/dash/views/layout.erubis

@@ -1,11 +1,16 @@
 <html>
 <head>
   <title>Dashboard</title>
-  <meta http-equiv="refresh" content="1" />
   <link rel="stylesheet" type="text/css" href="/css" />
+
+  <script type="text/javascript">
+    setTimeout(function() {
+      location.reload(true);
+    }, 10000);
+  </script>
 </head>
 
-<body>
+<body onload="refresh();">
   <div>
     <h1>Dashboard</h1>
     <span style="position: absolute; top: 4px; right: 4px;">(as of <%= time Time.now.to_i %>)</span>

data/lib/ustate/emailer.rb

@@ -1,5 +1,8 @@
 module UState
   class Emailer
+    # Sends emails when the index receives state transitions matching specific
+    # queries.
+
     require 'net/smtp'
 
     attr_accessor :from
@@ -32,7 +35,7 @@ module UState
       raise ArgumentError, "no from address" unless @from
       
       # Subject
-      subject = "#{s.host} #{s.service} #{s.state}"
+      subject = "#{s.host} #{s.service}"
       if s.once
         subject << " transient "
       else
@@ -59,11 +62,10 @@ EOF
 
     # Dispatch emails to each address which is interested in this state
     def receive(*states)
-      state = states.last
       Thread.new do
         @tell.each do |address, q|
-          if q === state
-            email address, state
+          if states.any? { |state| p  state; q === state }
+            email address, states.last
           end
         end
       end

data/lib/ustate/graphite.rb

@@ -0,0 +1,101 @@
+module UState
+  class Graphite
+    # Forwards states to Graphite.
+    HOST = '127.0.0.1'
+    PORT = 2003
+    INTERVAL = 5
+
+    attr_accessor :query
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :interval
+
+    def initialize(index, opts = {})
+      @index = index
+      @query = opts[:query]
+      @host = opts[:host] || HOST
+      @port = opts[:port] || PORT
+      @interval = opts[:interval] || INTERVAL
+      @locket = Mutex.new
+
+      start
+    end
+
+    def connect
+      @socket = TCPSocket.new(@host, @port)
+    end
+
+    def graph(q)
+      if @query
+        @query = "(#{@query}) or (#{q})"
+      else
+        @query = q
+      end
+    end
+
+    def forward(state)
+      # Figure out what time to use.
+      present = Time.now.to_i
+      if (present - state.time) >= @interval
+        time = present
+      else
+        time = state.time
+      end
+
+      # Construct message
+      string = "#{path(state)} #{state.metric} #{time}"
+      
+      # Validate string
+      if string["\n"]
+        raise ArgumentError, "#{string} has a newline"
+      end
+
+      with_connection do |s|
+        s.puts string
+      end
+    end
+
+    # Formats a state into a Graphite metric path.
+    def path(state)
+      if state.host
+        host = state.host.split('.').reverse.join('.')
+        "#{host}.#{state.service.gsub(' ', '.')}"
+      else
+        state.service.gsub(' ', '.')
+      end
+    end
+
+    def start
+      @runner = Thread.new do
+        loop do
+          @index.query(Query.new(string: @query)).each do |state|
+            forward state
+          end
+          sleep @interval
+        end
+      end
+    end
+
+    def with_connection
+      tries = 0
+      @locket.synchronize do
+        begin
+          tries += 1
+          yield (@socket or connect)
+        rescue IOError => e
+          raise if tries > 3
+          connect and retry
+        rescue Errno::EPIPE => e
+          raise if tries > 3
+          connect and retry
+        rescue Errno::ECONNREFUSED => e
+          raise if tries > 3
+          connect and retry
+        rescue Errno::ECONNRESET => e
+          raise if tries > 3
+          connect and retry
+        end
+      end
+    end
+  end
+end

data/lib/ustate/metric_thread.rb

@@ -0,0 +1,68 @@
+class UState::MetricThread
+  # A metric thread is simple: it wraps some metric object which responds to <<,
+  # and every interval seconds, calls #flush which replaces the object and calls
+  # a user specified function.
+ 
+  INTERVAL = 10
+  
+  attr_accessor :interval
+  attr_accessor :metric
+
+  # client = UState::Client.new
+  # m = MetricThread.new Mtrc::Rate do |rate|
+  #   client << rate
+  # end
+  #
+  # loop do
+  #   sleep rand
+  #   m << rand
+  # end
+  def initialize(klass, *klass_args, &f)
+    @klass = klass
+    @klass_args = klass_args
+    @f = f
+    @interval = INTERVAL
+
+    @metric = new_metric
+
+    start
+  end
+
+  def <<(*a)
+    @metric.<<(*a)
+  end
+
+  def new_metric
+    @klass.new *@klass_args
+  end
+
+  def flush
+    old, @metric = @metric, new_metric
+    @f[old]
+  end
+
+  def start
+    raise RuntimeError, "already running" if @runner
+  
+    @running = true
+    @runner = Thread.new do
+      while @running
+        sleep @interval
+        begin
+          flush
+        rescue Exception => e
+        end
+      end
+      @runner = nil
+    end
+  end
+
+  def stop
+    stop!
+    @runner.join
+  end
+
+  def stop!
+    @running = false
+  end
+end

data/lib/ustate/query.rb

@@ -3,5 +3,22 @@ module UState
     include Beefcake::Message
   
     optional :string, :string, 1
+
+    # Converts a Query or string to a query AST.
+    def self.query(q)
+      case q
+      when String
+        parser = QueryStringParser.new
+        q = parser.parse(q)
+        unless q
+          raise ArgumentError, "error parsing #{query_string.inspect} at line #{parser.failure_line}:#{parser.failure_column}: #{parser.failure_reason}"
+        end
+        q.query
+      when Query
+        query q.string
+      else
+        raise ArgumentError, "don't know what to do with #{q.class} #{q.inspect}"
+      end
+    end
   end 
 end

data/lib/ustate/query_string.rb

@@ -635,8 +635,13 @@ module UState
           if r3
             r0 = r3
           else
-            @index = i0
-            r0 = nil
+            r4 = _nt_null
+            if r4
+              r0 = r4
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
@@ -1048,6 +1053,57 @@ module UState
       r0
     end
 
+    module Null0
+      def ruby_value
+        nil
+      end
+      alias sql ruby_value
+    end
+
+    def _nt_null
+      start_index = index
+      if node_cache[:null].has_key?(index)
+        cached = node_cache[:null][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      if has_terminal?('null', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
+        @index += 4
+      else
+        terminal_parse_failure('null')
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+        r0.extend(Null0)
+      else
+        if has_terminal?('nil', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 3))
+          @index += 3
+        else
+          terminal_parse_failure('nil')
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+          r0.extend(Null0)
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+
+      node_cache[:null][start_index] = r0
+
+      r0
+    end
+
     def _nt_space
       start_index = index
       if node_cache[:space].has_key?(index)

data/lib/ustate/query_string.treetop

@@ -92,7 +92,7 @@ module UState
     end
 
     rule value
-      double_quoted_string / float / integer
+      double_quoted_string / float / integer / null
     end
 
     rule integer
@@ -137,6 +137,15 @@ module UState
       }
     end
 
+    rule null
+      ('null' / 'nil') {
+        def ruby_value
+          nil
+        end
+        alias sql ruby_value
+      }
+    end
+
     rule space
       [\s]+
     end

data/lib/ustate/server.rb

@@ -14,9 +14,14 @@ module UState
     require 'treetop'
     require 'ustate/query_string'
     require 'ustate/query/ast'
+    require 'ustate/metric_thread'
+    require 'mtrc'
 
     attr_accessor :backends
     attr_accessor :index
+    attr_writer :aggregator
+    attr_writer :emailer
+    attr_writer :graphite
    
     def initialize(opts = {})
       # Backends
@@ -30,11 +35,21 @@ module UState
       setup_signals
     end
 
+    def aggregator(opts = {})
+      require 'ustate/aggregator'
+      @aggregator ||= UState::Aggregator.new(@index, opts)
+    end
+
     def emailer(opts = {})
       require 'ustate/emailer'
       @emailer ||= UState::Emailer.new(@index, opts)
     end
 
+    def graphite(opts = {})
+      require 'ustate/graphite'
+      @graphite ||= UState::Graphite.new(@index, opts)
+    end
+
     def start
       @index.start
      

data/lib/ustate/server/index.rb

@@ -10,8 +10,17 @@ module UState
 
     THREADS = 1000
     BUFFER_SIZE = 10
+    # Forget about states after
+    EXPIRY = 1000
+
+    # Update metrics every
+    INSERT_RATE_INTERVAL = 5
+    INSERT_TIMES_INTERVAL = 5
     
-    attr_reader :db, :queue 
+    attr_reader :db, :queue
+    attr_accessor :expiry
+    attr_accessor :insert_rate_interval
+    attr_accessor :insert_times_interval
 
     def initialize(opts = {})
       @db = Sequel.sqlite
@@ -23,6 +32,10 @@ module UState
       @on_state_once = []
       @on_state = []
 
+      @expiry = opts[:expiry] || EXPIRY
+
+      @insert_rate_interval = opts[:insert_rate_interval] || INSERT_RATE_INTERVAL
+      @insert_times_interval = opts[:insert_times_interval] || INSERT_TIMES_INTERVAL
       setup_db
     end
 
@@ -31,7 +44,11 @@ module UState
     end
 
     def <<(s)
+      t0 = Time.now
       process s
+      dt = Time.now - t0
+      @insert_times << dt
+      @insert_rate << 1
     end
 
     def thread(s)
@@ -83,7 +100,7 @@ module UState
         # Update
         if current[:time] <= s.time
           if current[:state] != s.state
-            on_state_change current, s
+            on_state_change row_to_state(current), s
           end           
 
           # Update
@@ -128,6 +145,36 @@ module UState
       end
     end
 
+    # Remove states older than @expiry
+    def reap
+      @db[:states].filter { |s| 
+        s.time < (Time.now - @expiry).to_i 
+      }.each do |row|
+        on_state_change(
+          row_to_state(row),
+          row_to_state(
+            row.merge(
+              state: 'unknown',
+              description: "ustate has not heard from this service since #{Time.at(row[:time])}",
+              metric_f: nil, 
+              time: Time.now.to_i
+            )
+          )
+        )
+        @db[:states].filter(host: row[:host], state: row[:state]).delete
+      end
+    end
+
+    # Periodically expire old states.
+    def reaper
+      Thread.new do
+        loop do
+          sleep 1
+          reap
+        end
+      end
+    end
+
     # Converts a row to a State
     def row_to_state(row)
       State.new(row)
@@ -149,13 +196,49 @@ module UState
     def start
       stop!
       @pool = []
+      @reaper = reaper
+
+      @insert_rate = MetricThread.new(Mtrc::Rate) do |r|
+        self << State.new(
+          service: "ustate insert rate",
+          state: "ok",
+          host: Socket.gethostname,
+          time: Time.now.to_i,
+          metric_f: r.rate.to_f,
+        )
+      end
+      @insert_rate.interval = @insert_rate_interval
+      
+      @insert_times = MetricThread.new(Mtrc::SortedSamples) do |r|
+        self << State.new(
+          service: "ustate insert 50",
+          state: "ok",
+          host: Socket.gethostname,
+          time: Time.now.to_i,
+          metric_f: r % 50,
+        )
+        self << State.new(
+          service: "ustate insert 95",
+          state: "ok",
+          host: Socket.gethostname,
+          time: Time.now.to_i,
+          metric_f: r % 95,
+        )
+        self << State.new(
+          service: "ustate insert 99",
+          state: "ok",
+          host: Socket.gethostname,
+          time: Time.now.to_i,
+          metric_f: r % 99,
+        )
+      end
+      @insert_times.interval = @insert_times_interval
     end
 
     # Finish up
     def stop
-      @pool.each do |thread|
-        thread.join
-      end
+      @insert_rate.stop rescue nil
+      @insert_times.stop rescue nil
     end
 
     def stop!

data/lib/ustate/state.rb

@@ -1,19 +1,156 @@
-class UState::State
-  include Beefcake::Message
-  
-  optional :time, :int64, 1 
-  optional :state, :string,  2
-  optional :service, :string, 3
-  optional :host, :string, 4
-  optional :description, :string, 5
-  optional :once, :bool, 6
-  optional :metric_f, :float, 15
-
-  def metric
-    @metric || metric_f
-  end
+module UState
+  class State
+    include Beefcake::Message
+    
+    optional :time, :int64, 1 
+    optional :state, :string,  2
+    optional :service, :string, 3
+    optional :host, :string, 4
+    optional :description, :string, 5
+    optional :once, :bool, 6
+    optional :metric_f, :float, 15
+
+    # 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.
+    def self.average(states, init = State.new)
+      init = case init
+             when State
+               init.dup
+             else
+               State.new init
+             end
+      
+      # Metric
+      init.metric_f ||= states.inject(0.0) { |a, state|
+          a + (state.metric || 0)
+        } / states.size
+      if init.metric_f.nan?
+        init.metric_f = 0.0
+      end
+
+      # State
+      init.state ||= mode states.map(&:state)
+      init.service ||= mode states.map(&:service)
+
+      # Time
+      init.time ||= begin
+        (states.inject(0) do |a, state|
+          a + state.time.to_f
+        end / states.size).to_i
+      rescue
+      end
+      init.time ||= Time.now.to_i
+
+      init
+    end
+
+    # 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.
+    def self.sum(states, init = State.new)
+      init = case init
+             when State
+               init.dup
+             else
+               State.new init
+             end
+      
+      # Metric
+      init.metric_f ||= states.inject(0.0) { |a, state|
+          a + (state.metric || 0)
+        }
+      if init.metric_f.nan?
+        init.metric_f = 0.0
+      end
+
+      # State
+      init.state ||= mode states.map(&:state)
+      init.service ||= mode states.map(&:service)
+
+      # Time
+      init.time ||= begin
+        (states.inject(0) do |a, state|
+          a + state.time.to_f
+        end / states.size).to_i
+      rescue 
+      end
+      init.time ||= Time.now.to_i
+
+      init
+    end
+    
+    # Finds the maximum of a set of states. Metric is the maximum. State is the
+    # highest, as defined by Dash.config.state_order. Time is the mean.
+    def self.max(states, init = State.new)
+      init = case init
+             when State
+               init.dup
+             else
+               State.new init
+             end
+      
+      # Metric
+      init.metric_f ||= states.inject(0.0) { |a, state|
+          a + (state.metric || 0)
+        }
+      if init.metric_f.nan?
+        init.metric_f = 0.0
+      end
+
+      # State
+      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 ||= begin
+        (states.inject(0) { |a, state|
+          a + state.time.to_f
+        } / states.size).to_i
+      rescue
+      end
+      init.time ||= Time.now.to_i
+
+      init
+    end
+    
+    def self.mode(array)
+      array.inject(Hash.new(0)) do |counts, e|
+        counts[e] += 1
+        counts
+      end.sort_by { |e, count| count }.last.first rescue nil
+    end
+
+    # Partition a list of states by a field
+    # Returns a hash of field_value => state
+    def self.partition(states, field)
+      states.inject(Hash.new { [] }) do |p, state|
+        p[state.send(field)] << state
+      end
+    end
+
+    # Sorts states by a field. nil values first.
+    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
+
+    def metric
+      @metric || metric_f
+    end
 
-  def metric=(m)
-    @metric = m
+    def metric=(m)
+      @metric = m
+    end
   end
 end

data/lib/ustate/version.rb

@@ -1,3 +1,3 @@
 module UState
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ustate-client
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-06 00:00:00.000000000 -07:00
-default_executable: 
+date: 2011-09-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beefcake
-  requirement: &15107700 !ruby/object:Gem::Requirement
+  requirement: &69429590 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +21,10 @@ dependencies:
         version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *15107700
+  version_requirements: *69429590
 - !ruby/object:Gem::Dependency
   name: trollop
-  requirement: &15107220 !ruby/object:Gem::Requirement
+  requirement: &69428990 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,7 +32,18 @@ dependencies:
         version: 1.16.2
   type: :runtime
   prerelease: false
-  version_requirements: *15107220
+  version_requirements: *69428990
+- !ruby/object:Gem::Dependency
+  name: mtrc
+  requirement: &69428610 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *69428610
 description: 
 email: aphyr@aphyr.com
 executables: []
@@ -41,41 +51,42 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ustate.rb
-- lib/ustate/query/not_equals.rb
-- lib/ustate/query/equals.rb
-- lib/ustate/query/or.rb
-- lib/ustate/query/approximately.rb
-- lib/ustate/query/and.rb
-- lib/ustate/query/ast.rb
-- lib/ustate/query/not.rb
+- lib/ustate/graphite.rb
 - lib/ustate/query_string.treetop
-- lib/ustate/server.rb
-- lib/ustate/emailer.rb
-- lib/ustate/query.rb
+- lib/ustate/message.rb
+- lib/ustate/metric_thread.rb
+- lib/ustate/aggregator.rb
 - lib/ustate/version.rb
-- lib/ustate/state.rb
-- lib/ustate/client/query.rb
-- lib/ustate/query_string.rb
-- lib/ustate/server/index.rb
+- lib/ustate/server/graphite.rb
 - lib/ustate/server/backends.rb
-- lib/ustate/server/backends/tcp.rb
 - lib/ustate/server/backends/base.rb
-- lib/ustate/server/graphite.rb
+- lib/ustate/server/backends/tcp.rb
+- lib/ustate/server/index.rb
 - lib/ustate/server/connection.rb
+- lib/ustate/server.rb
+- lib/ustate/dash.rb
+- lib/ustate/state.rb
+- lib/ustate/query.rb
+- lib/ustate/client/query.rb
 - lib/ustate/client.rb
-- lib/ustate/message.rb
-- lib/ustate/dash/helper/renderer.rb
-- lib/ustate/dash/views/css.scss
 - lib/ustate/dash/views/index.erubis
 - lib/ustate/dash/views/layout.erubis
-- lib/ustate/dash/state.rb
+- lib/ustate/dash/views/css.scss
 - lib/ustate/dash/controller/index.rb
 - lib/ustate/dash/controller/css.rb
 - lib/ustate/dash/config.rb
-- lib/ustate/dash.rb
+- lib/ustate/dash/helper/renderer.rb
+- lib/ustate/query/or.rb
+- lib/ustate/query/not_equals.rb
+- lib/ustate/query/ast.rb
+- lib/ustate/query/equals.rb
+- lib/ustate/query/approximately.rb
+- lib/ustate/query/not.rb
+- lib/ustate/query/and.rb
+- lib/ustate/query_string.rb
+- lib/ustate/emailer.rb
 - LICENSE
 - README.markdown
-has_rdoc: true
 homepage: https://github.com/aphyr/ustate
 licenses: []
 post_install_message: 
@@ -96,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ustate-client
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Client for the distributed state server ustate.

data/lib/ustate/dash/state.rb

@@ -1,75 +0,0 @@
-class UState::State
-  # Average a set of states together. Chooses the meane metric, the mode
-  # state, and the mean time. If init is provided, its values override (where present) the
-  # computed ones.
-  def average(states, init = State.new)
-    # Metric
-    init.metric ||= begin
-      states.inject(0) { |a, state|
-        a + (state.metric || 0)
-      } / states.size
-    rescue
-      nil
-    end
-
-    # State
-    init.state ||= states.inject(Hash.new(0)) do |counts, s|
-      counts[s.state] += 1
-      counts
-    end.sort_by { |state, count| count }.first.first rescue nil
-
-    init.time ||= begin
-      states.inject(0) do |a, state|
-        a + state.time.to_f
-      end / states.size
-    rescue
-    end
-
-    init
-  end
-
-  # Finds the maximum of a set of states. Metric is the maximum. State is the highest, 
-  # as defined by Dash.config.state_order. Time is the mean.
-  def max(states, init = {})
-    init.metric ||= states.inject(0) { |a, state|
-        a + (state.metric || 0)
-      }
-
-    init.state] ||= states.inject(nil) do |max, state|
-      state.state if Dash.config[:state_order][state.state] > Dash.config[:state_order][max]
-    end
-
-    init.time ||= begin
-      states.inject(0) { |a, state|
-        a + state.time.to_f
-      } / states.size
-    rescue
-      nil
-    end
-
-    init
-  end
-
-  # Partition a list of states by a field
-  # Returns a hash of field_value => state
-  def partition(states, field)
-    states.inject(Hash.new { [] }) do |p, state|
-      p[state.send(field)] << state
-    end
-  end
-
-  # Sorts states by a field. nil values first.
-  def 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
-end