reptile 0.0.1 → 0.0.4

data/README.rdoc

@@ -6,6 +6,52 @@ Reptile is an easy to use utility that will monitor your MySQL replication, so y
 
 A mysql replication setup.
 
+== SYNOPSIS
+
+Put a config file at /etc/reptile.yml, /etc/reptile/reptile.yml, ./reptile.yml, or specify one on the command line.
+
+
+  [nick@s34 ~]$ replication_status -h
+  Usage: replication_status [path_to_config_file]
+      -h, --help                       Displays this help info
+      -s, --status                     Displays the slave status
+      -d, --diff                       Checks the row count difference between master and slave
+      -r, --report                     Sends a report email
+      -b, --heartbeat                  Checks the heartbeat timestamp difference between master and slave
+  [nick@s34 ~]$ replication_status -s
+    * a_database slave is up and running
+    * b_database slave is up and running
+    * c_database slave is up and running
+
+=== Super simple crontab setup
+
+  [nick@s34 ~]$ sudo crontab -l
+  Password:
+  MAILTO="user@example.com"
+  # Use the '-e' arg to only spit out errors, which will be sent out by crontab
+  */15 * * * * replication_status -e
+
+=== Setup SQL
+
+Run this SQL to setup the DBs/perms for Reptile.  Using different users, since each user requires significantly different permissions.  
+
+  GRANT REPLICATION SLAVE, REPLICATION CLIENT, SUPER ON *.* TO 'repl'@"localhost" IDENTIFIED BY 'repl_user_pass';
+  GRANT REPLICATION SLAVE, REPLICATION CLIENT, SUPER ON *.* TO 'repl'@"MONITOR_HOST_IP" IDENTIFIED BY 'repl_user_pass';
+
+  GRANT SELECT, REPLICATION CLIENT ON *.* TO 'ro_user'@"localhost" IDENTIFIED BY 'ro_user_pass';
+  GRANT SELECT, REPLICATION CLIENT ON *.* TO 'ro_user'@"MONITOR_HOST_IP" IDENTIFIED BY 'ro_user_pass';
+
+  CREATE DATABASE replication_monitor;
+
+  GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'heartbeat_user'@"localhost" IDENTIFIED BY 'heartbeat_user_pass';
+  GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'heartbeat_user'@"MONITOR_HOST_IP" IDENTIFIED BY 'heartbeat_user_pass';
+
+  CREATE TABLE replication_monitor.heartbeats (
+    unix_time INTEGER NOT NULL, 
+    db_time TIMESTAMP NOT NULL, 
+    INDEX time_idx(unix_time)
+  )
+
 == INSTALL:
 
 sudo gem install reptile
@@ -33,4 +79,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -5,11 +5,12 @@ require File.dirname(__FILE__) + '/lib/reptile'
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
 $hoe = Hoe.new('reptile', Reptile::VERSION) do |p|
-  p.developer('FIXME full name', 'FIXME email')
+  p.developer('Nick Stielau', 'nick.stielau@gmail.com')
   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   p.post_install_message = 'PostInstall.txt'
   p.rubyforge_name       = p.name
   p.bin_files            = ["bin/replication_status"]
+  p.summary              = "Cold-blooded MySQL replication monitoring."
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"]
   ]
@@ -22,13 +23,13 @@ end
 
 desc "Upload current documentation to Rubyforge"
 task :upload_docs => [:redocs] do
-  sh "scp -r doc/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/doc/"
+  sh "scp -r doc/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/doc"
 end
 
 desc "Upload current documentation to Rubyforge"
 task :upload_site do
   #webgen && scp -r output/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/
-  sh "scp -r site/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/"
+  sh "scp -r webgen_site/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/"
 end
 
 require 'newgem/tasks' # load /tasks/*.rake

data/bin/replication_status

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+require 'rubygems'
 require 'optparse'
 require 'reptile'
 
@@ -36,6 +37,10 @@ OptionParser.new do |opts|
   opts.on("-g", "--start_slaves", "Starts all slaves") do
     commands << 'start_slaves'
   end
+  
+  opts.on("-e", "--errors", "Show only errors.") do
+    commands << 'errors'
+  end
 
   begin
     opts.parse!(ARGV)
