ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/lib/new_relic/control/instrumentation.rb

@@ -1,12 +1,23 @@
 module NewRelic
   class Control
+    # Contains methods that relate to adding and executing files that
+    # contain instrumentation for the Ruby Agent
     module Instrumentation
+
+      # Adds a list of files in Dir.glob format
+      # (e.g. '/app/foo/**/*_instrumentation.rb')
+      # 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 Exception => e
+          rescue => e
             log.error "Error loading instrumentation file '#{file}': #{e}"
             log.debug e.backtrace.join("\n")
           end
@@ -23,8 +34,11 @@ module NewRelic
 
       # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
       # This will load the file synchronously if we've already loaded the default
-      # instrumentation.
+      # instrumentation, otherwise instrumentation files specified
+      # here will be deferred until all instrumentation is run
       #
+      # This happens after the agent has loaded and all dependencies
+      # are ready to be instrumented
       def add_instrumentation pattern
         if @instrumented
           load_instrumentation_files pattern
@@ -32,11 +46,16 @@ module NewRelic
           @instrumentation_files << pattern
         end
       end
-
+      
+      # Signals the agent that it's time to actually load the
+      # instrumentation files. May be overridden by subclasses
       def install_instrumentation
         _install_instrumentation
       end
-
+      
+      # adds samplers to the stats engine so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses NewRelic::Agent::Sampler
       def load_samplers
         agent = NewRelic::Agent.instance
         NewRelic::Agent::Sampler.sampler_classes.each do | subclass |

data/lib/new_relic/control/logging_methods.rb

@@ -1,15 +1,19 @@
 
 module NewRelic
   class Control
+    # Contains methods that relate to locating, creating, and writing
+    # to the log file and/or standard out
     module LoggingMethods
 
       attr_accessor :log_file
-
+      
+      # returns either the log set up with setup_log or else a new
+      # logger pointing to standard out, if we're trying to log before
+      # a log exists
       def log
-        # If we try to get a log before one has been set up, return a stdout log
-        unless @log
+        if !@log
           l = Logger.new(STDOUT)
-          l.level = Logger::INFO
+          l.level = Logger::INFO          
           return l
         end
         @log
@@ -24,12 +28,18 @@ module NewRelic
         return unless should_log?
         log.send level, msg if @log
       end
-
+      
+      # true if the agent has settings, and the agent is enabled,
+      # otherwise false
       def should_log?
         @settings && agent_enabled?
       end
 
       # set the log level as specified in the config file
+      #
+      # Possible values are from the Logger class: debug, info, warn,
+      #error, and fatal
+      # Defaults to info
       def set_log_level!(logger)
         case fetch("log_level","info").downcase
           when "debug" then logger.level = Logger::DEBUG
@@ -42,10 +52,11 @@ module NewRelic
         logger
       end
 
-      # change the format just for our logger
+      # patches the logger's format_message method to change the format just for our logger
       def set_log_format!(logger)
         def logger.format_message(severity, timestamp, progname, msg)
-          "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+          prefix = @logdev.dev == STDOUT ? '** [NewRelic]' : ''
+          prefix + "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
         end
         logger
       end
@@ -54,8 +65,14 @@ module NewRelic
       #
       # Control subclasses may override this, but it can be called multiple times.
       def setup_log
-        @log_file = "#{log_path}/#{log_file_name}"
-        @log = Logger.new(@log_file) rescue nil
+        if log_to_stdout?
+          @log = Logger.new(STDOUT) 
+        else
+          @log_file = "#{log_path}/#{log_file_name}"
+          @log = Logger.new(@log_file) rescue nil
+          @log ||= Logger.new(STDOUT) # failsafe to STDOUT
+        end
+        
         if @log
           set_log_format!(@log)
           set_log_level!(@log)
@@ -65,22 +82,60 @@ module NewRelic
         # above
         log
       end
-
+      
+      # simply puts a message to standard out, prepended with the
+      # '** [NewRelic]' sigil to make sure people know where the message
+      # comes from. This should be used sparingly
       def to_stdout(msg)
         STDOUT.puts "** [NewRelic] " + msg
       end
