scout 5.4.5.1.alpha → 5.4.6.alpha

data/lib/scout/plugin.rb

@@ -133,15 +133,6 @@ module Scout
       END
     end
 
-    # resets everything except memory. Memory stays intact. This is used for real-time reporting
-    def reset!
-      @data_for_server = { :reports   => [ ],
-                           :alerts    => [ ],
-                           :errors    => [ ],
-                           :summaries => [ ],
-                           :memory  => @memory }
-    end
-
     #
     # Usage:
     # 

data/lib/scout/streamer.rb

@@ -30,45 +30,43 @@ module Scout
       load_history
 
       # get the array of plugins, AKA the plugin plan
-      @plugin_plan = Array(@history["old_plugins"])
-      info("Starting streamer with key=#{streaming_key} and plugin_ids: #{plugin_ids.inspect}. #{@history_file} includes plugin ids #{@plugin_plan.map{|p|p['id']}.inspect}")
+      @all_plugins = Array(@history["old_plugins"])
+      info("Starting streamer with key=#{streaming_key} and plugin_ids: #{plugin_ids.inspect}. #{@history_file} includes plugin ids #{@all_plugins.map{|p|p['id']}.inspect}")
 
-      # Compile instances of the plugins specified in the passed plugin_ids
-      plugin_ids.each_with_index do |plugin_id,i|
-        plugin_data=@plugin_plan.find{|plugin| plugin['id'] && plugin['id'].to_i == plugin_id}
-        if plugin_data
-          begin
-            plugin=get_instance_of(plugin_data, plugin_id)
-            info("#{i+1}) plugin_id=#{plugin_id} - instance of #{plugin.class.name} created for #{plugin_data['name']}" )
-            if plugin.is_a?(Plugin) # safety check that it's an instance of Plugin
-              @plugin_hashes.push(:instance=>plugin, :id=>plugin_id, :name=>plugin_data['name'])
-            end
-          rescue Exception
-            error("Encountered an error compiling: #{$!.message}")
-            error $!.backtrace.join('\n')
-          end
-        else
-          info("#{i+1}) plugin_id=#{plugin_id} specified in #{plugin_ids.inspect} but not found in #{@history_file}")
-        end
-      end
+      # selected_plugins is subset of the @all_plugins -- those selected in plugin_ids
+      selected_plugins = compile_plugins(@all_plugins, plugin_ids)
 
-      info "Finished compilation. #{@plugin_plan.size} plugins; #{@plugin_hashes.size} instances instantiated"
 
       # main loop. Continue running until global $continue_streaming is set to false OR we've been running for MAX DURATION
       iteration=1 # use this to log the data at a couple points
       while(streamer_start_time+MAX_DURATION > Time.now && $continue_streaming) do
         plugins=[]
-        @plugin_hashes.each_with_index do |plugin_hash,i|
-          plugin=plugin_hash[:instance]
+        selected_plugins.each_with_index do |plugin_hash,i|
+          # create an actual instance of the plugin
+          plugin=get_instance_of(plugin_hash)
+
           start_time=Time.now
-          plugin.reset!
-          plugin.run
+
+          data = {}
+          begin
+            Timeout.timeout(30, PluginTimeoutError) do
+              data = plugin.run
+            end
+          rescue Timeout::Error, PluginTimeoutError
+            error "Plugin took too long to run."
+          end
+
           duration=((Time.now-start_time)*1000).to_i
 
+          id_and_name = plugin_hash['id_and_name']
+          @history["last_runs"][id_and_name] = start_time
+          @history["memory"][id_and_name]    = data[:memory]
+
           plugins << {:duration=>duration,
                      :fields=>plugin.reports.inject{|memo,hash|memo.merge(hash)},
-                     :name=>plugin_hash[:name],
-                     :id=>plugin_hash[:id]}
+                     :name=>plugin_hash['name'],
+                     :id=>plugin_hash['id'],
+                     :class=>plugin_hash['code_class']}
         end
 
         bundle={:hostname=>hostname,
@@ -76,6 +74,7 @@ module Scout
                  :num_processes=>`ps -e | wc -l`.chomp.to_i,
                  :plugins=>plugins }
 
