newrelic_rpm 2.10.6 → 2.10.8

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -0,0 +1,21 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails3
+        module Errors
+          def newrelic_notice_error(exception, custom_params = {})
+            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+            filtered_params.merge!(custom_params)
+            NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  class ActionController::Base
+    include NewRelic::Agent::Instrumentation::Rails3::Errors
+  end
+end

data/lib/new_relic/agent/method_tracer.rb

@@ -23,12 +23,12 @@ module Agent
   # To instrument a class method:
   #
   #     require 'new_relic/agent/method_tracer'
-  #     class A
-  #       extend NewRelic::Agent::MethodTracer
+  #     class An
   #       def self.process
   #         ...
   #       end
   #       class << self
+  #         include NewRelic::Agent::MethodTracer
   #         add_method_tracer :process
   #       end
   #     end

data/lib/new_relic/agent/samplers/delayed_job_lock_sampler.rb

@@ -5,7 +5,7 @@ module NewRelic
     def initialize
       super :delayed_job_lock
       raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj'] 
-      raise Unsupported, "No DJ worker present" if NewRelic::DelayedJobInjection.worker_name
+      raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
     end
     
     def stats

data/lib/new_relic/agent/stats_engine/samplers.rb

@@ -16,7 +16,7 @@ module Agent
       
       def spawn_sampler_thread
         
-        return if !@sampler_process.nil? && @sampler_process == $$ 
+        return if @sampler_thread && @sampler_thread.alive?
         
         # start up a thread that will periodically poll for metric samples
         return if periodic_samplers.empty?
@@ -30,7 +30,6 @@ module Agent
           end
         end
         @sampler_thread['newrelic_label'] = 'Sampler Tasks'
-        @sampler_process = $$
       end
       
       # Add an instance of Sampler to be invoked about every 10 seconds on a background

data/lib/new_relic/agent/transaction_sampler.rb

@@ -223,7 +223,7 @@ module Agent
   class TransactionSampleBuilder
     attr_reader :current_segment, :sample
     
-    include CollectionHelper
+    include NewRelic::CollectionHelper
     
     def initialize(time=nil)
       time ||= Time.now.to_f

data/lib/new_relic/agent/worker_loop.rb

@@ -1,78 +1,57 @@
+require 'thread'
 module NewRelic
-module Agent
-  
-  # A worker loop executes a set of registered tasks on a single thread.  
-  # A task is a proc or block with a specified call period in seconds.  
-  class WorkerLoop
+  module Agent
     
-    attr_reader :log
-    attr_reader :pid
-    
-    def initialize(log = Logger.new(STDERR))
-      @tasks = []
-      @log = log
-      @should_run = true
-      @pid = $$
-    end
-    
-    # Run infinitely, calling the registered tasks at their specified
-    # call periods.  The caller is responsible for creating the thread
-    # that runs this worker loop
-    def run
-      while keep_running do
-        run_next_task
+    # A worker loop executes a set of registered tasks on a single thread.  
+    # A task is a proc or block with a specified call period in seconds.  
+    class WorkerLoop
+      
+      def initialize
+        @log = log
+        @should_run = true
       end
-    end
-    
-    def keep_running
-      @should_run && (@pid == $$)
-    end
-    
-    def stop
-      @should_run = false
-    end
-    
-    MIN_CALL_PERIOD = 0.1
-    
-    # add a task to the worker loop.  The task will be called approximately once
-    # every call_period seconds.  The task is passed as a block
-    def add_task(call_period, desc="", &task_proc)
-      if call_period < MIN_CALL_PERIOD
-        raise ArgumentError, "Invalid Call Period (must be > #{MIN_CALL_PERIOD}): #{call_period}" 
+      
+      def lock
+        @@lock ||= Mutex.new
       end
-      @tasks << LoopTask.new(call_period, desc, &task_proc)
-    end
-    
-    private 
-    def next_task
-      @tasks.inject do |soonest, task|
-       (task.next_invocation_time < soonest.next_invocation_time) ? task : soonest
+      
+      def log
+        NewRelic::Control.instance.log
       end
-    end
-    
-    def run_next_task
-      if @tasks.empty?
-        sleep 5.0
-        return
+      # Run infinitely, calling the registered tasks at their specified
+      # call periods.  The caller is responsible for creating the thread
+      # that runs this worker loop
+      def run(period, &block)
+        @period = period
+        @next_invocation_time = Time.now + @period
+        @task = block
+        while keep_running do
+          now = Time.now
+          while now < @next_invocation_time
+            # sleep until this next task's scheduled invocation time
+            sleep_time = @next_invocation_time - now
+            sleep sleep_time if sleep_time > 0
+            now = Time.now
+          end
+          run_task if keep_running
+        end
       end
       
