factorylabs-newrelic_rpm 2.10.2.2

data/test/new_relic/version_number_test.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::VersionNumberTest < Test::Unit::TestCase
+  
+  def test_comparison__first
+    versions = %w[1.0.0 0.1.0 0.0.1 10.0.1 1.10.0].map {|s| NewRelic::VersionNumber.new s }
+    assert_equal %w[0.0.1 0.1.0 1.0.0 1.10.0 10.0.1], versions.sort.map(&:to_s)
+    v0 = NewRelic::VersionNumber.new '1.2.3'
+    v1 = NewRelic::VersionNumber.new '1.2.2'
+    v3 = NewRelic::VersionNumber.new '1.2.2'
+    assert v0 > v1
+    assert v1 == v1
+    assert v1 == v3
+  end
+  def test_comparison__second
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < v1
+    assert v1 > v3
+    assert v3 < v0
+  end
+  def test_bug
+    v0 = NewRelic::VersionNumber.new '2.8.999'
+    v1 = NewRelic::VersionNumber.new '2.9.10'
+    assert v1 > v0
+    assert v0 <= v1
+  end
+  def test_long_version
+    v0 = NewRelic::VersionNumber.new '1.2.3.4'
+    v1 = NewRelic::VersionNumber.new '1.2.3.3'
+    v3 = NewRelic::VersionNumber.new '1.3'
+    assert v0 > v1
+    assert v0 < '1.2.3.5'
+    assert ! (v0 < '1.2.3.4')
+    assert v3 > v0
+  end
+  def test_sort
+    values = %w[1.1.1 
+                1.1.99 
+                1.1.999 
+                2.0.6 
+                2.6.5 
+                2.7 
+                2.7.1 
+                2.7.2 
+                2.7.2.0
+                3
+                999]
+    assert_equal values, values.map{|v| NewRelic::VersionNumber.new v}.sort.map(&:to_s)
+  end
+  def test_compare_string
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < '2.2.2'
+    assert v1 > '1.1.2'
+    assert v3 < '1.2.0'
+    assert v0 == '1.2.0'
+  end
+  def test_4_numbers
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '1.2.0.1'
+    v2 = NewRelic::VersionNumber.new '1.2.1.0'
+    v3 = NewRelic::VersionNumber.new '1.2.1.1'
+    assert v0 < v1
+    assert v1 < v2
+    assert v2 < v3
+    assert v0 < v3
+    assert v0 < '1.2.0.1'
+    assert v0 > '1.1.0.1'
+  end
+  def test_string
+    assert_equal '1.2.0', NewRelic::VersionNumber.new('1.2.0').to_s
+    assert_equal '1.2', NewRelic::VersionNumber.new('1.2').to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,53 @@
+module NewRelic; TEST = true; end unless defined? NewRelic::TEST
+#ENV['NEWRELIC_ENABLE'] = 'true'
+ENV['RAILS_ENV'] = 'test'
+NEWRELIC_PLUGIN_DIR = File.expand_path(File.join(File.dirname(__FILE__),".."))
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"test")
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"ui/helpers")
+$LOAD_PATH.uniq!
+
+require File.expand_path(File.join(NEWRELIC_PLUGIN_DIR, "..","..","..","config","environment"))
+
+require 'test_help'
+require 'mocha'
+require 'test/unit'
+
+def assert_between(floor, ceiling, value, message = nil)
+  assert floor <= value && value <= ceiling,
+  message || "expected #{floor} <= #{value} <= #{ceiling}"
+end
+
+def compare_metrics expected_list, actual_list
+  actual = Set.new actual_list
+  actual.delete('GC/cumulative') # in case we are in REE
+  expected = Set.new expected_list
+  assert_equal expected.to_a.sort, actual.to_a.sort, "extra: #{(actual - expected).to_a.join(", ")}; missing: #{(expected - actual).to_a.join(", ")}"
+end
+=begin Enable this to see test names as they run
+Test::Unit::TestCase.class_eval do
+  def run_with_info *args, &block
+    puts "#{self.class.name.underscore}/#{@method_name}"
+    run_without_info *args, &block
+  end
+  alias_method_chain :run, :info
+end
+=end
+module TransactionSampleTestHelper
+  def make_sql_transaction(*sql)
+    sampler = NewRelic::Agent::TransactionSampler.new
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction '/path', nil, :jim => "cool"
+    sampler.notice_push_scope "a"
+    
+    sampler.notice_transaction '/path/2', nil, :jim => "cool"
+    
+    sql.each {|sql_statement| sampler.notice_sql(sql_statement, {:adapter => "test"}, 0 ) }
+    
+    sleep 1.0
+    yield if block_given?
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty
+    
+    sampler.samples[0]
+  end
+end

data/test/ui/newrelic_controller_test.rb

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

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

@@ -0,0 +1,220 @@
+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=params[:file].to_s
+    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

data/ui/helpers/google_pie_chart.rb

@@ -0,0 +1,49 @@
+
+# A wrapper around the google charts service.
+# TODO consider making generic and open sourcing
+class GooglePieChart
+  attr_accessor :width, :height, :color
+
+  def initialize
+    # an array of [label, value]
+    @data = []
+    self.width = 300
+    self.height = 200
+  end
+
+  def add_data_point(label, value)
+    @data << [label, value]
+    @max = (@max.nil? || @max < value ? value : @max)
+  end
+
+  # render the chart to html by creating an image object and
+  # placing the correct URL to the google charts api
+  def render
+    labels = []
+    values = []
+    @data.each do |label, value|
+      labels << CGI::escape(label)
+      values << (value > 0 ? value * 100 / @max : value).round.to_s
+    end
+    params = {:cht => 'p', :chs => "#{width}x#{height}", :chd => "t:#{values.join(',')}", :chl => labels.join('|') }
+    params['chco'] = color if color
+    
+    url = "http://chart.apis.google.com/chart?#{to_query(params)}"
+
+    alt_msg = "This pie chart is generated by Google Charts. You must be connected to the Internet to view this chart."
+    html = "<img id=\"pie_chart_image\" src=\"#{url}\" alt=\"#{alt_msg}\"/>"
+    return html       
+  end
+  
+private
+  # Hash#to_query is not present in all supported rails platforms, so implement
+  # its equivalent here.
+  def to_query(params)
+    p = []
+    params.each do |k,v|
+      p << "#{k}=#{v}"
+    end
+    
+    p.join "&"
+  end
+end