@@ -46,19 +51,37 @@ OptionParser.new do |opts|
   end
 end
 
-config_file = 'replication.yml'
+if !ARGV.empty? && ARGV.length > 1
+  abort "Too many arguments; please specify only the directory containing the 'reptile.yml' file, or a yml config file itself."
+end
 
-if ARGV.empty? && !File.exists?(config_file)
-  abort "Please specify the directory containing the '#{config_file}' file, e.g. `#{File.basename($0)} ~/repl'"
-elsif !ARGV.empty? && !File.exists?(ARGV.first)
-  abort "`#{ARGV.first}' does not exist."
-elsif !ARGV.empty? && !File.directory?(ARGV.first)
-  abort "`#{ARGV.first}' is not a directory."
-elsif !ARGV.empty? && ARGV.length > 1
-  abort "Too many arguments; please specify only the directory to #{File.basename($0)}."
+config_file_name = "reptile.yml"
+config_file_locations = ["/etc/#{config_file_name}", "/etc/reptile/#{config_file_name}", "./#{config_file_name}"]
+config_location_param = ARGV.first
+
+config_file = nil
+if config_location_param
+  if File.directory?(config_location_param) && File.exist?(File.join(config_location_param, config_file_name))
+    config_file = File.join(config_location_param, config_file_name)
+  elsif File.exist?(config_location_param) && !File.directory?(config_location_param)
+    config_file = config_location_param
+  else
+    abort "Please specify the directory containing the '#{config_file_name}' file, or the config file itself." 
+  end
+else
+  config_file_locations.each do |f|
+    if File.exist?(f)
+      config_file = f
+      break
+    end
+  end
+  if config_file.nil?
+    abort "Couldn't find a config file at #{config_file_locations.join(', ')}"
+  end
 end
 
-Reptile::ReplicationMonitor.load_config_file(ARGV.first.nil? ? config_file : "#{ARGV.first}/#{config_file}")
+
+Reptile::ReplicationMonitor.load_config_file(config_file)
 
 if (commands.include?('start_slaves') || commands.include?('stop_slaves'))
   Reptile::Runner.send(commands[0]) 

data/lib/reptile/databases.rb

@@ -22,15 +22,15 @@ private
 
     def get_masters
       masters = databases.dup
-      masters.each_key{|key| masters.delete(key) if masters[key]['master'].nil? }
-      masters.each_key{|key| masters[key] = masters[key]['master'] }
+      masters.each_key{|name| masters.delete(name) if masters[name]['master'].nil? }
+      masters.each_key{|name| masters[name] = masters[name]['master'] }
       masters
     end
     
     # TODO: make private
     def get_slaves
       dbs = databases.dup
-      dbs.each_key{|name| dbs.delete(key) if dbs[name]['slave'].nil? }
+      dbs.each_key{|name| dbs.delete(name) if dbs[name]['slave'].nil? }
       dbs.each_key{|name| dbs[name] = dbs[name]['slave'] }
       slaves = dbs
     end
@@ -44,7 +44,7 @@ private
       puts "****"
       puts "Error connecting to database: #{e}"
       puts "****"
-      puts YAML::dump(configs)
+      puts configs.inspect
       exit 1
     end
   end

data/lib/reptile/delta_monitor.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Reptile
   # This monitor compares the row counts for each table for each master and slave.  
   class DeltaMonitor
@@ -12,15 +14,12 @@ module Reptile
       @user
     end
   
-    def self.open_log()
-      logFile = 'db_delta.log'
-      @logFileObj = File.open(logFile, "a")
+    def self.logger=(new_logger)
+      @logger = new_logger  
     end
-  
-    def self.log(msg)
-      open_log if @logFileObj.nil?
-      puts msg
-      @logFileObj.puts msg
+    
+    def self.get_logger
+      @logger ||= Logger.new(STDOUT)
     end
   
     # Retrieve the active database connection.  Nil of none exists.
@@ -46,18 +45,24 @@ module Reptile
       print_deltas(db_name, deltas, master_configs)
     
       deltas
