riemann-client 0.0.6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Kyle Kingsbury
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,66 @@
+Installing
+==========
+
+    gem install riemann-client
+
+Use
+===
+
+``` ruby
+require 'riemann/client'
+
+# Create a client. Host and port are optional.
+c = Riemann::Client.new host: 'localhost', port: 5555
+
+# Send a simple event
+c << {service: 'testing', metric: 2.5}
+
+# Or a more complex one
+c << {
+  host: 'web3',
+  service: 'api latency',
+  state: 'warn',
+  metric: 63.5
+  description: "63.5 milliseconds per request"
+  time: Time.now.to_i - 10
+}
+
+# :host defaults to gethostname(). :time defaults to current unix time. You
+# can explicitly override host...
+
+c << {host: nil, service: 'the cloud', state: 'nebulous'}
+
+# Get all the states from the server
+c['true']
+
+# Or specific states matching a query
+c['host =~ "%.dc1" and (state = "critical" or state = "warning")']
+
+```
+
+Transports
+==========
+
+Riemann::Client sends small events over UDP by default, and uses TCP for
+queries and large events. UDP sends are essentially "shouting into the void".
+They will not block your application and are roughly an order of magnitude
+faster than TCP, but you will not know if the server is down or encountered an
+error. You can specify what transport to use by selecting a subclient:
+
+``` ruby
+c.udp << { :state "ok" } # => nil
+c.tcp << { :state "ok" } # => #<Message ...>
+c.tcp["true"]            # => [#<Event ... >, ...]
+c.udp["true"]            # => raise Riemann::Client::Unsupported
+```
+
+Client state management
+=======================
+
+Riemann::Client provides some classes to make managing state updates easier.
+
+Riemann::MetricThread starts a thread to poll a metric periodically, which can
+be used to flush an accumulated value to ustate at regular intervals.
+
+Riemann::AutoState bundles a state and a client together. Any changes to the
+AutoState automatically send the new state to the client.

data/lib/riemann.rb

@@ -0,0 +1,11 @@
+module Riemann
+  $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+  require 'beefcake'
+  require 'riemann/version'
+  require 'riemann/state'
+  require 'riemann/event'
+  require 'riemann/query'
+  require 'riemann/message'
+  require 'riemann/client'
+end

data/lib/riemann/auto_state.rb

@@ -0,0 +1,120 @@
+module Riemann
+  class AutoState
+    # Binds together a state hash and a Client. Any change made here
+    # sends the state to the client. Useful when updates to a state are made
+    # decoherently, e.g. across many methods. Combine with MetricThread (or
+    # just Thread.new { loop { autostate.flush; sleep n } }) to ensure regular
+    # updates.
+    #
+    # example:
+    #
+    # class Job
+    #   def initialize
+    #     @state = AutoState.new
+    #     @state.service = 'job'
+    #     @state.state = 'starting up'
+    #
+    #     run
+    #   end
+    #
+    #   def run
+    #     loop do
+    #       begin
+    #         a
+    #         b
+    #       rescue Exception => e
+    #         @state.once(
+    #           state: 'error',
+    #           description: e.to_s
+    #         )
+    #       end
+    #     end
+    #   end
+    #
+    #   def a
+    #     @state.state = 'heavy lifting a'
+    #     ...
+    #   end
+    #
+    #   def b
+    #     @state.state = 'heavy lifting b'
+    #     ...
+    #   end
+    
+    def initialize(client = Client.new, state = {})
+      @client = client
+      @state = state
+    end
+
+    def description=(description)
+      @state[:description] = description
+      flush
+    end
+
+    def description
+      @state[:description]
+    end
+
+    # Send state to client
+    def flush
+      @state[:time] = Time.now.to_i
+      @client << @state
+    end
+
+    def host=(host)
+      @state[:host] = host
+      flush
+    end
+
+    def host
+      @state[:host]
+    end
+
+    def metric=(metric)
+      @state[:metric] = metric
+      flush
+    end
+    alias metric_f= metric=
+
+    def metric
+      @state[:metric]
+    end
+    alias metric_f metric
+
+    # Performs multiple updates, followed by flush.
+    # Example: merge state: critical, metric_f: 10235.3
+    def merge(opts)
+      @state.merge! opts
+      flush
+    end
+    alias << merge
+
+    # Issues an immediate update of the state with tag "once"
+    # set, but does not update the local state. Useful for transient errors.
+    # Opts are merged with the state.
+    def once(opts)
+      o = @state.merge opts
+      o[:time] = Time.now.to_i
+      o[:tags] = ((o[:tags] | ["once"]) rescue ["once"])
+      @client << o
+    end
+
+    def state=(state)
+      @state[:state] = state
+      flush
+    end
+
+    def state
+      @state[:state]
+    end
+
+    def service=(service)
+      @state[:service] = service
+      flush
+    end 
+
+    def service
+      @state[:service]
+    end
+  end
+end

