astro-collectd 0.0.6 → 0.0.7

data/lib/collectd/em_server.rb

@@ -0,0 +1,21 @@
+require 'eventmachine'
+
+module Collectd
+  class EmServer < Values
+
+    def initialize(interval, host, port)
+      super(interval)
+      @sock = UDPSocket.new(host.index(':') ? Socket::AF_INET6 : Socket::AF_INET)
+      @sock.connect(host, port)
+
+      EM.add_periodic_timer(interval) do
+        Collectd.run_pollables_for self
+        Thread.critical = true
+        pkt = make_pkt
+        Thread.critical = false
+        @sock.send(pkt, 0)
+      end
+    end
+
+  end
+end

data/lib/collectd/em_support.rb

@@ -0,0 +1,21 @@
+module Collectd
+  # EventMachine support stuff. Included in Collectd::Plugin.
+  module EmPlugin
+    ##
+    # Attaches additional callback and errback to deferrable to track
+    # a common set of success/error rate/latency
+    def track_deferrable(name, deferrable)
+      attach_time = Time.now
+      deferrable.callback do |*a|
+        push_deferrable_values("#{name} success", attach_time)
+      end
+      deferrable.errback do |*a|
+        push_deferrable_values("#{name} error", attach_time)
+      end
+    end
+    def push_deferrable_values(name, attach_time)
+      latency(name).gauge = Time.now - attach_time
+      counter(name).count! 1
+    end
+  end
+end

data/lib/collectd/interface.rb