+    rescue Exception => e
+      get_logger.error "Error: Caught #{e}"
+      get_logger.error "DB Name: #{db_name}"
+      get_logger.error "Master Configs: #{master_configs.inspect}"
+      get_logger.error "Slave Configs: #{slave_configs.inspect}"
+      raise e
     end
     
     # Prints stats about the differences in number of rows between the master and slave
     def self.print_deltas(db_name, deltas, configs)
       non_zero_deltas = deltas.select{|table, delta| not delta.zero?}
       if non_zero_deltas.size.zero?
-        log "Replication counts A-OK for #{db_name} on #{configs['host']} @ #{Time.now}"
+        get_logger.info "Replication counts A-OK for #{db_name} on #{configs['host']} @ #{Time.now}"
       else
-        log "Replication Row Count Deltas for #{db_name} on #{configs['host']} @ #{Time.now}"
-        log "There #{non_zero_deltas.size > 1 ? 'are' : 'is'} #{non_zero_deltas.size} #{non_zero_deltas.size > 1 ? 'deltas' : 'delta'}"
+        get_logger.info "Replication Row Count Deltas for #{db_name} on #{configs['host']} @ #{Time.now}"
+        get_logger.info "There #{non_zero_deltas.size > 1 ? 'are' : 'is'} #{non_zero_deltas.size} #{non_zero_deltas.size > 1 ? 'deltas' : 'delta'}"
         non_zero_deltas.each do |table, delta|
-          log "  #{table} table: #{delta}" unless delta.zero?
+          get_logger.info "  #{table} table: #{delta}" unless delta.zero?
         end
       end
     end

data/lib/reptile/heartbeat.rb

@@ -28,23 +28,22 @@ module Reptile
     def self.user
       @user ||= {}
     end
-  
-    # Merge the connection settings in the configs parameter with HeartBeat defaults. 
+    
     def self.connect(configs)
-      ReplicationMonitor.connect(configs.merge(user))
+      Databases.connect(configs.merge(user).merge("database" => 'replication_monitor'))
     end
   
     # Write a heartbeat.
     # Thump thump.
     def self.write(name, configs)
-      connect(configs)
+      self.connect(configs)
       heartbeat = Heartbeat.create(:unix_time => Time.now.to_i, :db_time => "NOW()")
-      log "Wrote heartbeat to #{name} at #{Time.at(heartbeat.unix_time)}"
+      get_logger.info "Wrote heartbeat to #{name} at #{Time.at(heartbeat.unix_time)}"
     end
 
     # Read the most recent heartbeat and return the delay in seconds, or nil if no heartbeat are found.
     def self.read(name, configs)
-      connect(configs)
+      self.connect(configs)
     
       current_time = Time.now
 
@@ -53,7 +52,7 @@ module Reptile
     
        # No heartbeats at all!
       if heartbeat.nil?
-        log "No heartbeats found on #{name} at #{Time.now}"
+        get_logger.info "No heartbeats found on #{name} at #{Time.now}"
         return nil;
       end
    
@@ -62,26 +61,21 @@ module Reptile
       delay = (Time.now - Time.at(heartbeat.unix_time)).round
       #delay = (Time.now - heartbeat.db_time)
 
-      log "Read heartbeat from #{name} at #{Time.at(heartbeat.unix_time)}. The delay is #{strfdelay(delay)}"
+      get_logger.info "Read heartbeat from #{name} at #{Time.at(heartbeat.unix_time)}. The delay is #{strfdelay(delay)}"
     
       delay
     end
    
-private
-   
-    # Open the 'heartbeat.log' file.
-    def self.open_log
-      logFile = 'heartbeat.log'
-      @logFileObj = File.open(logFile, "a")
+    def self.logger=(new_logger)
+      @logger = new_logger  
     end
-  
-    # Log a message, both to the file and standard out.
-    def self.log(msg)
-      open_log if @logFileObj.nil?
-      puts msg
-      @logFileObj.puts msg
+    
+    def self.get_logger
+      @logger ||= Logger.new(STDOUT)
     end
     
+private
+    
     # Format the delay (in seconds) as a human-readable string.
     def self.strfdelay(delay)
       seconds = delay % 60

data/lib/reptile/replication_monitor.rb

