entombedvirus-munin_manager 0.0.1

data/Manifest

@@ -0,0 +1,16 @@
+README.markdown
+bin/munin_manager
+bin/runner
+lib/munin_manager.rb
+lib/munin_manager/log_reader.rb
+lib/munin_manager/plugins/haproxy_response_time.rb
+lib/munin_manager/plugins/rails_response_time.rb
+lib/munin_manager/plugins.rb
+lib/munin_manager/acts_as_munin_plugin.rb
+test/haproxy_response_time_test.rb
+test/log_reader_test.rb
+test/test_helper.rb
+test/rails_response_time_test.rb
+ext/string.rb
+Rakefile
+Manifest

data/Rakefile

@@ -0,0 +1,22 @@
+require 'echoe'
+Echoe.new('munin_manager', '0.0.1') do |s|
+  s.description = "Tool to maintain and install munin plugins written in Ruby"
+  s.author = "Rohith Ravi"
+  s.email = "entombedvirus@gmail.com"
+end
+
+#spec = Gem::Specification.new do |s| 
+#  s.name = "MuninManager"
+#  s.version = "0.0.1"
+#  s.platform = Gem::Platform::RUBY
+#  s.files = FileList["{bin,lib,ext}/**/*"].to_a
+#  s.require_path = "lib"
+#  s.autorequire = "munin_manager"
+#  s.test_files = FileList["{test}/**/*test.rb"].to_a
+#  s.has_rdoc = false
+#  s.extra_rdoc_files = ["README.markdown"]
+#end
+# 
+#Rake::GemPackageTask.new(spec) do |pkg| 
+#  pkg.need_tar = true 
+#end

data/bin/munin_manager

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ruby-debug'
+
+require 'optparse'
+require 'ostruct'
+require "#{File.dirname(__FILE__)}/../lib/munin_manager"
+
+options = OpenStruct.new
+options.plugin_dir = "/etc/munin/plugins"
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: munin_manager <command> [<plugin_name>[:<symlink_name>]] [options]"
+  opts.separator ""
+  
+  opts.separator "Commands:"
+  
+  opts.on("-l", "--list", "List available plugins to install") do
+    buffer = []
+    buffer << "Available Plugins"
+    buffer << "================="
+    buffer << ""
+    
+    MuninManager::Plugins.each do |plugin|
+      buffer << plugin.plugin_name
+    end
+    
+    buffer << ""
+    puts buffer.join("\n")
+  end
+  
+  opts.on("-s", "--show PLUGIN_NAME", "Shows details about a plugin") do |name|
+    begin
+      puts MuninManager::Plugins[name].help_text
+    rescue NoMethodError
+      STDERR.puts "'%s' plugin was not found" % name
+    rescue
+      STDERR.puts "No additional information is available about this plugin."
+    end
+  end
+  
+  opts.on("-i", "--install PLUGIN_NAME [PLUGIN_NAME]", Array,
+    "Installs a plugin by creating a symlink in '%s'" % options.plugin_dir) do |names|
+    if options.plugins = MuninManager::Plugins[*names]
+      options.action = :install
+      options.plugin_names = names
+    else
+      puts "'%s' plugin not found" % names.join
+    end
+  end
+  
+  opts.on("-u", "--uninstall PLUGIN_NAME [PLUGIN_NAME]", Array,
+    "Removes plugins from '%s'" % options.plugin_dir,
+    "if it is a symlink") do |names|
+    
+    if options.plugins = MuninManager::Plugins[*names]
+      options.action = :uninstall      
+      options.plugin_names = names
+    else
+      puts "'#{names}' plugin not found"
+    end
+  end
+
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("--plugin-dir DIR", "Directory where symlinks will be created when a plugin is installed",
+         "(default is '%s'" % options.plugin_dir) do |dir|
+    if File.directory?(dir) && File.writable?(dir)
+      options.plugin_dir = dir
+    else
+      STDERR.puts "'%s' does not exist or is not writable" % options.plugin_dir
+    end
+  end
+
+  opts.on("--force", "Forces the installation or uninstallation of plugins") do
+    options.force = true
+  end
+  
+  
+end
+
+parser.parse!(ARGV)
+options.freeze!
+
+case options.action
+when :uninstall, :install
+  plugins = Array(MuninManager::Plugins[*options.plugin_names])
+  plugins.each {|p| p.send(options.action, options)}
+end