+        # stream the data via pusherapp
         begin
           Pusher[streaming_key].trigger!('server_data', bundle)
         rescue Pusher::Error => e
@@ -85,15 +84,7 @@ module Scout
 
         if iteration == 2 || iteration == 100
           info "Run #{iteration} data dump:"
-          info bundle.to_json
-        end
-
-        if false
-          # debugging
-          File.open(File.join(File.dirname(@history_file),"debug.txt"),"w") do |f|
-            f.puts "... sleeping @ #{Time.now.strftime("%I:%M:%S %p")}..."
-            f.puts bundle.to_yaml
-          end
+          info bundle.inspect
         end
 
         sleep(SLEEP)
@@ -106,42 +97,71 @@ module Scout
     
     private
 
-    # plugin is a hash of plugin data from the history file (id, name, code, etc).
-    # This plugin returns an instantiated instance of the plugin
-    def get_instance_of(plugin, plugin_id)
+    # Compile instances of the plugins specified in the passed plugin_ids
+    def compile_plugins(all_plugins,plugin_ids)
+      num_classes_compiled=0
+      selected_plugins=[]
+      plugin_ids.each_with_index do |plugin_id,i|
+        plugin=all_plugins.find{|plugin| plugin['id'] && plugin['id'].to_i == plugin_id}
+        if plugin
+          begin
+            # take care of plugin overrides
+            local_path = File.join(File.dirname(@history_file), "#{plugin_id}.rb")
+            if File.exist?(local_path)
+              code_to_run = File.read(local_path)
+            else
+              code_to_run=plugin['code'] || ""
+            end
 
-      # take care of plugin overrides
-      local_path = File.join(File.dirname(@history_file), "#{plugin_id}.rb")
-      if File.exist?(local_path)
-        code_to_run = File.read(local_path)
-      else
-        code_to_run=plugin['code'] || ""
+            code_class=Plugin.extract_code_class(code_to_run)
+
+            # eval the plugin code if it's not already defined
+            if !Object.const_defined?(code_class)
+              eval(code_to_run, TOPLEVEL_BINDING, plugin['name'] )
+
+              # turn certain methods into null-ops, so summaries aren't generated. Note that this is ad-hoc, and not future-proof.
+              klass=Scout::Plugin.const_get(code_class)
+              if code_class=="RailsRequests"
+                klass.module_eval { def analyze;end; }
+              end
+              if code_class=="ApacheAnalyzer"
+                klass.module_eval { def generate_log_analysis;end; }
+              end
+              info "#{i+1}) #{plugin['name']} (id=#{plugin_id}) - #{code_class} compiled."
+              num_classes_compiled+=1
+            else
+              info "#{i+1}) #{plugin['name']} (id=#{plugin_id}) - #{code_class} was compiled previously."
+            end
+            # we'll use code_class and id_and name again
+            plugin['code_class']=code_class
+            plugin['id_and_name']= "#{plugin['id']}-#{plugin['name']}".sub(/\A-/, "")
+            selected_plugins << plugin
+          rescue Exception
+            error("Encountered an error compiling: #{$!.message}")
+            error $!.backtrace.join('\n')
+          end
+        else
+          info("#{i+1}) plugin_id=#{plugin_id} specified in #{plugin_ids.inspect} but not found in #{@history_file}")
+        end
       end
 
-      id_and_name = "#{plugin_id}-#{plugin['name']}".sub(/\A-/, "")
-      last_run    = @history["last_runs"][id_and_name] ||
-                    @history["last_runs"][plugin['name']]
-      memory      = @history["memory"][id_and_name] ||
-                    @history["memory"][plugin['name']]
-      options=(plugin['options'] || Hash.new)
-      options.merge!(:tuner_days=>"")
-
-      code_class=Plugin.extract_code_class(code_to_run)
-
-      # eval the plugin code if it's not already defined
-      if !Plugin.const_defined?(code_class)
-        eval(code_to_run, TOPLEVEL_BINDING, plugin['path'] || plugin['name'] )
-      end
+      info "Finished compilation. #{num_classes_compiled} plugin classes compiled for the #{plugin_ids.size} plugin(s) needed for streaming."
+      return selected_plugins
+    end
 
