munin-plugins-rails 0.2.10

data/README.rdoc

@@ -0,0 +1,74 @@
+= Munin-Rails-Plugins
+Collection of Concise Munin plugins for Rails server environments.
+This will make monitoring your rails app a piece of cake.
+
+This project contains munin plugins that not only work in munin, but are also concise (see references).
+Most things in this repository rely heavily on the request-log-analyzer gem.
+
+== What's in the box?
+* passenger_memory_stats - Munin plugin to monitor the memory usage of passenger application servers.
+* pasenger_queue - Montoring of passenger queue lenth.
+* passenger_status - Running, active and maximum number of passenger instances as well as sessions.
+* rails_database_time - Min, avg, max of database times.
+* rails_request_duration - Min, avg, max of the total request durations.
+* rails_request_error - Application errors and process blocker counters.
+* rails_requests - Get, put, post and delete requests.
+* rails_view_render_time - Min, avg and max view render times.
+
+For screenshots, head over to: http://barttenbrinke.github.com/munin-plugins-rails/
+
+== Installation
+The plugins follows the default munin installation scheme:
+    git clone git://github.com/barttenbrinke/munin-plugins-rails.git
+    cp munin-plugins-rails/rails_requests /usr/share/munin/plugins/
+    chmod +x /usr/share/munin/plugins/rails_requests
+    ln -s /usr/share/munin/plugins/rails_requests /etc/munin/plugins/rails_requests
+    vi /etc/munin/plugin-conf.d/munin-node
+
+Paste the configuration from the documentation of rails_requests into the munin-node file.
+    [rails_requests]
+    env.log_file '/path/to/production.log'
+    user www-data
+    command /usr/local/bin/ruby %c
+
+Run "/etc/munin/plugins/rails_requests autoconf" and "munin-run rails_requests" to test the plugin.
+
+For more detailed information, see the documentation embedded in the plugin.
+Each plugin is packed with an example config and a ln -s you can copy.
+
+== Monitoring multiple applications
+
+If you want to run the plugin for more than one app the best way is to symlink the plugin multiple times.
+Also set a different graph_category for each of app. For instance:
+
+    ln -s /usr/share/munin/plugins/rails_requests /etc/munin/plugins/rails_app1_requests
+    ln -s /usr/share/munin/plugins/rails_requests /etc/munin/plugins/rails_app2_requests
+
+And in the munin-node file:
+
+    [rails_app1_*]
+    env.log_file '/path/to/app1/production.log'
+    env.graph_category App1
+
+    [rails_app2_*]
+    env.log_file '/path/to/app2/production.log'
+    env.graph_category App2
+
+== Problems
+* sudo gem install request-log-analyzer
+* Check if the paths in the plugin configuration are correct.
+* Make sure the specified user is allowed to write to /tmp and access your rails logfile.
+
+If you encounter performance problems with your app, please take a look at the request-log-analyzer wiki on
+examples on how to drill down to the core of your problem. If you want to hire an expert, please visit us at
+http://railsdoctors.com or mail me at: bart@railsdoctors.com
+
+Happy monitoring!
+
+== Additional information
+* Railsdoctors:         http://railsdoctors.com
+* Request-log-analzer:  http://github.com/wvanbergen/request-log-analyzer/
+* Screenshots           http://barttenbrinke.github.com/munin-plugins-rails/
+* Munin:                http://munin.projects.linpro.no/wiki/ConcisePlugins
+* License:              MIT
+

data/VERSION

@@ -0,0 +1 @@
+0.2.10

data/bin/request-log-analyzer-munin

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'munin-plugins-rails'
+Munin::Command.new.run(ARGV)

data/lib/munin-plugins-rails.rb

@@ -0,0 +1,7 @@
+require 'munin/request_log_analyzer_plugin'
+require 'munin/rails_plugin'
+require 'munin/command'
+
+Dir.glob(File.join(File.dirname(__FILE__), "munin", "plugins", "*.rb")).each do |file|
+  require file
+end

data/lib/munin/command.rb

