es-scout 5.3.0.es1

data/lib/es-scout/command/test.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby -wKU
+
+require "pp"
+
+module Scout
+  class Command
+    class Test < Command
+      def run
+        create_pid_file_or_exit
+        plugin, *provided_options = @args
+        # read the plugin_code from the file specified
+        plugin_code    = File.read(plugin)
+
+        options_for_run = {}
+
+        # deal with embedded options yaml
+        if  options_yaml = Scout::Plugin.extract_options_yaml_from_code(plugin_code)
+          options=Scout::PluginOptions.from_yaml(options_yaml)
+
+          if options.error
+            puts "Problem parsing option definition in the plugin code (ignoring and continuing):"
+            puts options_yaml
+          else
+            puts "== Plugin options: "
+            puts options.to_s
+            options.select{|o|o.has_default?}.each{|o|options_for_run[o.name]=o.default}
+          end
+        else
+          puts "== This plugin doesn't have option metadata."
+        end
+
+        # provided_options are what the user gave us in the command line. Here, we merge them into
+        # the defaults we've already established (if any) for this run.
+        provided_options.each do |e|
+          if e.include?('=')
+            k,v=e.split('=',2)
+            options_for_run[k]=v
+          else
+            puts "ERROR: Option '#{e}' is no good -- provided options should be in the format name=value."
+          end
+        end
+        if options_for_run.any?
+          puts "== Running plugin with: #{options_for_run.to_a.map{|a| "#{a.first}=#{a.last}"}.join('; ') }"
+        else
+          puts "== You haven't provided any options for running this plugin."
+        end
+
+        Scout::Server.new(nil, nil, history, log) do |scout|
+          scout.prepare_checkin
+          scout.process_plugin( 'interval'  => 0,
+                                'plugin_id' => 1,
+                                'name'      => "Local Plugin",
+                                'code'      => plugin_code,
+                                'options'   => options_for_run,
+                                'path'      => plugin )
+          puts "== Output:"
+          scout.show_checkin(:pp)
+        end  
+      end
+    end
+  end
+end