-      # now that we know the class is defined, reference its class
-      klass=Scout::Plugin.const_get(code_class)
+    # plugin is a hash of plugin data from the history file (id, name, code, etc).
+    # This plugin returns an instantiated instance of the plugin
+    def get_instance_of(plugin)
 
-      # turn certain methods into null-ops, so summaries aren't generated. Note that this is ad-hoc, and not future-proof.
-      if klass.name=="RailsRequests"; def klass.analyze;end;end
-      if klass.name=="ApacheAnalyzer"; def klass.generate_log_analysis;end;end
+      id_and_name = plugin['id_and_name']
+      last_run    = @history["last_runs"][id_and_name]
+      memory      = @history["memory"][id_and_name]
+      options=(plugin['options'] || Hash.new)
+      options.merge!(:tuner_days=>"")
 
       # finally, return an instance of the plugin
-      klass.load(last_run, (memory || Hash.new), options)
+      klass=Scout::Plugin.const_get(plugin['code_class'])
+      return klass.load(last_run, (memory || Hash.new), options)
     end
 
 

data/lib/scout/version.rb

@@ -1,3 +1,3 @@
 module Scout
-  VERSION = "5.4.5.1.alpha"
+  VERSION = "5.4.6.alpha"
 end

data/test/scout_test.rb

@@ -410,7 +410,7 @@ mybar=100
       scout(@client.key) # to write the initial history file. Sinatra MUST be running
       $continue_streaming = true # so the streamer will run once
       streamer=Scout::Streamer.new("http://none", "bogus_client_key", PATH_TO_DATA_FILE, [@client.plugins.first.id]+plugins.map(&:id), "bogus_streaming_key",nil) # for debugging, make last arg Logger.new(STDOUT)
-      res = $streamer_data # $streamer_data via the mock_streamer call
+      res = Pusher::Channel.streamer_data  # via the mock_streamer call
 
       assert res.is_a?(Hash)
       assert res[:plugins].is_a?(Array)
@@ -422,6 +422,7 @@ mybar=100
     end # end of mock_pusher
   end
 
+  # the local plugin shouldn't report
   def test_streamer_with_local_plugin
     local_path=File.join(AGENT_DIR,"my_local_plugin.rb")
     code=<<-EOC
@@ -435,11 +436,11 @@ mybar=100
     mock_pusher do
       $continue_streaming = true # so the streamer will run once
       streamer=Scout::Streamer.new("http://none", "bogus_client_key", PATH_TO_DATA_FILE, [@client.plugins.first.id], "bogus_streaming_key",nil) # for debugging, make last arg Logger.new(STDOUT)
-      res = $streamer_data # $streamer_data via the mock_streamer call
+      res = Pusher::Channel.streamer_data # Pusher::Channel.streamer_data via the mock_streamer call
 
       assert res.is_a?(Hash)
       assert res[:plugins].is_a?(Array)
-      assert_equal 1, res[:plugins].size
+      assert_equal 1, res[:plugins].size # this is NOT the local plugin, it's a regular plugin that's already there
       assert_equal 2, res[:plugins][0][:fields][:load]
     end # end of mock_pusher
   end
@@ -469,6 +470,20 @@ mybar=100
     assert_nil @client.reload.streamer_command
   end
 
+  def test_streamer_with_memory
+    mock_pusher(3) do
+      plugin = create_plugin(@client, "memory plugin", PLUGIN_FIXTURES[:memory][:code], PLUGIN_FIXTURES[:memory][:sig])
+      scout(@client.key)
+      #puts YAML.load(File.read(PATH_TO_DATA_FILE))['memory'].to_yaml
+
+      $continue_streaming = true # so the streamer will start running
+      # for debugging, make last arg Logger.new(STDOUT)
+      streamer=Scout::Streamer.new("http://none", "bogus_client_key", PATH_TO_DATA_FILE, [plugin.id], "bogus_streaming_key",nil)
+      res = Pusher::Channel.streamer_data # Pusher::Channel.streamer_data via the mock_pusher call
+      assert_equal 3, res[:plugins][0][:fields][:v], "after the two streamer runs, this plugin should report v=3 -- it increments each run"
+    end
+  end
+
 
   ######################
   ### Helper Methods ###