@@ -0,0 +1,77 @@
+require 'fileutils'
+require 'erb'
+module Munin
+  class Command     
+    def run(args)
+      if args.first == "install"
+        install_passenger_plugins
+      elsif args.first == "add"
+        args.shift
+        install_application(args)
+      end
+    end
+    PASSENGER_PLUGINS = %W{munin_passenger_memory_stats munin_passenger_queue munin_passenger_status}
+    RAILS_PLUGINS = %W{munin_rails_database_time munin_rails_request_duration munin_rails_request_error munin_rails_requests munin_rails_view_render_time}
+
+    PASSENGER_PLUGIN_CONFIG = <<-DATA
+[<%= plugin_target_name %>]
+user root
+command /usr/local/bin/ruby %c
+env.passenger_status '/usr/local/bin/passenger-status'
+env.passenger_memory_stats '/usr/local/bin/passenger-memory-stats'    
+env.graph_category Passenger
+DATA
+
+    RAILS_PLUGIN_CONFIG = <<-DATA
+[<%= plugin_target_name %>]    
+env.log_file <%= options[:log_file] %>
+user root
+command /usr/local/bin/ruby %c
+env.request_log_analyzer /usr/local/bin/request-log-analyzer    
+env.graph_category <%= plugin_target_name %>
+DATA
+
+    def install_application(args)
+      app_name = args.shift
+      log_file = args.shift
+      RAILS_PLUGINS.each do |plugin|
+        plugin_target_name = [app_name, plugin].join("_")
+        add_plugin(plugin, plugin_target_name)
+        add_plugin_config(plugin_target_name, RAILS_PLUGIN_CONFIG, :log_file => log_file)
+      end      
+    end
+
+    def install_passenger_plugins
+      PASSENGER_PLUGINS.each do |plugin|
+        add_plugin(plugin, plugin)
+        add_plugin_config(plugin, PASSENGER_PLUGIN_CONFIG)
+      end
+    end
+
+    def add_plugin_config(plugin_target_name, config_template, options = {})
+      FileUtils.mkdir_p(munin_plugin_config_path)      
+      template = ERB.new config_template
+      File.open(File.join(munin_plugin_config_path, plugin_target_name), "w+") do |file|
+        file << template.result(binding)      
+      end
+    end
+
+    def add_plugin(plugin_file, plugin_target_name = nil)
+      FileUtils.mkdir_p(munin_plugins_path)      
+      plugin_target_name ||= plugin_file
+      `ln -nsf "#{File.join(munin_dir, plugin_file)}" "#{munin_plugins_path}/#{plugin_target_name}"`      
+    end
+
+    def munin_plugins_path
+      "/etc/munin/plugins"
+    end
+    
+    def munin_plugin_config_path
+      "/etc/munin/plugin-conf.d"
+    end    
+
+    def munin_dir
+      File.join(File.dirname(__FILE__), "..", "..", "munin")
+    end
+  end
+end

data/lib/munin/plugins/passenger_memory_stats.rb

@@ -0,0 +1,42 @@
+module Munin
+  class PassengerMemoryStats < RequestLogAnalyzerPlugin    
+    def ensure_configuration
+      require_passenger_gem
+      require_passenger_memory_stats
+      
+      super
+    end
+
+    def config
+      memory_info = open('/proc/meminfo', 'r') do |lines|
+        lines.inject({}) do |h, line|
+          matched = line.match(/^([\w_\(\)]+):\s+(\d+)/)
+          h[matched[1].to_sym] = matched[2].to_i * 1024
+          h
+        end
+      end
+      upper_limit = memory_info[:MemTotal]
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Passenger memory stats
+graph_vlabel Bytes
+graph_args --base 1000 -l 0 --upper-limit #{upper_limit}
+graph_info The memory used by passenger instances on this application server
+
+memory.label memory
+CONFIG
+      exit 0
+    end
+
+    # Collect the data
+    # <tt>debug</tt> Show debug information
+    def run
+      stats = run_command(passenger_memory_stats, debug)
+
+      #### Total private dirty RSS: 81.81 MB
+      stats =~ /RSS:\s*([\d\.]+)\s*MB\Z/m
+      memory = ($1.to_f * 1024 * 1024).to_i
+      puts "memory.value #{memory}"
+    end
+  end
+end

