newrelic_rpm 2.9.9 → 2.10.3

data/lib/new_relic/control/external.rb

@@ -0,0 +1,13 @@
+# This is the control used when starting up in the context of 
+# The New Relic Infrastructure Agent.  We want to call this
+# out specifically because in this context we are not monitoring
+# the running process, but actually external things.
+require 'new_relic/control/ruby'
+
+class NewRelic::Control::External < NewRelic::Control::Ruby
+
+  def init_config(options={})
+    super
+  end
+  
+end

data/lib/new_relic/control/merb.rb

@@ -8,6 +8,8 @@ class NewRelic::Control::Merb < NewRelic::Control
   end
   
   def to_stdout(msg)
+    Merb.logger.info("NewRelic ~ " + msg)
+  rescue Exception => e
     STDOUT.puts "NewRelic ~ " + msg 
   end
   

data/lib/new_relic/control/rails.rb

@@ -21,9 +21,11 @@ class NewRelic::Control::Rails < NewRelic::Control
   def init_config(options={})
     rails_config=options[:config]
     if !agent_enabled?
-      RAILS_DEFAULT_LOGGER.info "New Relic Agent not running"
+      # 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.
+      ::RAILS_DEFAULT_LOGGER.info "New Relic Agent not running."
     else
-      RAILS_DEFAULT_LOGGER.info "Starting the New Relic Agent"
+      ::RAILS_DEFAULT_LOGGER.info "Starting the New Relic Agent."
       install_developer_mode rails_config if developer_mode?
     end
   end
@@ -41,7 +43,7 @@ class NewRelic::Control::Rails < NewRelic::Control
       Dependencies.load_paths << controller_path
       Dependencies.load_paths << helper_path
     else
-      to_stdout "ERROR: Rails version #{Rails::VERSION::STRING} too old for developer mode to work."
+      to_stdout "ERROR: Rails version #{::Rails::VERSION::STRING} too old for developer mode to work."
       return
     end
     install_devmode_route
@@ -60,6 +62,12 @@ class NewRelic::Control::Rails < NewRelic::Control
       current_paths << controller_path
     end
     
+    def to_stdout(message)
+      ::RAILS_DEFAULT_LOGGER.info(message)
+    rescue Exception => e
+      STDOUT.puts(message)
+    end
+        
     #ActionController::Routing::Routes.reload! unless NewRelic::Control.instance['skip_developer_route']
     
     # inform user that the dev edition is available if we are running inside
@@ -86,7 +94,10 @@ class NewRelic::Control::Rails < NewRelic::Control
       next if self.instance_methods.include? 'draw_with_newrelic_map'
       def draw_with_newrelic_map
         draw_without_newrelic_map do | map |
-          map.named_route 'newrelic_developer', '/newrelic/:action/:id', :controller => 'newrelic' unless NewRelic::Control.instance['skip_developer_route']
+          unless NewRelic::Control.instance['skip_developer_route']
+            map.named_route 'newrelic_developer', '/newrelic/:action/:id', :controller => 'newrelic' 
+            map.named_route 'newrelic_file', '/newrelic/file/*file', :controller => 'newrelic', :action=>'file'
+          end
           yield map        
         end
       end
@@ -106,6 +117,7 @@ class NewRelic::Control::Rails < NewRelic::Control
         ::Rails.configuration.action_controller.allow_concurrency == true
       end
     end
+    local_env.append_environment_value('Rails Env') { ENV['RAILS_ENV'] }
     if rails_version >= NewRelic::VersionNumber.new('2.1.0')
       local_env.append_gem_list do
         ::Rails.configuration.gems.map do | gem |
@@ -133,9 +145,7 @@ class NewRelic::Control::Rails < NewRelic::Control
   def install_shim
     super
     require 'new_relic/agent/instrumentation/controller_instrumentation'
-    require 'new_relic/agent/instrumentation/error_instrumentation'
     ActionController::Base.send :include, NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
-    Object.send :include, NewRelic::Agent::Instrumentation::ErrorInstrumentation::Shim
   end
   
 end

data/lib/new_relic/control/ruby.rb