-      # get the next task to be executed, which is the task with the lowest (ie, soonest)
-      # next invocation time.
-      task = next_task
+      def keep_running
+        @should_run
+      end
       
-      while Time.now < task.next_invocation_time
-        
-        # sleep until this next task's scheduled invocation time
-        sleep_time = task.next_invocation_time - Time.now
-        sleep sleep_time if sleep_time > 0
-        return if !keep_running
+      def stop
+        @should_run = false
       end
       
-      begin
-        task.execute if keep_running
+      def run_task
+        lock.synchronize do
+          @task.call 
+        end
       rescue ServerError => e
         log.debug "Server Error: #{e}"
-      rescue NewRelic::Agent::ForceRestartException => e
+      rescue NewRelic::Agent::ForceRestartException, NewRelic::Agent::ForceDisconnectException
         # blow out the loop
         raise
       rescue RuntimeError => e
@@ -86,34 +65,16 @@ module Agent
           log.debug message
           log.debug e.backtrace.join("\n")
         end
-      rescue Timeout::Error, NewRelic::Agent::IgnoreSilentlyException
+      rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
         # Want to ignore these because they are handled already
       rescue ScriptError, StandardError => e 
         log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}" 
         log.debug e.backtrace.join("\n")
-      end
-    end
-    
-    class LoopTask
-      
-      def initialize(call_period, desc="", &task_proc) 
-        @call_period = call_period
-        @last_invocation_time = Time.now
-        @task = task_proc
-        @desc = desc
-      end
-      def to_s
-        "Task[#{@desc}]"
-      end
-      def next_invocation_time
-        @last_invocation_time + @call_period
-      end
-      
-      def execute
-        @last_invocation_time = Time.now
-        @task.call
+      ensure
+        while @next_invocation_time < Time.now
+          @next_invocation_time += @period
+        end        
       end
     end
   end
 end
-end

data/lib/new_relic/{agent/collection_helper.rb → collection_helper.rb}

@@ -1,6 +1,5 @@
 module NewRelic
-  module Agent
-    module CollectionHelper
+  module CollectionHelper
   # Transform parameter hash into a hash whose values are strictly
   # strings
   def normalize_params(params)
@@ -65,6 +64,5 @@ module NewRelic
       truncate(flatten(string), len)     
     end
   end
-end
-end
+  end
 end

data/lib/new_relic/control.rb

@@ -87,8 +87,8 @@ module NewRelic
       # between calling init_plugin the first time and the second time, the env
       # has been overridden
       @settings = nil
-      
-      options.each { |sym, val | self[sym.to_s] = val unless sym == :config }
+      settings
+      merge_options(options)
       if logger_override
         @log = logger_override
         # Try to grab the log filename
@@ -482,6 +482,22 @@ module NewRelic
       self.class.newrelic_root
     end
     
+    # Merge the given options into the config options.
+    # They might be a nested hash
+    def merge_options(options, hash=self)
+      options.each do |key, val |
+        case
+        when key == :config then next 
+        when val.is_a?(Hash)
+          merge_options(val, hash[key.to_s] ||= {})
+        when val.nil?
+          hash.delete(key.to_s)
+        else 
+          hash[key.to_s] = val
+        end
+      end
+    end
+    
     def load_instrumentation_files pattern
       Dir.glob(pattern) do |file|
         begin

data/lib/new_relic/control/rails3.rb

@@ -0,0 +1,75 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values, 
+# etc.
+class NewRelic::Control::Rails3 < NewRelic::Control
+  
+  def env
+    @env ||= ::Rails.env.to_s
+  end
+
+  def root
+    @root ||= Rails.root.to_s
+  end
+
+  def logger
+    ::Rails.logger
+  end
+  
+  def base_log_file
+    logger.instance_eval {
+      @log.path
+    }
+  rescue
+    File.join(root, 'log')
+  end
+  private :base_log_file
+
+  def log_path
+    @log_path ||= File.expand_path(File.dirname(base_log_file))
+  end
+
+  def vendor_root
+    @vendor_root ||= File.join(root,'vendor','rails')
+  end
+  
+  def version
+    @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
+  end
+
+  def init_config(options={})
+    rails_config=options[:config]
+    if !agent_enabled?
+      # Might not be running if it does not think mongrel, thin, passenger, etc
+      # is running, if it things it's a rake task, or if the agent_enabled is false.
+      logger.info "New Relic Agent not running."
+    else
+      logger.info "Starting the New Relic Agent."
+    end
+  end
+  
+  protected 
+  
+  # Collect the Rails::Info into an associative array as well as the list of plugins
+  def append_environment_info
+    local_env.append_environment_value('Rails version'){ version }
+    local_env.append_environment_value('Rails threadsafe') do
+      ::Rails.configuration.action_controller.allow_concurrency == true
+    end
+    local_env.append_environment_value('Rails Env') { env }
+    local_env.append_gem_list do
+      ::Rails.configuration.gems.map do | gem |
+        version = (gem.respond_to?(:version) && gem.version) ||
+          (gem.specification.respond_to?(:version) && gem.specification.version)
+        gem.name + (version ? "(#{version})" : "")
+      end
+    end      
+    local_env.append_plugin_list { ::Rails.configuration.plugins }
+  end
+  
+  def install_shim
+    super
+    require 'new_relic/agent/instrumentation/controller_instrumentation'
+    ActionController::Base.send :include, NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+  end
+  
+end

