collectd 0.0.12

data/README.rst

@@ -0,0 +1,146 @@
+ruby-collectd
+=============
+
+`ruby-collectd` lets you send statistics to `collectd` from Ruby.
+
+This can be useful if you want to **instrument data** from within daemons 
+or servers written in Ruby.
+
+`ruby-collectd` works by talking the `collectd` network protocol, and 
+sending stats periodicially to a network-aware instance of `collectd`.
+
+Setup
+-----
+
+You need to have `collectd` load the network plugin, and listen on UDP
+port `25826` (so it's acting as a server): 
+
+:: 
+
+  # /etc/collectd.conf
+
+  LoadPlugin network
+  
+  <Plugin "network">
+    Listen "ff18::efc0:4a42"
+  </Plugin>
+
+
+To install the gem, make sure GitHub's RubyGems server is known to your local 
+RubyGems, then install it:
+
+::
+   
+  gem sources -a http://gems.github.com
+  sudo gem install astro-collectd
+
+
+Usage
+-----
+
+::
+
+    require 'rubygems'
+    require 'collectd'
+
+First of all, specify a server to send data to:
+
+::
+
+    Collectd.add_server(interval=10, addr='ff18::efc0:4a42', port=25826)
+
+Each server you add will receive all the data you push later. 
+An interval of 10 is quite reasonable. Because of UDP and `collectd`'s 
+network buffering, you can set the interval to less than 10, but you 
+won't see much benefit.
+
+`ruby-collectd` gives you a free data collector out of the box, and it's
+a nice gentle introduction to instrumenting your app. 
+
+To collect memory and CPU statistics of your Ruby process, do:
+
+::
+
+    Stats = Collectd.my_process(:woo_data)
+    Stats.with_full_proc_stats
+
+In the first line, we set up a new plugin. ``my_process`` is the plugin 
+name (magically handled by method_missing), and ``:woo_data`` is the 
+plugin instance. 
+
+A **plugin name** is generally an application's name, and a **plugin instance**
+is a unique identifier of an instance of an application (i.e. you have 
+multiple daemons or scripts running at the same time).
+
+In the second line, ``with_full_proc_stats`` is a method provided by 
+`ruby-collectd` that collects stats about the current running process.
+It makes use of polled gauges, which we talk about later. 
+
+Behind the scenes, ``with_full_proc_stats`` is using a **simple interface**
+you can use to instrument your own data. 
+
+Back in the first line we set up a plugin which we wanted to record some 
+data on. ``with_full_proc_stats`` sets up **types**, which are a kind of data
+you are measuring (in this case CPU and memory usage).
+
+You can do this yourself like this: 
+
+::
+
+    Stats = Collectd.my_daemon(:backend)
+
+    # Set counter absolutely
+    Stats.my_counter(:my_sleep).counter = 0
+    Stats.my_gauge(:my_gauge).gauge = 23 
+
+    loop do 
+      # Increment counter relatively
+      Stats.my_counter(:my_sleep).count! 5
+      # Set gauge absolutely
+      Stats.my_gauge(:my_stack).gauge = rand(40)
+      sleep 5
+    end
+
+    
+(Don't worry if this doesn't make sense - gauges and counters are explained 
+below)
+
+You can also **poll** for your data, if you feel comfortable with that:
+
+::
+
+    Stats.counter(:seconds_elapsed).polled_counter do
+      Time.now.to_i
+    end
+
+
+Glossary / collectd's data model
+--------------------------------
+
+`collectd` groups data by **six categories:**
+
+* *hostname* is grabbed from ``hostname -f``
+* *plugin* is the application's name
+* *plugin-instance* is passed from the programs' side with the
+  programs instance identifier, useful if you're running the same
+  script twice (PIDs are quite too random)
+* *type* is the kind of data you are measuring and must be defined in
+  types.db_ for collectd to understand
+* *type-instance* provides further distinction and have no relation to
+  other type-instances. Multiple type-instances are only rendered into
+  one graph by collection3 if defined with module GenericStacked.
+* *values* are one or more field names and types belonging
+  together. The exact amount of fields and their corresponding names
+  (useful to collection3) are specified in collectd's types.db_.
+
+A value can be either of **two types:**
+
+* *COUNTER* is for increasing counters where you want to plot the
+  delta. Network interface traffic counters are a good example.
+* *GAUGE* is values that go up and down to be plotted as-is, like a
+  temperature graph.
+
+
+.. _types.db: http://collectd.org/documentation/manpages/types.db.5.shtml
+
+

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'jeweler'
+rescue LoadError
+  raise "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Jeweler::Tasks.new do |s|
+  s.name = "collectd"
+  s.summary = "Send collectd statistics from Ruby"
+  s.email = "astro@spaceboyz.net"
+  s.homepage = "http://github.com/astro/ruby-collectd"
+  s.authors = ["Stephan Maka"]
+  s.files =  FileList["[A-Z]*", "{lib,spec,examples}/**/*"]
+  #s.add_dependency 'eventmachine'
+end
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run all Spec"
+  Spec::Rake::SpecTask.new('spec') do |spec|
+    spec.spec_files = FileList['spec/*.rb']
+    spec.verbose = true
+    spec.warning = true
+    spec.rcov = true
+    spec.rcov_opts = []
+    spec.rcov_opts = ['--exclude', 'spec']
+  end
+rescue LoadError
+  task :spec do
+    abort "Rspec is not available. In order to run rspec, you must: sudo gem install rspec"
+  end
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 12
+:major: 0
+:minor: 0

data/examples/em_sender.rb

@@ -0,0 +1,19 @@
+require 'eventmachine'
+require 'collectd'
+
+EM.run do
+  Collectd::use_eventmachine = true
+  Collectd::add_server 1
+  Stats = Collectd.ruby_collectd(:test)
+  Stats.with_full_proc_stats
+
+  c = 0
+  EM.add_periodic_timer(0.01) do
+    Stats.ping(:fun).gauge = 42 + Math.sin(Time.now.to_f / 600) * 23.5
+    Stats.cpu(:time).counter = c
+
+    c += 1
+    print '.'
+    STDOUT.flush
+  end
+end

data/examples/sender.rb

@@ -0,0 +1,16 @@
+require 'collectd'
+
+Collectd::add_server 1
+Stats = Collectd::ruby_collectd(:test)
+Stats.with_full_proc_stats
+
+c = 0
+loop do
+  Stats.ping(:fun).gauge = 42 + Math.sin(Time.now.to_f / 600) * 23.5
+  Stats.cpu(:time).counter = c
+  c += 1
+  Thread.pass
+  sleep 0.01
+  print '.'
+  STDOUT.flush
+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
+
+

data/lib/collectd/em_server.rb

@@ -0,0 +1,24 @@
+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
+        begin
+          @sock.send(pkt, 0)
+        rescue SystemCallError
+        end
+      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,211 @@
+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)
+      if defined?(EM) && EM.reactor_running?
+        @@servers << EmServer.new(interval, addr, port)
+      else
+        @@servers << Server.new(interval, addr, port)
+      end
+    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 || 0
+        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 || next
+        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,111 @@
+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=nil)
+        number ? @type = number : @type
+      end
+
+      def type
+        self.class.type
+      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,46 @@
+module Collectd
+  ##
+  # Included by Interface
+  module ProcStats
+    def process_status(field)
+      fields = {}
+      begin
+        IO.readlines("/proc/#{$$}/status").each { |line|
+          line.strip!
+          if line =~ /^(.+?):\s+(.+)$/
+            fields[$1] = $2
+          end
+        }
+      rescue Errno::ENOENT
+        nil
+      else
+        fields[field]
+      end
+    end
+
+    def with_polled_memory
+      memory('VmRSS').polled_gauge do
+        (v = process_status('VmRSS')) ? v.to_i * 1024 : nil
+      end
+      memory('VmSize').polled_gauge do
+        (v = process_status('VmSize')) ? v.to_i * 1024 : nil
+      end
+
+      self
+    end
+
+    def with_polled_cpu
+      cpu('user').polled_counter do
+        (Process::times.utime * 100).to_i
+      end
+      cpu('system').polled_counter do
+        (Process::times.stime * 100).to_i
+      end
+    end
+
+    def with_full_proc_stats
+      with_polled_memory
+      with_polled_cpu
+    end
+  end
+end