data/lib/es-scout/command/troubleshoot.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby -wKU
+
+require "uri"
+require "socket"
+require "net/https"
+require "timeout"
+
+
+module Scout
+  class Command
+    class APITimeoutError < RuntimeError; end
+
+    HTTP_HEADERS = { "Client-Version"  => Scout::VERSION,
+                     "Client-Hostname" => Socket.gethostname}
+
+    class Troubleshoot < Command
+      
+      def initialize(options, args)
+        @post = options[:troubleshoot_post]
+        @include_history = !options[:troubleshoot_no_history]
+        @contents=[]
+        options[:verbose]=true # force verbose logging for this command
+        super
+      end
+
+      def run
+        puts "Gathering troubleshooting information about your Scout install ... "
+
+        heading "Scout Info"
+        bullet "History file", history
+        bullet "Version", Scout::VERSION
+
+        heading "Latest Log"
+        contents=File.read(log_path) rescue "Log not found at #{log_path}"
+        text contents
+
+        heading "Rubygems Environment"
+        text `gem env`
+
+        heading "Ruby info"
+        bullet "Path to executable", `which ruby`
+        bullet "Version", `ruby -v`
+        bullet "Ruby's internal path",  $:.join(', ')
+
+        heading "Installed Gems"
+        text `gem list --local`
+
+
+        if @include_history
+          heading "History file Contents"
+          contents=File.read(history) rescue "History not found at #{log_path}"
+          text contents
+        else
+          heading "Skipping History file Contents"
+        end
+
+        heading "Agent directory Contents"
+        text `ls -la #{config_dir}`
+
+        heading ""
+
+        if @post
+          puts "Posting troubleshooting info to #{@server} ... "
+          url = URI.join( @server,"/admin/troubleshooting_reports")
+          post_form(url, "Couldn't contact server at #{@server}",{:body=>contents_as_text}) do |res|
+            puts "Scout server says: \"#{res.body}\""
+          end
+        else
+          puts contents_as_text
+        end
+
+        puts " ... Done"
+      end
+    end
+
+    private
+    def heading(s)
+      @contents += ["",s,"**************************************************************************************************",""]
+    end
+
+    def bullet(label,s)
+      @contents << " - #{label} :  #{s.chomp}"
+    end
+
+    def text(s)
+      @contents << s
+    end
+
+    def contents_as_text
+      @contents.join("\n")
+    end
+
+    def post_form(url, error, form_data, headers = Hash.new, &response_handler)
+      return unless url
+      request(url, response_handler, error) do |connection|
+        post = Net::HTTP::Post.new( url.path +
+                                    (url.query ? ('?' + url.query) : ''),
+                                    HTTP_HEADERS.merge(headers) )
+        post.set_form_data(form_data)
+        connection.request(post)
+      end
+    end
+
+    def request(url, response_handler, error, &connector)
+      response           = nil
+      Timeout.timeout(5 * 60, APITimeoutError) do
+        http               = Net::HTTP.new(url.host, url.port)
+        if url.is_a? URI::HTTPS
+          http.use_ssl     = true
+          http.ca_file     = File.join( File.dirname(__FILE__),
+                                        *%w[.. .. data cacert.pem] )
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER |
+                             OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+        end
+        response           = no_warnings { http.start(&connector) }
+      end
+      case response
+      when Net::HTTPSuccess, Net::HTTPNotModified
+        response_handler[response] unless response_handler.nil?
+      else
+        error = "Server says: #{response['x-scout-msg']}" if response['x-scout-msg']
+        log.fatal error
+        raise SystemExit.new(error)
+      end
+    rescue Timeout::Error
+      log.fatal "Request timed out."
+      exit
+    rescue Exception
+      raise if $!.is_a? SystemExit
+      log.fatal "An HTTP error occurred:  #{$!.message}"
+      exit
+    end
+
+    def no_warnings
+      old_verbose = $VERBOSE
+      $VERBOSE    = false
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/es-scout/command.rb

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby -wKU
+
+require "optparse"
+require "fileutils"
+
+module Scout
+  class Command
+    def self.user
+      @user ||= ENV["USER"] || ENV["USERNAME"] || "root"
+    end
+
+    def self.program_name
+      @program_name ||= File.basename($PROGRAM_NAME)
+    end
+
+    def self.program_path
+      @program_path ||= File.expand_path($PROGRAM_NAME)
+    end
+
+    def self.usage
+      @usage
+    end
+
+    def self.parse_options(argv)
+      options = { }
+
+      op = OptionParser.new do |opts|
+        opts.banner = "Usage:"
+
+        opts.separator "--------------------------------------------------------------------------"
+        opts.separator "  Normal checkin with server:"
+        opts.separator "    #{program_name} [OPTIONS] CLIENT_KEY"
+        opts.separator "    ... OR ..."
+        opts.separator "    #{program_name} [OPTIONS] run CLIENT_KEY"
+        opts.separator "  Install:"
+        opts.separator "    #{program_name}"
+        opts.separator "    ... OR ..."
+        opts.separator "    #{program_name} [OPTIONS] install"
+        opts.separator "  Troubleshoot:"
+        opts.separator "    #{program_name} [OPTIONS] troubleshoot"
+        opts.separator "    ... print troubleshooting info, or post it back to scoutapp.com."
+        opts.separator "  Local plugin testing:"
+        opts.separator "    #{program_name} [OPTIONS] test " +
+                       "PATH_TO_PLUGIN [PLUGIN_OPTIONS]"
+        opts.separator "[PLUGIN_OPTIONS] format: opt1=val1 opt2=val2 opt2=val3 ..."
+        opts.separator "Plugin will use internal defaults if options aren't provided."
+        opts.separator " "
+        opts.separator "Note: This client is meant to be installed and"
+        opts.separator "invoked through cron or any other scheduler."
+        opts.separator " "
+        opts.separator "Specific Options:"
+        opts.separator "--------------------------------------------------------------------------"
+        opts.on( "-s", "--server SERVER", String,
+                 "The URL for the server to report to." ) do |url|
+          options[:server] = url
+        end
+
+        opts.on( "-d", "--data DATA", String,
+                 "The data file used to track history." ) do |file|
+          options[:history] = file
+        end
+        opts.on( "-l", "--level LEVEL",
+                 Logger::SEV_LABEL.map { |l| l.downcase },
+                 "The level of logging to report. Use -ldebug for most detail." ) do |level|
+          options[:level] = level
+        end
+
+        opts.separator " "
+        opts.separator "Common Options:"
+        opts.separator "--------------------------------------------------------------------------"
+        opts.on( "-h", "--help",
+                 "Show this message." ) do
+          puts opts
+          exit
+        end
+        opts.on( "-v", "--[no-]verbose",
+                 "Turn on logging to STDOUT" ) do |bool|
+          options[:verbose] = bool
+        end
+
+        opts.on( "-V", "--version",
+                 "Display the current version") do |version|
+          puts Scout::VERSION
+          exit
+        end
+
+        opts.on( "-F", "--force", "Force checkin to Scout server regardless of last checkin time") do |bool|
+          options[:force] = bool
+        end
+
+        opts.separator " "
+        opts.separator "Troubleshooting Options:"
+        opts.separator "--------------------------------------------------------------------------"
+        opts.on( "--post", "For use with 'troubleshoot' - post the troubleshooting results back to scoutapp.com") do
+          options[:troubleshoot_post] = true
+        end
+        opts.on( "--no-history", "For use with 'troubleshoot' - don't include the history file contents.") do
+          options[:troubleshoot_no_history] = true
+        end
+
+        opts.separator " "
+        opts.separator "Examples: "
+        opts.separator "--------------------------------------------------------------------------"
+        opts.separator "1. Normal run (replace w/your own key):"
+        opts.separator "     scout 6ecad322-0d17-4cb8-9b2c-a12c4541853f"
+        opts.separator "2. Normal run with logging to standard out (replace w/your own key):"
+        opts.separator "     scout --verbose 6ecad322-0d17-4cb8-9b2c-a12c4541853f"
+        opts.separator "3. Test a plugin:"
+        opts.separator "     scout test my_plugin.rb foo=18 bar=42"
+
+      end
+
+      begin
+        op.parse!(argv)
+        @usage = op.to_s
+      rescue
+        puts op
+        exit
+      end
+      options
+    end
+    private_class_method :parse_options
+
+    def self.dispatch(argv)
+      # capture help command
+      argv.push("--help") if argv.first == 'help'
+      options = parse_options(argv)
+      command = if name_or_key = argv.shift
+                  if cls = (Scout::Command.const_get(name_or_key.capitalize) rescue nil)
+                    cls.new(options, argv)
+                  else
+                    Run.new(options, [name_or_key] + argv)
+                  end
+                else
+                  Install.new(options, argv)
+                end
+      command.run
+    end
+
+    def initialize(options, args)
+      @server  = options[:server]  || "https://soluzionipa.it/"
+      @history = options[:history] ||
+                 File.join( File.join( (File.expand_path("~") rescue "/"),
+                                       ".scout" ),
+                            "client_history.yaml" )
+      @verbose = options[:verbose] || false
+      @level   = options[:level]   || "info"
+      @force   = options[:force]   || false
+
+      @args    = args
+
+      # create config dir if necessary
+      @config_dir = File.dirname(history)
+      FileUtils.mkdir_p(@config_dir) # ensure dir exists
+
+      @log_path = File.join(@config_dir, "latest_run.log")
+
+    end
+
+    attr_reader :server, :history, :config_dir, :log_path
+
+
+    def verbose?
+      @verbose
+    end
+
+    def log
+      return @log if defined? @log
+      @log = if verbose?
+               log                 = ScoutLogger.new($stdout)
+               log.datetime_format = "%Y-%m-%d %H:%M:%S "
+               log.level           = level
+               log
+             else
+               log                 = ScoutLogger.new(nil)
+               log.datetime_format = "%Y-%m-%d %H:%M:%S "
+               log.level           = Logger::DEBUG
+               log
+             end
+    end
+
+    def level
+      Logger.const_get(@level.upcase) rescue Logger::INFO
+    end
+
+    def user
+      @user ||= Command.user
+    end
+
+    def program_name
+      @program_name ||= Command.program_name
+    end
+
+    def program_path
+      @program_path ||= Command.program_path
+    end
+
+    def usage
+      @usage ||= Command.usage
+    end
+
+    def create_pid_file_or_exit
+      pid_file = File.join(config_dir, "scout_client_pid.txt")
+      begin
+        File.open(pid_file, File::CREAT|File::EXCL|File::WRONLY) do |pid|
+          pid.puts $$
+        end
+        at_exit do
+          begin
+            File.unlink(pid_file)
+          rescue
+            log.error "Unable to unlink pid file:  #{$!.message}" if log
+          end
+        end
+      rescue
+        pid     = File.read(pid_file).strip.to_i rescue "unknown"
+        running = true
+        begin
+          Process.kill(0, pid)
+          if stat = File.stat(pid_file)
+            if mtime = stat.mtime
+              if Time.now - mtime > 25 * 60  # assume process is hung after 25m
+                log.info "Trying to KILL an old process..." if log
+                Process.kill("KILL", pid)
+                running = false
+              end
+            end
+          end
+        rescue Errno::ESRCH
+          running = false
+        rescue
+          # do nothing, we didn't have permission to check the running process
+        end
+        if running
+          if pid == "unknown"
+            log.warn "Could not create or read PID file.  "                +
+                     "You may need to specify the path to the config directory.  " +
+                     "See:  http://scoutapp.com/help#data_file" if log
+          else
+            log.warn "Process #{pid} was already running" if log
+          end
+          exit
+        else
+          log.info "Stale PID file found.  Clearing it and reloading..." if log
+          File.unlink(pid_file) rescue nil
+          retry
+        end
+      end
+
+      self
+    end
+  end
+end
+
+# dynamically load all available commands
+Dir.glob(File.join(File.dirname(__FILE__), *%w[command *.rb])) do |command|
+  require command
+end