data/lib/new_relic/local_environment.rb

@@ -5,7 +5,7 @@ module NewRelic
   # An instance of LocalEnvironment is responsible for determining
   # three things: 
   #
-  # * Framework - :rails, :merb, :ruby, :external, :test
+  # * Framework - :rails, :rails3, :merb, :ruby, :external, :test
   # * Dispatcher - A supported dispatcher, or nil (:mongrel, :thin, :passenger, :webrick, etc)
   # * Dispatcher Instance ID, which distinguishes agents on a single host from each other
   #
@@ -17,7 +17,7 @@ module NewRelic
 
     attr_accessor :dispatcher # mongrel, thin, webrick, or possibly nil
     attr_accessor :dispatcher_instance_id # used to distinguish instances of a dispatcher from each other, may be nil
-    attr_accessor :framework # rails, merb, external, ruby, test
+    attr_accessor :framework # rails, rails3, merb, external, ruby, test
     attr_reader :mongrel    # The mongrel instance, if there is one, captured as a convenience
     attr_reader :processors # The number of cpus, if detected, or nil
     alias environment dispatcher
@@ -179,13 +179,21 @@ module NewRelic
         when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
         when defined?(::NewRelic::TEST) then :test
         when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
-        when defined?(::Rails) then :rails
+        when defined?(::Rails) then check_rails_version
         when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra      
         when defined?(::NewRelic::IA) then :external
       else :ruby
       end      
     end
 
+    def check_rails_version
+      if Rails::VERSION::MAJOR < 3     
+        :rails
+      else
+        :rails3
+      end
+    end
+
     def check_for_torquebox
       return unless defined?(::JRuby) &&
          ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil) 

data/lib/new_relic/noticed_error.rb

@@ -1,10 +1,11 @@
 # This class encapsulates an error that was noticed by RPM in a managed app.
 class NewRelic::NoticedError
+  extend NewRelic::CollectionHelper
   attr_accessor :path, :timestamp, :params, :exception_class, :message
   
   def initialize(path, data, exception, timestamp = Time.now)
     self.path = path
-    self.params = data
+    self.params = NewRelic::NoticedError.normalize_params(data)
     
     self.exception_class = exception ? exception.class.name : '<no exception>'
     

data/lib/new_relic/version.rb

@@ -3,9 +3,9 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 2
     MINOR = 10
-    TINY  = 6
-    EXPERIMENTAL = nil 
-    STRING = [MAJOR, MINOR, TINY, EXPERIMENTAL].compact.join('.')
+    TINY  = 8
+    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
   
   # Helper class for managing version comparisons 
@@ -14,7 +14,7 @@ module NewRelic
     include Comparable
     def initialize(version_string)
       version_string ||= '1.0.0'
-      @parts = version_string.split('.').map{|n| n.to_i }
+      @parts = version_string.split('.').map{|n| n =~ /^\d+$/ ? n.to_i : n}
     end
     def major_version; @parts[0]; end
     def minor_version; @parts[1]; end
@@ -42,11 +42,12 @@ module NewRelic
       a, b = parts1.first, parts2.first
       case
         when a.nil? && b.nil? then 0
-        when a.nil? then -1
-        when b.nil? then 1
-        when a == b
-          compare(parts1[1..-1], parts2[1..-1])
-        else
+        when a.nil? then b.is_a?(Fixnum) ?  -1 : 1
+        when b.nil? then -compare(parts2, parts1)
+        when a.to_s == b.to_s then compare(parts1[1..-1], parts2[1..-1])
+        when a.is_a?(String) then b.is_a?(Fixnum) ?  -1 : (a <=> b)
+        when b.is_a?(String) then -compare(parts2, parts1) 
+        else # they are both fixnums, not nil
           a <=> b
       end
     end