@@ -1,7 +1,10 @@
+require 'logger'
+
 module Reptile
   class ReplicationMonitor
+    
     # Attempts to load the replication.yml configuration file.
-    def self.load_config_file(databases_file)
+    def self.load_config_file(databases_file)      
       @databases_file = databases_file
       yaml = YAML::load(File.read(@databases_file))
       @configs = yaml.delete('config')
@@ -14,8 +17,8 @@ module Reptile
       DeltaMonitor.user = users.ro_user
       Runner.databases = databases
       
-      raise "Please specify a delay theshold 'delay_threshold_secs: 360'" if @configs['delay_threshold_secs'].nil?
-      raise "Please specify a row delta theshold 'row_difference_threshold: 10'" if @configs['row_difference_threshold'].nil?
+      raise "Please specify a delay threshold 'delay_threshold_secs: 360'" if @configs['delay_threshold_secs'].nil?
+      raise "Please specify a row delta threshold 'row_difference_threshold: 10'" if @configs['row_difference_threshold'].nil?
       
     rescue Errno::EACCES => e
       puts "Unable to open config file: Permission Denied"
@@ -35,17 +38,25 @@ module Reptile
     def self.users
       @users
     end
+    
+    def self.errors
+      get_logger.sev_threshold = Logger::ERROR
+      check_slaves
+      heartbeat
+      diff_tables
+    end
   
     def self.diff_tables
       unsynced_dbs = 0
+      DeltaMonitor.logger = get_logger
     
-      databases.each_pair do |name, roles|
+      databases.databases.each_pair do |name, roles|
         master, slave = roles['master'], roles['slave']
         deltas = DeltaMonitor.diff(name, master, slave)
                                   
         egregious_deltas = deltas.select{|table, delta| delta > configs['row_difference_threshold'] }                           
         if egregious_deltas.size > 0
-          queue_replication_warning :host => master[:host], :database => master[:database], :deltas => egregious_deltas, :noticed_at => Time.now
+          queue_replication_warning :host => master["host"], :database => master["database"], :deltas => egregious_deltas, :noticed_at => Time.now
           unsynced_dbs += 1
         end
       end
@@ -54,14 +65,15 @@ module Reptile
     end
   
     def self.heartbeat
-      databases.each_key do |name|
-        Heartbeat.write(name, databases[name]['master'])
+      Heartbeat.logger = get_logger
+      
+      databases.masters.each_pair do |name, configs|
+        Heartbeat.write(name, configs)
       end
     
       overdue_slaves = 0
     
-      databases.each_key do |name|
-        db_configs = databases[name]['slave']
+      databases.slaves.each_pair do |name, db_configs|
         delay = Heartbeat.read(name, db_configs)
         if delay.nil?
           queue_replication_warning :host => name, 
@@ -85,8 +97,9 @@ module Reptile
     def self.check_slaves
       databases.slaves.each do |slave_name, slave_configs|
         status = Status.check_slave_status(slave_name, slave_configs)
+        get_logger.info "'#{slave_name}' is '#{status}'"
         if status != Status.const_get(:RUNNING)
-          queue_replication_warning :host => name, 
+          queue_replication_warning :host => slave_name, 
                                     :database => configs[:database], 
                                     :status_error => Status.get_error_message(status), 
                                     :noticed_at => Time.now
@@ -101,7 +114,7 @@ module Reptile
       email.body = ''
     
       if options[:delay]
-        email.body +=  "There was a #{delay} second replication latency, which is greater than the allowed latency of #{configs['delay_threshold_secs']} seconds"
+        email.body +=  "There was a #{options[:delay]} second replication latency, which is greater than the allowed latency of #{configs['delay_threshold_secs']} seconds"
       elsif options[:deltas]
         email.body += "The following tables have master/slave row count difference greater than the allowed #{configs['row_difference_threshold']}\n\n"
         options[:deltas].each do |table, delta|      
@@ -115,8 +128,11 @@ module Reptile
     
       email.body += "\n"
       email.body += "  Server: #{options[:host]}\n"
-      email.body += "  Databse: #{options[:database]}\n"
+      email.body += "  Database: #{options[:database]}\n" unless options[:database].blank?
     