data/lib/es-scout/plugin.rb

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby -wKU
+
+
+module Scout
+
+  class Plugin
+
+    EMBEDDED_OPTIONS_REGEX = /OPTIONS ?= ?<<-?([A-Z_]+)(.*)\1/m
+
+    class << self
+      attr_accessor :last_defined
+
+      def inherited(new_plugin)
+        @last_defined = new_plugin
+      end
+
+      def load(last_run, memory, options)
+        new(last_run, memory, options)
+      end
+      
+      # 
+      # You can use this method to indicate one or more libraries your plugin
+      # requires:
+      # 
+      #   class MyNeedyPlugin < Scout::Plugin
+      #     needs "faster_csv", "elif"
+      #     # ...
+      #   end
+      # 
+      # Your build_report() method will not be called if all libraries cannot
+      # be loaded.  RubyGems will be loaded if needed to find the libraries.
+      # 
+      def needs(*libraries)
+        if libraries.empty?
+          @needs ||= [ ]
+        else
+          needs.push(*libraries.flatten)
+        end
+      end
+
+      # true if the code seems to have embedded options
+      def has_embedded_options?(code)
+        code =~ EMBEDDED_OPTIONS_REGEX
+      end
+
+      # extracts the internal YAML, if any, and returns the YAML string.
+      # returns nil if no embedded options.
+      def extract_options_yaml_from_code(code)
+        code =~ EMBEDDED_OPTIONS_REGEX
+        return $2
+      end
+    end
+
+    # Creates a new Scout Plugin to run.
+    def initialize(last_run, memory, options)
+      @last_run = last_run
+      @memory   = memory
+      @options  = options
+    end
+    
+    def option(name)
+      @options[name] || @options[name.is_a?(String) ? name.to_sym : String(name)]
+    end
+
+    # Builds the data to send to the server.
+    #
+    # We programatically define several helper methods for creating this data.
+    # 
+    # Usage:
+    # 
+    #   reports << {:data => "here"}
+    #   report(:data => "here")
+    #   add_report(:data => "here")
+    # 
+    #   alerts << {:subject => "subject", :body => "body"}
+    #   alert("subject", "body")
+    #   alert(:subject => "subject", :body => "body")
+    #   add_alert("subject", "body")
+    #   add_alert(:subject => "subject", :body => "body")
+    # 
+    #   errors << {:subject => "subject", :body => "body"}
+    #   error("subject", "body")
+    #   error(:subject => "subject", :body => "body")
+    #   add_error("subject", "body")
+    #   add_error(:subject => "subject", :body => "body")
+    #     
+    def data_for_server
+      @data_for_server ||= { :reports   => [ ],
+                             :alerts    => [ ],
+                             :errors    => [ ],
+                             :summaries => [ ],
+                             :memory  => { } }
+    end
+    
+    %w[report alert error summary].each do |kind|
+      class_eval <<-END
+        if "#{kind}" == "summary"
+          def summaries
+            data_for_server[:summaries]
+          end
+        else
+          def #{kind}s
+            data_for_server[:#{kind}s]
+          end
+        end
+        
+        if "#{kind}" == "report"
+          def report(new_entry)
+            reports << new_entry
+          end
+        elsif "#{kind}" == "summary"
+          def summary(new_entry)
+            summaries << new_entry
+          end
+        else
+          def #{kind}(*fields)
+            #{kind}s << ( fields.first.is_a?(Hash) ?
+                          fields.first :
+                          {:subject => fields.first, :body => fields.last} )
+          end
+        end
+        alias_method :add_#{kind}, :#{kind}
+      END
+    end
+    
+    #
+    # Usage:
+    # 
+    #   memory(:no_track)
+    #   memory.delete(:no_track)
+    #   memory.clear
+    # 
+    def memory(name = nil)
+      if name.nil?
+        data_for_server[:memory]
+      else
+        @memory[name] ||
+        @memory[name.is_a?(String) ? name.to_sym : String(name)]
+      end
+    end
+    
+    #
+    # Usage:
+    # 
+    #   remember(:name, value)
+    #   remember(:name1, value1, :name2, value2)
+    #   remember(:name => value)
+    #   remember(:name1 => value1, :name2 => value2)
+    #   remember(:name1, value1, :name2 => value2)
+    # 
+    def remember(*args)
+      hashes, other = args.partition { |value| value.is_a? Hash }
+      hashes.each { |hash| memory.merge!(hash) }
+      (0...other.size).step(2) { |i| memory.merge!(other[i] => other[i + 1]) }
+    end
+    
+    #
+    # Usage:
+    #
+    #   counter(:rkbps, stats['rsect'] / 2, :per => :second)
+    #   counter(:rpm, request_counter, :per => :minute)
+    #   counter(:swap_ins, vmstat['pswpin'], :per => :second, :round => true)
+    #
+    def counter(name, value, options = {}, &block)
+      current_time = Time.now
+
+      if data = memory("_counter_#{name}")
+        last_time, last_value = data[:time], data[:value]
+        elapsed_seconds       = current_time - last_time
+
+        # We won't log it if the value has wrapped or enough time hasn't
+        # elapsed
+        if value >= last_value && elapsed_seconds >= 1
+          if block
+            result = block.call(last_value, value)
+          else
+            result = value - last_value
+          end
+
+          case options[:per]
+          when :second, 'second'
+            result = result / elapsed_seconds.to_f
+          when :minute, 'minute'
+            result = result / elapsed_seconds.to_f * 60.0
+          else
+            raise "Unknown option for ':per': #{options[:per].inspect}"
+          end
+
+          if options[:round]
+            # Backward compatibility
+            options[:round] = 1 if options[:round] == true
+
+            result = (result * (10 ** options[:round])).round / (10 ** options[:round]).to_f
+          end
+
+          report(name => result)
+        end
+      end
+
+      remember("_counter_#{name}" => { :time => current_time, :value => value })
+    end
+
+    #
+    # Old plugins will work because they override this method.  New plugins can
+    # now leave this method in place, add a build_report() method instead, and
+    # use the new helper methods to build up content inside which will
+    # automatically be returned as the end result of the run.
+    # 
+    def run
+      build_report if self.class.needs.all? { |l| library_available?(l) }
+      data_for_server
+    end
+    
+    private
+    
+    #
+    # Returns true is a library can be loaded.  A bare require is made as the
+    # first attempt.  If that fails, RubyGems is loaded and another attempt is
+    # made.  If the library cannot be loaded either way, an error() is generated
+    # and build_report() will not be called.
+    # 
+    def library_available?(library)
+      begin
+        require library
+      rescue LoadError
+        begin
+          require "rubygems"
+          require library
+        rescue LoadError
+          error("Failed to load library", "Could not load #{library}")
+          return false
+        end
+      end
+      true
+    end
+  end
+end