data/lib/riemann/client.rb

@@ -0,0 +1,89 @@
+require 'riemann'
+
+class Riemann::Client
+  class Error < RuntimeError; end
+  class InvalidResponse < Error; end
+  class ServerError < Error; end
+  class Unsupported < Error; end
+  class TooBig < Unsupported; end
+  
+  require 'thread'
+  require 'socket'
+  require 'time'
+
+  HOST = '127.0.0.1'
+  PORT = 5555
+
+  require 'riemann/client/tcp'
+  require 'riemann/client/udp'
+
+  attr_accessor :host, :port, :tcp, :udp
+
+  def initialize(opts = {})
+    @host = opts[:host] || HOST
+    @port = opts[:port] || PORT
+    @udp = UDP.new opts
+    @tcp = TCP.new opts
+  end
+
+  # Send a state
+  def <<(event_opts)
+    # Create state
+    case event_opts
+    when Riemann::State
+      event = event_opts
+    when Riemann::Event
+      event = event_opts
+    else
+      unless event_opts.include? :host
+        event_opts[:host] = Socket.gethostname
+      end
+      event = Riemann::Event.new(event_opts)
+    end
+
+    message = Riemann::Message.new :events => [event]
+
+    # Transmit
+    send_maybe_recv message
+  end
+
+  # Returns an array of states matching query.
+  def [](query)
+    response = query(query)
+    (response.events || []) |
+      (response.states || [])
+  end
+
+  # Close both UDP and TCP sockets.
+  def close
+    @udp.close
+    @tcp.close
+  end
+
+  # Connect both UDP and TCP sockets.
+  def connect
+    udp.connect
+    tcp.connect
+  end
+
+  def connected?
+    tcp.connected? and udp.connected?
+  end
+
+  # Ask for states
+  def query(string = "true")
+    send_recv Riemann::Message.new(query: Riemann::Query.new(string: string))
+  end
+
+  def send_recv(*a)
+    @tcp.send_recv *a
+  end
+
+  def send_maybe_recv(*a)
+    begin
+      @udp.send_maybe_recv *a
+    rescue TooBig
+      @tcp.send_maybe_recv *a
+    end
+  end
+end

data/lib/riemann/client/tcp.rb