@@ -0,0 +1,207 @@
+require 'collectd/pkt'
+require 'collectd/em_support'
+
+
+module Collectd
+  class << self
+
+    def hostname
+      @@hostname ||= `hostname -f`.strip
+      @@hostname
+    end
+    def hostname=(h)
+      @@hostname = h
+    end
+
+    @@servers = []
+
+    def add_server(interval, addr='ff18::efc0:4a42', port=25826)
+      @@servers << Server.new(interval, addr, port)
+    end
+
+    def <<(server)
+      @@servers << server
+    end
+
+    def reset!
+      @@servers.each do |server|
+        server.close if server.respond_to?(:close)
+      end
+      @@servers = []
+      @@pollables = []
+    end
+
+    def each_server(&block)
+      @@servers.each(&block)
+    end
+
+    def add_pollable(&block)
+      @@pollables ||= []
+      @@pollables << block
+    end
+    def run_pollables_for(server)
+      @@pollables ||= []
+      @@pollables.each do |block|
+        block.call(server)
+      end
+    end
+
+    def method_missing(plugin, plugin_instance)
+      Plugin.new(plugin, plugin_instance)
+    end
+
+  end
+
+  ##
+  # Interface helper
+  class Plugin
+    include ProcStats
+    include EmPlugin
+    def initialize(plugin, plugin_instance)
+      @plugin, @plugin_instance = plugin, plugin_instance
+    end
+    def method_missing(type, type_instance)
+      Type.new(@plugin, @plugin_instance, type, type_instance)
+    end
+  end
+
+  ##
+  # Interface helper
+  class Type
+    def initialize(plugin, plugin_instance, type, type_instance)
+      @plugin, @plugin_instance = plugin, plugin_instance
+      @type, @type_instance = type, type_instance
+    end
+    ##
+    # GAUGE
+    def gauge=(values)
+      values = [values] unless values.kind_of? Array
+      Collectd.each_server do |server|
+        server.set_gauge(plugin_type, values)
+      end
+    end
+    ##
+    # COUNTER
+    def counter=(values)
+      values = [values] unless values.kind_of? Array
+      Collectd.each_server do |server|
+        server.set_counter(plugin_type, values)
+      end
+    end
+    def count!(*values)
+      Collectd.each_server do |server|
+        server.inc_counter(plugin_type, values)
+      end
+    end
+    def polled_gauge(&block)
+      Collectd.add_pollable do |server|
+        values = block.call
+        if values
+          values = [values] unless values.kind_of? Array
+          server.set_gauge(plugin_type, values)
+        end
+      end
+    end
+    def polled_count(&block)
+      Collectd.add_pollable do |server|
+        values = block.call
+        if values
+          values = [values] unless values.kind_of? Array
+          server.inc_counter(plugin_type, values)
+        end
+      end
+    end
+    def polled_counter(&block)
+      Collectd.add_pollable do |server|
+        values = block.call
+        if values
+          values = [values] unless values.kind_of? Array
+          server.set_counter(plugin_type, values)
+        end
+      end
+    end
+    private
+    ##
+    # [plugin, plugin_instance, type, type_instance]
+    def plugin_type
+      [@plugin, @plugin_instance, @type, @type_instance]
+    end
+  end
+
+  ##
+  # Value-holder, baseclass for servers
+  class Values
+    attr_reader :interval
+    def initialize(interval)
+      @interval = interval
+      @counters = {}
+      @gauges = {}
+    end
+    def set_counter(plugin_type, values)
+      @counters[plugin_type] = values
+    end
+    def inc_counter(plugin_type, values)
+      old_values = @counters[plugin_type] || []
+      values.map! { |value|
+        value + (old_values.shift || 0)
+      }
+      @counters[plugin_type] = values
+    end
+    def set_gauge(plugin_type, values)
+      # Use count & sums for average
+      if @gauges.has_key?(plugin_type)
+        old_values = @gauges[plugin_type]
+        count = old_values.shift
+        values.map! { |value| value + (old_values.shift || value) }
+        @gauges[plugin_type] = [count + 1] + values
+      else
+        @gauges[plugin_type] = [1] + values
+      end
+    end
+
+    def make_pkt
+      plugin_type_values = {}
+      @counters.each do |plugin_types,values|
+        plugin, plugin_instance, type, type_instance = plugin_types
+        plugin_type_values[plugin] ||= {}
+        plugin_type_values[plugin][plugin_instance] ||= {}
+        plugin_type_values[plugin][plugin_instance][type] ||= {}
+        plugin_type_values[plugin][plugin_instance][type][type_instance] =
+        Packet::Values.new(values.map { |value| Packet::Values::Counter.new(value) })
+      end
+      @gauges.each do |plugin_types,values|
+        plugin, plugin_instance, type, type_instance = plugin_types
+        plugin_type_values[plugin] ||= {}
+        plugin_type_values[plugin][plugin_instance] ||= {}
+        plugin_type_values[plugin][plugin_instance][type] ||= {}
+        count = values.shift
+        values.map! { |value| value.to_f / count }
+        plugin_type_values[plugin][plugin_instance][type][type_instance] =
+        Packet::Values.new(values.map { |value| Packet::Values::Gauge.new(value) })
+      end
+      pkt = [Packet::Host.new(Collectd.hostname),
+             Packet::Time.new(Time.now.to_i),
+             Packet::Interval.new(10)]
+      plugin_type_values.each do |plugin,plugin_instances|
+        pkt << Packet::Plugin.new(plugin)
+        plugin_instances.each do |plugin_instance,types|
+          pkt << Packet::PluginInstance.new(plugin_instance)
+          types.each do |type,type_instances|
+            pkt << Packet::Type.new(type)
+            type_instances.each do |type_instance,values|
+              pkt << Packet::TypeInstance.new(type_instance)
+              pkt << values
+            end
+          end
+        end
+      end
+
+      # Reset only gauges. Counters are persistent for incrementing.
+      @gauges = {}
+
+      # And return serialized packet of parts
+      pkt.to_s
+    end
+  end
+
+end

data/lib/collectd/pkt.rb

