newrelic_rpm 2.12.3 → 2.13.0.beta3

data/lib/new_relic/commands/new_relic_commands.rb

@@ -1,30 +0,0 @@
-require 'optparse'
-
-# Run the command given by the first argument.  Right
-# now all we have is deployments. We hope to have other
-# kinds of events here later.
-
-libdir = File.expand_path(File.join(File.dirname(__FILE__), '..','..'))
-command_list = Dir[File.join(libdir,'new_relic','commands','*.rb')].map{|command| command =~ /.*\/(.*)\.rb/ && $1}
-command_list.delete 'new_relic_commands'
-extra = []
-options = ARGV.options do |opts|
-  script_name = File.basename($0)
-  opts.banner = "Usage: #{__FILE__} #{ command_list.join(" | ")} [options]"
-  opts.separator "use -h to see detailed command options"
-  opts
-end
-extra = options.order!
-command = extra.shift
-if !command_list.include?(command)
-  STDERR.puts options
-else
-  require File.join(libdir, 'new_relic','commands', command + ".rb")
-  command_class = NewRelic::Commands.const_get(command.capitalize) 
-  begin
-    command_class.new(extra).run
-  rescue NewRelic::Commands::CommandFailure => failure
-    STDERR.puts failure.message
-    exit failure.exit_code
-  end
-end

data/lib/new_relic/control/rails.rb

