scout 5.3.5 → 5.4.4.alpha

data/.gitignore

@@ -0,0 +1,6 @@
+doc/*
+pkg/*
+.DS_Store
+**/.DS_Store
+.idea
+working_dir/

data/CHANGELOG

@@ -1,15 +1,3 @@
-== Master
-
-== 5.3.5
-
-* Moved proxy support to explicit command line flags --http_proxy and https_proxy
-* fixed two unused variables that were causing warnings under 1.9.3
-
-== 5.3.4
-
-* Incorporating sleep interval into Server#time_to_checkin?
-* Added proxy support command line flags
-
 == 5.3.3
 
 * Sending embedded options to server for local & plugin overrides.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in scout.gemspec
+gemspec

data/README

@@ -64,3 +64,11 @@ It's often helpful to log the output to a file. To do so:
 
 
 For additional help, please visit http://scoutapp.com
+
+== Credits / Contact
+
+Contact support@scoutapp.com with questions.
+
+Primary maintainers: Andre Lewis (andre@scoutapp.com) and Derek Haynes (derek@scoutapp.com)
+
+Many thanks to James Edward Gray II, Charles Brian Quinn, and Matt Todd for early work on the Scout agent!

data/Rakefile

@@ -1,109 +1,7 @@
-require "rake/rdoctask"
-require "rake/testtask"
-require "rake/gempackagetask"
-require "rake/contrib/rubyforgepublisher"
-require "net/ssh"
+require "bundler/gem_tasks"
 
