munin2graphite 0.1.0

data/lib/graphite/base.rb

@@ -0,0 +1,30 @@
+require 'net/http'
+
+module Graphite
+  class Base    
+
+
+    # connection instance (shared with every instance of the class)
+    def self.connection      
+      @@init_header ||= {}      
+      @@connection ||= Net::HTTP.new(@@endpoint)
+    end
+
+    # If the operation needs authentication you have to call this first
+    def self.authenticate(user = @@user,password = @@password)
+      response = self.connection.post("/account/login","nextPage=/&password=#{password}&username=#{user}")
+      @@init_header =  {"Cookie" => response.get_fields('Set-Cookie').first}
+    end
+
+    def self.set_connection(endpoint,user = "",password = "")
+      @@endpoint = endpoint
+      @@user ||= user
+      @@password ||= password
+    end
+    
+    # Get
+    def self.get(path,args)      
+      self.connection.get(path + "?" + args.map { |i,j| i.to_s + "=" + j }.join("&"),@@init_header)
+    end
+  end
+end

data/lib/graphite/graph.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module Graphite
+  class Graph < Graphite::Base
+    attr_accessor :name,:id,:allow_children,:leaf,:url
+
+    def self.find_by_query_and_path(query,path)
+      graph_type = "#{self}" == "Graphite::MyGraph" ? "mygraph" : "usergraph"
+      return JSON.parse(self.get("/browser/#{graph_type}/",{:format => "treejson",:query => query,:path =>path}).body).map do |graphic_hash|
+        graphic = MyGraph.new
+        graphic.url            = graphic_hash["graphUrl"]
+        graphic.name           = graphic_hash["id"]
+        graphic.leaf           = graphic_hash["leaf"] == 1
+        graphic.allow_children = graphic_hash["allowChildren"] == 1
+        graphic
+      end
+    end
+
+
+    def self.descend_to_leaf(query,path)
+      result = []
+      self.find_by_query_and_path(query,path).each do |graph|
+        if graph.leaf 
+          return graph 
+        else
+          result << self.descend_to_leaf(graph.name + "*",graph.name)
+        end        
+      end
+      return result
+    end
+
+    def self.find_all_by_query(query)
+      result = []
+      self.find_by_query_and_path(query,"").each do |graph|        
+        result << self.descend_to_leaf(graph.name + "*",graph.name)
+      end
+      return result.flatten
+    end
+  end
+end

data/lib/graphite/metric.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module Graphite
+  class Metric < Graphite::Base
+    attr_accessor :name,:id,:allow_children,:leaf 
+
+    def self.find_by_query(query)
+
+      return JSON.parse(self.get("/metrics/find",{:format => "treejson",:query => query}).body).map do |metric_hash|
+        metric = Metric.new
+        metric.name           = metric_hash["text"]
+        metric.id             = metric_hash["id"]
+        metric.allow_children = metric_hash["allowChildren"] == 1
+        metric.leaf           = metric_hash["leaf"] == 1
+        metric
+      end
+    end
+  end
+end

data/lib/graphite/my_graph.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+module Graphite
+  class MyGraph < Graph
+
+    def save!
+      MyGraph.get("/composer/mygraph/",:action => "save", :graphName => name,:url => url.gsub("&","%26"))
+      Munin2Graphite::Config.log.debug("Saving: #{name} ") 
+      Munin2Graphite::Config.log.debug("   url: #{url}  ") 
+
+    end
+
+    def delete!
+      MyGraph.get("/composer/mygraph/",:action => "delete", :graphName => name,:url => url.gsub("&","%26"))
+    end
+
+    # Returns a graph by name
+    def self.find_by_name(name)
+      MyGraph.find_by_query_and_path(name,name.split(".").first).first
+    end
+    
+  end
+end

data/lib/graphite/user_graph.rb

@@ -0,0 +1,4 @@
+module Graphite
+  class UserGraph < Graph
+  end
+end