-
+      
+      # Sets up and caches the log path, attempting to create it if it
+      # does not exist.  If it does not succeed, it prints an
+      # error and returns nil.
+      # This comes from the configuration variable 'log_file_path' in the configuration file.
       def log_path
         return @log_path if @log_path
-        @log_path = File.expand_path(fetch('log_file_path', 'log/'))
-        if !File.directory?(@log_path) && ! (Dir.mkdir(@log_path) rescue nil)
-          log!("Error creating New Relic log directory '#{@log_path}'", :error)
+        if log_to_stdout?
+          @log_path = nil
+        else
+          if ENV['NEW_RELIC_LOG']
+            log_path_setting = File.dirname(ENV['NEW_RELIC_LOG'])
+          else
+            log_path_setting = fetch('log_file_path', 'log')
+          end
+          @log_path = find_or_create_file_path(log_path_setting)
+          log!("Error creating log directory #{log_path_setting}, using standard out for logging.", :warn) unless @log_path
         end
         @log_path
       end
+        
+      def find_or_create_file_path(path_setting)
+        for abs_path in [ File.expand_path(path_setting),
+                          File.expand_path(File.join(root, path_setting)) ] do
+          if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
+            return abs_path[%r{^(.*?)/?$}]
+          end
+        end
+        nil
+      end
 
+      def log_to_stdout?
+        return true if @stdout
+        destination = ENV['NEW_RELIC_LOG'] || fetch('log_file_path', 'log')
+        if destination.upcase == 'STDOUT'
+          @stdout = true
+        end
+      end
+        
+      # Retrieves the log file's name from the config file option
+      #'log_file_name', defaulting to 'newrelic_agent.log'
       def log_file_name
-        fetch('log_file_name', 'newrelic_agent.log')
+        if ENV['NEW_RELIC_LOG']
+          File.basename(ENV['NEW_RELIC_LOG'])
+        else
+          fetch('log_file_name', 'newrelic_agent.log')
+        end
       end
     end
     include LoggingMethods

data/lib/new_relic/control/server_methods.rb

@@ -7,13 +7,16 @@ module NewRelic
     end
 
     ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
-
+    
+    # Contains methods that deal with connecting to the server
     module ServerMethods
-
+      
       def server
         @remote_server ||= server_from_host(nil)
       end
-
+      
+      # 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 ||=
@@ -22,12 +25,17 @@ module NewRelic
         (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
         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']
       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'
 
@@ -45,7 +53,10 @@ module NewRelic
         return host if verify_certificate?
         return nil if host.nil? || host.downcase == "localhost"
         ip = resolve_ip_address(host)
-        log.info "Resolved #{host} to #{ip}"
+
+        # FIXME: commented out to squelch STDOUT output for RUBY-839
+        # should bring it back when logging / startup is fixed
+        # log.info "Resolved #{host} to #{ip}"
         ip
       end
 
@@ -55,18 +66,20 @@ module NewRelic
       # address and don't have a good default.
       def resolve_ip_address(host)
         Resolv.getaddress(host)
-      rescue Exception => e
+      rescue => e
         log.warn("DNS Error caching IP address: #{e}")
         log.debug(e.backtrace.join("\n   "))
         begin
           log.info("Trying native DNS lookup since Resolv failed")
           IPSocket.getaddress(host)
-        rescue Exception => e
+        rescue => e
           log.error("Could not look up server address: #{e}")
           nil
         end
       end
-
+      
+      # The path to the certificate file used to verify the SSL
+      # connection if verify_peer is enabled
       def cert_file_path
         File.expand_path(File.join(newrelic_root, 'cert', 'cacert.pem'))
       end

data/lib/new_relic/delayed_job_injection.rb

@@ -12,10 +12,18 @@ module NewRelic
 end
 
 DependencyDetection.defer do
+  @name = :delayed_job_injection
+  
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker)
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
   end
