wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/control/instrumentation.rb

@@ -9,17 +9,12 @@ module NewRelic
       # This requires the files within a rescue block, so that any
       # errors within instrumentation files do not affect the overall
       # agent or application in which it runs.
-      #
-      # Logs at debug level for each file loaded, and logs errors in
-      # file loading at error level
       def load_instrumentation_files pattern
         Dir.glob(pattern) do |file|
           begin
-            log.debug "Processing instrumentation file '#{file}'"
             require file.to_s
           rescue => e
-            log.error "Error loading instrumentation file '#{file}': #{e}"
-            log.debug e.backtrace.join("\n")
+            ::NewRelic::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
           end
         end
       end
@@ -60,19 +55,19 @@ module NewRelic
         agent = NewRelic::Agent.instance
         NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
           begin
-            log.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+            ::NewRelic::Agent.logger.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
             sampler = subclass.new
             if subclass.use_harvest_sampler?
               agent.stats_engine.add_harvest_sampler sampler
-              log.debug "Registered #{subclass.name} for harvest time sampling"
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for harvest time sampling"
             else
               agent.stats_engine.add_sampler sampler
-              log.debug "Registered #{subclass.name} for periodic sampling"
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for periodic sampling"
             end
           rescue NewRelic::Agent::Sampler::Unsupported => e
-            log.info "#{subclass} sampler not available: #{e}"
+            ::NewRelic::Agent.logger.info "#{subclass} sampler not available: #{e}"
           rescue => e
-            log.error "Error registering sampler: #{e}, #{e.backtrace.join("\n")}"
+            ::NewRelic::Agent.logger.error "Error registering sampler:", e
           end
         end
       end
@@ -92,7 +87,7 @@ module NewRelic
         File.join(instrumentation_path, app.to_s, '*.rb')
         @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
         DependencyDetection.detect!
-        log.debug "Finished instrumentation"
+        ::NewRelic::Agent.logger.info "Finished instrumentation"
       end
     end
     include Instrumentation

data/lib/new_relic/control/server_methods.rb

@@ -18,29 +18,27 @@ module NewRelic
       # the server we should contact for api requests, like uploading
       # deployments and the like
       def api_server
-        api_host = self['api_host'] || 'rpm.newrelic.com'
-        @api_server ||=
-          NewRelic::Control::Server.new \
-        api_host,
-        (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
-        nil
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], nil)
       end
       
       # a new instances of the proxy server - this passes through if
       # there is no proxy, otherwise it has proxy configuration
       # information pulled from the config file
       def proxy_server
-        @proxy_server ||=
-          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
+                                                             Agent.config[:proxy_port],
+                                                             Agent.config[:proxy_user],
+                                                             Agent.config[:proxy_pass])
       end
       
       # turns a hostname into an ip address and returns a
       # NewRelic::Control::Server that contains the configuration info
       def server_from_host(hostname=nil)
-        host = hostname || self['host'] || 'collector.newrelic.com'
+        host = hostname || Agent.config[:host]
 
         # if the host is not an IP address, turn it into one
-        NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host)
+        NewRelic::Control::Server.new(host, Agent.config[:port],
+                                      convert_to_ip_address(host))
       end
 
       # Check to see if we need to look up the IP address
@@ -50,10 +48,11 @@ module NewRelic
       def convert_to_ip_address(host)
         # here we leave it as a host name since the cert verification
         # needs it in host form
-        return host if verify_certificate?
+        return host if Agent.config[:ssl] && Agent.config[:verify_certificate]
         return nil if host.nil? || host.downcase == "localhost"
         ip = resolve_ip_address(host)
-        log.info "Resolved #{host} to #{ip}"
+
+        ::NewRelic::Agent.logger.debug "Resolved #{host} to #{ip}"
         ip
       end
 
@@ -64,13 +63,12 @@ module NewRelic
       def resolve_ip_address(host)
         Resolv.getaddress(host)
       rescue => e
-        log.warn("DNS Error caching IP address: #{e}")
-        log.debug(e.backtrace.join("\n   "))
+        ::NewRelic::Agent.logger.warn("DNS Error caching IP address:", e)
         begin