data/lib/graphite.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.join(File.dirname(__FILE__)),"graphite")
+require 'graphite/base'
+require 'graphite/metric'
+require 'graphite/graph'
+require 'graphite/my_graph'
+require 'graphite/user_graph'
+

data/lib/munin2graphite/config.rb

@@ -0,0 +1,117 @@
+require 'parseconfig'
+require 'logger'
+module Munin2Graphite
+
+  class Config
+
+    class NotConfiguredException < Exception; end
+    class ConfigFileNotFoundException < Exception; end
+    class MalformedConfigFileException < Exception; end
+    class RequiredFieldMissingException < Exception; end
+
+    class << self
+
+      # Returns the config for a given class
+      def config_for_class(klass)
+        return @config[klass.to_s.decamelize.to_sym]
+      end
+
+      def workers
+        return @config.groups
+      end
+
+      attr_accessor :config
+
+      # This method will return a config class but for a given worker, so everything will be the same as in the original class
+      # but the config changes made in this worker
+      def config_for_worker(worker)
+        return self if worker == "global"
+        cloned = self.clone
+        cloned.config = @config.clone
+        cloned.config.params = @config.params.merge(@config.params[worker])
+        return cloned
+      end
+
+      def deconfigure!
+        @config = nil
+        @config_file = nil
+      end
+
+      def configured?
+        return @config_file != nil
+      end
+
+      def parse_config
+        begin
+          @config = ParseConfig.new(@config_file)
+        rescue Errno::ENOENT
+          raise ConfigFileNotFoundException.new("Error, trying to open the config file #{@config_file}")
+        rescue ArgumentError => exception
+          raise MalformedConfigFileException.new("Malformed config file '#{@config_file}' #{exception.message}")
+        rescue
+          raise "Unknown error when trying to open config file '#{@config_file}'"
+        end
+        @config
+      end
+
+      def check_config
+        fields={:carbon => [:hostname,:port],:graphite => [:endpoint,:metric_prefix,:user,:password],:scheduler => [:metrics_period,:graphs_period]}
+        fields.each do |k,v|
+          v.each do |inner_field|
+            field = "#{k}_#{inner_field}"
+            if !@config.params[field] 
+              workers.each do |worker|
+                raise RequiredFieldMissingException.new("Error, required field not found in config ':#{field}' for worker #{worker}") unless @config.params[worker][field]
+              end
+              
+              raise RequiredFieldMissingException.new("Error, required field not found in config ':#{field}'") if workers.empty?
+            end
+          end
+        end
+      end
+     
+      def method_missing(method_name,*args)
+        if !@config
+          if @config_file
+            parse_and_check!
+          end
+          raise NotConfiguredException.new("Not Configured") unless @config
+        end
+          
+        if method_name == :"[]"
+          if @config.params.has_key?(args.first.to_s)
+            return @config.params[args.first.to_s]
+          end
+        end
+        if @config.params.respond_to?method_name
+          return @config.params.send(method_name,*args)
+        end
+        super
+      end
+
+      def log        
+        @log ||= if self["log"] == "STDOUT"
+                   Logger.new(STDOUT)
+                 else
+                   Logger.new(self["log"])
+                 end
+        @log.level = self["log_level"] == "DEBUG" ? Logger::DEBUG : Logger::INFO
+        @log
+      end
+
+      def config_file=(config_file)
+        @config_file = config_file
+      end
+
+      def config=(config)
+        @config = config
+        check_config
+      end
+
+      def parse_and_check!
+        parse_config
+        check_config
+      end
+    end
+  end
+end

data/lib/munin2graphite/scheduler.rb