-
+  
+  executes do
+    if NewRelic::Agent.respond_to?(:logger)
+      NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation hooks'
+    end
+  end
+  
   executes do
     Delayed::Worker.class_eval do
       def initialize_with_new_relic(*args)
@@ -35,4 +43,9 @@ DependencyDetection.defer do
     end
   end
 end
-DependencyDetection.detect!
+
+# If Rails is defined, this gets called in an after_initialize hook
+# see NewRelic::Control::Frameworks::Rails#init_config
+unless defined?(Rails)
+  DependencyDetection.detect!
+end

data/lib/new_relic/helper.rb

@@ -0,0 +1,21 @@
+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
+
+  end
+end

data/lib/new_relic/language_support.rb

@@ -0,0 +1,95 @@
+module NewRelic::LanguageSupport
+  extend self
+  
+  module Control
+    def self.included(base)
+      # need to use syck rather than psych when possible
+      if defined?(::YAML::ENGINE)
+        if !NewRelic::LanguageSupport.using_engine?('jruby') &&
+            (NewRelic::LanguageSupport.using_version?('1.9.1') ||
+             NewRelic::LanguageSupport.using_version?('1.9.2'))
+          base.class_eval do
+            def load_newrelic_yml(*args)
+              yamler = ::YAML::ENGINE.yamler
+              ::YAML::ENGINE.yamler = 'syck'
+              val = super
+              ::YAML::ENGINE.yamler = yamler
+              val
+            end
+          end
+        end
+      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
+    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
+    else
+      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)
+      ::GC.disable
+      val = yield
+      ::GC.enable
+      val
+    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

@@ -14,12 +14,16 @@ module NewRelic
   #
   # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
   class LocalEnvironment
-
-    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, 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
+    
+    # mongrel, thin, webrick, or possibly nil
+    attr_accessor :dispatcher
+    # 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
 
     def initialize
@@ -45,25 +49,31 @@ module NewRelic
     def append_environment_value(name, value = nil)
       value = yield if block_given?
       @config[name] = value if value
-    rescue Exception
+    rescue
       # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
       raise if @framework == :test
     end
-
+    
+    # yields to the block and appends the returned value to the list
+    # of gems - this catches errors that might be raised in the block
     def append_gem_list
       @gems += yield
-    rescue Exception => e
+    rescue => e
       # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
       raise if @framework == :test
     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 Exception
+    rescue
       # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
       raise if @framework == :test
     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?
@@ -72,7 +82,9 @@ module NewRelic
       end
       @dispatcher_instance_id
     end
-
+    
+    # Interrogates some common ruby constants for useful information
+    # about what kind of ruby environment the agent is running in
     def gather_ruby_info
       append_environment_value('Ruby version'){ RUBY_VERSION }
       append_environment_value('Ruby description'){ RUBY_DESCRIPTION } if defined? ::RUBY_DESCRIPTION
@@ -83,40 +95,63 @@ module NewRelic
         gather_jruby_info
       end
     end
-
+    
+    # like gather_ruby_info but for the special case of JRuby
     def gather_jruby_info
       append_environment_value('JRuby version') { JRUBY_VERSION }
       append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
     end
 
-    # See what the number of cpus is, works only on linux.
-    def gather_cpu_info
-      return unless File.readable? '/proc/cpuinfo'
+    # See what the number of cpus is, works only on some linux variants
+    def gather_cpu_info(proc_file='/proc/cpuinfo')
+      return unless File.readable? proc_file
       @processors = append_environment_value('Processors') do
-        processors = File.readlines('/proc/cpuinfo').select { |line| line =~ /^processor\s*:/ }.size
-        raise "Cannot determine the number of processors in /proc/cpuinfo" unless processors > 0
+        cpuinfo = ''
+        File.open(proc_file) do |f|
+          loop do
+            begin
+              cpuinfo << f.read_nonblock(4096).strip
+            rescue EOFError
+              break
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+              cpuinfo = ''
+              break # don't select file handle, just give up
+            end
+          end
+        end
+        processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
+
+        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}")
+        end
         processors
       end
     end
