honkster-newrelic_rpm 2.13.1

data/lib/new_relic/control/logging_methods.rb

@@ -0,0 +1,74 @@
+
+module NewRelic
+  class Control
+    module LoggingMethods
+
+      attr_accessor :log_file
+
+      def log
+        # If we try to get a log before one has been set up, return a stdout log
+        unless @log
+          l = Logger.new(STDOUT)
+          l.level = Logger::INFO
+          return l
+        end
+        @log
+      end
+
+      # send the given message to STDOUT so that it shows
+      # up in the console.  This should be used for important informational messages at boot.
+      # The to_stdout may be implemented differently by different config subclasses.
+      # This will NOT print anything if tracers are not enabled
+      def log!(msg, level=:info)
+        return unless should_log?
+        to_stdout msg
+        log.send level, msg if @log
+      end
+
+      def should_log?
+        @settings && agent_enabled?
+      end
+
+      # 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
+
+        # change the format just for our logger
+
+        def log.format_message(severity, timestamp, progname, msg)
+          "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+
+        # set the log level as specified in the config file
+
+        case fetch("log_level","info").downcase
+          when "debug" then log.level = Logger::DEBUG
+          when "info" then log.level = Logger::INFO
+          when "warn" then log.level = Logger::WARN
+          when "error" then log.level = Logger::ERROR
+          when "fatal" then log.level = Logger::FATAL
+        else log.level = Logger::INFO
+        end
+        log
+      end
+
+      def to_stdout(msg)
+        STDOUT.puts "** [NewRelic] " + msg
+      end
+
+      def log_path
+        return 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)
+        end
+        @log_path
+      end
+
+      def log_file_name
+        fetch('log_file_name', 'newrelic_agent.log')
+      end
+    end
+  end
+end

data/lib/new_relic/control/profiling.rb