data/lib/munin/plugins/passenger_queue.rb

@@ -0,0 +1,27 @@
+module Munin
+  class PassengerQueue < RequestLogAnalyzerPlugin
+    def ensure_configuration
+      require_passenger_status
+      super      
+    end
+
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Passenger queue
+graph_vlabel count
+graph_args --base 1000 -l 0
+graph_info The amount of requests waiting on global queue
+
+requests.label requests
+CONFIG
+      exit 0
+    end
+
+    def run
+      status = run_command(passenger_status, debug)      
+      status =~ /Waiting on global queue:\s+(\d+)/
+      puts "requests.value #{$1}"
+    end
+  end
+end

data/lib/munin/plugins/passenger_status.rb

@@ -0,0 +1,46 @@
+module Munin
+  class PassengerStatus < RequestLogAnalyzerPlugin
+    def ensure_configuration
+      require_passenger_status
+      super
+    end
+
+    def config
+      status = `#{passenger_status}`
+
+      status =~ /max\s+=\s+(\d+)/
+      upper_limit = $1 || 150
+
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Passenger status
+graph_vlabel count
+graph_args --base 1000 -l 0 --upper-limit #{upper_limit}
+graph_info The amount of active passengers on this application server - railsdoctors.com
+
+sessions.label sessions
+max.label max processes
+running.label running processes
+active.label active processes
+CONFIG
+      exit 0
+    end
+
+    def run
+      status = run_command(passenger_status, debug)
+
+      status =~ /max\s+=\s+(\d+)/
+      puts "max.value #{$1}"
+
+      status =~ /count\s+=\s+(\d+)/
+      puts "running.value #{$1}"
+
+      status =~ /active\s+=\s+(\d+)/
+      puts "active.value #{$1}"
+
+      total_sessions = 0
+      status.scan(/Sessions: (\d+)/).flatten.each { |count| total_sessions += count.to_i }
+      puts "sessions.value #{total_sessions}"
+    end
+  end
+end

data/lib/munin/plugins/rails_database_time.rb

@@ -0,0 +1,49 @@
+module Munin
+  class RailsDatabaseTime < RailsPlugin
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Database time
+graph_vlabel Seconds
+graph_args --base 1000 -l 0
+graph_info The minimum, maximum and average database times - railsdoctors.com
+
+min.label min
+max.label max
+average.label avg
+CONFIG
+      exit 0
+    end
+
+    # Gather information
+    def run
+      ensure_log_file
+
+      # Initialize values
+      max_value = 0
+      min_value = 1.0/0.0
+      cumulative = 0
+      hits = 0
+      
+      rla = parse_request_log_analyzer_data
+
+      if rla && rla["Database time"]
+        rla["Database time"].each do |item|
+          max_value = item[1][:max] if item[1][:max] > max_value
+          min_value = item[1][:min] if item[1][:min] < min_value
+          hits += item[1][:hits]
+          cumulative += item[1][:sum]
+        end
+      else
+        hits = 1
+        min_value = 0
+      end
+
+      # Report in seconds
+      puts "max.value #{max_value}"
+      puts "min.value #{min_value}"
+      puts "average.value #{cumulative / hits.to_f}"
+    end
+
+  end
+end

data/lib/munin/plugins/rails_request_duration.rb

@@ -0,0 +1,47 @@
+module Munin
+  class RailsRequestDuration < RailsPlugin
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Request time
+graph_vlabel Seconds
+graph_args --base 1000 -l 0
+graph_info The minimum, maximum and average request times - railsdoctors.com
+
+min.label min
+max.label max
+average.label avg
+CONFIG
+      exit 0
+    end
+
+    # Gather information
+    def run
+      ensure_log_file
+
+      # Initialize values
+      max_value = 0
+      min_value = 1.0/0.0
+      cumulative = 0
+      hits = 0
+
+      rla = parse_request_log_analyzer_data
+
+      if rla && rla["Request duration"]
+        rla["Request duration"].each do |item|
+          max_value = item[1][:max] if item[1][:max] > max_value
+          min_value = item[1][:min] if item[1][:min] < min_value
+          hits += item[1][:hits]
+          cumulative += item[1][:sum]
+        end
+      else
+        hits = 1
+        min_value = 0
+      end
+
+      puts "max.value #{max_value}"
+      puts "min.value #{min_value}"
+      puts "average.value #{cumulative / hits.to_f}"
+    end
+  end
+end