@@ -0,0 +1,107 @@
+module Collectd
+  module Packet
+
+    class Part
+      def to_s(content)
+        [type, content.length + 4].pack("nn") + content
+      end
+
+      ##
+      # Makes subclasses more declarative
+      def self.type(number)
+        define_method(:type) { number }
+      end
+    end
+
+    class String < Part
+      def initialize(s)
+        @s = s
+      end
+      def to_s
+        super "#{@s}\000"
+      end
+    end
+
+    class Number < Part
+      def initialize(n)
+        @n = n
+      end
+      def to_s
+        super [@n >> 32, @n & 0xffffffff].pack("NN")
+      end
+    end
+
+    class Host < String
+      type 0
+    end
+
+    class Time < Number
+      type 1
+    end
+
+    class Plugin < String
+      type 2
+    end
+
+    class PluginInstance < String
+      type 3
+    end
+
+    class Type < String
+      type 4
+    end
+
+    class TypeInstance < String
+      type 5
+    end
+
+    class Values < Part
+      type 6
+      def initialize(v)
+        @v = v
+      end
+      def to_s
+        types, values = [], []
+        @v.each { |v1|
+          types << [v1.type].pack("C")
+          values << v1.to_s
+        }
+        super [@v.length].pack("n") + types.join + values.join
+      end
+
+      class Counter < Part
+        type 0
+        def initialize(c)
+          @c = c
+        end
+        def to_s
+          [@c >> 32, @c & 0xffffffff].pack("NN")
+        end
+      end
+
+      class Gauge < Part
+        type 1
+        def initialize(f)
+          @f = f
+        end
+        def to_s
+          [@f].pack("d")
+        end
+      end
+    end
+
+    class Interval < Number
+      type 7
+    end
+
+
+    class Message < String
+      type 0x100
+    end
+
+    class Severity < Number
+      type 0x101
+    end
+
+  end
+end

data/lib/collectd/proc_stats.rb

@@ -0,0 +1,49 @@
+module Collectd
+  ##
+  # Included by Interface
+  module ProcStats
+    def with_polled_memory
+      def process_status(field)
+        fields = {}
+        IO.readlines("/proc/#{$$}/status").each { |line|
+          line.strip!
+          if line =~ /^(.+?):\s+(.+)$/
+            fields[$1] = $2
+          end
+        }
+        fields[field]
+      end
+
+      memory('VmRSS').polled_gauge do
+        process_status('VmRSS').to_i * 1024
+      end
+      memory('VmSize').polled_gauge do
+        process_status('VmSize').to_i * 1024
+      end
+
+      self
+    end
+
+    def with_polled_cpu
+      def schedstats
+        if IO.readlines("/proc/#{$$}/schedstat").to_s =~ /^(\d+) (\d+) (\d+)/
+            [$1.to_i, $2.to_i, $3.to_i]
+        else
+          []
+        end
+      end
+
+      cpu('user').polled_counter do
+        schedstats[0]
+      end
+      cpu('wait').polled_counter do
+        schedstats[1]
+      end
+    end
+
+    def with_full_proc_stats
+      with_polled_memory
+      with_polled_cpu
+    end
+  end
+end

data/lib/collectd/server.rb

@@ -0,0 +1,26 @@
+require 'socket'
+require 'thread'
+
+module Collectd
+  class Server < Values
+
+    def initialize(interval, host, port)
+      super(interval)
+      @sock = UDPSocket.new(Socket::AF_INET6)
+      @sock.connect(host, port)
+
+      Thread.new do
+        loop do
+          sleep interval
+
+          Collectd.run_pollables_for self
+          Thread.critical = true
+          pkt = make_pkt
+          Thread.critical = false
+          @sock.send(pkt, 0)
+        end
+      end.abort_on_exception = true
+    end
+
+  end
+end

data/lib/collectd.rb

@@ -0,0 +1,10 @@
+require 'collectd/proc_stats'
+require 'collectd/interface'
+require 'collectd/server'
+begin
+  require 'collectd/em_server'
+rescue LoadError
+  # EM is optional
+end
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: astro-collectd
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Stephan Maka
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-01 00:00:00 -07:00
+date: 2009-05-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -21,8 +21,14 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- lib/collectd/pkt.rb
+- lib/collectd/em_server.rb
+- lib/collectd/interface.rb
+- lib/collectd/proc_stats.rb
+- lib/collectd/server.rb
+- lib/collectd/em_support.rb
+- lib/collectd.rb
 has_rdoc: false
 homepage: http://github.com/astro/ruby-collectd
 post_install_message: