munin2graphite 0.1.0

data/test/munin2graphite/config_test.rb

@@ -0,0 +1,53 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"../test_init")
+require 'tempfile'
+
+class TestMyGraph < Test::Unit::TestCase
+
+  def setup
+    Munin2Graphite::Config.deconfigure!
+  end
+
+  def teardown
+  end
+
+  def test_config_init_without_config_file
+    Munin2Graphite::Config.config_file = "/TMP/it does exist, C'mon!"
+    assert_raise(Munin2Graphite::Config::ConfigFileNotFoundException) {
+      Munin2Graphite::Config.carbon
+    }
+  end
+
+  def test_config_raises_exception_when_malformed
+    file = Tempfile.new('foo')
+    file.write("test_:::: : ::: [] of_a_malformed thing, \nthat does not confo")
+    file.close
+    Munin2Graphite::Config.config_file = file.path
+    assert_raise(Munin2Graphite::Config::MalformedConfigFileException) {
+      Munin2Graphite::Config.carbon
+    }
+    file.unlink
+  end
+
+  def test_config_raises_exception_when_not_configured
+    assert_raise(Munin2Graphite::Config::NotConfiguredException) {
+      Munin2Graphite::Config.carbon
+    }
+  end
+
+  def test_config_initialization_raises_exception_when_mandatory_fields_are_not_present
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    file = Tempfile.new('foo')
+    file.write(":thing:\n  :other_thing:")
+    file.close
+    Munin2Graphite::Config.config_file = file.path
+    assert_raise(Munin2Graphite::Config::RequiredFieldMissingException){
+      Munin2Graphite::Config.carbon
+    }
+  end
+
+  def test_correct_initalization
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    assert_not_equal Munin2Graphite::Config[:carbon][:hostname],"","should be filled"
+  end
+
+end

data/test/test_config.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"/test_init"))
+
+class TestMunin < Test::Unit::TestCase
+
+  def setup
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    @munin = Munin::Node.new(Munin2Graphite::Config["munin_hostname"],Munin2Graphite::Config["munin_port"])
+  end
+  
+  def test_config
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    assert Munin2Graphite::Config.configured?
+  end
+
+  def test_config_workers
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    assert_not_empty Munin2Graphite::Config.workers
+  end
+
+  def test_worker_config
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    worker_config = Munin2Graphite::Config.config_for_worker("test_worker1")
+    assert_not_equal Munin2Graphite::Config["munin_hostname"], worker_config["munin_hostname"]
+    assert_not_nil worker_config.log
+  end
+ 
+end

data/test/test_init.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.join(File.dirname(__FILE__) + "/../lib/"))
+require 'rubygems'
+require 'test/unit'
+require '../munin-ruby/lib/munin-ruby'
+require 'graphite'
+require 'munin2graphite'
+require 'munin_graph'
+require 'carbon'
+
+TEST_CONFIG_FILE = File.join(File.dirname(__FILE__),"config.conf")
+Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+Graphite::Base.set_connection(Munin2Graphite::Config["carbon_hostname"])
+Graphite::Base.authenticate(Munin2Graphite::Config["graphite_user"],Munin2Graphite::Config["graphite_password"])

data/test/test_munin.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"/test_init"))
+
+class TestMunin < Test::Unit::TestCase
+  def setup
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    @munin = Munin::Node.new(Munin2Graphite::Config["munin_hostname"],Munin2Graphite::Config["munin_port"])
+  end
+  
+  def test_metric_lists
+    metrics = @munin.list
+    assert_not_nil metrics
+    assert_not_empty metrics
+  end
+  
+  def test_nodes
+    nodes = @munin.nodes
+    assert_not_nil nodes
+    assert_not_empty nodes
+  end
+
+  def test_value_for
+    first_metric = @munin.list.first
+    values = @munin.fetch first_metric
+    assert_not_nil values
+    assert_not_empty values.keys
+  end
+
+  def test_graph_for
+    munin_graph = MuninGraph.graph_for @munin.raw_config(@munin.list.first)
+    assert_equal munin_graph.class, MuninGraph
+  end
+
+  def test_graph_for
+    @munin.list.each do |metric|
+      munin_graph = MuninGraph.graph_for @munin.config(metric,true)[metric]
+
+      munin_graph.config = Munin2Graphite::Config.merge("metric" => metric,"hostname" => @munin.nodes.first.split(".").first)
+      munin_graph.to_graphite.save!
+      assert_equal munin_graph.class, MuninGraph
+    end
+  end
+ 
+end

data/test/test_munin_graph.rb