@@ -0,0 +1,169 @@
+#
+# Author:: Jose Fernandez (@magec)
+# Copyright:: Copyright (c) 2011 UOC (Universitat Oberta de Catalunya)
+#
+# This program and entire repository is free software; you can
+# redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General putsPublic License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+require 'rufus/scheduler'
+module Munin2Graphite
+  ##
+  # This class holds the main scheduler of the system, it will perform the applicacion loops
+  class Scheduler
+
+    attr_accessor :scheduler
+
+    def initialize(config)
+      @config = config
+    end
+    
+    def category_from_config(config)
+      config.each_line do |configline|
+        if configline =~ /^graph_category ([0-9A-Za-z_-]+)$/
+          return configline.split[1]
+        end
+      end      
+      return "other"
+      raise "CategoryNotFound in #{config}"
+    end
+
+    def munin_config
+      return @munin_config if @munin_config 
+      @munin_config = {}
+
+      workers.each do |worker|
+        @munin_config[worker] = {}
+        config = @config.config_for_worker(worker)
+        munin  = Munin::Node.new(config["munin_hostname"],config["munin_port"])
+        nodes = config["munin_nodes"] ? config["munin_nodes"].split(",") : munin.nodes
+        @munin_config[worker][:nodes] = {}
+        nodes.each do |node|
+
+          @munin_config[worker][:nodes][node] = {:metrics => munin.list(node)}
+          @munin_config[worker][:nodes][node][:categories] = {}
+
+          @munin_config[worker][:nodes][node][:metrics].each do |metric|
+            @munin_config[worker][:nodes][node][:config] = munin.config(metric)[metric]
+            @munin_config[worker][:nodes][node][:raw_config] = munin.config(metric,true)[metric]
+            @munin_config[worker][:nodes][node][:categories][metric] = category_from_config(@munin_config[worker][:nodes][node][:raw_config])
+          end
+        end
+        munin.disconnect
+      end
+      @munin_config
+    end      
+
+    def workers
+      @workers ||= (@config.workers.empty? ?  ["global"] : @config.workers )
+    end
+
+    #
+    # This is the loop of the metrics scheduling
+    def obtain_metrics
+      config = @config.config_for_worker("global")
+      config.log.info("Obtaining metrics configuration")
+      munin_config
+      config.log.info("Getting metrics")
+      time = Time.now
+      workers.each do |worker|        
+        config = @config.config_for_worker(worker)
+        config.log.info("Worker #{worker}")
+
+        metric_base = config["graphite_metric_prefix"]
+
+        threads = []
+        munin_config[worker][:nodes].keys.each do |node|
+          threads << Thread.new do 
+            node_name = metric_base + "." + node.split(".").first
+            config.log.debug("Doing #{node_name}")
+            values = {}                       
+            config.log.debug("Asking for: #{node}")		
+            metric_time = Time.now
+            metrics = munin_config[worker][:nodes][node][:metrics]
+	    config.log.debug("Metrics " + metrics.join(","))
+            metrics_threads = []
+            categories = {}
+            metrics.each do |metric|
+              metrics_threads << Thread.new do
+                local_munin  = Munin::Node.new(config["munin_hostname"],config["munin_port"])
+                values[metric] =  local_munin.fetch metric
+                local_munin.disconnect
+              end            
+            end 
+            metrics_threads.each {|i| i.join;i.kill}
+            config.log.info("Done with: #{node} (#{Time.now - metric_time} s)")	
+            carbon = Carbon.new(config["carbon_hostname"],config["carbon_port"])
+            string_to_send = ""
+            values.each do |metric,results|          
+              category = munin_config[worker][:nodes][node][:categories][metric] 
+              results.each do |k,v|
+                v.each do |c_metric,c_value|
+                  string_to_send += "#{node_name}.#{category}.#{metric}.#{c_metric} #{c_value} #{Time.now.to_i}\n".gsub("-","_")  if c_value != "U"
+                end
+              end
+            end
+            send_time = Time.now
+            carbon.send(string_to_send)
+            carbon.flush
+            carbon.close
+           end
+        end
+        threads.each { |i| i.join }
+      end
+      @config.log.info("End   getting metrics, elapsed time (#{Time.now - time}s)")
+    end
+
+    ##
+    # The loop of the graphics creation
+    def obtain_graphs
+
+      workers = @config.workers
+      workers = ["global"] if workers.empty?
+
+      workers.each do |worker|
+        time = Time.now 
+        config = @config.config_for_worker worker
+        config.log.info("Begin : Sending Graph Information to Graphite for worker #{worker}")         
+        munin  = Munin::Node.new(config["munin_hostname"],config["munin_port"])
+        nodes = config["munin_nodes"] ? config["munin_nodes"].split(",") : munin.nodes
+        nodes.each do |node|
+          config.log.info("Graphs for #{node}")
+          munin.list(node).each do |metric|
+            config.log.info("Configuring #{metric}")
+            Graphite::Base.set_connection(config["carbon_hostname"])
+            Graphite::Base.authenticate(config["graphite_user"],config["graphite_password"])
+            munin_graph = MuninGraph.graph_for munin.config(metric,true)[metric]
+            
+            munin_graph.config = config.merge("metric" => "#{metric}","hostname" => node.split(".").first)
+            config.log.debug("Saving graph #{metric}")
+            munin_graph.to_graphite.save!
+          end
+        end
+        config.log.info("End   : Sending Graph Information to Graphite for worker #{worker}, elapsed time (#{Time.now - time}s)")
+        munin.disconnect
+      end
+
+    end
+
+    def start
+      @config.log.info("Scheduler started")
+      @scheduler = Rufus::Scheduler.start_new
+      obtain_metrics
+      @scheduler.every @config["scheduler_metrics_period"] do
+        obtain_metrics
+      end
+      obtain_graphs
+    end
+    
+  end
+end