-          log.info("Trying native DNS lookup since Resolv failed")
+          ::NewRelic::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
           IPSocket.getaddress(host)
         rescue => e
-          log.error("Could not look up server address: #{e}")
+          ::NewRelic::Agent.logger.error("Could not look up server address: #{e}")
           nil
         end
       end
@@ -94,10 +92,10 @@ module NewRelic
         http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
                                       proxy_server.user, proxy_server.password)
         http = http_class.new(host.ip || host.name, host.port)
-        log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
-        if use_ssl?
+        ::NewRelic::Agent.logger.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
+        if Agent.config[:ssl]
           http.use_ssl = true
-          if verify_certificate?
+          if Agent.config[:verify_certificate]
             http.verify_mode = OpenSSL::SSL::VERIFY_PEER
             http.ca_file = cert_file_path
           else

data/lib/new_relic/delayed_job_injection.rb

@@ -15,12 +15,12 @@ DependencyDetection.defer do
   @name = :delayed_job_injection
   
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
   end
   
   executes do
     if NewRelic::Agent.respond_to?(:logger)
-      NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation hooks'
+      ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation hooks'
     end
   end
   

data/lib/new_relic/helper.rb

@@ -0,0 +1,34 @@
+module NewRelic
+  # A singleton for shared generic helper methods
+  module Helper
+    extend self
+
+    # confirm a string is correctly encoded (in >= 1.9)
+    # If not force the encoding to ASCII-8BIT (binary)
+    if RUBY_VERSION >= '1.9'
+      def correctly_encoded(string)
+        return string unless string.is_a? String
+        string.valid_encoding? ? string : string.force_encoding("ASCII-8BIT")
+      end
+    else
+      #noop
+      def correctly_encoded(string)
+        string
+      end
+    end
+
+    def instance_method_visibility(klass, method_name)
+      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :private
+      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :protected
+      else
+        :public
+      end
+    end
+
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
+  end
+end

data/lib/new_relic/language_support.rb

@@ -1,28 +1,6 @@
 module NewRelic::LanguageSupport
   extend self
-  
-  module DataSerialization
-    def self.included(base)
-      # need to disable GC during marshal load in 1.8.7
-      if NewRelic::LanguageSupport.using_version?('1.8.7') &&
-          !NewRelic::LanguageSupport.using_engine?('jruby') &&
-          !NewRelic::LanguageSupport.using_engine?('rbx')
-        base.class_eval do
-          def self.load(*args)
-            if defined?(::GC) && ::GC.respond_to?(:disable)
-              ::GC.disable
-              val = super
-              ::GC.enable
-              val
-            else
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-  
+
   module Control
     def self.included(base)
       # need to use syck rather than psych when possible
@@ -43,21 +21,22 @@ module NewRelic::LanguageSupport
       end
     end
   end
-  
-  module SynchronizedHash
-    def self.included(base)
-      # need to lock iteration of stats hash in 1.9.x
-      if NewRelic::LanguageSupport.using_version?('1.9') ||
-          NewRelic::LanguageSupport.using_engine?('jruby')
-        base.class_eval do
-          def each(*args, &block)
-            @lock.synchronize { super }
-          end
-        end
-      end
+
+  @@forkable = nil
+  def can_fork?
+    # this is expensive to check, so we should only check once
+    return @@forkable if @@forkable != nil
+
+    if Process.respond_to?(:fork)
+      # if this is not 1.9.2 or higher, we have to make sure
+      @@forkable = ::RUBY_VERSION < '1.9.2' ? test_forkability : true
+    else
+      @@forkable = false
     end
+
+    @@forkable
   end
-  
+
   def using_engine?(engine)
     if defined?(::RUBY_ENGINE)
       ::RUBY_ENGINE == engine
@@ -65,9 +44,49 @@ module NewRelic::LanguageSupport
       engine == 'ruby'
     end
   end
