sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/language_support.rb

@@ -0,0 +1,92 @@
+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
+
+  @@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)
+      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/latest_changes.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+
+module NewRelic
+  module LatestChanges
+    def self.default_changelog
+      File.join(File.dirname(__FILE__), '..', '..', 'CHANGELOG')
+    end
+
+    def self.read(changelog=default_changelog)
+      footer = <<'EOS'
+See https://github.com/newrelic/rpm/blob/master/CHANGELOG for a full list of
+changes.
+EOS
+
+      return footer unless File.exists?(changelog) 
+
+      version_count = 0
+      changes = []
+      File.read(changelog).each_line do |line|
+        if line.match(/##\s+v[\d.]+\s+##/)
+          version_count += 1
+        end
+        break if version_count >= 2
+        changes << line.chomp
+      end
+
+      changes << footer
+      change_message =  changes.join("\n")
+    end
+  end
+end

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,385 @@
+require 'set'
+require 'new_relic/version'
+
+module NewRelic
+  # An instance of LocalEnvironment is responsible for determining
+  # three things:
+  #
+  # * 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
+    # mongrel, thin, webrick, or possibly nil
+    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
+    # The number of cpus, if detected, or nil - many platforms do not
+    # support this :(
+    attr_reader :processors
+
+    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_dispatcher
+      @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 => e
+      Agent.logger.error e
+    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 => e
+      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 => 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 @discovered_dispatcher.nil?
+          @dispatcher_instance_id = File.basename($0).split(".").first
+        end
+      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
+      append_environment_value('Ruby platform') { RUBY_PLATFORM }
+      append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
+      # room here for other ruby implementations, when.
+      if defined? ::JRUBY_VERSION
+        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 some linux variants
+    def gather_cpu_info(proc_file='/proc/cpuinfo')
+      return unless File.readable? proc_file
+      @processors = append_environment_value('Processors') do
+        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
+      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
+    end
+
+    # The name of the AR database adapter for the current environment and
+    # the current schema version
+    def gather_ar_adapter_info
+      append_environment_value 'Database adapter' do
+        if defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.respond_to?(:configurations)
+          config = ActiveRecord::Base.configurations[NewRelic::Control.instance.env]
+          if config
+            config['adapter']
+          end
+        end
+      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
+        gather_ar_adapter_info
+      end
+      if defined? ::DataMapper
+        gather_dm_adapter_info
+      end
+    end
+
+    # Collect base statistics about the environment and record them for
+    # comparison and change detection.
+    def gather_environment_info
+      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 }
+
+      # miscellaneous other helpful debugging information
+      gather_ruby_info
+      gather_system_info
+      gather_revision_info
+      gather_db_info
+    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
+
+    # 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?
+        @mongrel = find_class_in_object_space(::Mongrel::HttpServer)
+      end
+      @mongrel
+    end
+
+    private
+
+    # Although you can override the dispatcher with NEWRELIC_DISPATCHER this
+    # is not advisable since it implies certain api's being available.
+    def discover_dispatcher
+      dispatchers = %w[passenger torquebox trinidad glassfish resque thin mongrel litespeed webrick fastcgi unicorn]
+      while dispatchers.any? && @discovered_dispatcher.nil?
+        send 'check_for_'+(dispatchers.shift)
+      end
+    end
+
+    def check_for_torquebox
+      return unless defined?(::JRuby) &&
+         ( org.torquebox::TorqueBox rescue nil)
+      @discovered_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)) ||
+         (jruby_rack? && defined?(::GlassFish::Server)))
+      @discovered_dispatcher = :glassfish
+    end
+
+    def check_for_trinidad
+      return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+      @discovered_dispatcher = :trinidad
+    end
+
+    def jruby_rack?
+      ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+       defined?(org::jruby::rack::DefaultRackApplicationFactory))
+    end
+
+    def check_for_webrick
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      @discovered_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)
+      @discovered_dispatcher = :fastcgi
+    end
+
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+      @discovered_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
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        v = find_class_in_object_space(::Unicorn::HttpServer)
+        @discovered_dispatcher = :unicorn if v 
+      end
+    end
+
+    def check_for_resque
+      using_resque = (
+        defined?(::Resque) &&
+        (ENV['QUEUE'] || ENV['QUEUES']) &&
+        (File.basename($0) == 'rake' && ARGV.include?('resque:work'))
+      )
+      @discovered_dispatcher = :resque if using_resque
+    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|
+          @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.
+          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) && !@discovered_dispatcher
+        @discovered_dispatcher = :thin
+        @dispatcher_instance_id = default_port
+      end
+    end
+
+    def check_for_litespeed
+      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+        @discovered_dispatcher = :litespeed
+      end
+    end
+
+    def check_for_passenger
+      if defined?(::PhusionPassenger)
+        @discovered_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
+    # outputs a human-readable description
+    def to_s
+      s = "LocalEnvironment["
+      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
+      s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
+      s << "]"
+    end
+
+  end
+end