@@ -585,16 +600,23 @@ mybar=100
     p
   end
 
-  # this with a block to mock the pusher call. You can access the streamer data through the global $streamer_data
+  # this with a block to mock the pusher call. You can access the streamer data through the Pusher::Channel.streamer_data
   # Must be called with a code block
-  def mock_pusher
+  def mock_pusher(num_runs=1)
     # redefine the trigger! method, so the streamer doesn't loop indefinitely. We can't just mock it, because
     # we need to set the $continue_streaming=false
+    $num_runs_for_mock_pusher=num_runs
     Pusher::Channel.module_eval do
       alias orig_trigger! trigger!
+      def self.streamer_data;@@streamer_data;end # for getting the data back out
       def trigger!(event_name, data, socket=nil)
-        $streamer_data = data
-        $continue_streaming=false
+        @num_run_for_tests = @num_run_for_tests ? @num_run_for_tests+1 : 1
+        # puts "in mock pusher trigger! This is run #{@num_run_for_tests} of #{$num_runs_for_mock_pusher}"
+        @@streamer_data = data
+        if @num_run_for_tests >= $num_runs_for_mock_pusher
+          $continue_streaming=false
+          @num_run_for_tests=nil
+        end
       end
     end
     yield # must be called with a block
@@ -624,6 +646,16 @@ v6GYcfGCAsiZvnjl/2wsqjvrAl/zyuSW/s5YLsjxca1LEvhkyxbpnDGuj32k
 7gtxXcblNP6hm7A6AlBzP0hwYORR//gpLLGtmT5ewltHUj9aSUY0GQle3lvH
 /uzBDoV1x6mEYR2jPO5QQxL3BvTBvpC06ec8M/ZWbO9IwA7/DOs+vYfngxlp
 jbtpAK9QCaAalKy/Z29os/7aViHy9z9IVCpC/z3MDA==
+EOS
+      },
+      :memory=>{:code=>"class MemoryPlugin < Scout::Plugin;def build_report; v=memory(:v)||0; report(:v=>v);remember(:v,v+1);end;end",
+                :sig=><<EOS
+5GNahpevN9VW5f7rmo6Cfq+2TWp8pwukxbE5laAZtDea44KaNE9gSMfiNCqz
+rLAHvNXITJi0uI1rm+HXrak6L5oGvSouivCPtPTq1jRBy4QX2Sk9+gNEtTa8
+HXu5TIQLJ/+IYHIG2E5FWcbfddR8cmJkIl4zGs93IatQNTENksRzphob7Cz8
+wBwOHDG78kJ4TWEV5NIa5rLW8y2ltthfEPCTnS8/Zxa6h0qFtNrUWiU2KKtp
+xTbJ3RgWKUnAR3YrEGB/JjjkPN2FrsDRvlClGujaYIWpWGkf+GZcpUn+QYxP
+w7/kFz29Ds4hJRg2E2cWCHPtrD4dI0p/1iwP4XsxOw==
 EOS
       }
   } # end of PLUGIN_FIXTURES

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: scout
 version: !ruby/object:Gem::Version
-  version: 5.4.5.1.alpha
-  prerelease: 8
+  version: 5.4.6.alpha
+  prerelease: 6
 platform: ruby
 authors:
 - Andre Lewis
@@ -11,11 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-14 00:00:00.000000000 Z
+date: 2011-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elif
-  requirement: &70137852313700 !ruby/object:Gem::Requirement
+  requirement: &70103547353160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,7 +23,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137852313700
+  version_requirements: *70103547353160
 description: ! 'Scout makes monitoring and reporting on your web applications as flexible
   and simple as possible.