data/lib/munin2graphite.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.join(File.expand_path(File.dirname(__FILE__),"munin2graphite")))
+require 'rubygems'
+require 'munin-ruby'
+require 'carbon'
+require 'graphite'
+require 'munin_graph'
+require 'munin2graphite/config'
+require 'munin2graphite/scheduler'

data/lib/munin_graph.rb

@@ -0,0 +1,136 @@
+require 'ast_node'
+require 'graphite'
+#
+# Author:: Jose Fernandez (@magec)
+# Copyright:: Copyright (c) 2011 UOC (Universitat Oberta de Catalunya)
+# License:: GNU General Public License version 2 or later
+#
+# This program and entire repository is free software; you can
+# redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+##
+# This class allows the transformation between graphite and munin config. It constructs an AST parsing the munin config information and
+# allows to output a valid graphic in graphite url format
+# Jose Fernandez 2011
+#
+class MuninGraph
+
+  def self.graph_for(config)
+    MuninGraph.new(config)
+  end
+
+  def initialize(config)
+    @raw_config = config
+    parse_config
+  end
+
+  def config=(config)
+    @config = config
+    self.root.config = config
+  end
+
+  def to_graphite
+    graph = Graphite::MyGraph.new
+    self.root.compile
+    graph.url = self.root.url
+    self.root.properties[:category] ||= "other"
+    
+    graph.name = "#{@config["hostname"]}.#{self.root.properties["category"]}.#{self.root.properties["metric"]}"
+    graph.name = "#{@config["graphite_graph_prefix"]}.#{graph.name}" if @config["graphite_graph_prefix"] && @config["graphite_graph_prefix"] != "" 
+    return graph
+  end
+
+  attr_reader :root
+  
+  # This array of hashes will be used to match what kind of line we are dealing with and 
+  # to know the corresponding ast node class
+  TOKENS = [
+            {:matcher => /^graph_title .*/, :klass => GraphTitleGlobalDeclarationNode},
+            {:matcher => /^create_args .*/, :klass => CreateArgsGlobalDeclarationNode},
+            {:matcher => /^graph_args .*/, :klass => GraphArgsGlobalDeclarationNode},
+            {:matcher => /^graph_category .*/, :klass => GraphCategoryGlobalDeclarationNode},
+            {:matcher => /^graph_info .*/, :klass => GraphInfoGlobalDeclarationNode},
+            {:matcher => /^graph_order .*/, :klass => GraphOrderGlobalDeclarationNode},
+            {:matcher => /^graph_vlabel .*/, :klass => GraphVLabelGlobalDeclarationNode},
+            {:matcher => /^graph_total .*/, :klass => GraphTotalGlobalDeclarationNode},
+            {:matcher => /^graph_scale .*/, :klass => GraphScaleGlobalDeclarationNode},
+            {:matcher => /^graph .*/, :klass => GraphGlobalDeclarationNode},
+            {:matcher => /^host_name .*/, :klass => HostNameGlobalDeclarationNode},
+            {:matcher => /^update .*/, :klass => UpdateGlobalDeclarationNode},
+            {:matcher => /^graph_period .*/, :klass => GraphPeriodGlobalDeclarationNode},
+            {:matcher => /^graph_vtitle .*/, :klass => GraphVTitleGlobalDeclarationNode},
+            {:matcher => /^service_order .*/, :klass => ServiceOrderGlobalDeclarationNode},
+            {:matcher => /^graph_width .*/, :klass => GraphWidthGlobalDeclarationNode},
+            {:matcher => /^graph_height .*/, :klass => GraphHeightGlobalDeclarationNode},
+            {:matcher => /^graph_printfformat .*/, :klass => GraphPrintFormatGlobalDeclarationNode},
+            {:matcher => /([\w_]+)\.label\ .*$/,:klass => LabelFieldPropertyNode},
+            {:matcher => /([\w_]+)\.cdef\ .*$/,:klass => CDefFieldPropertyNode},
+            {:matcher => /([\w_]+)\.draw\ .*$/,:klass => DrawFieldPropertyNode},
+            {:matcher => /([\w_]+)\.graph\ .*$/,:klass => GraphFieldPropertyNode},
+            {:matcher => /([\w_]+)\.info\ .*$/,:klass => InfoFieldPropertyNode},
+            {:matcher => /([\w_]+)\.extinfo\ .*$/,:klass => ExtInfoFieldPropertyNode},
+            {:matcher => /([\w_]+)\.max\ .*$/,:klass => MaxFieldPropertyNode},
+            {:matcher => /([\w_]+)\.min\ .*$/,:klass => MinFieldPropertyNode},
+            {:matcher => /([\w_]+)\.negative\ .*$/,:klass => NegativeFieldPropertyNode},
+            {:matcher => /([\w_]+)\.type\ .*$/,:klass => TypeFieldPropertyNode},
+            {:matcher => /([\w_]+)\.warning\ .*$/,:klass => WarningFieldPropertyNode},
+            {:matcher => /([\w_]+)\.critical\ .*$/,:klass => CriticalFieldPropertyNode},
+            {:matcher => /([\w_]+)\.colour\ .*$/,:klass => ColourFieldPropertyNode},
+            {:matcher => /([\w_]+)\.skipdraw\ .*$/,:klass => SkipDrawFieldPropertyNode},
+            {:matcher => /([\w_]+)\.sum\ .*$/,:klass => SumFieldPropertyNode},
+            {:matcher => /([\w_]+)\.stack\ .*$/,:klass => StackFieldPropertyNode},
+            {:matcher => /([\w_]+)\.linevalue\[:color\[:label\]\]\ .*$/,:klass => LineValueFieldPropertyNode},
+            {:matcher => /([\w_]+)\.oldname\ .*$/,:klass => OldNameFieldPropertyNode},
+            {:matcher => /([\w_]+)\.value\ .*$/,:klass => ValueFieldPropertyNode} 
+     ]
+
+   def parse_config
+     @root = ASTNode.new("")
+     @root.parent = nil
+     current_node = @root
+     @raw_config.each_line do |line|
+       # For every line of config we match against every token
+       TOKENS.each do |token|
+         if line =~ token[:matcher]
+           # When we find a match...
+           if token[:klass].new("").is_a? FieldPropertyNode
+             # In Property field we have to set it to a FieldDeclarationNode (an artificial node grouping those fields)
+             if !current_node.is_a? FieldDeclarationNode
+               # A new FieldDeclaration has to ve created
+               node = FieldDeclarationNode.new("")
+               node.properties[:field_name] = $1
+               current_node.add_child node
+               current_node = node
+             elsif current_node.properties[:field_name] != $1
+               if (aux = @root.children_of_class(FieldDeclarationNode).find { |i| i.properties[:field_name] == $1 } )
+                 current_node =  aux
+               else
+                 # We use the one declared before (note that different metrics could not be interlaced)
+                 node = FieldDeclarationNode.new("")
+                 node.properties[:field_name] = $1
+                 current_node.parent.add_child node
+                 current_node = node
+               end
+             end
+             current_node.add_child token[:klass].send("new",line)
+           else
+             @root.add_child token[:klass].send("new",line)
+           end
+           break
+        end
+      end
+    end
+  end
+end