@@ -4,20 +4,23 @@
 # It loads the settings from the newrelic.yml section
 # based on the value of RUBY_ENV or RAILS_ENV. 
 class NewRelic::Control::Ruby < NewRelic::Control
-
+  
   def env
-    @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || 'development'
+    @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
   end
   def root
-    Dir['.']
+    @root ||= ENV['APP_ROOT'] || Dir['.']
   end
   # Check a sequence of file locations for newrelic.yml
   def config_file
     files = []
     files << File.join(root,"config","newrelic.yml")
     files << File.join(root,"newrelic.yml")
-    files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
-    files << File.join(ENV["HOME"], "newrelic.yml")
+    if ENV["HOME"]
+      files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml") 
+      files << File.join(ENV["HOME"], "newrelic.yml")
+    end
+    files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
     files.each do | file |
       return File.expand_path(file) if File.exists? file
     end

data/lib/new_relic/control/sinatra.rb

@@ -0,0 +1,18 @@
+
+require 'new_relic/control/ruby'
+
+class NewRelic::Control::Sinatra < NewRelic::Control::Ruby
+  
+  def env
+    @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+  end
+
+  # This is the control used when starting up in the context of 
+  # The New Relic Infrastructure Agent.  We want to call this
+  # out specifically because in this context we are not monitoring
+  # the running process, but actually external things.
+  def init_config(options={})
+    super
+  end
+  
+end

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,25 @@
+# This installs some code to manually start the agent when a delayed job worker starts.
+
+module NewRelic
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end
+
+Delayed::Worker.class_eval do
+  def initialize_with_new_relic(*args)
+    initialize_without_new_relic(*args)
+    worker_name = case
+    when self.respond_to?(:name) then self.name
+    when self.class.respond_to?(:default_name) then self.class.default_name
+    end
+    dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    self.class.logger.info "RPM Monitoring DJ worker #{dispatcher_instance_id}"
+    NewRelic::Agent.manual_start :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+    NewRelic::DelayedJobInjection.worker_name = worker_name
+  end
+  
+  alias initialize_without_new_relic initialize
+  alias initialize initialize_with_new_relic
+end if defined?(::Delayed::Worker) and not NewRelic::Control.instance['disable_dj']

data/lib/new_relic/histogram.rb

@@ -0,0 +1,89 @@
+# Histogram is used for organizing response times
+# into an 'Exponential Histogram'.  Feature based in part on DHH proposal:
+# http://37signals.com/svn/posts/1836-the-problem-with-averages
+#
+# Histogram builds a set of buckets of geometrically growing size, with the assumption that most
+# apps have long-tail response times, and therefore you need the most granularity at the lowest
+# r/t level.
+class NewRelic::Histogram
+
+  # Used to stub out API methods when the agent is not enabled
+  module Shim
+    def process(response_time); end
+  end
+  # Stores statistics for response times falling in a particular range.
+  # A bucket has a min and max response time.  A response time event
+  # falls in a bucket if min <= r/t < max.  A bucket also 
+  # has an associated metric for reporting data to RPM.  The 
+  # bucket range is encoded in the metic name
+  class Bucket
+    
+    attr_reader :min, :max, :stats
+
+    def initialize(min, max = nil)
+      @min = min
+      @max = max
+    end
+    
+    def stats
+      NewRelic::Agent.get_stats("Response Times/#{min_millis}/#{max_millis}")
+    end
+  
+    # This has return value like <=> but does something more
+    # than simply compare.  If the value falls within range for
+    # the bucket, increment count and return 0; otherwise return
+    # a value < 0 if the value belongs in a bucket with a lower range
+    # you can guess what it returns if the value belongs in a bucket
+    # with a higher range. (Hint: it's not 0, and it's not less than zero.)
+    def process(value)
+      if value < min
+        return -1
+    
+      # max == nil means unlimited max (last bucket)
+      elsif max && value >= max
+        return 1
+
+      else
+        stats.record_data_point(value)
+        return 0
+      end
+    end
+
+    def min_millis
+      (min * 1000).round
+    end
+  
+    def max_millis
+      max.nil? ? nil : (max * 1000).round
+    end
+  
+    def to_s
+      "#{min_millis} - #{max_millis}: #{stats.call_count}"
+    end
+  end
+
+  attr_reader :buckets
+  
+  # Histogram uses apdex T / 10 as its minimum bucket size, and grows from there.
+  # 30 data points should be adequate resolution.
+  def initialize(first_bucket_max = 0.010, bucket_count = 30, multiplier = 1.3)
+    @buckets = []
+    
+    min = 0
+    max = first_bucket_max
+    
+     (bucket_count - 1).times do 
+      @buckets << Bucket.new(min, max)
+      min = max
+      max *= multiplier
+    end
+    @buckets << Bucket.new(max)
+  end
+  
+  def process(response_time)
+    buckets.each do |bucket|
+      found = bucket.process(response_time) 
+      return if found == 0
+    end
+  end
+end