data/lib/collectd/server.rb

@@ -0,0 +1,29 @@
+require 'socket'
+require 'thread'
+
+module Collectd
+  class Server < Values
+
+    def initialize(interval, host, port)
+      super(interval)
+      @sock = UDPSocket.new(host.index(':') ? Socket::AF_INET6 : Socket::AF_INET)
+      @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
+          begin
+            @sock.send(pkt, 0)
+          rescue SystemCallError
+          end
+        end
+      end.abort_on_exception = true
+    end
+
+  end
+end

data/spec/interface_spec.rb

@@ -0,0 +1,197 @@
+$: << File.dirname(__FILE__) + '/../lib'
+require 'collectd'
+
+describe Collectd do
+  before(:each) do
+    @server = mock('Server')
+    Collectd << @server
+  end
+  after(:each) do
+    Collectd.reset!
+  end
+
+  it 'should set_counter' do
+    @server.should_receive(:set_counter).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23])
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).counter = 23
+  end
+  it 'should inc_counter' do
+    @server.should_receive(:inc_counter).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23, 42])
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).count! 23, 42
+  end
+  it 'should set_gauge' do
+    @server.should_receive(:set_gauge).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23, 42, 5])
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).gauge = [23, 42, 5]
+  end
+
+  it 'should poll a pollable' do
+    pollable = mock('Pollable')
+    Collectd.add_pollable { |*a|
+      pollable.call *a
+    }
+    pollable.should_receive(:call).with(@server).and_return(nil)
+    Collectd.run_pollables_for @server
+  end
+  it 'should poll a polled_count' do
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).polled_count do
+      [23, 42, 5, 7]
+    end
+    @server.should_receive(:inc_counter).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23, 42, 5, 7])
+    Collectd.run_pollables_for @server
+  end
+  it 'should poll a polled_counter' do
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).polled_counter do
+      [23, 42, 5, 7]
+    end
+    @server.should_receive(:set_counter).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23, 42, 5, 7])
+    Collectd.run_pollables_for @server
+  end
+  it 'should poll a polled_gauge' do
+    Collectd.plugin1(:plugin_instance1).type1(:type_instance1).polled_gauge do
+      [23, 42, 5, 7]
+    end
+    @server.should_receive(:set_gauge).
+      with([:plugin1, :plugin_instance1,
+            :type1, :type_instance1], [23, 42, 5, 7])
+    Collectd.run_pollables_for @server
+  end
+end
+
+class StubServer < Collectd::Values
+  attr_reader :counters
+  attr_reader :gauges
+  def initialize
+    super(1000)
+  end
+end
+
+describe Collectd::ProcStats do
+  before(:each) do
+    @server = StubServer.new
+    Collectd << @server
+    Collectd.plugin1(:plugin_instance1).with_full_proc_stats
+    Collectd.run_pollables_for @server
+  end
+  after(:each) do
+    Collectd.reset!
+  end
+
+  context 'when polling memory' do
+    it 'should report VmRSS' do
+      g = @server.gauges[[:plugin1, :plugin_instance1, :memory, "VmRSS"]]
+      g[0].should be_kind_of(Fixnum)
+    end
+    it 'should report VmSize' do
+      g = @server.gauges[[:plugin1, :plugin_instance1, :memory, "VmSize"]]
+      g[0].should be_kind_of(Fixnum)
+    end
+  end
+  context 'when polling cpu' do
+    it 'should report user time' do
+      c = @server.counters[[:plugin1, :plugin_instance1, :cpu, "user"]]
+      c[0].should be_kind_of(Fixnum)
+    end
+    it 'should report system time' do
+      c = @server.counters[[:plugin1, :plugin_instance1, :cpu, "system"]]
+      c[0].should be_kind_of(Fixnum)
+    end
+  end
+end
+
+describe Collectd::EmPlugin do
+  before(:each) do
+    @server = StubServer.new
+    Collectd << @server
+    @df = EM::DefaultDeferrable.new
+    Collectd.plugin1(:plugin_instance1).track_deferrable('df', @df)
+  end
+  after(:each) do
+    Collectd.reset!
+  end
+
+  context 'when succeeding' do
+    it 'should callback' do
+      @df.succeed
+    end
+    it 'should report latency' do
+      @df.succeed
+      g = @server.gauges[[:plugin1, :plugin_instance1, :latency, 'df_success']]
+      g[0].should be_kind_of(Numeric)
+    end
+    it 'should increase a counter' do
+      @df.succeed
+      c = @server.counters[[:plugin1, :plugin_instance1, :counter, 'df_success']]
+      c[0].should be_kind_of(Numeric)
+    end
+  end
+  context 'when failing' do
+    it 'should callback' do
+      @df.fail
+    end
+    it 'should report latency' do
+      @df.fail
+      g = @server.gauges[[:plugin1, :plugin_instance1, :latency, 'df_error']]
+      g[0].should be_kind_of(Numeric)
+    end
+    it 'should increase a counter' do
+      @df.fail
+      c = @server.counters[[:plugin1, :plugin_instance1, :counter, 'df_error']]
+      c[0].should be_kind_of(Numeric)
+    end
+  end
+end
+
+describe Collectd::Server do
+  before :all do
+    Collectd.add_server(0.1)
+  end
+  after :all do
+    Collectd.reset!
+  end
+
+  it "should spawn a Collectd::Server" do
+    servers = []
+    Collectd.each_server { |s| servers << s }
+    servers.length.should == 1
+    servers[0].should be_kind_of(Collectd::Server)
+  end
+
+  it "should run for 2 seconds" do
+    sleep 2
+  end
+end
+
+describe Collectd::EmServer do
+  it "should spawn a Collectd::Server" do
+    EM.run {
+      Collectd.add_server 0.1
+      EM.next_tick {
+        EM.stop
+        servers = []
+        Collectd.each_server { |s| servers << s }
+        servers.length.should == 1
+        servers[0].should be_kind_of(Collectd::EmServer)
+        Collectd.reset!
+      }
+    }
+  end
+
+  it "should run for 2 seconds" do
+    EM.run {
+      Collectd.add_server 0.1
+      EM::Timer.new(2) {
+        EM.stop
+        Collectd.reset!
+      }
+    }
+  end
+end if defined?(EM)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: collectd
+version: !ruby/object:Gem::Version 
+  version: 0.0.12
+platform: ruby
+authors: 
+- Stephan Maka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: astro@spaceboyz.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rst
+files: 
+- README.rst
+- Rakefile
+- VERSION.yml
+- examples/em_sender.rb
+- examples/sender.rb
+- lib/collectd.rb
+- lib/collectd/em_server.rb
+- lib/collectd/em_support.rb
+- lib/collectd/interface.rb
+- lib/collectd/pkt.rb
+- lib/collectd/proc_stats.rb
+- lib/collectd/server.rb
+- spec/interface_spec.rb
+has_rdoc: true
+homepage: http://github.com/astro/ruby-collectd
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Send collectd statistics from Ruby
+test_files: 
+- spec/interface_spec.rb
+- examples/sender.rb
+- examples/em_sender.rb