@@ -0,0 +1,286 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"/test_init"))
+
+class TestMuninGraph < Test::Unit::TestCase
+
+  def setup
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    @munin = Munin::Node.new(Munin2Graphite::Config["munin_hostname"],Munin2Graphite::Config["munin_port"])
+    @simple_graph = MuninGraph.new(<<END
+graph_title ACPI Thermal zone temperatures
+graph_vlabel Celcius
+graph_category sensors
+graph_info This graph shows the temperature in different ACPI Thermal zones.  If there is only one it will usually be the case temperature.
+THM0.label THM0
+THM0.colour black
+THM1.label THM1
+END
+)
+    @apache_graph = MuninGraph.new(<<END
+graph_title Apache accesses
+graph_args --base 1000
+graph_vlabel accesses / ${graph_period}
+graph_category apache
+accesses80.label port 80
+accesses80.type DERIVE
+accesses80.max 1000000
+accesses80.min 0
+accesses80.info The number of accesses (pages and other items served) globaly on the Apache server
+END
+)
+
+    @processes_graph = MuninGraph.new(<<END
+graph_title Apache processes
+graph_args --base 1000 -l 0
+graph_category apache
+graph_order busy80 idle80 
+graph_vlabel processes
+graph_total total
+busy80.label busy servers 80
+busy80.draw AREA
+busy80.colour 33cc00
+idle80.label idle servers 80
+idle80.draw STACK
+idle80.colour 0033ff
+free80.label free slots 80
+free80.draw STACK
+free80.colour ccff00
+END
+)    
+
+    @log_graph = MuninGraph.new(<<END
+config iostat_ios
+graph_title IO Service time
+graph_args --base 1000 --logarithmic
+graph_category disk
+graph_vlabel seconds
+graph_info For each applicable disk device this plugin shows the latency (or delay) for I/O operations on that disk device.  The delay is in part made up of waiting for the disk to flush the data, and if data arrives at the disk faster than it can read or write it then the delay time will include the time needed for waiting in the queue.
+dev104_0_rtime.label cciss/c0d0 read
+dev104_0_rtime.type GAUGE
+dev104_0_rtime.draw LINE2
+dev104_0_rtime.cdef dev104_0_rtime,1000,/
+dev104_0_wtime.label cciss/c0d0 write
+dev104_0_wtime.type GAUGE
+dev104_0_wtime.draw LINE2
+dev104_0_wtime.cdef dev104_0_wtime,1000,/
+dev104_16_rtime.label cciss/c0d1 read
+dev104_16_rtime.type GAUGE
+dev104_16_rtime.draw LINE2
+dev104_16_rtime.cdef dev104_16_rtime,1000,/
+dev104_16_wtime.label cciss/c0d1 write
+dev104_16_wtime.type GAUGE
+dev104_16_wtime.draw LINE2
+dev104_16_wtime.cdef dev104_16_wtime,1000,/
+END
+)
+    @simple_graph.config = Munin2Graphite::Config.merge({ 
+                                                                     "metric_prefix" => "test.frontends.linux",
+                                                                     "category" => "sensors", 
+                                                                     "hostname" => "myhost",
+                                                                     "metric" => "acpi"}
+                                                                   )
+    @apache_graph.config = Munin2Graphite::Config.merge({ "metric_prefix" => "test.frontends.linux",
+                                                          "category" => "apache",
+                                                          "hostname" => "myhost",
+                                                          "metric" => "apache_accesses"
+                                                        })
+
+    @processes_graph.config = Munin2Graphite::Config.merge({ 
+                                                             "metric_prefix" => "test.frontends.linux",
+                                                             "category" => "apache",
+                                                             "hostname" => "myhost",
+                                                             "metric" => "apache_processes"
+                                                           })
+    @log_graph.config = Munin2Graphite::Config.merge({
+                                                       "metric_prefix" => "test.frontends.linux",
+                                                       "category" => "apache",
+                                                       "hostname" => "myhost",
+                                                       "metric" => "iostat_ios"
+                                                     })
+  end
+
+  def test_get_title
+    root = @simple_graph.root
+    assert_equal root.children.length, 6
+  end
+
+  def test_compilation_on_simple_graph
+    root = @simple_graph.root
+    root.compile
+    field_declarations = root.children_of_class(FieldDeclarationNode)
+    assert_equal field_declarations.first.compile,"alias(test.frontends.linux.myhost.sensors.acpi.THM0,'THM0')"
+    assert_equal root.graph_properties[:vtitle], "Celcius"
+    assert_equal root.graph_properties[:title], "ACPI Thermal zone temperatures"
+  end
+
+  def test_compilation_on_derivative_graph
+    root = @apache_graph.root
+    field_declarations = root.children_of_class(FieldDeclarationNode)
+    root.compile
+    assert_equal field_declarations.first.compile,"alias(scale(nonNegativeDerivative(test.frontends.linux.myhost.apache.apache_accesses.accesses80),0.0166666666666667),'port 80')"
+    assert_equal root.graph_properties[:yMax], 1000000
+    assert_equal root.graph_properties[:yMin], 0
+    assert_equal root.properties[:base] , 1000
+    assert_equal root.graph_properties[:title], "Apache accesses"
+  end
+
+  def test_children_of_class
+    root = @simple_graph.root
+    assert_equal root.children_of_class(GlobalDeclarationNode).length, 4
+    field_declarations = root.children_of_class(FieldDeclarationNode)
+#   puts field_declarations.map(&:properties).inspect
+    assert_equal field_declarations.length,2
+    assert_equal field_declarations.first.children.length,2
+    assert_equal field_declarations[1].children.length,1
+  end
+
+  def test_stacked_graph    
+    root = @processes_graph.root
+    @processes_graph.root.compile
+    stacked = false
+    root.targets.each do |target|
+      if target.compile =~ /stacked/
+        stacked = true
+      end
+    end
+    assert_equal stacked,true
+
+  end
+
+  def test_variable_substitution
+    @apache_graph.root.compile
+    assert_nil  @apache_graph.root.url =~ /graph_period/
+  end
+
+  def test_random_colors
+    root = @processes_graph.root
+    @processes_graph.root.compile
+    assert_equal @processes_graph.root.graph_properties[:colorList].first , "#33cc00"
+  end
+
+  def test_logarithmic_graph
+    root = @log_graph.root
+    root.compile
+    root.targets.each do |target|
+#      assert_not_nil target.compile =~ /log/
+    end
+  end
+
+  def test_global_attributes_can_appear_wherever
+    graph = MuninGraph.new(<<END
+graph_title Load average
+graph_args --base 1000 -l 0
+graph_vlabel load
+graph_scale no
+graph_category system
+load.label load
+graph_info The load average of the machine describes how many processes are in the run-queue (scheduled to run "immediately").
+load.info 5 minute load average
+END
+)
+    graph.config = Munin2Graphite::Config.merge({ 'metric' => "load",'hostname' => "localhost"})
+    graph.root.url
+  end
+
+  def test_host_name_changed
+    graph = MuninGraph.new(<<END
+host_name Firewalls
+graph_title Load average
+graph_args --base 1000 -l 0
+graph_vlabel load
+graph_scale no
+graph_category system
+load.label load
+graph_info The load average of the machine describes how many processes are in the run-queue (scheduled to run "immediately").
+load.info 5 minute load average
+END
+)
+    graph.config = Munin2Graphite::Config.merge({ 'metric' => "load",'hostname' => "localhost"})    
+    graph.root.url
+    assert_equal graph.root.properties['hostname'] , "Firewalls"
+  end
+
+
+  def test_multi_line
+    graph = MuninGraph.new(<<END                                                                                                                            
+graph_order down up
+graph_title eth2 traffic
+graph_args --base 1000
+  graph_vlabel bits in (-) / out (+) per ${graph_period}
+graph_category network
+graph_info This graph shows the traffic of the eth2 network interface. Please note that the traffic is shown in bits per second, not bytes. IMPORTANT: On 32 bit systems the data source for this plugin uses 32bit counters, which makes the plugin unreliable and unsuitable for most 100Mb (or faster) interfaces, where traffic is expected to exceed 50Mbps over a 5 minute period.  This means that this plugin is unsuitable for most 32 bit production environments. To avoid this problem, use the ip_ plugin instead.  There should be no problems on 64 bit systems running 64 bit kernels.
+down.label received
+down.type COUNTER
+down.graph no
+down.cdef down,8,*
+up.label bps
+up.type COUNTER
+up.negative down
+up.cdef up,8,*
+up.max 1000000000
+up.info Traffic of the eth2 interface. Maximum speed is 1000 Mbps.
+down.max 1000000000
+END
+)
+    graph.config = Munin2Graphite::Config.merge({ 'metric' => "load",'hostname' => "localhost"})
+    graph.root.compile
+    color_list = graph.root.graph_properties[:colorList]
+    assert_equal color_list.first , color_list[1] # Thew should be drawn with the same color
+    assert_match graph.root.url , /alias\(scale\(scale\(scale\(nonNegativeDerivative\(test.frontends.linux.localhost.network.load.down\),0.0166666666666667\),8\),-1/
+    assert_equal graph.root.children_of_class(FieldDeclarationNode).length , 2
+     graph.root.url
+  end
+
+  def test_network_graph
+    graph = MuninGraph.new(<<END
+host_name Switxos
+graph_category switch
+graph_title One switck
+graph_args --base 1000
+graph_vlabel Errors in (G) / out (B) per ${graph_period}
+fe_0_1_errors_in.label Errors IN
+fe_0_1_errors_in.draw LINE1
+fe_0_1_errors_in.type DERIVE
+fe_0_1_errors_in.cdef fe_0_1_errors_in,8,*
+fe_0_1_errors_in.max 2000000000
+fe_0_1_errors_in.min 0
+fe_0_1_errors_out.label Errors OUT
+fe_0_1_errors_out.draw LINE1
+fe_0_1_errors_out.type DERIVE
+fe_0_1_errors_out.cdef fe_0_1_errors_out,8,*
+fe_0_1_errors_out.max 2000000000
+fe_0_1_errors_out.min 0
+fe_0_2_errors_in.label Errors IN
+fe_0_2_errors_in.draw LINE1
+fe_0_2_errors_in.type DERIVE
+fe_0_2_errors_in.cdef fe_0_2_errors_in,8,*
+fe_0_2_errors_in.max 2000000000
+fe_0_2_errors_in.min 0
+fe_0_2_errors_out.label Errors OUT
+fe_0_2_errors_out.draw LINE1
+fe_0_2_errors_out.type DERIVE
+fe_0_2_errors_out.cdef fe_0_2_errors_out,8,*
+fe_0_2_errors_out.max 2000000000
+fe_0_2_errors_out.min 0
+fe_0_4_errors_in.label Errors IN
+fe_0_4_errors_in.draw LINE1
+fe_0_4_errors_in.type DERIVE
+fe_0_4_errors_in.cdef fe_0_4_errors_in,8,*
+fe_0_4_errors_in.max 2000000000
+fe_0_4_errors_in.min 0
+fe_0_4_errors_out.label Errors OUT
+fe_0_4_errors_out.draw LINE1
+fe_0_4_errors_out.type DERIVE
+fe_0_4_errors_out.cdef fe_0_4_errors_out,8,*
+fe_0_4_errors_out.max 2000000000
+fe_0_4_errors_out.min 0
+END
+)
+    graph.config = Munin2Graphite::Config.merge({ 'metric' => "load",'hostname' => "localhost"})
+    graph.root.compile
+    assert_equal graph.root.targets.length, 6
+    
+  end
+
+
+
+end

data/test/test_my_graph.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"/test_init"))
+require 'test/unit'
+
+class TestMyGraph < Test::Unit::TestCase
+
+  def setup
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+    @graphic = Graphite::MyGraph.new
+    @graphic.url = "http://graphite.uoc.es/composer/../render/?width=1371&height=707&_salt=1312965749.741&target=alias(scale(derivative(campus.frontends.linux.aleia.apache.apache_volume.volume80)%2C0.016666666666666666)%2C%22Bytes%20por%20segundo%22)&title=Bytes%20transmitidos"
+    @graphic.name = "Apache.Transferencia"
+    @graphic.save!
+  end
+  
+  def teardown    
+    Graphite::MyGraph.find_all_by_query("*").each do |graph|
+      graph.delete!
+    end
+  end
+
+  def test_find_by_query_and_path_before_authenticate
+    assert_equal Graphite::MyGraph.find_by_query_and_path("*","Apache").count, 1
+  end
+
+  def test_find_by_name
+    assert_equal Graphite::MyGraph.find_by_name("Apache.Transferencia").name , "Apache.Transferencia"
+  end
+
+end