@@ -0,0 +1,24 @@
+module NewRelic
+  class Control
+    module Profiling
+
+      # A flag used in dev mode to indicate if profiling is available
+      def profiling?
+        @profiling
+      end
+
+      def profiling_available?
+        @profiling_available ||=
+          begin
+            require 'ruby-prof'
+            true
+          rescue LoadError; end
+      end
+      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+      # loaded a true value is ignored.
+      def profiling=(val)
+        @profiling = profiling_available? && val && defined?(RubyProf)
+      end
+    end
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,88 @@
+module NewRelic
+  class Control
+
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+
+    module ServerMethods
+
+      def server
+        @remote_server ||= server_from_host(nil)
+      end
+
+      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
+      end
+
+      def proxy_server
+        @proxy_server ||=
+          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+      end
+
+      def server_from_host(hostname=nil)
+        host = hostname || self['host'] || 'collector.newrelic.com'
+
+        # 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)
+      end
+
+      # Look up the ip address of the host using the pure ruby lookup
+      # to prevent blocking.  If that fails, fall back to the regular
+      # IPSocket library.  Return nil if we can't find the host ip
+      # address and don't have a good default.
+      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 nil if host.nil? || host.downcase == "localhost"
+        # Fall back to known ip address in the common case
+        ip_address = '65.74.177.195' if host.downcase == 'collector.newrelic.com'
+        begin
+          ip_address = Resolv.getaddress(host)
+          log.info "Resolved #{host} to #{ip_address}"
+        rescue => e
+          log.warn "DNS Error caching IP address: #{e}"
+          log.debug e.backtrace.join("\n   ")
+          ip_address = IPSocket::getaddress host rescue ip_address
+        end
+        ip_address
+      end
+
+      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+      # Default is the collector but for api calls you need to pass api_server
+      #
+      # Experimental support for SSL verification:
+      # swap 'VERIFY_NONE' for 'VERIFY_PEER' line to try it out
+      # If verification fails, uncomment the 'http.ca_file' line
+      # and it will use the included certificate.
+      def http_connection(host = nil)
+        host ||= server
+        # Proxy returns regular HTTP if @proxy_host is nil (the default)
+        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?
+          http.use_ssl = true
+          if verify_certificate?
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+        http
+      end
+    end
+  end
+end
+

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,27 @@
+# This installs some code to manually start the agent when a delayed job worker starts.
+# It's not really instrumentation.  It's more like a hook from DJ to RPM so it gets
+# loaded at the time the RPM plugin initializes, which must be before the DJ worker
+# initializes.  Loaded from control.rb
+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}"
+    say "RPM Monitoring DJ worker #{dispatcher_instance_id}"
+    NewRelic::DelayedJobInjection.worker_name = worker_name
+    NewRelic::Agent.manual_start :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+  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,91 @@
+# 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.
+module NewRelic
+  class 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
+end

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,333 @@
+require 'set'
+require 'new_relic/version'
+
+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
+  #
+  # If the environment can't be determined, it will be set to
+  # nil and dispatcher_instance_id will have nil.
+  #
+  # 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
+    alias environment dispatcher
+
+    def initialize
+      # Extend self with any any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new framworks and dispatchers.
+      NewRelic::LocalEnvironment.constants.each do | const |
+        mod = NewRelic::LocalEnvironment.const_get const
+        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
+    end
+
+    # Add the given key/value pair to the app environment
+    # settings.  Must pass either a value or a block.  Block
+    # is called to get the value and any raised errors are
+    # silently ignored.
+    def append_environment_value name, value = nil
+      value = yield if block_given?
+      @config[name] = value if value
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def append_gem_list
+      @gems += yield
+    rescue Exception => e
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def append_plugin_list
+      @plugins += yield
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def dispatcher_instance_id
+      if @dispatcher_instance_id.nil?
+        if @dispatcher.nil?
+          @dispatcher_instance_id = File.basename($0).split(".").first
+        end
+      end
+      @dispatcher_instance_id
+    end
+
+    # 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 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
+      # This just creates a lot of keys
+      # 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
+        append_environment_value('JRuby version') { JRUBY_VERSION }
+        append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
+      end
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+      append_environment_value('OS') { ENV['OS'] }
+      append_environment_value('Arch') { `uname -p` } ||
+      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 = 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).
+      append_environment_value('Environment') { NewRelic::Control.instance.env }
+      # 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
+          File.open(rev_file) { | file | file.readline.strip }
+        end
+      end
+      # The name of the database adapter for the current environment.
+      if defined? ::ActiveRecord
+        append_environment_value 'Database adapter' do
+          ActiveRecord::Base.configurations[RAILS_ENV]['adapter']
+        end
+        append_environment_value 'Database schema version' do
+          ActiveRecord::Migrator.current_version
+        end
+      end
+      if defined? ::DataMapper
+        append_environment_value 'DataMapper version' do
+          require 'dm-core/version'
+          DataMapper::VERSION
+        end
+      end
+    end
+    # Take a snapshot of the environment information for this application
+    # Returns an associative array
+    def snapshot
+      i = @config.to_a
+      i << [ 'Plugin List', @plugins.to_a] if not @plugins.empty?
+      i << [ 'Gems', @gems.to_a] if not @gems.empty?
+      i
+    end
+
+    def mongrel
+      # 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
+      @mongrel
+    end
+
+    def unicorn
+      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
+      @unicorn
+    end
+
+    # Obsolete method for DelayedJob instrumentation support.  Now all DJ instrumentation
+    # is bundled in the newrelic_rpm gem and nobody should be invoking this method.
+    def delayed_worker=(worker)
+      $stderr.puts "WARNING: obsolete call to delayed_worker=(worker).  Please remove custom DJ instrumentation."
+    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]
+      while dispatchers.any? && @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 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) &&
+         ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil)
+      @dispatcher = :torquebox
+    end
+
+    def check_for_glassfish
+      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) &&
+          defined?(org::jruby::rack::DefaultRackApplicationFactory)) ||
+         defined?(::GlassFish::Server))
+      @dispatcher = :glassfish
+    end
+
+    def check_for_webrick
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      @dispatcher = :webrick
+      if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch)
+        # OPTIONS is set by script/server
+        @dispatcher_instance_id = OPTIONS.fetch(:port)
+      end
+      @dispatcher_instance_id = default_port unless @dispatcher_instance_id
+    end
+
+    def check_for_fastcgi
+      return unless defined?(::FCGI)
+      @dispatcher = :fastcgi
+    end
+
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+      @dispatcher = :mongrel
+
+      # Get the port from the server if it's started
+
+      if mongrel && mongrel.respond_to?(:port)
+        @dispatcher_instance_id = mongrel.port.to_s
+      end
+
+      # Get the port from the configurator if one was created
+      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
+
+      # Still can't find the port.  Let's look at ARGV to fall back
+      @dispatcher_instance_id = default_port if @dispatcher_instance_id.nil?
+    end
+
+    def check_for_unicorn
+      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) && 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|
+          @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.
+          if backend.respond_to? :port
+            @dispatcher_instance_id = backend.port
+          elsif backend.respond_to? :socket
+            @dispatcher_instance_id = backend.socket
+          else
+            raise "Unknown thin backend: #{backend}"
+          end
+        end # each thin instance
+      end
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
+        @dispatcher = :thin
+        @dispatcher_instance_id = default_port
+      end
+    end
+
+    def check_for_litespeed
+      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+        @dispatcher = :litespeed
+      end
+    end
+
+    def check_for_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
+      default_port = 3000
+      OptionParser.new do |opts|
+        opts.on("-p", "--port=port", String) { | p | default_port = p }
+        opts.parse(ARGV.clone) rescue nil
+      end
+      default_port
+    end
+
+    public
+    def to_s
+      s = "LocalEnvironment["
+      s << @framework.to_s
+      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
+      s << "]"
+    end
+
+  end
+end