data/bin/runner

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# This file will serve as the target for the symlinks in /etc/munin/plugins.
+# It's the responsibility of this script to run the plugin indicated by the
+# symlink name.
+
+this_file = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+require "#{File.dirname(this_file)}/../lib/munin_manager"
+
+plugin_name = File.basename($0)
+
+if plugin = MuninManager::Plugins[plugin_name]
+  plugin.run
+  exit(0)
+else
+  STDERR.puts "'%s' plugin was not found" % plugin_name
+  exit(1)
+end

data/ext/string.rb

@@ -0,0 +1,8 @@
+class String
+  unless String.new.respond_to?(:starts_with?)
+    def starts_with?(prefix)
+      prefix = prefix.to_s
+      self[0, prefix.length] == prefix
+    end
+  end
+end

data/lib/munin_manager/acts_as_munin_plugin.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+
+module MuninManager
+  module ActsAsMuninPlugin
+    def self.included(klass)
+      klass.send(:include, InstanceMethods)
+      klass.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def run
+        raise "This is the entry point of the plugin when invoked by munin. Needs implementation by included class"
+      end
+
+      def plugin_name
+        # Name of the plugin. Must not contain spaces or special chars
+        
+        # Default is underscorized version of the class name
+        self.name.split('::').last.
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+
+      def help_text
+        # Any general info concerning the plugin. Should be overriden by included class
+      end
+
+      def install(options)
+        symlink = File.join(options.plugin_dir, plugin_name)
+        runner = File.join(File.dirname(__FILE__), "..", "..", "bin", "runner")
+        runner = File.expand_path(runner)
+
+        if File.exists?(symlink) && !options.force
+          STDERR.puts "'%s' already exists. Please specify --force option to overwrite" % symlink
+          return
+        end
+
+        STDOUT.puts "Installing '%s' at '%s'" % [plugin_name, symlink]
+        FileUtils.ln_sf(runner, symlink)
+
+        STDOUT.puts help_text
+
+      rescue Errno::EACCES
+        STDERR.puts "ERROR: Permission denied while attempting to install to '%s'" % symlink
+      end
+
+      # Default uninstaller. Override in included classes if the default is not sufficient
+      def uninstall(options)
+        symlink = File.join(options.plugin_dir, plugin_name)
+
+        unless File.exists?(symlink)
+          STDERR.puts "'%s' does not seem to exist. Aborting..." % symlink
+          return
+        end
+
+        unless File.symlink?(symlink) || options.force
+          STDERR.puts "'%s' does not appear to be a symlink. Please specify --force option to remove" % symlink
+          return
+        end
+
+        STDOUT.puts "Removing '%s'..." % symlink
+        File.unlink(symlink)
+      end
+    end
+
+    module InstanceMethods
+      def config
+        raise "This is invoked by munin to get graph details. Needs implementation by included class"
+      end
+    end
+  end
+end

data/lib/munin_manager/log_reader.rb

@@ -0,0 +1,85 @@
+module MuninManager
+  # A LogReader that continues from where it left off.
+  # Ex:
+  # class RailsLogReader < LogReader
+  #     def scan(log_file)
+  #       @req_counter = 0
+  #       loop do
+  #         line = log_file.readline
+  #         @req_counter += 1 if line =~ /Completed in/
+  #       end
+  #     end
+  #     
+  #     def process!
+  #       # Do nothing
+  #     end
+  #     
+  #     def print_data
+  #       "num_requests.value #{@req_counter}"
+  #     end
+  #   end
+  #   
+  #   Usage:
+  #   
+  #   reader = RailsLogReader.new("log/development.log")
+  #   reader.collect!
+  #   reader.print_data
+  #   
+  class LogReader
+    attr_accessor :file_name, :me, :state_dir, :state_file
+
+    def initialize(file_name)
+      @file_name = file_name
+      @me = File.basename($0)
+      @state_dir = ENV['MUNIN_PLUGSTATE'] || '/var/lib/munin/plugin-state'
+    end
+
+    def state_file
+      @state_file ||= File.join(@state_dir, @me)
+    end
+
+    def collect!(options = {})
+      options = {
+        :save_state => true
+      }.merge(options)
+
+      File.open(@file_name, "r") do |f|
+        load_saved_state(f)
+        
+        begin
+          scan(f)
+        rescue EOFError
+        end
+        
+        process!
+        save_state(f) if options[:save_state]
+      end
+    end
+
+    def load_saved_state(log_file)
+      return unless File.exists?(state_file) && !(state = File.read(state_file)).nil?
+      pos, last_file_size = Marshal.load(state)
+
+      # Check for log rotation
+      return if File.size(@file_name) < last_file_size
+
+      log_file.pos = pos
+    end
+
+    def scan(log_file)
+      # Only subclasses know how to process each type of logfile
+      raise "Needs to be implemented by subclasses"
+    end
+
+    def process!
+      raise "Needs to be implemented by subclasses"
+    end
+    
+    def save_state(log_file)
+      File.open(state_file, "w") do |f|
+        f.write(Marshal.dump([log_file.pos, File.size(log_file)]))
+        f.flush
+      end
+    end
+  end
+end