-  
+
+  def broken_gc?
+    NewRelic::LanguageSupport.using_version?('1.8.7') &&
+      RUBY_PATCHLEVEL < 348 &&
+      !NewRelic::LanguageSupport.using_engine?('jruby') &&
+      !NewRelic::LanguageSupport.using_engine?('rbx')
+  end
+
+  def with_disabled_gc
+    if defined?(::GC) && ::GC.respond_to?(:disable)
+      val = nil
+      begin
+        ::GC.disable
+        val = yield
+      ensure
+        ::GC.enable
+      end
+      val
+    else
+      yield
+    end
+  end
+
+  def with_cautious_gc
+    if broken_gc?
+      with_disabled_gc { yield }
+    else
+      yield
+    end
+  end
+
   def using_version?(version)
     numbers = version.split('.')
     numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
   end
+
+  def test_forkability
+    child = Process.fork { exit! }
+    # calling wait here doesn't seem like it should necessary, but it seems to
+    # resolve some weird edge cases with resque forking.
+    Process.wait child
+    true
+  rescue NotImplementedError
+    false
+  end
 end

data/lib/new_relic/local_environment.rb

@@ -5,7 +5,6 @@ module NewRelic
   # An instance of LocalEnvironment is responsible for determining
   # three things:
   #
-  # * 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
   #
@@ -14,17 +13,17 @@ module NewRelic
   #
   # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
   class LocalEnvironment
-    
     # mongrel, thin, webrick, or possibly nil
-    attr_accessor :dispatcher
+    def discovered_dispatcher
+      discover_dispatcher unless @discovered_dispatcher
+      @discovered_dispatcher
+    end
+
     # used to distinguish instances of a dispatcher from each other, may be nil
     attr_writer :dispatcher_instance_id
-    # rails, rails3, merb, external, ruby, test, etc
-    attr_accessor :framework
     # The number of cpus, if detected, or nil - many platforms do not
     # support this :(
-    attr_reader :processors 
-    alias environment dispatcher
+    attr_reader :processors
 
     def initialize
       # Extend self with any any submodules of LocalEnvironment.  These can override
@@ -34,9 +33,7 @@ module NewRelic
         self.extend mod if mod.instance_of? Module
       end
 
-      discover_framework
       discover_dispatcher
-      @dispatcher = nil if @dispatcher == :none
       @gems = Set.new
       @plugins = Set.new
       @config = Hash.new
@@ -49,9 +46,8 @@ module NewRelic
     def append_environment_value(name, value = nil)
       value = yield if block_given?
       @config[name] = value if value
-    rescue
-      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
-      raise if @framework == :test
+    rescue => e
+      Agent.logger.error e
     end
     
     # yields to the block and appends the returned value to the list
@@ -59,24 +55,22 @@ module NewRelic
     def append_gem_list
       @gems += yield
     rescue => e
-      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
-      raise if @framework == :test
+      Agent.logger.error e
     end
     
     # yields to the block and appends the returned value to the list
     # of plugins - this catches errors that might be raised in the block
     def append_plugin_list
       @plugins += yield
-    rescue
-      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
-      raise if @framework == :test
+    rescue => e
+      Agent.logger.error e
     end
     
     # An instance id pulled from either @dispatcher_instance_id or by
     # splitting out the first part of the running file
     def dispatcher_instance_id
       if @dispatcher_instance_id.nil?
-        if @dispatcher.nil?
+        if @discovered_dispatcher.nil?
           @dispatcher_instance_id = File.basename($0).split(".").first
         end
       end
@@ -123,7 +117,7 @@ module NewRelic
 
         if processors == 0
           processors = 1 # assume there is at least one processor
-          NewRelic::Agent.logger.warn("Cannot determine the number of processors in #{proc_file}")
+          ::NewRelic::Agent.logger.warn("Cannot determine the number of processors in #{proc_file}")
         end
         processors
       end
@@ -198,8 +192,8 @@ module NewRelic
     # Collect base statistics about the environment and record them for
     # comparison and change detection.
     def gather_environment_info