+      # Print out email body to STDOUT
+      get_logger.error email.body
+      
       send_email(email)
     end
   
@@ -189,6 +205,9 @@ module Reptile
     end
   
     def self.send_email(email)
+      return unless configs['email_server'] && configs['email_port'] && configs['email_domain'] && 
+                    configs['email_password'] && configs['email_auth_type']
+      
       # TODO: could do Net::SMTP.respond_to?(enable_tls) ? enable_TLS : puts "Install TLS gem to use SSL/TLS"
       Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
       Net::SMTP.start(configs['email_server'], 
@@ -220,5 +239,11 @@ module Reptile
     #     end
     end
 
+    private
+    
+    def self.get_logger
+      @@logger ||= Logger.new(STDOUT)
+    end
+
   end
 end

data/lib/reptile/runner.rb

@@ -29,7 +29,7 @@ module Reptile
         configs.delete('port')
         configs.delete('host')
         # With activeRecord, you have to connect to some DB, even if you are acting on the server...
-        configs['database'] = 'information_schema'
+        configs['database'] = 'information_schema' unless configs['database']
         # TODO: Delete these somewhere else
         configs.delete('heartbeat')
         configs.delete('replication_user')

data/lib/reptile/status.rb

@@ -29,8 +29,7 @@ module Reptile
 
     # The user settings for a user that has global select privilidgess
     def self.user
-      raise "You need to specify a user!" if @user.nil?
-      @user
+      @user ||= {}
     end
     
     # Checks the value of the MySQL command "SHOW SLAVE STATUS".
@@ -38,13 +37,13 @@ module Reptile
     def self.check_slave_status(name, configs)
       # TODO: Do this in Databases
       configs.delete("port")
-      configs['database'] = "information_schema"
-      Databases.connect(configs.merge(user)).execute('SHOW SLAVE STATUS').each do |row|
-        if row =~ /Slave_SQL_Running/ && row =~ /No/
+      Databases.connect(configs.merge(user).merge('database' => 'information_schema')).execute('SHOW SLAVE STATUS').each_hash do |hash|
+        
+        if hash['Slave_SQL_Running'] == "No"
           return SQL_THREAD_DOWN
-        elsif row =~ /Slave_IO_Running/ && row =~ /No/
+        elsif hash['Slave_IO_Running'] == "No"
           return IO_THREAD_DOWN
-        elsif row =~ /Slave_Running/ && row =~ /No/
+        elsif hash['Slave_Running'] == "No"
           return SLAVE_DOWN
         else
           return RUNNING

data/lib/reptile/users.rb

@@ -8,6 +8,8 @@ module Reptile
   # to be even easier.
   class Users
     def initialize(options)
+      return if options.nil?
+      
       @repl_user = options["replication_user"]
       @ro_user = options["ro_user"]
       @heartbeat_user = options["heartbeat_user"]

data/lib/reptile.rb

@@ -19,5 +19,5 @@ require 'reptile/databases'
 require 'active_record'
 
 module Reptile
-  VERSION = '0.0.1'
+  VERSION = '0.0.4'
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification 
 name: reptile
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors: 
-- FIXME full name
+- Nick Stielau
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-06-26 00:00:00 -07:00
-default_executable: 
+date: 2009-08-13 00:00:00 -07:00
+default_executable: replication_status
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: newgem
@@ -34,7 +34,7 @@ dependencies:
     version: 
 description: ""
 email: 
-- FIXME email
+- nick.stielau@gmail.com
 executables: 
 - replication_status
 extensions: []
@@ -66,7 +66,9 @@ files:
 - test/test_helper.rb
 - test/test_reptile.rb
 has_rdoc: true
-homepage: Reptile is an easy to use utility that will monitor your MySQL replication, so you can forget about it and focus on the good stuff.  It provides a utility for generate replication reports, and can email if replication appears to be failing.
+homepage: http://reptile.rubyforge.org/
+licenses: []
+
 post_install_message: PostInstall.txt
 rdoc_options: 
 - --main
@@ -88,10 +90,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: reptile
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
-summary: ""
+summary: Cold-blooded MySQL replication monitoring.
 test_files: 
 - test/test_helper.rb
 - test/test_reptile.rb