data/lib/munin_manager/plugins/haproxy_response_time.rb

@@ -0,0 +1,87 @@
+module MuninManager
+  class Plugins::HaproxyResponseTime < LogReader
+    include ActsAsMuninPlugin
+
+    def data
+      @data ||= Hash.new {|h, k| h[k] = Array.new}
+    end
+
+    def scan(log_file)
+      loop do
+        line = log_file.readline
+        chunks = line.split(/\s+/)
+
+        timers = chunks[9].split("/") rescue []
+        data[:client_connect] << timers[0].to_f
+        data[:waiting_in_queue] << timers[1].to_f
+        data[:server_connect] << timers[2].to_f
+        data[:server_response] << timers[3].to_f
+        data[:rails_action] << line.match(/\{([0-9.]+)\}/).captures[0].to_f rescue 0
+        data[:total] << timers[4].to_f
+      end
+    end
+
+    def process!
+      data.each do |k, v|
+        data[k] = data[k].inject(0) {|sum, i| sum + i} / data[k].length rescue 0
+        data[k] = formatted(data[k] / 1000)
+      end
+    end
+    
+    def config
+      <<-LABEL                     
+graph_title HAProxy Response Breakdown
+graph_vlabel time (secs)
+graph_category Haproxy                
+client_connect.label Client Connect
+waiting_in_queue.label  Waiting In Queue
+server_connect.label  Server Connect
+server_response.label  Server Response
+rails_action.label  Rails Controller Action
+total.label Total Response Time
+      LABEL
+    end
+
+    def values
+      data.map {|k, v| "#{k}.value #{v}"}.join("\n")
+    end
+
+    def self.run
+      log_file = ENV['log_file'] || "/var/log/haproxy.log"
+      allowed_commands = ['config']
+
+      haproxy = new(log_file)
+
+      if cmd = ARGV[0] and allowed_commands.include? cmd then
+        puts haproxy.send(cmd.to_sym)
+      else
+        haproxy.collect!
+        puts haproxy.values
+      end
+    end
+
+    def self.help_text
+      %Q{
+#{plugin_name.capitalize} Munin Plugin
+===========================
+
+Please remember to add something like the lines below to /etc/munin/plugin-conf.d/munin-node
+if the haproxy log file is not at /var/log/haproxy.log
+
+[#{plugin_name}]
+env.log_file /var/log/custom/haproxy.log
+
+Also, make sure that the '/var/lib/munin/plugin-state' is writable by munin.
+
+$ sudo chmod 777 /var/lib/munin/plugin-state
+
+}
+    end
+    
+    private
+
+    def formatted(num)
+      "%.10f" % num
+    end
+  end
+end

data/lib/munin_manager/plugins/rails_response_time.rb

@@ -0,0 +1,91 @@
+module MuninManager
+  class Plugins::RailsResponseTime < LogReader
+    include ActsAsMuninPlugin
+
+    def data
+      @data ||= Hash.new {|h, k| h[k] = Array.new}
+    end
+
+    def scan(log_file)
+      current_action = nil
+      loop do
+        line = log_file.readline
+
+        if line.starts_with?("Processing ")
+          cols = line.split(/\s+/)
+          current_action = cols[1]
+        elsif line.starts_with?("Completed in ") && !current_action.nil?
+          cols = line.split(/\s+/)
+          data[current_action] << cols[2].to_f
+        end
+
+      end
+    end
+
+    def process!
+      data.each_pair do |action_name, response_times|
+        data[action_name] = response_times.inject(0) {|sum, i| sum + i} / data[action_name].length rescue 0
+      end
+    end
+
+    def config
+      configs = {
+        "graph_title" => "Rails Response Times (by Controller->Action)",
+        "graph_vlabel" => "time (secs)",
+        "graph_category" => "Performance"
+      }
+      self.collect!(:save_state => false)
+      self.data.each do |action_name, respose_time|
+        configs["#{format_for_munin(action_name)}.label"] = action_name.sub("#", "->")
+      end
+
+      configs["graph_order"] = self.data.to_a.
+        sort {|lhs, rhs| rhs[1] <=> lhs[1]}.
+        collect {|tuple| format_for_munin(tuple[0])}
+
+      configs.map {|key_value_pair| key_value_pair.join(" ")}.join("\n")
+    end
+
+    def values
+      data.map {|k, v| "#{format_for_munin(k)}.value #{"%.10f" % v}"}.join("\n")
+    end
+
+    def self.run
+      log_file = ENV['log_file'] || "/var/log/rails.log"
+      allowed_commands = ['config']
+
+      rails = new(log_file)
+
+      if cmd = ARGV[0] and allowed_commands.include? cmd then
+        puts rails.send(cmd.to_sym)
+      else
+        rails.collect!
+        puts rails.values
+      end
+    end
+
+    def self.help_text
+      %Q{
+#{plugin_name.capitalize} Munin Plugin
+===========================
+
+Please remember to add something like the lines below to /etc/munin/plugin-conf.d/munin-node
+if the rails log file is not at /var/log/rails.log
+
+[#{plugin_name}]
+env.log_file /var/log/custom/rails.log
+
+Also, make sure that the '/var/lib/munin/plugin-state' is writable by munin.
+
+$ sudo chmod 777 /var/lib/munin/plugin-state
+
+}
+    end
+
+    private
+
+    def format_for_munin(str)
+      str.to_s.gsub(/[^A-Za-z0-9_]/, "_")
+    end
+  end
+end

data/lib/munin_manager/plugins.rb

@@ -0,0 +1,24 @@
+module MuninManager
+  module Plugins
+    extend self
+    extend Enumerable
+    
+    def each(&block)
+      registered_plugins.each(&block)
+    end    
+    
+    def registered_plugins
+      @registered_plugins ||= constants.
+        map {|c| const_get(c) }.
+        select {|const| const.is_a?(Class) && const < MuninManager::ActsAsMuninPlugin}
+    end
+    
+    def [](*names)
+      if names.length == 1
+        return detect {|plugin| plugin.plugin_name == names.first}
+      end
+      
+      names.map {|name| self[name]}
+    end
+  end
+end

data/lib/munin_manager.rb

@@ -0,0 +1,9 @@
+munin_manager = File.join(File.dirname(__FILE__), "munin_manager")
+
+%w(../../ext/string log_reader plugins acts_as_munin_plugin).each do |f|
+  require File.join(munin_manager, f)
+end
+
+Dir[File.join(munin_manager, "plugins", "*")].each do |file|
+  require file
+end

data/munin_manager.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{munin_manager}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rohith Ravi"]
+  s.date = %q{2009-03-09}
+  s.description = %q{Tool to maintain and install munin plugins written in Ruby}
+  s.email = %q{entombedvirus@gmail.com}
+  s.executables = ["munin_manager", "runner"]
+  s.extra_rdoc_files = ["README.markdown", "bin/munin_manager", "bin/runner", "lib/munin_manager.rb", "lib/munin_manager/log_reader.rb", "lib/munin_manager/plugins/haproxy_response_time.rb", "lib/munin_manager/plugins/rails_response_time.rb", "lib/munin_manager/plugins.rb", "lib/munin_manager/acts_as_munin_plugin.rb", "ext/string.rb"]
+  s.files = ["README.markdown", "bin/munin_manager", "bin/runner", "lib/munin_manager.rb", "lib/munin_manager/log_reader.rb", "lib/munin_manager/plugins/haproxy_response_time.rb", "lib/munin_manager/plugins/rails_response_time.rb", "lib/munin_manager/plugins.rb", "lib/munin_manager/acts_as_munin_plugin.rb", "test/haproxy_response_time_test.rb", "test/log_reader_test.rb", "test/test_helper.rb", "test/rails_response_time_test.rb", "ext/string.rb", "Rakefile", "Manifest", "munin_manager.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Munin_manager", "--main", "README.markdown"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{munin_manager}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Tool to maintain and install munin plugins written in Ruby}
+  s.test_files = ["test/haproxy_response_time_test.rb", "test/log_reader_test.rb", "test/test_helper.rb", "test/rails_response_time_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/haproxy_response_time_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class HaproxyResponseTimeTest < Test::Unit::TestCase
+  include MuninManager::Plugins
+  
+  def setup
+    @reader = HaproxyResponseTime.new("#{TEST_DIR}/logs/haproxy.log")
+    @reader.state_dir = "#{TEST_DIR}/tmp"
+  end
+  
+  def teardown
+    File.unlink(@reader.state_file)
+  rescue
+    # Do nothing
+  end
+  
+  def test_parsing
+    @reader.collect!
+
+    expected_values = {
+      :rails_action => "0.0005463880",
+      :total => "0.5552000000",
+      :client_connect => "0.0000000000",
+      :waiting_in_queue => "0.0000000000",
+      :server_connect => "0.0000000000",
+      :server_response => "0.5547000000"
+    }
+    
+    expected_values.each do |field, val|
+      assert_equal(val, @reader.data[field], "Value mismatch in #{field}")
+    end
+  end
+  
+  def test_has_help_text
+    assert !HaproxyResponseTime.help_text.empty?
+  end
+end

data/test/log_reader_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class LogReaderTest < Test::Unit::TestCase
+  def setup
+    @reader = RailsLogReader.new("#{HERE}/logs/rails.log")
+    
+    File.open(@reader.file_name, 'w') do |f|
+      10.times {f.puts("Completed in")}
+      20.times {f.puts("Some other stuff")}
+    end
+  end
+  
+  def teardown
+    File.unlink(@reader.state_file)
+  end
+  
+  def test_remembers_last_position_in_log
+    @reader.collect!
+    assert_equal 10, @reader.num_requests
+    
+    File.open(@reader.file_name, 'a+') do |f|
+      10.times {f.puts("Completed in")}
+    end
+    
+    @new_reader = RailsLogReader.new(@reader.file_name)
+    @new_reader.collect!
+    
+    assert_equal 10, @new_reader.num_requests
+    assert_equal 40, File.new(@new_reader.file_name).readlines.length
+  end
+end

data/test/rails_response_time_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class RailsResponseTimeTest < Test::Unit::TestCase
+  include MuninManager::Plugins
+  
+  def setup
+    @reader = RailsResponseTime.new("#{TEST_DIR}/logs/rails.log")
+    @reader.state_dir = "#{TEST_DIR}/tmp"
+  end
+  
+  def teardown
+    File.unlink(@reader.state_file)
+  rescue
+    # Do nothing
+  end
+  
+  def test_parsing
+    @reader.collect!
+    assert @reader.data.keys.length > 0
+
+    @reader.data.each_pair do |k, v|
+      assert v > 0, "Value mismatch for #{k}"
+    end
+  end
+
+  def test_config_parses_log
+    assert @reader.config.split("\n").select {|line| not line.starts_with?("graph_")}.length > 0
+  end
+
+  def test_config_does_not_save_state
+    @reader.config
+    assert !File.exists?(@reader.state_file)
+  end
+  
+  def test_has_help_text
+    assert !RailsResponseTime.help_text.empty?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+TEST_DIR = File.dirname(__FILE__)
+%w(lib ext bin test).each do |dir| 
+  $LOAD_PATH.unshift "#{TEST_DIR}/../#{dir}"
+end
+
+%w(rubygems test/unit ruby-debug munin_manager).each do |f|
+  require f
+end
+
+class RailsLogReader < MuninManager::LogReader
+  def initialize(*params)
+    super
+    @state_dir = "#{TEST_DIR}/tmp"
+    @state_file = File.join(@state_dir, @me)
+  end
+  
+  def scan(log_file)
+    @req_counter = 0
+    loop do
+      line = log_file.readline
+      @req_counter += 1 if line =~ /Completed in/
+    end
+  end
+
+  def process!
+    # Do nothing
+  end
+
+  def num_requests
+    @req_counter
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: entombedvirus-munin_manager
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Rohith Ravi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Tool to maintain and install munin plugins written in Ruby
+email: entombedvirus@gmail.com
+executables: 
+- munin_manager
+- runner
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- bin/munin_manager
+- bin/runner
+- lib/munin_manager.rb
+- lib/munin_manager/log_reader.rb
+- lib/munin_manager/plugins/haproxy_response_time.rb
+- lib/munin_manager/plugins/rails_response_time.rb
+- lib/munin_manager/plugins.rb
+- lib/munin_manager/acts_as_munin_plugin.rb
+- ext/string.rb
+files: 
+- README.markdown
+- bin/munin_manager
+- bin/runner
+- lib/munin_manager.rb
+- lib/munin_manager/log_reader.rb
+- lib/munin_manager/plugins/haproxy_response_time.rb
+- lib/munin_manager/plugins/rails_response_time.rb
+- lib/munin_manager/plugins.rb
+- lib/munin_manager/acts_as_munin_plugin.rb
+- test/haproxy_response_time_test.rb
+- test/log_reader_test.rb
+- test/test_helper.rb
+- test/rails_response_time_test.rb
+- ext/string.rb
+- Rakefile
+- Manifest
+- munin_manager.gemspec
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Munin_manager
+- --main
+- README.markdown
+require_paths: 
+- lib
+- ext
+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: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: munin_manager
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Tool to maintain and install munin plugins written in Ruby
+test_files: 
+- test/haproxy_response_time_test.rb
+- test/log_reader_test.rb
+- test/test_helper.rb
+- test/rails_response_time_test.rb