@@ -0,0 +1,86 @@
+module Riemann
+  class Client
+    class TCP < Client
+      attr_accessor :host, :port, :socket
+
+      def initialize(opts = {})
+        @host = opts[:host] || HOST
+        @port = opts[:port] || PORT
+        @locket = Mutex.new
+      end
+
+      def connect
+        @socket = TCPSocket.new(@host, @port)
+      end
+
+      def close
+        @locket.synchronize do
+          @socket.close
+        end
+      end
+
+      def connected?
+        not @socket.closed?
+      end
+
+      # Read a message from a stream
+      def read_message(s)
+        if buffer = s.read(4) and buffer.size == 4
+          length = buffer.unpack('N').first
+          begin
+            str = s.read length
+            message = Riemann::Message.decode str
+          rescue => e
+            puts "Message was #{str.inspect}"
+            raise
+          end
+          
+          unless message.ok
+            puts "Failed"
+            raise ServerError, message.error
+          end
+          
+          message
+        else
+          raise InvalidResponse, "unexpected EOF"
+        end
+      end
+
+      def send_recv(message)
+        with_connection do |s|
+          s << message.encode_with_length
+          read_message s
+        end
+      end
+
+      alias send_maybe_recv send_recv
+
+      # Yields a connection in the block.
+      def with_connection
+        tries = 0
+        
+        @locket.synchronize do
+          begin
+            tries += 1
+              yield (@socket || 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
+          rescue InvalidResponse => e
+            raise if tries > 3
+            connect and retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riemann/client/udp.rb

@@ -0,0 +1,78 @@
+module Riemann
+  class Client
+    class UDP < Client
+      MAX_SIZE = 16384
+
+      attr_accessor :host, :port, :socket, :max_size
+
+      def initialize(opts = {})
+        @host = opts[:host] || HOST
+        @port = opts[:port] || PORT
+        @max_size = opts[:max_size] || MAX_SIZE
+        @locket = Mutex.new
+      end
+
+      def connect
+        @socket = UDPSocket.new
+      end
+
+      def close
+        @locket.synchronize do
+          @socket.close
+        end
+      end
+
+      def connected?
+        not @socket.closed?
+      end
+
+      # Read a message from a stream
+      def read_message(s)
+        raise Unsupported
+      end
+
+      def send_recv(*a)
+        raise Unsupported
+      end
+
+      def send_maybe_recv(message)
+        with_connection do |s|
+          x = message.encode ''
+          unless x.length < @max_size
+            raise TooBig
+          end
+
+          s.send(x, 0, @host, @port)
+          nil
+        end
+      end
+
+      # Yields a connection in the block.
+      def with_connection
+        tries = 0
+        
+        @locket.synchronize do
+          begin
+            tries += 1
+              yield (@socket || 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
+          rescue InvalidResponse => e
+            raise if tries > 3
+            connect and retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riemann/event.rb

@@ -0,0 +1,174 @@
+module Riemann
+  class Event
+    include Beefcake::Message
+    
+    optional :time, :int64, 1 
+    optional :state, :string,  2
+    optional :service, :string, 3
+    optional :host, :string, 4
+    optional :description, :string, 5
+    repeated :tags, :string, 7
+    optional :ttl, :float, 8
+    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 = Event.new)
+      init = case init
+             when Event
+               init.dup
+             else
+               Event.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
+
+      # Event
+      init.state ||= mode states.map(&:state)
+      init.service ||= mode states.map(&:service)
+
+      # Time
+      init.time = begin 
+        times = states.map(&:time).compact
+        (times.inject(:+) / times.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 = Event.new)
+      init = case init
+             when Event
+               init.dup
+             else
+               Event.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
+
+      # Event
+      init.state ||= mode states.map(&:state)
+      init.service ||= mode states.map(&:service)
+
+      # Time
+      init.time = begin 
+        times = states.map(&:time).compact
+        (times.inject(:+) / times.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. Event is the
+    # highest, as defined by Dash.config.state_order. Time is the mean.
+    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) { |a, state|
+          a + (state.metric || 0)
+        }
+      if init.metric_f.nan?
+        init.metric_f = 0.0
+      end
+
+      # 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 = begin 
+        times = states.map(&:time).compact
+        (times.inject(:+) / times.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({}) do |p, state|
+        k = state.send field
+        if p.include? k
+          p[k] << state
+        else
+          p[k] = [state]
+        end
+        p
+      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 initialize(hash = nil)
+      if hash
+        if hash[:metric]
+          super hash.merge(metric_f: hash[:metric])
+        else
+          super hash
+        end
+      else
+        super()
+      end
+
+      @time ||= Time.now.to_i
+    end
+
+    def metric
+      metric_f
+    end
+
+    def metric=(m)
+      self.metric_f = m
+    end
+  end
+end

data/lib/riemann/message.rb

@@ -0,0 +1,17 @@
+module Riemann
+  class Message
+    include Beefcake::Message
+    
+    optional :ok, :bool, 2
+    optional :error, :string, 3
+    repeated :states, State, 4
+    optional :query, Query, 5
+    repeated :events, Event, 6
+
+    def encode_with_length
+      buffer = ''
+      encoded = encode buffer
+      "#{[encoded.length].pack('N')}#{encoded}"
+    end
+  end 
+end

data/lib/riemann/metric_thread.rb

@@ -0,0 +1,68 @@
+class Riemann::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 = Riemann::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/riemann/query.rb

@@ -0,0 +1,7 @@
+module Riemann
+  class Query
+    include Beefcake::Message
+  
+    optional :string, :string, 1
+  end 
+end

data/lib/riemann/state.rb

@@ -0,0 +1,29 @@
+module Riemann
+  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
+    repeated :tags, :string, 7
+    optional :ttl, :float, 8
+    optional :metric_f, :float, 15
+
+    def initialize(*a)
+      super *a
+
+      @time ||= Time.now.to_i
+    end
+
+    def metric
+      @metric || metric_f
+    end
+
+    def metric=(m)
+      @metric = m
+    end
+  end
+end

data/lib/riemann/version.rb

@@ -0,0 +1,3 @@
+module Riemann
+  VERSION = '0.0.6'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: riemann-client
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- Kyle Kingsbury
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: beefcake
+  requirement: &15270360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *15270360
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &15269600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.16.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *15269600
+- !ruby/object:Gem::Dependency
+  name: mtrc
+  requirement: &15268880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *15268880
+description: 
+email: aphyr@aphyr.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/riemann/event.rb
+- lib/riemann/message.rb
+- lib/riemann/auto_state.rb
+- lib/riemann/metric_thread.rb
+- lib/riemann/version.rb
+- lib/riemann/state.rb
+- lib/riemann/query.rb
+- lib/riemann/client/udp.rb
+- lib/riemann/client/tcp.rb
+- lib/riemann/client.rb
+- lib/riemann.rb
+- LICENSE
+- README.markdown
+homepage: https://github.com/aphyr/riemann-ruby-client
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: riemann-client
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Client for the distributed event system Riemann.
+test_files: []