data/munin2graphite.gemspec

@@ -0,0 +1,96 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "munin2graphite"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jose Fernandez (magec)"]
+  s.date = "2011-12-09"
+  s.description = "This gem will install as a daemon and can be used to connect to a graphite and a carbon backend. It will not only post the data for the metrics but also create graphs into graphite, by means of a translation from munin-node."
+  s.email = "jfernandezperez@gmail.com"
+  s.executables = ["munin2graphite", "munin2graphite-daemon"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "bin/munin2graphite",
+    "bin/munin2graphite-daemon",
+    "conf/munin2graphite.conf.example",
+    "etc/munin2graphite/munin2graphite.conf.example",
+    "lib/ast_node.rb",
+    "lib/carbon.rb",
+    "lib/graphite.rb",
+    "lib/graphite/base.rb",
+    "lib/graphite/graph.rb",
+    "lib/graphite/metric.rb",
+    "lib/graphite/my_graph.rb",
+    "lib/graphite/user_graph.rb",
+    "lib/munin2graphite.rb",
+    "lib/munin2graphite/config.rb",
+    "lib/munin2graphite/scheduler.rb",
+    "lib/munin_graph.rb",
+    "munin2graphite.gemspec",
+    "test/munin2graphite/config_test.rb",
+    "test/test_config.rb",
+    "test/test_init.rb",
+    "test/test_munin.rb",
+    "test/test_munin_graph.rb",
+    "test/test_my_graph.rb",
+    "test/test_scheduler.rb"
+  ]
+  s.homepage = "http://github.com/magec/munin2graphite"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Allows to post both data and graphic info from munin to graphite (https://launchpad.net/graphite)"
+  s.test_files = [
+    "test/munin2graphite/config_test.rb",
+    "test/test_config.rb",
+    "test/test_init.rb",
+    "test/test_munin.rb",
+    "test/test_munin_graph.rb",
+    "test/test_my_graph.rb",
+    "test/test_scheduler.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rufus-scheduler>, ["= 2.0.10"])
+      s.add_runtime_dependency(%q<daemons>, ["= 1.1.4"])
+      s.add_runtime_dependency(%q<parseconfig>, [">= 0"])
+      s.add_runtime_dependency(%q<munin-ruby>, ["~> 0.2.1"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+    else
+      s.add_dependency(%q<rufus-scheduler>, ["= 2.0.10"])
+      s.add_dependency(%q<daemons>, ["= 1.1.4"])
+      s.add_dependency(%q<parseconfig>, [">= 0"])
+      s.add_dependency(%q<munin-ruby>, ["~> 0.2.1"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    end
+  else
+    s.add_dependency(%q<rufus-scheduler>, ["= 2.0.10"])
+    s.add_dependency(%q<daemons>, ["= 1.1.4"])
+    s.add_dependency(%q<parseconfig>, [">= 0"])
+    s.add_dependency(%q<munin-ruby>, ["~> 0.2.1"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+  end
+end
+