data/lib/new_relic/local_environment.rb

@@ -1,10 +1,11 @@
 require 'set'
+require 'new_relic/version'
 
 module NewRelic 
   # An instance of LocalEnvironment is responsible for determining
   # three things: 
   #
-  # * Framework - :rails, :merb, :ruby, :test
+  # * Framework - :rails, :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
   #
@@ -16,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, :ruby, test
+    attr_accessor :framework # rails, 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
@@ -73,6 +74,7 @@ module NewRelic
       append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
       append_environment_value('Application root') { File.expand_path(NewRelic::Control.instance.root) }
       append_environment_value('Ruby version'){ RUBY_VERSION }
+      append_environment_value('Ruby description'){ RUBY_DESCRIPTION } if defined? ::RUBY_DESCRIPTION
       append_environment_value('Ruby platform') { RUBY_PLATFORM }
       append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
       if defined? ::JRUBY_VERSION
@@ -86,11 +88,8 @@ module NewRelic
       append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
       # See what the number of cpus is, works only on linux.
       @processors = append_environment_value('Processors') do
-        processors = 0
-        File.read('/proc/cpuinfo').each_line do | line |
-          processors += 1 if line =~ /^processor\s*:/
-        end 
-        raise unless processors > 0
+        processors = File.readlines('/proc/cpuinfo').select { |line| line =~ /^processor\s*:/ }.size
+        raise "Cannot determine the number of processors in /proc/cpuinfo" unless processors > 0
         processors
       end if File.readable? '/proc/cpuinfo'
       # The current Rails environment (development, test, or production).
@@ -103,7 +102,7 @@ module NewRelic
         end
       end
       # The name of the database adapter for the current environment.
-      if defined? ActiveRecord
+      if defined? ::ActiveRecord
         append_environment_value 'Database adapter' do
           ActiveRecord::Base.configurations[RAILS_ENV]['adapter']
         end
@@ -111,7 +110,7 @@ module NewRelic
           ActiveRecord::Migrator.current_version
         end
       end
-      if defined? DataMapper
+      if defined? ::DataMapper
         append_environment_value 'DataMapper version' do
           require 'dm-core/version'
           DataMapper::VERSION
@@ -128,28 +127,36 @@ module NewRelic
     end
     
     def mongrel
-      return @mongrel if @mongrel || ! defined? Mongrel::HttpServer 
+      # Note that the odd defined? sequence is necessary to work around a bug in an older version
+      # of JRuby.
+      return @mongrel if @mongrel || ! (defined?(::Mongrel) && defined?(::Mongrel::HttpServer)) 
       ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel|
         @mongrel = mongrel
-      end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
+      end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
       @mongrel
     end
     
     def unicorn
-      return @unicorn if @unicorn || ! defined? Unicorn::HttpServer 
+      return @unicorn if @unicorn || ! (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) 
       ObjectSpace.each_object(Unicorn::HttpServer) do |unicorn|
         @unicorn = unicorn
-      end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
+      end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
       @unicorn
     end
 
+    # Obsolete method for DelayedJob instrumentation support, which is
+    # now in the rpm_contrib gem.
+    def delayed_worker=(worker)
+      $stderr.puts "WARNING: DelayedJob instrumentation has been moved to the rpm_contrib gem."
+    end
+
     private
     
     # Although you can override the framework with NEWRELIC_DISPATCHER this
     # is not advisable since it implies certain api's being available.
     def discover_dispatcher
       @dispatcher = ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
