munin-plugins-rails 0.2.10 → 0.2.11

data/README.rdoc

@@ -1,10 +1,13 @@
 = 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.
 
+The project has now been converted into a gem. 
+If you are looking for the loose scripts, please checkout https://github.com/barttenbrinke/munin-plugins-rails/tree/stable 
+ 
 == 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.
@@ -14,61 +17,78 @@ Most things in this repository rely heavily on the request-log-analyzer gem.
 * 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
+Installing should be as easy as
 
-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
+gem install munin-rails-plugins
 
-Run "/etc/munin/plugins/rails_requests autoconf" and "munin-run rails_requests" to test the plugin.
+After that you have two options:
 
-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.
+You can add the passenger plugins that will monitor the server as a whole. These include:
+* 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.
 
-== Monitoring multiple applications
+To do this run:
 
-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:
+sudo request-log-analyzer-munin install 
 
-    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
+This will create the necessary symlinks in /etc/munin/plugins and create reasonable configurations in /etc/munin/plugin-conf.d:
 
-And in the munin-node file:
+* munin_passenger_memory_stats
+* munin_passenger_queue
+* munin_passenger_status
 
-    [rails_app1_*]
-    env.log_file '/path/to/app1/production.log'
-    env.graph_category App1
+You can customize these as needed.
 
-    [rails_app2_*]
-    env.log_file '/path/to/app2/production.log'
-    env.graph_category App2
+You can add a specific application's log file so that you can use the following:
+* rails_database_time
+* rails_request_duration
+* rails_request_error
+* rails_requests
+* rails_view_render_time
 
+To do this run
+
+sudo request-log-analyzer-munin add app_name path_to_log_file
+
+app_name: this will be the prefix for the graphs and the munin plugins so it should be a valid identifier (/[A-Za-z0-9_]*/).
+path_to_log_file: this is the path to the log file against which request-log-analyzer will run
+
+After running this command you'll have appropriate symlinks in /etc/munin/plugins and a set of configuration files in /etc/munin/plugin-conf.d:
+
+* app_name_munin_rails_database_time
+* app_name_munin_rails_request_duration
+* app_name_munin_rails_request_error
+* app_name_munin_rails_requests
+* app_name_munin_rails_view_render_time
+
+For more detailed information, see the documentation embedded in the plugins. 
+
+Remember to restart munin-node. 
+ 
 == 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
-
+* License:              MIT

data/VERSION

@@ -1 +1 @@
-0.2.10
+0.2.11

data/bin/request-log-analyzer-munin

@@ -1,4 +1,29 @@
 #!/usr/bin/env ruby
 
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
 require 'munin-plugins-rails'
-Munin::Command.new.run(ARGV)
+
+if ARGV.length > 0
+  Munin::Command.new.run(ARGV)
+else
+  puts "Request-log-analyzer-munin, by Andrew Eberbach & Bart ten Brinke - version 0.2.10"
+  puts
+  puts "This gem automatates munin-plugin configurations for monitoring of rails apps using"
+  puts "the request-log-analyzer gem"
+  puts
+  puts "Usage: request-log-analyzer-munin [install|appname] <OPTIONS>"
+  puts
+  puts
+  puts "To install passenger plugins:"
+  puts "  request-log-analyzer-munin install"
+  puts
+  puts "To install railsplugins:"
+  puts "  request-log-analyzer-munin <app-name> <log-file>"
+  puts
+  puts "Examples:"
+  puts "  request-log-analyzer-munin install"
+  puts "  request-log-analyzer-munin MyAwesomeApp /srv/my_app/current/log/production.log"
+  puts
+  exit(0)
+end

data/lib/munin/command.rb

@@ -19,7 +19,7 @@ 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
+env.graph_category <%= graph_category %>
 DATA
 
     RAILS_PLUGIN_CONFIG = <<-DATA
@@ -28,27 +28,29 @@ 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 %>
+env.graph_category <%= graph_category %>
 DATA
 
+    PASSENGER_CATEGORY = "Passenger"
+
     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)
+        add_plugin_config(plugin_target_name, app_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)
+        add_plugin_config(plugin, PASSENGER_CATEGORY, PASSENGER_PLUGIN_CONFIG)
       end
     end
 
-    def add_plugin_config(plugin_target_name, config_template, options = {})
+    def add_plugin_config(plugin_target_name, graph_category, 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|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: munin-plugins-rails
 version: !ruby/object:Gem::Version 
-  hash: 3
-  prerelease: false
+  hash: 1
+  prerelease: 
   segments: 
   - 0
   - 2
-  - 10
-  version: 0.2.10
+  - 11
+  version: 0.2.11
 platform: ruby
 authors: 
 - Andrew Eberbach
@@ -16,10 +16,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-19 00:00:00 +01:00
+date: 2011-03-28 00:00:00 -04:00
 default_executable: request-log-analyzer-munin
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: request-log-analyzer
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: andrew@ebertech.ca
 executables: 
@@ -82,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: Plugins for Munin that use passenger and RLA