-require "rubygems"
-require "rubyforge"
-
-dir = File.dirname(__FILE__)
-lib = File.join(dir, "lib", "scout.rb")
-version = File.read(lib)[/^\s*VERSION\s*=\s*(['"])(\d\.\d\.\d)\1/, 2]
-history = File.read("CHANGELOG").split(/^(===.*)/)
-changes ||= history[0..2].join.strip
-
-need_tar = true
-need_zip = true
-
-task :default => [:test]
-
-Rake::TestTask.new do |test|
-  test.libs << "test"
-  test.test_files = [ "test/scout_test.rb" ]
-  test.verbose = true
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc.main = "README"
-  rdoc.rdoc_dir = "doc/html"
-  rdoc.title = "Scout Client Documentation"
-  rdoc.rdoc_files.include( "README",  "INSTALL",
-                           "TODO",    "CHANGELOG",
-                           "AUTHORS", "COPYING",
-                           "LICENSE", "lib/" )
-end
-
-spec = Gem::Specification.new do |spec|
-  spec.name = "scout"
-  spec.version = version
-
-  spec.platform = Gem::Platform::RUBY
-  spec.summary = "Scout makes monitoring and reporting on your web applications as flexible and simple as possible."
-
-  # TODO: test suite
-  # spec.test_suite_file = "test/ts_all.rb"
-  spec.files = Dir.glob("{bin,lib}/**/*.rb") +
-          Dir.glob("{data,vendor}/**/*") +
-          %w[Rakefile]
-  spec.executables = ["scout"]
-
-  spec.has_rdoc = true
-  spec.extra_rdoc_files = %w[ AUTHORS COPYING README INSTALL TODO CHANGELOG
-	                            LICENSE ]
-  spec.rdoc_options << "--title" << "Scout Client Documentation" <<
-          "--main" << "README"
-
-  spec.require_path = "lib"
-
-  spec.add_dependency "elif"
-
-  spec.author = "Scout Monitoring"
-  spec.email = "support@scoutapp.com"
-  spec.rubyforge_project = "scout"
-  spec.homepage = "http://scoutapp.com"
-  spec.description = <<END_DESC
-Scout makes monitoring and reporting on your web applications as flexible and simple as possible.
-END_DESC
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = need_tar
-  pkg.need_tar = need_zip
-end
-
-desc "Publishes to Scout Gem Server and Rubyforge"
-task :publish => [:package, :publish_rubyforge]
-
-desc "Publishes Gem to Rubyforge"
-task :publish_rubyforge => [:package] do
-  puts "Publishing on RubyForge"
-  forge = RubyForge.new
-  forge.configure
-  puts "Logging in"
-  forge.login
-
-  release = forge.userconfig
-  release["release_changes"] = File.read(File.join(dir, "CHANGELOG"))
-  release["preformatted"] = true
-
-  package = "pkg/#{spec.name}-#{version}"
-  files = %W[#{package}.tgz #{package}.zip #{package}.gem].compact
-
-  puts "Releasing #{spec.name}-#{version}"
-  forge.add_release(spec.rubyforge_project, spec.name, version, *files)
-end
-
-desc "Upload current documentation to Scout Gem Server and RubyForge"
-task :upload_docs => [:rdoc] do
-  sh "scp -r doc/html/* " +
-          "deploy@gems.scoutapp.com:/var/www/gems/docs"
-
-  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
-  host = "#{config["username"]}@rubyforge.org"
-
-  remote_dir = "/var/www/gforge-projects/#{spec.rubyforge_project}"
-  local_dir = 'doc/html'
-
-  sh %{rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}}
-end
+# Provides the Following tasks:
+#
+# rake build    # Builds gem into the pkg directory
+# rake install  # Build and install the current version into system gems
+# rake release  # Create, tag, build, and publish the current version to rubygems.org

data/bin/scout

@@ -5,6 +5,7 @@ $VERBOSE = true # -w
 #$KCODE   = "u"  # -Ku
 
 $LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+
 require "scout"
 
 Scout::Command.dispatch(ARGV)

data/lib/scout.rb

@@ -1,11 +1,12 @@
 #!/usr/bin/env ruby -wKU
-
-module Scout
-  VERSION = "5.3.5".freeze
-end
+require "scout/version"
 
 require "scout/command"
 require "scout/plugin"
 require "scout/plugin_options"
 require "scout/scout_logger"
+require "scout/server_base"
 require "scout/server"
+require "scout/streamer"
+require "scout/daemon_spawn"
+require "scout/streamer_control"

data/lib/scout/command.rb

@@ -72,16 +72,6 @@ module Scout
           options[:server_name] = server_name
         end
 
-        opts.on("--http-proxy URL", String,
-                 "Optional http proxy for non-SSL traffic." ) do |http_proxy|
-          options[:http_proxy] = http_proxy
-        end
-
-        opts.on("--https-proxy URL", String,
-                 "Optional https proxy for SSL traffic." ) do |https_proxy|
-          options[:https_proxy] = https_proxy
-        end
-
         opts.separator " "
         opts.separator "Common Options:"
         opts.separator "--------------------------------------------------------------------------"
@@ -105,6 +95,16 @@ module Scout
           options[:force] = bool
         end
 
+        opts.on( "-p", "--plugin_ids PLUGINS", String,
+                 "A subset of plugin ids, for streaming mode only - not generally used manually.") do |plugins|
+          options[:plugin_ids] = plugins.split(",").map(&:to_i)
+        end
+
+        opts.on( "-k", "--streaming_key KEY", String,
+                 "for streaming mode only - not generally used manually.") do |streaming_key|
+          options[:streaming_key] = streaming_key
+        end
+
         opts.separator " "
         opts.separator "Troubleshooting Options:"
         opts.separator "--------------------------------------------------------------------------"
@@ -164,9 +164,8 @@ module Scout
       @level   = options[:level]   || "info"
       @force   = options[:force]   || false
       @server_name    = options[:server_name]
-      @http_proxy     = options[:http_proxy] || ""
-      @https_proxy    = options[:https_proxy] || ""
 
+      @options = options
       @args    = args
 
       # create config dir if necessary

data/lib/scout/command/install.rb

@@ -22,7 +22,7 @@ module Scout
 
         puts "\nAttempting to contact the server..."
         begin
-          Scout::Server.new(server, key, history, log, @http_proxy, @https_proxy) do |scout|
+          Scout::Server.new(server, key, history, log) do |scout|
             scout.fetch_plan
             scout.run_plugins_by_plan
           end

data/lib/scout/command/run.rb

@@ -9,7 +9,7 @@ module Scout
         configuration_directory = config_dir
         log.debug("Configuration directory is #{configuration_directory} ") if log
         # TODO: too much external logic of command doing things TO server. This should be moved into the server class.
-        @scout = Scout::Server.new(server, key, history, log, server_name, @http_proxy, @https_proxy)
+        @scout = Scout::Server.new(server, key, history, log, server_name)
         @scout.load_history
         
         unless $stdin.tty?
@@ -19,6 +19,18 @@ module Scout
         
         @scout.fetch_plan
 
+        log.info "streamer command=#{@scout.streamer_command}"
+        # Spawn streamer if directed to, or stop it. @scout.streamer_command should only be [start|stop]
+        if @scout.streamer_command.is_a?(String) && @scout.streamer_command.start_with?("start") || @scout.streamer_command == "stop"
+          tokens = @scout.streamer_command.split(",")
+          tokens.shift # gets rid of the "start"
+          streaming_key=tokens.shift
+          plugin_ids = tokens.map(&:to_i)
+          stream=Scout::Command::Stream.new(@options.merge(:streaming_key=>streaming_key,:plugin_ids=>plugin_ids), [key, @scout.streamer_command])
+          stream.run
+        end
+
+        # Check in if appropriate
         if @scout.new_plan || @scout.time_to_checkin?  || @force
           if @scout.new_plan
             log.info("Now checking in with new plugin plan") if log

data/lib/scout/command/sign.rb

@@ -11,7 +11,7 @@ module Scout
       VERIFY_MODE = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
       
       def run
-        url = @args.first
+        url, *provided_options = @args
         # read the plugin_code from the file specified
         if url.nil? or url == ''
           puts "Please specify the path to the plugin (scout sign /path/to/plugin.rb)"
@@ -35,13 +35,7 @@ module Scout
         
         puts "Posting Signature..."
         uri = URI.parse(url)
-
-        # take care of http/https proxy, if specified in command line options
-        # Given a blank string, the proxy_uri URI instance's host/port/user/pass will be nil
-        # Net::HTTP::Proxy returns a regular Net::HTTP class if the first argument (host) is nil
-        proxy_uri = URI.parse(uri.is_a?(URI::HTTPS) ? @https_proxy : @http_proxy)
-        http=Net::HTTP::Proxy(proxy_uri.host,proxy_uri.port,proxy_uri.user,proxy_uri.port).new(uri.host, uri.port)
-
+        http = Net::HTTP.new(uri.host, uri.port)
         if uri.is_a?(URI::HTTPS)
           http.use_ssl = true
           http.ca_file     = CA_FILE

data/lib/scout/command/stream.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby -wKU
+
+require "logger"
+
+module Scout
+  class Command
+    class Stream < Command
+      PID_FILENAME="streamer.pid"
+
+      def run
+        @key = @args[0]
+        daemon_command = @args[1]
+        @plugin_ids = @options[:plugin_ids]
+
+        if !@key
+          puts "usage: scout stream [your_scout_key] [start|stop]"
+          exit(1)
+        end
+
+        # server and history methods are inherited from Scout::Command base class
+        streamer_log_file=File.join(File.dirname(history),"scout_streamer.log")
+        streamer_pid_file=File.join(File.dirname(history),"scout_streamer.pid")
+
+        streamer_control_options = {:log_file => streamer_log_file,
+                                    :pid_file => streamer_pid_file,
+                                    :sync_log => true,
+                                    :working_dir => File.dirname(history)}
+
+        # we use STDOUT for the logger because daemon_spawn directs STDOUT to a log file
+        streamer_control_args = [server, @key, history, @plugin_ids, @options[:streaming_key],Logger.new(STDOUT)]
+
+        if daemon_command.include? "start" # can be 'start' or 'restart'
+          if File.exists?(streamer_pid_file)
+            puts "PID file existed. Restarting ..."
+            Scout::StreamerControl.restart(streamer_control_options,streamer_control_args)
+          else
+            puts "Starting ... "
+            Scout::StreamerControl.start(streamer_control_options,streamer_control_args)
+          end
+        elsif daemon_command == "stop"
+          puts "Stopping ..."
+          Scout::StreamerControl.stop(streamer_control_options,[])
+        else
+          puts "usage: scout stream [your_scout_key] [start|stop]"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/scout/command/test.rb

@@ -45,7 +45,7 @@ module Scout
           puts "== You haven't provided any options for running this plugin."
         end
 
-        Scout::Server.new(nil, nil, history, log, @http_proxy, @https_proxy) do |scout|
+        Scout::Server.new(nil, nil, history, log) do |scout|
           scout.prepare_checkin
           scout.process_plugin( 'interval'  => 0,
                                 'plugin_id' => 1,

data/lib/scout/daemon_spawn.rb

@@ -0,0 +1,215 @@
+require 'fileutils'
+
+# Taken unchanged from https://github.com/alexvollmer/daemon-spawn
+#
+# Large portions of this were liberally stolen from the
+# 'simple-daemon' project at http://simple-daemon.rubyforge.org/
+module DaemonSpawn
+  VERSION = '0.3.0'
+
+  def self.usage(msg=nil) #:nodoc:
+    print "#{msg}, " if msg
+    puts "usage: #{$0} <command> [options]"
+    puts "Where <command> is one of start, stop, restart or status"
+    puts "[options] are additional options passed to the underlying process"
+  end
+
+  def self.alive?(pid)
+    Process.kill 0, pid
+  rescue Errno::ESRCH
+    false
+  end
+
+  def self.start(daemon, args) #:nodoc:
+    if !File.writable?(File.dirname(daemon.log_file))
+      STDERR.puts "Unable to write log file to #{daemon.log_file}"
+      exit 1
+    end
+
+    if !File.writable?(File.dirname(daemon.pid_file))
+      STDERR.puts "Unable to write PID file to #{daemon.pid_file}"
+      exit 1
+    end
+
+    if daemon.alive? && daemon.singleton
+      STDERR.puts "An instance of #{daemon.app_name} is already " +
+        "running (PID #{daemon.pid})"
+      exit 0
+    end
+
+    fork do
+      Process.setsid
+      exit if fork
+      open(daemon.pid_file, 'w') { |f| f << Process.pid }
+      Dir.chdir daemon.working_dir
+      old_umask = File.umask 0000
+      log = File.new(daemon.log_file, "a")
+      File.umask old_umask
+      log.sync = daemon.sync_log
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen log
+      STDERR.reopen STDOUT
+      trap("TERM") {daemon.stop; exit}
+      daemon.start(args)
+    end
+    puts "#{daemon.app_name} started."
+  end
+
+  def self.stop(daemon) #:nodoc:
+    if pid = daemon.pid
+      FileUtils.rm(daemon.pid_file)
+      Process.kill(daemon.signal, pid)
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+      end
+      if ticks = daemon.timeout
+        while ticks > 0 and alive?(pid) do
+          puts "Process is still alive. #{ticks} seconds until I kill -9 it..."
+          sleep 1
+          ticks -= 1
+        end
+        if alive?(pid)
+          puts "Process didn't quit after timeout of #{daemon.timeout} seconds. Killing..."
+          Process.kill 9, pid
+        end
+      end
+    else
+      puts "PID file not found. Is the daemon started?"
+    end
+  rescue Errno::ESRCH
+    puts "PID file found, but process was not running. The daemon may have died."
+  end
+
+  def self.status(daemon) #:nodoc:
+    puts "#{daemon.app_name} is #{daemon.alive? ? "" : "NOT "}running (PID #{daemon.pid})"
+  end
+
+  class Base
+    attr_accessor :log_file, :pid_file, :sync_log, :working_dir, :app_name, :singleton, :index, :signal, :timeout
+
+    def initialize(opts = {})
+      raise 'You must specify a :working_dir' unless opts[:working_dir]
+      self.working_dir = opts[:working_dir]
+      self.app_name = opts[:application] || classname
+      self.pid_file = opts[:pid_file] || File.join(working_dir, 'tmp', 'pids', app_name + '.pid')
+      self.log_file = opts[:log_file] || File.join(working_dir, 'logs', app_name + '.log')
+      self.signal = opts[:signal] || 'TERM'
+      self.timeout = opts[:timeout]
+      self.index = opts[:index] || 0
+      if self.index > 0
+        self.pid_file += ".#{self.index}"
+        self.log_file += ".#{self.index}"
+      end
+      self.sync_log = opts[:sync_log]
+      self.singleton = opts[:singleton] || false
+    end
+
+    def classname #:nodoc:
+      self.class.to_s.split('::').last
+    end
+
+    # Provide your implementation. These are provided as a reminder
+    # only and will raise an error if invoked. When started, this
+    # method will be invoked with the remaining command-line arguments.
+    def start(args)
+      raise "You must implement a 'start' method in your class!"
+    end
+
+    # Provide your implementation. These are provided as a reminder
+    # only and will raise an error if invoked.
+    def stop
+      raise "You must implement a 'stop' method in your class!"
+    end
+
+    def alive? #:nodoc:
+      if File.file?(pid_file)
+        DaemonSpawn.alive? pid
+      else
+        false
+      end
+    end
+
+    def pid #:nodoc:
+      IO.read(self.pid_file).to_i rescue nil
+    end
+
+    def self.build(options)
+      count = options.delete(:processes) || 1
+      daemons = []
+      count.times do |index|
+        daemons << new(options.merge(:index => index))
+      end
+      daemons
+    end
+
+    def self.find(options)
+      pid_file = new(options).pid_file
+      basename = File.basename(pid_file).split('.').first
+      pid_files = Dir.glob(File.join(File.dirname(pid_file), "#{basename}.*pid*"))
+      pid_files.map { |f| new(options.merge(:pid_file => f)) }
+    end
+
+    # Invoke this method to process command-line args and dispatch
+    # appropriately. Valid options include the following _symbols_:
+    # - <tt>:working_dir</tt> -- the working directory (required)
+    # - <tt>:log_file</tt> -- path to the log file
+    # - <tt>:pid_file</tt> -- path to the pid file
+    # - <tt>:sync_log</tt> -- indicate whether or not to sync log IO
+    # - <tt>:singleton</tt> -- If set to true, only one instance is
+    # allowed to start
+    # args must begin with 'start', 'stop', 'status', or 'restart'.
+    # The first token will be removed and any remaining arguments
+    # passed to the daemon's start method.
+    def self.spawn!(opts = {}, args = ARGV)
+      case args.any? and command = args.shift
+      when 'start', 'stop', 'status', 'restart'
+        send(command, opts, args)
+      when '-h', '--help', 'help'
+        DaemonSpawn.usage
+        exit
+      else
+        DaemonSpawn.usage "Invalid command"
+        exit 1
+      end
+    end
+
+    def self.start(opts, args)
+      living_daemons = find(opts).select { |d| d.alive? }
+      if living_daemons.any?
+        puts "Daemons already started! PIDS: #{living_daemons.map {|d| d.pid}.join(', ')}"
+        exit 1
+      else
+        build(opts).map { |d| DaemonSpawn.start(d, args) }
+      end
+    end
+
+    def self.stop(opts, args)
+      daemons = find(opts)
+      if daemons.empty?
+        puts "No PID files found. Is the daemon started?"
+        exit 1
+      else
+        daemons.each { |d| DaemonSpawn.stop(d) }
+      end
+    end
+
+    def self.status(opts, args)
+      daemons = find(opts)
+      if daemons.empty?
+        puts 'No PIDs found'
+      else
+        daemons.each { |d| DaemonSpawn.status(d) }
+      end
+    end
+
+    def self.restart(opts, args)
+      daemons = build(opts)
+      daemons.map do |daemon|
+        DaemonSpawn.stop(daemon)
+        sleep 0.1
+        DaemonSpawn.start(daemon, args)
+      end
+    end
+  end
+end