data/lib/munin/plugins/rails_request_error.rb

@@ -0,0 +1,42 @@
+module Munin
+  class RailsRequestError < RailsPlugin
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Request errors
+graph_vlabel Count
+graph_info The amount of request errors - railsdoctors.com
+
+error.label error
+blocker.label blocker
+CONFIG
+      exit 0
+    end
+
+    # Gather information
+    def run
+      ensure_log_file
+
+      # Initialize values
+      error_value = 0
+      blocker_value = 0
+
+      rla = parse_request_log_analyzer_data
+
+      if rla && rla["Failed requests"]
+        rla["Failed requests"].each do |item|
+          error_value += item[1]
+        end
+      end
+
+      if rla && rla["Process blockers (> 1 sec duration)"]
+        rla["Process blockers (> 1 sec duration)"].each do |item|
+          blocker_value += item[1]
+        end
+      end
+
+      puts "error.value #{error_value}"
+      puts "blocker.value #{blocker_value}"
+    end
+  end
+end

data/lib/munin/plugins/rails_requests.rb

@@ -0,0 +1,51 @@
+module Munin
+  class RailsRequests < RailsPlugin
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title Processed requests
+graph_vlabel Requests per second
+graph_info The amount of requests processed by this application server - railsdoctors.com
+
+get.label get
+get.draw AREA
+post.label post
+post.draw STACK
+put.label put
+put.draw STACK
+delete.label delete
+delete.draw STACK
+CONFIG
+      exit 0
+    end
+
+    # Gather information
+    def run
+      ensure_log_file
+
+      # Initialize values
+      get_value     = 0
+      post_value    = 0
+      put_value     = 0
+      delete_value  = 0
+
+      # Walk through the 
+      File.open(get_request_log_analyzer_file).each_line{ |line|
+        if match = line.match(/^\s+GET\:\s(\d+).*/)
+          get_value = match[1].to_i
+        elsif match = line.match(/^\s+POST\:\s(\d+).*/)
+          post_value = match[1].to_i
+        elsif match = line.match(/^\s+PUT\:\s(\d+).*/)
+          put_value = match[1].to_i
+        elsif match = line.match(/^\s+DELETE\:\s(\d+).*/)
+          delete_value = match[1].to_i
+        end
+      }
+
+      puts "get.value #{get_value / interval.to_f}"
+      puts "post.value #{post_value / interval.to_f}"
+      puts "put.value #{put_value / interval.to_f}"
+      puts "delete.value #{delete_value / interval.to_f}"
+    end
+  end
+end

data/lib/munin/plugins/rails_view_render_time.rb

@@ -0,0 +1,47 @@
+module Munin
+  class RailsViewRenderTime < RailsPlugin
+    def config
+      puts <<-CONFIG
+graph_category #{graph_category}
+graph_title View render times
+graph_vlabel Seconds
+graph_args --base 1000 -l 0
+graph_info The minimum, maximum and average view render times - railsdoctors.com
+
+min.label min
+max.label max
+average.label avg
+CONFIG
+      exit 0
+    end
+
+    # Gather information
+    def run
+      ensure_log_file
+      
+      # Initialize values
+      max_value = 0
+      min_value = 1.0/0.0
+      cumulative = 0
+      hits = 0
+
+      rla = parse_request_log_analyzer_data
+
+      if rla && rla["View rendering time"]
+        rla["View rendering time"].each do |item|
+          max_value = item[1][:max] if item[1][:max] > max_value
+          min_value = item[1][:min] if item[1][:min] < min_value
+          hits += item[1][:hits]
+          cumulative += item[1][:sum]
+        end
+      else
+        hits = 1
+        min_value = 0
+      end
+
+      puts "max.value #{max_value}"
+      puts "min.value #{min_value}"
+      puts "average.value #{cumulative / hits.to_f}"
+    end
+  end
+end

data/lib/munin/rails_plugin.rb