-      dispatchers = %w[passenger glassfish thin mongrel litespeed webrick fastcgi unicorn]
+      dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
       while dispatchers.any? && @dispatcher.nil?
         send 'check_for_'+(dispatchers.shift)
       end
@@ -158,17 +165,28 @@ module NewRelic
     def discover_framework
       # Although you can override the framework with NEWRELIC_FRAMEWORK this
       # is not advisable since it implies certain api's being available.
+      #
+      # Note that the odd defined? sequence is necessary to work around a bug in an older version
+      # of JRuby.
       @framework = case
-        when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym 
-        when defined? NewRelic::TEST then :test
-        when defined? Merb::Plugins then :merb
-        when defined? Rails then :rails
+        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?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra      
+        when defined?(::NewRelic::IA) then :external
       else :ruby
       end      
     end
 
+    def check_for_torquebox
+      return unless defined?(::JRuby) &&
+         ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil) 
+      @dispatcher = :torquebox
+    end
+
     def check_for_glassfish
-      return unless defined?(::Java) &&
+      return unless defined?(::JRuby) &&
          (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
          defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
          ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
@@ -177,9 +195,9 @@ module NewRelic
     end
 
     def check_for_webrick
-      return unless defined?(WEBrick::VERSION)
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
       @dispatcher = :webrick
-      if defined?(OPTIONS) && OPTIONS.respond_to?(:fetch) 
+      if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch) 
         # OPTIONS is set by script/server
         @dispatcher_instance_id = OPTIONS.fetch(:port)
       end
@@ -187,13 +205,13 @@ module NewRelic
     end
     
     def check_for_fastcgi
-      return unless defined? FCGI
+      return unless defined?(::FCGI)
       @dispatcher = :fastcgi
     end
 
     # this case covers starting by mongrel_rails
     def check_for_mongrel
-      return unless defined?(Mongrel::HttpServer) 
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
       @dispatcher = :mongrel
       
       # Get the port from the server if it's started
@@ -203,10 +221,10 @@ module NewRelic
       end
       
       # Get the port from the configurator if one was created
-      if @dispatcher_instance_id.nil? && defined?(Mongrel::Configurator)
+      if @dispatcher_instance_id.nil? && defined?(::Mongrel::Configurator)
         ObjectSpace.each_object(Mongrel::Configurator) do |mongrel|
           @dispatcher_instance_id = mongrel.defaults[:port] && mongrel.defaults[:port].to_s
-        end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
+        end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
       end
       
       # Still can't find the port.  Let's look at ARGV to fall back
@@ -214,16 +232,31 @@ module NewRelic
     end
     
     def check_for_unicorn
-      return unless defined?(Unicorn::HttpServer)
+      return unless defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
       
       # unlike mongrel, unicorn manages muliple threads and ports, so we 
       # have to map multiple processes into one instance, as we do with passenger
       @dispatcher = :unicorn
     end
       
+    def check_for_sinatra
+      return unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+      
+      begin
+        version = ::Sinatra::VERSION
+      rescue
+        $stderr.puts("Error determining Sinatra version")
+      end
+
+      if ::NewRelic::VersionNumber.new('0.9.2') > version
+        $stderr.puts("Your Sinatra version is #{version}, we highly recommend upgrading to >=0.9.2")
+      end
+
+      @dispatcher = :sinatra
+    end
     
     def check_for_thin
-      if defined? Thin::Server
+      if defined?(::Thin) && defined?(::Thin::Server)
         # This case covers the thin web dispatcher
         # Same issue as above- we assume only one instance per process
         ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
@@ -240,7 +273,7 @@ module NewRelic
           end
         end # each thin instance
       end
-      if defined?(Thin::VERSION) && !@dispatcher
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
         @dispatcher = :thin
         @dispatcher_instance_id = default_port
       end
@@ -253,11 +286,12 @@ module NewRelic
     end
     
     def check_for_passenger
-      if defined?(Passenger::AbstractServer) || defined?(IN_PHUSION_PASSENGER) 
+      if (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER) 
         @dispatcher = :passenger
       end
     end
-  
+    
+
     def default_port
       require 'optparse'
       # If nothing else is found, use the 3000 default