@@ -1,151 +0,0 @@
-# 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 = super || ::RAILS_DEFAULT_LOGGER.instance_eval do
-      File.dirname(@log.path) rescue File.dirname(@logdev.filename) 
-    end rescue File.join(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?
-      # Might not be running if it does not think mongrel, thin, passenger, etc
-      # is running, if it things it's a rake task, or if the agent_enabled is false.
-      ::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
-    
-    def to_stdout(message)
-      ::RAILS_DEFAULT_LOGGER.info(message)
-    rescue Exception => e
-      STDOUT.puts(message)
-    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/test/new_relic/agent/mock_ar_connection.rb

@@ -1,40 +0,0 @@
-module ActiveRecord
-  class Base
-    class << self
-      def test_connection(config)
-        @connect ||= Connection.new
-      end
-    end
-  end
-  
-  class Connection
-    attr_accessor :throw
-    attr_reader :disconnected
-    
-    def initialize
-      @disconnected = false
-      @throw = false
-    end
-    
-    def disconnect!()
-      @disconnected = true
-    end
-    
-    def find()
-      # used to test that we've instrumented this...
-    end
-
-    def select_rows(s)
-      execute(s)
-    end
-    def execute(s)
-      fail "" if @throw
-      if s != "EXPLAIN #{::SQL_STATEMENT}"
-        fail "Unexpected sql statement #{s}"        
-      end
-      s
-    end
-  end
-end
-
-

data/test/ui/newrelic_controller_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper')) 
-require 'newrelic_helper'
-require 'active_record_fixtures'
-
-class NewRelic::Agent::NewrelicControllerTest < Test::Unit::TestCase
-
-  # Clearly we need a functional test for the controller.  For now
-  # I want to at least make sure the class loads in all versions of rails.
-  def test_controller_loading
-    NewrelicController
-  rescue
-    fail "Controller would not load:#{$!}"
-  end
-end

data/test/ui/newrelic_helper_test.rb

@@ -1,53 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper')) 
-require 'newrelic_helper'
-require 'active_record_fixtures'
-
-class NewRelic::Agent::NewrelicHelperTest < Test::Unit::TestCase
-  include NewrelicHelper
-  
-  def params
-    {}
-  end
-  
-  def setup
-    super
-    ActiveRecordFixtures.setup
-    # setup instrumentation
-    NewRelic::Agent.manual_start 
-    # let's get a real stack trace
-    begin
-      ActiveRecordFixtures::Order.find 0
-    rescue => e
-      @exception = e
-      return
-    end
-    flunk "should throw"
-  end
-  def teardown
-    ActiveRecordFixtures.teardown
-    NewRelic::Agent.instance.shutdown
-    super
-  end
-  def test_application_caller
-    assert_match /setup/, application_caller(@exception.backtrace)
-  end
-  
-  def test_application_stack_trace__rails
-    assert_clean(application_stack_trace(@exception.backtrace, true), true)
-  end
-  def test_application_stack_trace__no_rails
-    assert_clean(application_stack_trace(@exception.backtrace, false), false)
-  end 
-  def test_with_delimiter
-    assert_equal "123,456.123456", with_delimiter(123456.123456)
-  end
-  
-  private
-  def assert_clean(backtrace, rails=false)
-    if !rails
-      assert_equal 0, backtrace.grep('/rails/').size, backtrace.join("\n")
-    end
-    assert_equal 0, backtrace.grep(/trace/).size, backtrace.join("\n")
-    assert_equal 0, backtrace.grep(/newrelic_rpm\/agent/).size, backtrace.join("\n")
-  end
-end

data/ui/controllers/newrelic_controller.rb

@@ -1,220 +0,0 @@
-class NewrelicController < ActionController::Base
-  include NewrelicHelper
-  helper NewrelicHelper
-  
-  # See http://wiki.rubyonrails.org/rails/pages/Safe+ERB:
-  # We don't need to worry about checking taintedness
-  def initialize(*args)
-    @skip_checking_tainted = true
-    super *args
-  end
-  
-  # do not include any filters inside the application since there might be a conflict
-  if respond_to? :filter_chain
-    filters = filter_chain.collect do |f|
-      if f.respond_to? :filter
-        # rails 2.0
-        f.filter
-      elsif f.respond_to? :method
-        # rails 2.1
-        f.method
-      else
-        fail "Unknown filter class. Please send this exception to support@newrelic.com"
-      end
-    end
-    skip_filter filters
-  end
-  
-  # for this controller, the views are located in a different directory from
-  # the application's views.
-  view_path = File.join(File.dirname(__FILE__), '..', 'views')
-  if respond_to? :append_view_path # rails 2.1+
-    self.append_view_path view_path
-  elsif respond_to? :view_paths   # rails 2.0+
-    self.view_paths << view_path
-  else                                      # rails <2.0
-    self.template_root = view_path
-  end
-  
-  layout "newrelic_default"
-  
-  write_inheritable_attribute('do_not_trace', true)
-  
-  def profile
-    NewRelic::Control.instance.profiling = params['start'] == 'true'
-    get_samples
-    redirect_to :action => 'index'
-  end
-  
-  def file
-    file_name=Array(params[:file]).join
-    file_name=~/^.*[.]([^.]*)$/
-    ext=$1
-    case ext
-      when 'css' then
-        forward_to_file '/newrelic/stylesheets/', 'text/css'
-      when 'gif','jpg','png' then
-        forward_to_file '/newrelic/images/', "image/#{ext}"
-      when 'js' then
-        forward_to_file '/newrelic/javascript/', 'text/javascript'
-      else
-        raise "Unknown type '#{ext}' (#{file_name})"
-    end
-  end
-
-  def index
-    get_samples
-  end
-  
-  def threads
-    
-  end
-  
-  def reset
-    NewRelic::Agent.instance.transaction_sampler.reset!
-    redirect_to :action => 'index'
-  end
-
-  def show_sample_detail
-    show_sample_data
-  end
-  
-  def show_sample_summary
-    show_sample_data
-  end
-  
-  def show_sample_sql
-    show_sample_data
-  end
-  
-  
-  def explain_sql
-    get_segment
-    
-    render :action => "sample_not_found" and return unless @sample 
-    
-    @sql = @segment[:sql]
-    @trace = @segment[:backtrace]
-    
-    if NewRelic::Agent.agent.record_sql == :obfuscated  
-      @obfuscated_sql = @segment.obfuscated_sql
-    end
-    
-    explanations = @segment.explain_sql
-    if explanations
-      @explanation = explanations.first 
-      if !@explanation.blank?
-        first_row = @explanation.first
-        # Show the standard headers if it looks like a mysql explain plan
-        # Otherwise show blank headers
-        if first_row.length < NewRelic::MYSQL_EXPLAIN_COLUMNS.length
-          @row_headers = nil
-        else
-          @row_headers = NewRelic::MYSQL_EXPLAIN_COLUMNS
-        end
-      end
-    end
-  end
-  
-  # show the selected source file with the highlighted selected line
-  def show_source
-    @filename = params[:file]
-    line_number = params[:line].to_i
-    
-    if !File.readable?(@filename)
-      @source="<p>Unable to read #{@filename}.</p>"
-      return
-    end
-    begin
-      file = File.new(@filename, 'r')
-    rescue => e
-      @source="<p>Unable to access the source file #{@filename} (#{e.message}).</p>"
-      return
-    end
-    @source = ""
-    
-    @source << "<pre>"
-    file.each_line do |line|
-      # place an anchor 6 lines above the selected line (if the line # < 6)
-      if file.lineno == line_number - 6
-        @source << "</pre><pre id = 'selected_line'>"
-        @source << line.rstrip
-        @source << "</pre><pre>"
-        
-        # highlight the selected line
-      elsif file.lineno == line_number
-        @source << "</pre><pre class = 'selected_source_line'>"
-        @source << line.rstrip
-        @source << "</pre><pre>"
-      else
-        @source << line
-      end
-    end
-  end
-  
-  private 
-  
-  # root path is relative to plugin newrelic_rpm/ui/views directory.
-  def forward_to_file(root_path, content_type='ignored anyway')
-    file = File.expand_path(File.join(__FILE__,"../../views", root_path, params[:file]))
-    last_modified = File.mtime(file)
-    date_check = request.respond_to?(:headers) ? request.headers['if-modified-since'] : request.env['HTTP_IF_MODIFIED_SINCE']
-    if date_check && Time.parse(date_check) >= last_modified
-      expires_in 24.hours
-      head :not_modified, 
-      :last_modified => last_modified,
-      :type => 'text/plain'
-    else
-      response.headers['Last-Modified'] = last_modified.to_formatted_s(:rfc822)
-      expires_in 24.hours
-      send_file file, :content_type => mime_type_from_extension(file), :disposition => 'inline' #, :filename => File.basename(file)
-    end
-  end
-  
-  def show_sample_data
-    get_sample
-    
-    render :action => "sample_not_found" and return unless @sample 
-    
-    @request_params = @sample.params[:request_params] || {}
-    @custom_params = @sample.params[:custom_params] || {}
-
-    controller_metric = @sample.root_segment.called_segments.first.metric_name
-    
-    controller_segments = controller_metric.split('/')
-    @sample_controller_name = controller_segments[1..-2].join('/').camelize+"Controller"
-    @sample_action_name = controller_segments[-1].underscore
-    
-    render :action => :show_sample
-  end
-  
-  def get_samples
-    @samples = NewRelic::Agent.instance.transaction_sampler.samples.select do |sample|
-      sample.params[:path] != nil
-    end
-    
-    return @samples = @samples.sort{|x,y| y.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)').duration <=>
-        x.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)').duration} if params[:h]
-    return @samples = @samples.sort{|x,y| x.params[:uri] <=> y.params[:uri]} if params[:u]
-    @samples = @samples.reverse
-  end
-  
-  def get_sample
-    get_samples
-    sample_id = params[:id].to_i
-    @samples.each do |s|
-      if s.sample_id == sample_id
-        @sample = stripped_sample(s)
-        return 
-      end
-    end
-  end
-  
-  def get_segment
-    get_sample
-    return unless @sample
-    
-    segment_id = params[:segment].to_i
-    @segment = @sample.find_segment(segment_id)
-  end
-end