@@ -0,0 +1,83 @@
+module Munin
+  class RailsPlugin < RequestLogAnalyzerPlugin
+
+    attr_accessor :interval
+    attr_accessor :number_of_lines
+    attr_accessor :log_file
+    attr_accessor :log_format
+    attr_accessor :after_time
+    attr_accessor :floor_time
+    attr_accessor :temp_folder
+    attr_accessor :temp_prefix
+    attr_accessor :temp_file_name
+    attr_accessor :request_log_analyzer  
+
+    def handle_arguments(args, environment)
+      super
+      
+      self.interval        = environment['interval'] ? environment['interval'].to_i : 300
+      self.number_of_lines = environment['lines'] || 50000
+      self.log_file        = environment['log_file'] || args[0]
+      self.log_format      = environment['log_format'] ? "--format #{environment['log_format']}" : ''
+      self.after_time      = (Time.now - interval).strftime('%Y%m%d%H%M%S')
+      self.floor_time      = Time.at((Time.now.to_f / interval).floor * interval)
+
+      self.temp_folder     = '/tmp'
+      self.temp_prefix     = graph_category == 'App' ? 'rla' : graph_category.downcase
+      self.temp_file_name       = "#{temp_prefix}_#{floor_time.to_i}.yml"
+      self.request_log_analyzer = environment['request_log_analyzer'] || '/usr/bin/request-log-analyzer'       
+    end
+
+    def parse_request_log_analyzer_data
+      YAML::load_file( get_request_log_analyzer_file )
+    end
+
+    def get_request_log_analyzer_file
+      fetch_or_create_yaml_file(log_file, debug)
+    end
+
+    def ensure_configuration
+      require_request_log_analyzer_gem
+      require_yaml_gem
+      require_tail_command
+
+      super
+    end    
+    
+    def ensure_log_file
+      if log_file == "" || log_file.nil?
+        $stderr.puts "Filepath unspecified. Exiting"
+        exit 1
+      end      
+    end
+
+    def fetch_or_create_yaml_file(log_file, debug = false)
+      # Clean up any old temp files left in de temp folder
+      Dir.new(temp_folder).entries.each do |file_name|
+        if match = file_name.match(/^#{temp_prefix}_.*\.yml/)
+          if match[0] != temp_file_name
+            puts "Removing old cache file: #{file_name}" if debug
+            File.delete(temp_folder + "/" + file_name)
+          end
+        end
+      end
+
+      temp_file = temp_folder + "/" + temp_file_name
+
+      # Create temp file rla if needed
+      unless File.exists?(temp_file)
+        puts "Processing the last #{number_of_lines} lines of #{log_file} which are less then #{interval} seconds old." if debug
+        status = `tail -n #{number_of_lines} #{log_file} | #{request_log_analyzer} - --after #{after_time} #{log_format} -b --dump #{temp_file}`
+
+        unless $?.success?
+          $stderr.puts "failed executing request-log-analyzer. Is the gem path correct?"
+          exit 1
+        end
+      else
+        puts "Processing cached YAML result #{temp_file}" if debug
+      end
+
+      return temp_file
+    end      
+  end
+end

data/lib/munin/request_log_analyzer_plugin.rb

@@ -0,0 +1,115 @@
+module Munin
+  class RequestLogAnalyzerPlugin
+    attr_accessor :graph_category
+    attr_accessor :passenger_memory_stats
+    attr_accessor :passenger_status
+    attr_accessor :debug
+    attr_accessor :environment
+
+    def initialize(args, environment)
+      handle_arguments(args, environment)      
+      ensure_configuration
+      
+      if args[0] == "config"
+        config
+      elsif args[0] == "autoconf"
+        autoconf
+      end
+    end
+    
+    def handle_arguments(args, environment)
+      self.environment = environment
+      self.graph_category = environment['graph_category'] || 'App'            
+    
+      if args[0] == "debug"
+        args.shift
+        self.debug = true
+      end        
+    end
+
+    def require_passenger_gem
+      require_gem("passenger", ">=2.0")
+    end
+    
+    def run_command(command, debug = false)
+      result = `#{command}`
+
+      unless $?.success?
+        $stderr.puts "failed executing #{command}"
+        exit 1
+      end
+
+      puts result if debug      
+      
+      result
+    end
+    
+    def require_request_log_analyzer_gem
+      require_gem("request-log-analyzer", ">=1.1.6")
+    end
+    
+    def require_yaml_gem
+      begin
+        require 'yaml'
+      rescue Exception => e
+        puts "no (yaml not found)"
+        exit 1
+      end           
+    end
+    
+    def require_command(command_name)
+      status = `#{command_name}`
+      unless $?.success?
+        puts "no (error when excuting #{command_name})"
+        exit 1
+      end        
+    end
+    
+    def require_tail_command
+      unless `echo "test" | tail 2>/dev/null`.include?("test")
+        puts "no (tail command not found)"
+        exit 1
+      end      
+    end
+    
+    def require_passenger_status
+      self.passenger_status = environment['passenger_status'] || '/usr/local/bin/passenger-status'
+      #to use if you have multiple passenger on the host like phusion passenger standalone
+      if environment['apache_pid_file']
+        self.passenger_status = "cat #{environment['apache_pid_file']} | xargs -0 #{passenger_status}"        
+      end
+      
+      require_command(passenger_status)
+    end
+    
+    def require_passenger_memory_stats
+      self.passenger_memory_stats  = environment['passenger_memory_stats'] || '/usr/local/bin/passenger-memory-stats'            
+      
+      require_command(passenger_memory_stats)
+    end
+    
+    def require_gem(gemname, version = nil)
+      begin
+        require 'rubygems'
+        if version
+          gem gemname, version
+        else
+          gem gemname
+        end
+      rescue Exception => e
+        puts "no (Gem not found: #{e})"
+        exit 1
+      end      
+    end
+    
+    def ensure_configuration
+      
+    end
+    
+    def autoconf
+      ensure_configuration
+      puts "yes"
+      exit 0      
+    end
+  end
+end

data/munin/munin_passenger_memory_stats

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+passenger_memory_stats - Munin plugin to monitor the memory usage of passenger application servers.
+Monitors the memory consumed by passenger instances.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have passenger installed.
+
+=head1 CONFIGURATION
+The plugin needs to execute passenger-memory-stats.
+This configuration section shows the defaults of the plugin:
+
+  [passenger_*]
+  user root
+  command /usr/local/bin/ruby %c
+  
+Options
+  env.passenger_memory_stats '/path/to/passenger-memory-stats'  # Path to passenger memory status.
+  env.graph_category 'App'                                      # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/passenger_memory_stats /etc/munin/plugins/passenger_memory_stats
+
+=head1 INTERPRETATION
+The plugin shows the memory consumed by passenger instances.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Ilya Lityuga
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+Munin::PassengerMemoryStats.new(ARGV, ENV).run

data/munin/munin_passenger_queue

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+passenger_queue - Munin plugin to monitor passenger queue.
+Monitors the amount of requests in global queue.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have passenger installed.
+
+=head1 CONFIGURATION
+The plugin needs to execute passenger-status.
+This configuration section shows the defaults of the plugin:
+
+  [passenger_*]
+  user root
+  command /usr/local/bin/ruby %c
+  
+Options
+  env.passenger_status '/path/to/passenger-status'  # Path to passenger-status
+  env.apache_pid_file '/path/to/apache2.pid'        # Path to passenger-status (like /var/run/apache2.pid)
+  env.graph_category 'App'                          # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/passenger_queue /etc/munin/plugins/passenger_queue
+
+=head1 INTERPRETATION
+The plugin shows the current number of requests waiting on global queue.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Michaël Witrant - http://michael.witrant.com/
+Bart ten Brinke - railsdoctors.com
+Daniel Manges - http://gist.github.com/20319
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::PassengerQueue.new(ARGV, ENV).run

data/munin/munin_passenger_status

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+passenger_status - Munin plugin to monitor passenger application servers.
+Monitors the amount of sessions and running, active and maximum amount of passenger instances.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have passenger installed.
+
+=head1 CONFIGURATION
+The plugin needs to execute passenger-status.
+This configuration section shows the defaults of the plugin:
+
+  [passenger_*]
+  user root
+  command /usr/local/bin/ruby %c
+
+Options
+  env.passenger_status '/path/to/passenger-status'  # Path to passenger-status
+  env.graph_category 'App'                          # Graph Category. Defaults to App.
+  env.apache_pid_file '/var/run/apache2.pid'        # Use if you want to monitor multiple installations.
+
+ln -s /usr/share/munin/plugins/passenger_status /etc/munin/plugins/passenger_status
+
+=head1 INTERPRETATION
+The plugin shows the maximum, active and current number of running passenger instances.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7.1
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+Daniel Manges - http://gist.github.com/20319
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::PassengerStatus.new(ARGV, ENV).run

data/munin/munin_rails_database_time

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+rails_database_time - Munin plugin to monitor the minimum, average and maximum database times.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have a rails application log.
+
+=head1 CONFIGURATION
+The request-log-analyzer gem has to be intalled.
+Also the script has to be able to access the rails log file and tail.
+This configuration section shows the defaults of the plugin:
+
+  [rails_database_time]
+  env.log_file '/path/to/production.log'
+  user www-data
+  command /usr/local/bin/ruby %c
+  log_format rails3
+
+Options
+  env.lines 50000                             # Number of lines to tail
+  env.interval 300                            # Munin interval in seconds (used for graphs and caching)
+  env.log_format                              # request-log-analyzer log format (passed to '--format')
+  env.request_log_analyzer '/usr/local/bin'   # Path to gem. Use this for Debian.
+  env.graph_category 'App'                    # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/rails_database_time /etc/munin/plugins/rails_database_time
+
+=head1 INTERPRETATION
+Three lines are graphed, showing the minimum, average and maximum database times.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::RailsDatabaseTime.new(ARGV, ENV).run

data/munin/munin_rails_request_duration

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+rails_request_duration - Munin plugin to monitor the minimum, average and maximum request duration.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have a rails application log.
+
+=head1 CONFIGURATION
+The request-log-analyzer gem has to be intalled.
+Also the script has to be able to access the rails log file and tail.
+This configuration section shows the defaults of the plugin:
+
+  [rails_request_duration]
+  env.log_file '/path/to/production.log'
+  user www-data
+  command /usr/local/bin/ruby %c
+  log_format rails3
+
+Options
+  env.lines 50000                             # Number of lines to tail
+  env.interval 300                            # Munin interval in seconds (used for graphs and caching)
+  env.log_format                              # request-log-analyzer log format (passed to '--format')
+  env.request_log_analyzer '/usr/local/bin'   # Path to gem. Use this for Debian.
+  env.graph_category 'App'                    # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/rails_request_duration /etc/munin/plugins/rails_request_duration
+
+=head1 INTERPRETATION
+Three lines are graphed, showing the minimum, average and maximum request times.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::RailsRequestDuration.new(ARGV, ENV).run

data/munin/munin_rails_request_error

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+rails_request_error - Munin plugin to monitor the amount of errors and process blockers.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have a rails application log.
+
+=head1 CONFIGURATION
+The request-log-analyzer gem has to be intalled.
+Also the script has to be able to access the rails log file and tail.
+This configuration section shows the defaults of the plugin:
+
+  [rails_request_error]
+  env.log_file '/path/to/production.log'
+  user www-data
+  command /usr/local/bin/ruby %c
+  log_format rails3
+
+Options
+  env.lines 50000                             # Number of lines to tail
+  env.interval 300                            # Munin interval in seconds (used for graphs and caching)
+  env.log_format                              # request-log-analyzer log format (passed to '--format')
+  env.request_log_analyzer '/usr/local/bin'   # Path to gem. Use this for Debian.
+  env.graph_category 'App'                    # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/rails_request_error /etc/munin/plugins/rails_request_error
+
+=head1 INTERPRETATION
+Two lines are graphed, one showing the amount of errors raised and one showing the amount of process
+blockers. Process blockers are requests that took longer than 1 second to complete.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::RailsRequestError.new(ARGV, ENV).run

data/munin/munin_rails_requests

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+rails_requests - Munin plugin to monitor the amount of get, put, post and delete requests from a
+rails application log.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have a rails application log.
+
+=head1 CONFIGURATION
+The request-log-analyzer gem has to be intalled.
+Also the script has to be able to access the rails log file and tail.
+This configuration section shows the defaults of the plugin:
+
+  [rails_requests]
+  env.log_file '/path/to/production.log'
+  user www-data
+  command /usr/local/bin/ruby %c
+  log_format rails3
+  
+Options
+  env.lines 50000                             # Number of lines to tail
+  env.interval 300                            # Munin interval in seconds (used for graphs and caching)
+  env.log_format                              # request-log-analyzer log format (passed to '--format')
+  env.request_log_analyzer '/usr/local/bin'   # Path to gem. Use this for Debian.
+  env.graph_category 'App'                    # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/rails_requests /etc/munin/plugins/rails_requests
+
+=head1 INTERPRETATION
+All HTTP methods are stacked so that the total equals the amount of requests processed per 5 minutes.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::RailsRequests.new(ARGV, ENV).run

data/munin/munin_rails_view_render_time

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+pod=<<-POD
+
+=head1 NAME
+rails_view_render_time - Munin plugin to monitor the minimum, average and maximum view render times.
+
+=head1 APPLICABLE SYSTEMS
+All systems that have a rails application log.
+
+=head1 CONFIGURATION
+The request-log-analyzer gem has to be intalled.
+Also the script has to be able to access the rails log file and tail.
+This configuration section shows the defaults of the plugin:
+
+  [rails_view_render_time]
+  env.log_file '/path/to/production.log'
+  user www-data
+  command /usr/local/bin/ruby %c
+  log_format rails3
+
+Options
+  env.lines 50000                             # Number of lines to tail
+  env.interval 300                            # Munin interval in seconds (used for graphs and caching)
+  env.log_format                              # request-log-analyzer log format (passed to '--format')
+  env.request_log_analyzer '/usr/local/bin'   # Path to gem. Use this for Debian.
+  env.graph_category 'App'                    # Graph Category. Defaults to App.
+
+ln -s /usr/share/munin/plugins/rails_view_render_time /etc/munin/plugins/rails_view_render_time
+
+=head1 INTERPRETATION
+Three lines are graphed, showing the minimum, average and maximum view render times.
+
+=head1 MAGIC MARKERS
+  #%# family=auto
+  #%# capabilities=autoconf
+
+=head1 VERSION
+1.9.7
+
+=head1 BUGS
+None known
+
+=head1 AUTHOR
+Bart ten Brinke - railsdoctors.com
+
+=head1 LICENSE
+MIT
+
+POD
+require 'rubygems'
+require 'munin-plugins-rails'
+
+Munin::RailsViewRenderTime.new(ARGV, ENV).run

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: munin-plugins-rails
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 10
+  version: 0.2.10
+platform: ruby
+authors: 
+- Andrew Eberbach
+- Bart ten Brinke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-19 00:00:00 +01:00
+default_executable: request-log-analyzer-munin
+dependencies: []
+
+description: 
+email: andrew@ebertech.ca
+executables: 
+- request-log-analyzer-munin
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- VERSION
+- lib/munin-plugins-rails.rb
+- lib/munin/command.rb
+- lib/munin/plugins/passenger_memory_stats.rb
+- lib/munin/plugins/passenger_queue.rb
+- lib/munin/plugins/passenger_status.rb
+- lib/munin/plugins/rails_database_time.rb
+- lib/munin/plugins/rails_request_duration.rb
+- lib/munin/plugins/rails_request_error.rb
+- lib/munin/plugins/rails_requests.rb
+- lib/munin/plugins/rails_view_render_time.rb
+- lib/munin/rails_plugin.rb
+- lib/munin/request_log_analyzer_plugin.rb
+- munin/munin_passenger_memory_stats
+- munin/munin_passenger_queue
+- munin/munin_passenger_status
+- munin/munin_rails_database_time
+- munin/munin_rails_request_duration
+- munin/munin_rails_request_error
+- munin/munin_rails_requests
+- munin/munin_rails_view_render_time
+- README.rdoc
+- bin/request-log-analyzer-munin
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Plugins for Munin that use passenger and RLA
+test_files: []
+