-
+    
+    # Grabs the architecture string from either `uname -p` or the env
+    # variable PROCESSOR_ARCHITECTURE
     def gather_architecture_info
       append_environment_value('Arch') { `uname -p` } ||
         append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
     end
-
+    
+    # gathers OS info from either `uname -v`, `uname -s`, or the OS
+    # env variable
     def gather_os_info
       append_environment_value('OS version') { `uname -v` }
       append_environment_value('OS') { `uname -s` } ||
         append_environment_value('OS') { ENV['OS'] }
     end
-
+    
+    # Gathers the architecture and cpu info
     def gather_system_info
       gather_architecture_info
       gather_cpu_info
     end
-
+    
+    # Looks for a capistrano file indicating the current revision
     def gather_revision_info
-      # Look for a capistrano file indicating the current revision:
       rev_file = File.join(NewRelic::Control.instance.root, "REVISION")
       if File.readable?(rev_file) && File.size(rev_file) < 64
         append_environment_value('Revision') do
@@ -124,9 +159,11 @@ module NewRelic
         end
       end
     end
-
+    
+    # The name of the AR database adapter for the current environment and
+    # the current schema version
     def gather_ar_adapter_info
-      # The name of the database adapter for the current environment.
+      
       append_environment_value 'Database adapter' do
         if defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
             ActiveRecord::Base.respond_to?(:configurations)
@@ -136,18 +173,18 @@ module NewRelic
           end
         end
       end
-      append_environment_value 'Database schema version' do
-        ActiveRecord::Migrator.current_version
-      end
     end
-
+    
+    # Datamapper version
     def gather_dm_adapter_info
       append_environment_value 'DataMapper version' do
         require 'dm-core/version'
         DataMapper::VERSION
       end
     end
-
+    
+    # sensing for which adapter is defined, then appends the relevant
+    # config information
     def gather_db_info
       # room here for more database adapters, when.
       if defined? ::ActiveRecord
@@ -181,17 +218,23 @@ module NewRelic
       i << [ 'Gems', @gems.to_a] if not @gems.empty?
       i
     end
-
+    
+    # it's a working jruby if it has the runtime method, and object
+    # space is enabled
     def working_jruby?
       !(defined?(::JRuby) && JRuby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
     end
-
+    
+    # Runs through all the objects in ObjectSpace to find the first one that
+    # match the provided class
     def find_class_in_object_space(klass)
       ObjectSpace.each_object(klass) do |x|
         return x
       end
+      return nil
     end
-
+    
+    # Sets the @mongrel instance variable if we can find a Mongrel::HttpServer
     def mongrel
       return @mongrel if @mongrel
       if defined?(::Mongrel) && defined?(::Mongrel::HttpServer) && working_jruby?
@@ -199,22 +242,15 @@ module NewRelic
       end
       @mongrel
     end
-
-    def unicorn
-      return @unicorn if @unicorn
-      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
-        @unicorn = find_class_in_object_space(::Unicorn::HttpServer)
-      end
-      @unicorn
-    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 torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
+      @dispatcher ||= ENV['NEW_RELIC_DISPATCHER'] && ENV['NEW_RELIC_DISPATCHER'].to_sym
+      dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi rainbows unicorn sinatra]
       while dispatchers.any? && @dispatcher.nil?
         send 'check_for_'+(dispatchers.shift)
       end
@@ -228,6 +264,7 @@ module NewRelic
       # 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
@@ -307,11 +344,17 @@ module NewRelic
     end
 
     def check_for_unicorn
-      return unless defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        v = find_class_in_object_space(::Unicorn::HttpServer)
+        @dispatcher = :unicorn if v 
+      end
+    end
 
-      # 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
+    def check_for_rainbows
+      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && working_jruby?
+        v = find_class_in_object_space(::Rainbows::HttpServer)
+        @dispatcher = :rainbows if v
+      end
     end
 
     def check_for_sinatra
@@ -379,6 +422,7 @@ module NewRelic
     end
 
     public
+    # outputs a human-readable description
     def to_s
       s = "LocalEnvironment["
       s << @framework.to_s