genki-newrelic_rpm 2.10.1

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

@@ -0,0 +1,22 @@
+class NewRelic::Control::Merb < NewRelic::Control
+  
+  def env
+    @env ||= ::Merb.env
+  end
+  def root 
+    ::Merb.root
+  end
+  
+  def to_stdout(msg)
+    STDOUT.puts "NewRelic ~ " + msg 
+  end
+  
+  def init_config options={}
+    ::Merb::Plugins.add_rakefiles File.join(newrelic_root,"lib/tasks/all.rb")
+    
+    # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+    ::Merb::Plugins.config[:newrelic] = {
+      :config => self
+    }
+  end
+end

data/lib/new_relic/control/rails.rb

@@ -0,0 +1,143 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values, 
+# etc.
+class NewRelic::Control::Rails < NewRelic::Control
+  
+  def env
+    @env ||= RAILS_ENV.dup
+  end
+  def root
+    RAILS_ROOT
+  end
+  
+  def log_path
+    path = ::RAILS_DEFAULT_LOGGER.instance_eval do
+      File.dirname(@log.path) rescue File.dirname(@logdev.filename) 
+    end rescue "#{root}/log"
+    File.expand_path(path)
+  end
+  # In versions of Rails prior to 2.0, the rails config was only available to 
+  # the init.rb, so it had to be passed on from there.  
+  def init_config(options={})
+    rails_config=options[:config]
+    if !agent_enabled?
+      RAILS_DEFAULT_LOGGER.info "New Relic Agent not running"
+    else
+      RAILS_DEFAULT_LOGGER.info "Starting the New Relic Agent"
+      install_developer_mode rails_config if developer_mode?
+    end
+  end
+  
+  def install_developer_mode(rails_config)
+    return if @installed
+    @installed = true
+    controller_path = File.expand_path(File.join(newrelic_root, 'ui', 'controllers'))
+    helper_path = File.expand_path(File.join(newrelic_root, 'ui', 'helpers'))
+    
+    if defined? ActiveSupport::Dependencies
+      Dir["#{helper_path}/*.rb"].each { |f| require f }
+      Dir["#{controller_path}/*.rb"].each { |f| require f }
+    elsif defined? Dependencies.load_paths
+      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."
+      return
+    end
+    install_devmode_route
+    
+    # If we have the config object then add the controller path to the list.
+    # Otherwise we have to assume the controller paths have already been
+    # set and we can just append newrelic.
+    
+    if rails_config
+      rails_config.controller_paths << controller_path
+    else
+      current_paths = ActionController::Routing.controller_paths
+      if current_paths.nil? || current_paths.empty?
+        to_stdout "WARNING: Unable to modify the routes in this version of Rails.  Developer mode not available."
+      end
+      current_paths << controller_path
+    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
+    # a webserver process
+    if @local_env.dispatcher_instance_id
+      port = @local_env.dispatcher_instance_id.to_s =~ /^\d+/ ? ":#{local_env.dispatcher_instance_id}" : ":port" 
+      to_stdout "NewRelic Agent Developer Mode enabled."
+      to_stdout "To view performance information, go to http://localhost#{port}/newrelic"
+    end
+  end
+  
+  def rails_version
+    @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
+  end
+  
+  protected 
+  
+  def install_devmode_route
+    # This is a monkey patch to inject the developer tool route into the
+    # parent app without requiring users to modify their routes. Of course this 
+    # has the effect of adding a route indiscriminately which is frowned upon by 
+    # some: http://www.ruby-forum.com/topic/126316#563328
+    ActionController::Routing::RouteSet.class_eval do
+      next if self.instance_methods.include? 'draw_with_newrelic_map'
+      def draw_with_newrelic_map
+        draw_without_newrelic_map do | map |
+          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
+      alias_method_chain :draw, :newrelic_map
+    end
+  end
+  
+  def rails_vendor_root
+    File.join(root,'vendor','rails')
+  end
+  
+  # Collect the Rails::Info into an associative array as well as the list of plugins
+  def append_environment_info
+    local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
+    if rails_version >= NewRelic::VersionNumber.new('2.2.0')
+      local_env.append_environment_value('Rails threadsafe') do
+        ::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 |
+          version = (gem.respond_to?(:version) && gem.version) ||
+           (gem.specification.respond_to?(:version) && gem.specification.version)
+          gem.name + (version ? "(#{version})" : "")
+        end
+      end
+      # The plugins is configured manually.  If it's nil, it loads everything non-deterministically
+      if ::Rails.configuration.plugins
+        local_env.append_plugin_list { ::Rails.configuration.plugins }
+      else
+        ::Rails.configuration.plugin_paths.each do |path|
+          local_env.append_plugin_list { Dir[File.join(path, '*')].collect{ |p| File.basename p if File.directory? p }.compact }
+        end
+      end
+    else
+      # Rails prior to 2.1, can't get the gems.  Find plugins in the default location
+      local_env.append_plugin_list do
+        Dir[File.join(root, 'vendor', 'plugins', '*')].collect{ |p| File.basename p if File.directory? p }.compact
+      end
+    end
+  end
+  
+  def install_shim
+    super
+    require 'new_relic/agent/instrumentation/controller_instrumentation'
+    ActionController::Base.send :include, NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+  end
+  
+end

data/lib/new_relic/control/ruby.rb

@@ -0,0 +1,34 @@
+# A control used when no framework is detected.
+# Looks for a newrelic.yml file in several locations
+# including ./, ./config, $HOME/.newrelic and $HOME/.
+# 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'
+  end
+  def root
+    @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")
+    files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
+    files.each do | file |
+      return File.expand_path(file) if File.exists? file
+    end
+    return File.expand_path(files.first)
+  end
+  def to_stdout(msg)
+    STDOUT.puts msg
+  end
+  
+  def init_config(options={})
+  end
+  
+end

data/lib/new_relic/control/sinatra.rb

@@ -0,0 +1,14 @@
+
+require 'new_relic/control/ruby'
+
+class NewRelic::Control::Sinatra < NewRelic::Control::Ruby
+  
+  # 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/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
+      @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

@@ -0,0 +1,285 @@
+require 'set'
+
+module NewRelic 
+  # An instance of LocalEnvironment is responsible for determining
+  # three things: 
+  #
+  # * 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
+  #
+  # 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, 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
+      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
+      append_environment_value('Application root') { File.expand_path(NewRelic::Control.instance.root) }
+      append_environment_value('Ruby version'){ RUBY_VERSION }
+      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
+      return @mongrel if @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::HttpServer 
+      ObjectSpace.each_object(Unicorn::HttpServer) do |unicorn|
+        @unicorn = unicorn
+      end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
+      @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 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.
+      @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 defined? Sinatra::Base then :sinatra      
+        when defined? NewRelic::IA then :external
+      else :ruby
+      end      
+    end
+
+    def check_for_glassfish
+      return unless defined?(::Java) &&
+         (((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)))
+      @dispatcher = :glassfish
+    end
+
+    def check_for_webrick
+      return unless 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::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::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::Base)
+      @dispatcher = :sinatra
+    end
+    
+    def check_for_thin
+      if 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::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::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