-      append_environment_value 'Framework', @framework.to_s
-      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
+      append_environment_value 'Framework', Agent.config[:framework].to_s
+      append_environment_value 'Dispatcher', Agent.config[:dispatcher].to_s if Agent.config[:dispatcher]
       append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
       append_environment_value('Environment') { NewRelic::Control.instance.env }
 
@@ -245,47 +239,19 @@ module NewRelic
     
     private
 
-    # Although you can override the framework with NEWRELIC_DISPATCHER this
+    # Although you can override the dispatcher 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
-      @dispatcher ||= ENV['NEW_RELIC_DISPATCHER'] && ENV['NEW_RELIC_DISPATCHER'].to_sym
       dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
-      while dispatchers.any? && @dispatcher.nil?
+      while dispatchers.any? && @discovered_dispatcher.nil?
         send 'check_for_'+(dispatchers.shift)
       end
     end
 
-    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 ENV['NEW_RELIC_FRAMEWORK'] then ENV['NEW_RELIC_FRAMEWORK'].to_sym
-                     when defined?(::NewRelic::TEST) then :test
-                     when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
-                     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) &&
          ( org.torquebox::TorqueBox rescue nil)
-      @dispatcher = :torquebox
+      @discovered_dispatcher = :torquebox
     end
 
     def check_for_glassfish
@@ -293,12 +259,12 @@ module NewRelic
         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
           defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
          (jruby_rack? && defined?(::GlassFish::Server)))
-      @dispatcher = :glassfish
+      @discovered_dispatcher = :glassfish
     end
 
     def check_for_trinidad
       return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
-      @dispatcher = :trinidad
+      @discovered_dispatcher = :trinidad
     end
 
     def jruby_rack?
@@ -308,7 +274,7 @@ module NewRelic
 
     def check_for_webrick
       return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
-      @dispatcher = :webrick
+      @discovered_dispatcher = :webrick
       if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch)
         # OPTIONS is set by script/server
         @dispatcher_instance_id = OPTIONS.fetch(:port)
@@ -318,13 +284,13 @@ module NewRelic
 
     def check_for_fastcgi
       return unless defined?(::FCGI)
-      @dispatcher = :fastcgi
+      @discovered_dispatcher = :fastcgi
     end
 
     # this case covers starting by mongrel_rails
     def check_for_mongrel
       return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
-      @dispatcher = :mongrel
+      @discovered_dispatcher = :mongrel
 
       # Get the port from the server if it's started
 
@@ -346,7 +312,7 @@ module NewRelic
     def check_for_unicorn
       if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
         v = find_class_in_object_space(::Unicorn::HttpServer)
-        @dispatcher = :unicorn if v 
+        @discovered_dispatcher = :unicorn if v 
       end
     end
 
@@ -363,7 +329,7 @@ module NewRelic
         $stderr.puts("Your Sinatra version is #{version}, we highly recommend upgrading to >=0.9.2")
       end
 
-      @dispatcher = :sinatra
+      @discovered_dispatcher = :sinatra
     end
 
     def check_for_thin
@@ -371,7 +337,7 @@ module NewRelic
         # 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|
-          @dispatcher = :thin
+          @discovered_dispatcher = :thin
           backend = thin_dispatcher.backend
           # We need a way to uniquely identify and distinguish agents.  The port
           # works for this.  When using sockets, use the socket file name.
@@ -384,21 +350,21 @@ module NewRelic
           end
         end # each thin instance
       end
-      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
-        @dispatcher = :thin
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@discovered_dispatcher
+        @discovered_dispatcher = :thin
         @dispatcher_instance_id = default_port
       end
     end
 
     def check_for_litespeed
       if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
-        @dispatcher = :litespeed
+        @discovered_dispatcher = :litespeed
       end
     end
 
     def check_for_passenger
-      if (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
-        @dispatcher = :passenger
+      if defined?(::PhusionPassenger)
+        @discovered_dispatcher = :passenger
       end
     end
 
@@ -418,8 +384,7 @@ module NewRelic
     # outputs a human-readable description
     def to_s
       s = "LocalEnvironment["
-      s << @framework.to_s
-      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
       s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
       s << "]"
     end