data/test/test_scheduler.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"/test_init"))
+
+class TestMuninGraph < Test::Unit::TestCase
+
+  def setup
+    Munin2Graphite::Config.config_file = TEST_CONFIG_FILE
+  end
+
+  def test_obtain_metrics
+    @scheduler = Munin2Graphite::Scheduler.new(Munin2Graphite::Config)
+    @scheduler.obtain_metrics
+  end
+
+  def test_obtain_graphs
+    @scheduler = Munin2Graphite::Scheduler.new(Munin2Graphite::Config)
+    @scheduler.obtain_graphs
+  end
+
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: munin2graphite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jose Fernandez (magec)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: &14306040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *14306040
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &14305560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *14305560
+- !ruby/object:Gem::Dependency
+  name: parseconfig
+  requirement: &14305080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *14305080
+- !ruby/object:Gem::Dependency
+  name: munin-ruby
+  requirement: &14304600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *14304600
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &14304120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *14304120
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &14303640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *14303640
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &14303160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *14303160
+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.
+email: jfernandezperez@gmail.com
+executables:
+- munin2graphite
+- munin2graphite-daemon
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+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
+homepage: http://github.com/magec/munin2graphite
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -924376751011725776
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Allows to post both data and graphic info from munin to graphite (https://launchpad.net/graphite)
+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