dolores_rpm 3.2.0.2

data/test/new_relic/version_number_test.rb

@@ -0,0 +1,89 @@
+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_prerelease
+    v0 = NewRelic::VersionNumber.new '1.2.0.beta'
+    assert_equal [1,2,0,'beta'], v0.parts
+    assert v0 > '1.1.9.0'
+    assert v0 > '1.1.9.alpha'
+    assert v0 > '1.2.0.alpha'
+    assert v0 == '1.2.0.beta'
+    assert v0 < '1.2.1'
+    assert v0 < '1.2.0'
+    assert v0 < '1.2.0.c'
+    assert v0 < '1.2.0.0'
+
+  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_contexts.rb

@@ -0,0 +1,29 @@
+
+module TestContexts
+  def with_running_agent
+
+    context 'with running agent' do # this is needed for the nested setups
+
+      setup do
+        @log_data = StringIO.new
+        @log = Logger.new(@log_data)
+        NewRelic::Agent.manual_start :log => @log
+        @agent = NewRelic::Agent.instance
+        @agent.transaction_sampler.send :clear_builder
+        @agent.transaction_sampler.reset!
+        @agent.stats_engine.clear_stats
+      end
+
+      yield
+
+      def teardown
+        super
+        NewRelic::Agent.shutdown
+        @log_data.reset
+        NewRelic::Control.instance['dispatcher']=nil
+        NewRelic::Control.instance['dispatcher_instance_id']=nil
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,154 @@
+module NewRelic; TEST = true; end unless defined? NewRelic::TEST
+ENV['RAILS_ENV'] = 'test'
+NEWRELIC_PLUGIN_DIR = File.expand_path(File.join(File.dirname(__FILE__),".."))
+$LOAD_PATH << '.'
+$LOAD_PATH << '../../..'
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"test")
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"ui/helpers")
+$LOAD_PATH.uniq!
+
+require 'rubygems'
+# We can speed things up in tests that don't need to load rails.
+# You can also run the tests in a mode without rails.  Many tests
+# will be skipped.
+
+begin
+  require 'config/environment'
+  begin
+    require 'test_help'
+  rescue LoadError
+    # ignore load problems on test help - it doesn't exist in rails 3
+  end
+
+rescue LoadError
+  # To run the tests against a standalone agent build, you need to
+  # add a rails app to the load path.  It can be 2.* to 3.*.  It should
+  # referenc newrelic_rpm in the Gemfile with a :path option pointing 
+  # to this work directory.
+  guess = File.expand_path("../../../rpm", __FILE__)
+  if $LOAD_PATH.include? guess
+    puts "Unable to load Rails for New Relic tests.  See note in test_helper.rb"
+    raise
+  else
+    $LOAD_PATH << guess
+    retry
+  end
+end
+require 'newrelic_rpm'
+
+require 'test/unit'
+require 'shoulda'
+require 'test_contexts'
+require 'mocha'
+require 'mocha/integration/test_unit'
+require 'mocha/integration/test_unit/assertion_counter'
+
+class Test::Unit::TestCase
+  include Mocha::API
+
+  # we can delete this trick when we stop supporting rails2.0.x
+  if ENV['BRANCH'] != 'rails20'
+    # a hack because rails2.0.2 does not like double teardowns
+    def teardown
+      mocha_teardown
+    end
+  end
+end
+
+def assert_between(floor, ceiling, value, message="expected #{floor} <= #{value} <= #{ceiling}")
+  assert((floor <= value && value <= ceiling), message)
+end
+
+def check_metric_time(metric, value, delta)
+  time = NewRelic::Agent.get_stats(metric).total_call_time
+  assert_between((value - delta), (value + delta), time)
+end
+
+def check_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def check_unscoped_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats_unscoped(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def generate_unscoped_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats_no_scope(metric).call_count
+    sum
+  end
+end
+
+def generate_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats(metric).call_count
+    sum
+  end
+end
+
+def assert_does_not_call_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_equal first_metrics, last_metrics, "should not have changed these metrics"
+end
+
+def assert_calls_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+def assert_calls_unscoped_metrics(*metrics)
+  first_metrics = generate_unscoped_metric_counts(*metrics)
+  yield
+  last_metrics = generate_unscoped_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+
+def compare_metrics(expected, actual)
+  actual.delete_if {|a| a.include?('GC/cumulative') } # in case we are in REE
+  assert_equal(expected.to_a.sort, actual.to_a.sort, "extra: #{(actual - expected).to_a.inspect}; missing: #{(expected - actual).to_a.inspect}")
+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 0.02
+    yield if block_given?
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty
+
+    sampler.samples[0]
+  end
+
+  def run_sample_trace_on(sampler, path='/path')
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction path, path, {}
+    sampler.notice_push_scope "Controller/sandwiches/index"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
+    sampler.notice_push_scope "ab"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", nil, 0)
+    yield sampler if block_given?
+    sampler.notice_pop_scope "ab"
+    sampler.notice_push_scope "lew"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
+    sampler.notice_pop_scope "lew"
+    sampler.notice_pop_scope "Controller/sandwiches/index"
+    sampler.notice_scope_empty
+    sampler.samples[0]
+  end
+
+end

data/ui/helpers/developer_mode_helper.rb

@@ -0,0 +1,357 @@
+require 'pathname'
+require File.expand_path('../google_pie_chart', __FILE__)
+require 'new_relic/collection_helper'
+require 'new_relic/metric_parser/metric_parser'
+module NewRelic::DeveloperModeHelper
+  include NewRelic::CollectionHelper
+
+  private
+
+  # limit of how many detail/SQL rows we display - very large data sets (~10000+) crash browsers
+  def trace_row_display_limit
+    2000
+  end
+
+  def trace_row_display_limit_reached
+   (!@detail_segment_count.nil? && @detail_segment_count > trace_row_display_limit) || @sample.sql_segments.length > trace_row_display_limit
+  end
+
+  # return the sample but post processed to strip out segments that normally don't show
+  # up in production (after the first execution, at least) such as application code loading
+  def stripped_sample(sample = @sample)
+    sample.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)')
+  end
+
+  # return the highest level in the call stack for the trace that is not rails or
+  # newrelic agent code
+  def application_caller(trace)
+    trace = strip_nr_from_backtrace(trace) unless params[:show_nr]
+    trace.each do |trace_line|
+      file, line, gem = file_and_line(trace_line)
+      unless file && exclude_file_from_stack_trace?(file, false, gem)
+        return trace_line
+      end
+    end
+    trace.last
+  end
+
+  def application_stack_trace(trace, include_rails = false)
+    trace = strip_nr_from_backtrace(trace) unless params[:show_nr]
+    trace.reject do |trace_line|
+      file, line, gem = file_and_line(trace_line)
+      file && exclude_file_from_stack_trace?(file, include_rails, gem)
+    end
+  end
+
+  def render_backtrace
+    if @segment[:backtrace]
+      content_tag('h3', 'Application Stack Trace') +
+      render(:partial => 'stack_trace')
+    end
+  end
+
+  def h(text)
+    text
+  end
+
+  def agent_views_path(path)
+    path
+  end
+
+  def url_for_source(trace_line)
+    file, line = file_and_line(trace_line)
+    return "#" if file.nil?
+    begin
+      file = Pathname.new(file).realpath
+    rescue Errno::ENOENT
+      # we hit this exception when Pathame.realpath fails for some reason; attempt a link to
+      # the file without a real path.  It may also fail, only when the user clicks on this specific
+      # entry in the stack trace
+    rescue
+      # catch all other exceptions.  We're going to create an invalid link below, but that's okay.
+    end
+    if using_textmate?
+      "txmt://open?url=file://#{file}&line=#{line}"
+    else
+      "show_source?file=#{file}&line=#{line}&anchor=selected_line"
+    end
+  end
+
+  def dev_name(metric_name)
+    NewRelic::MetricParser::MetricParser.parse(metric_name).developer_name
+  end
+
+  # write the metric label for a segment metric in the detail view
+  def write_segment_label(segment)
+    if source_available && segment[:backtrace] && (source_url = url_for_source(application_caller(segment[:backtrace])))
+      link_to dev_name(segment.metric_name), source_url
+    else
+      dev_name(segment.metric_name)
+    end
+  end
+
+  def source_available
+    true
+  end
+
+  # write the metric label for a segment metric in the summary table of metrics
+  def write_summary_segment_label(segment)
+    dev_name(segment.metric_name)
+  end
+
+  def write_stack_trace_line(trace_line)
+    link_to trace_line, url_for_source(trace_line)
+  end
+
+  # write a link to the source for a trace
+  def link_to_source(trace)
+    image_url = 'file/images/' + (using_textmate? ? "textmate.png" : "file_icon.png")
+
+    link_to "<img src=#{image_url} alt=\"View Source\" title=\"View Source\"/>", url_for_source(application_caller(trace))
+  end
+
+  # print the formatted timestamp for a segment
+  def timestamp(segment)
+    sprintf("%1.3f", segment.entry_timestamp)
+  end
+
+  def format_timestamp(time)
+    time.strftime("%H:%M:%S")
+  end
+
+  def colorize(value, yellow_threshold = 0.05, red_threshold = 0.15, s=to_ms(value))
+    if value > yellow_threshold
+      color = (value > red_threshold ? 'red' : 'orange')
+      "<font color=#{color}>#{s}</font>"
+    else
+      "#{s}"
+    end
+  end
+
+  def expanded_image_path()
+    '/newrelic/file/images/arrow-open.png'
+  end
+
+  def collapsed_image_path()
+    '/newrelic/file/images/arrow-close.png'
+  end
+
+  def explain_sql_url(segment)
+    "explain_sql?id=#{@sample.sample_id}&amp;segment=#{segment.segment_id}"
+  end
+
+  def segment_duration_value(segment)
+    link_to colorize(segment.duration, 0.05, 0.15, "#{with_delimiter(to_ms(segment.duration))} ms"), explain_sql_url(segment)
+  end
+
+  def line_wrap_sql(sql)
+    sql.gsub(/\,/,', ').squeeze(' ') if sql
+  end
+
+  def render_sample_details(sample)
+    @indentation_depth=0
+    # skip past the root segments to the first child, which is always the controller
+    first_segment = sample.root_segment.called_segments.first
+
+    # render the segments, then the css classes to indent them
+    render_segment_details(first_segment).to_s + render_indentation_classes(@indentation_depth).to_s
+  end
+
+  # the rows logger plugin disables the sql tracing functionality of the NewRelic agent -
+  # notify the user about this
+  def rows_logger_present?
+    File.exist?(File.join(File.dirname(__FILE__), "../../../rows_logger/init.rb"))
+  end
+
+  def expand_segment_image(segment, depth)
+    if depth > 0
+      if !segment.called_segments.empty?
+        row_class =segment_child_row_class(segment)
+        link_to_function("<img src=\"#{collapsed_image_path}\" id=\"image_#{row_class}\" class_for_children=\"#{row_class}\" class=\"#{(!segment.called_segments.empty?) ? 'parent_segment_image' : 'child_segment_image'}\"", "toggle_row_class(this)")
+      end
+    end
+  end
+
+  def segment_child_row_class(segment)
+    "segment#{segment.segment_id}"
+  end
+
+  def summary_pie_chart(sample, width, height)
+    pie_chart = GooglePieChart.new
+    pie_chart.color, pie_chart.width, pie_chart.height = '6688AA', width, height
+
+    chart_data = sample.breakdown_data(6)
+    chart_data.each { |s| pie_chart.add_data_point dev_name(s.metric_name), to_ms(s.exclusive_time) }
+
+    pie_chart.render
+  end
+
+  def segment_row_classes(segment, depth)
+    classes = []
+
+    classes << "segment#{segment.parent_segment.segment_id}" if depth > 1
+
+    classes << "view_segment" if segment.metric_name.index('View') == 0
+    classes << "summary_segment" if segment.is_a?(NewRelic::TransactionSample::CompositeSegment)
+
+    classes.join(' ')
+  end
+
+  # render_segment_details should be called before calling this method
+  def render_indentation_classes(depth)
+    styles = []
+     (1..depth).each do |d|
+      styles <<  ".segment_indent_level#{d} { display: inline-block; margin-left: #{(d-1)*20}px }"
+    end
+    content_tag("style", styles.join(' '))
+  end
+
+  def sql_link_mouseover_options(segment)
+    { :onmouseover => "sql_mouse_over(#{segment.segment_id})", :onmouseout => "sql_mouse_out(#{segment.segment_id})"}
+  end
+
+  def explain_sql_link(segment, child_sql = false)
+    link_to 'SQL', explain_sql_url(segment)+ '"' + sql_link_mouseover_options(segment).map {|k,v| "#{k}=\"#{v}\""}.join(' ')+ 'fake=\"'
+  end
+
+  def explain_sql_links(segment)
+    if segment[:sql]
+      explain_sql_link segment
+    else
+      links = []
+      segment.called_segments.each do |child|
+        if child[:sql]
+          links << explain_sql_link(child, true)
+        end
+      end
+      links[0..1].join(', ') + (links.length > 2?', ...':'')
+    end
+  end
+
+  private
+  # return three objects, the file path, the line in the file, and the gem the file belongs to 
+  # if found
+  def file_and_line(stack_trace_line)
+    if stack_trace_line =~ /^(?:(\w+) \([\d.]*\) )?(.*):(\d+)/
+      return $2, $3, $1
+    else
+      return nil
+    end
+  end
+
+  def using_textmate?
+    NewRelic::Control.instance.use_textmate?
+  end
+
+
+  def render_segment_details(segment, depth=0)
+    @detail_segment_count ||= 0
+    @detail_segment_count += 1
+
+    return '' if @detail_segment_count > trace_row_display_limit
+
+    @indentation_depth = depth if depth > @indentation_depth
+    repeat = nil
+    if segment.is_a?(NewRelic::TransactionSample::CompositeSegment)
+      html = ''
+    else
+      repeat = segment.parent_segment.detail_segments.length if segment.parent_segment.is_a?(NewRelic::TransactionSample::CompositeSegment)
+      html = render(:partial => 'segment', :object => [segment, depth, repeat])
+      depth += 1
+    end
+
+    segment.called_segments.each do |child|
+      html << render_segment_details(child, depth)
+    end
+
+    html
+  end
+
+  def exclude_file_from_stack_trace?(file, include_rails, gem=nil)
+    return false if include_rails
+    return true if file !~ /\.(rb|java)/
+    return true if %w[rack activerecord activeresource activesupport actionpack railties].include? gem
+    %w[/actionmailer/
+             /activerecord
+             /activeresource
+             /activesupport
+             /lib/mongrel
+             /actionpack
+             /passenger/
+             /railties
+             benchmark.rb].each { |s| return true if file.include? s }
+     false
+  end
+
+  def show_view_link(title, page_name)
+    link_to_function("[#{title}]", "show_view('#{page_name}')");
+  end
+
+
+  def link_to(name, location)
+    location = "/newrelic/#{location}" unless /:\/\// =~ location
+    "<a href=\"#{location}\">#{name}</a>"
+  end
+
+  def link_to_if(predicate, text, location="")
+    if predicate
+      link_to(text, location)
+    else
+      text
+    end
+  end
+
+  def link_to_unless_current(text, hash)
+    unless params[hash.keys[0].to_s]
+      link_to(text,"?#{hash.keys[0]}=#{hash.values[0]}")
+    else
+      text
+    end
+  end
+
+  def cycle(even, odd)
+    @cycle ||= 'a'
+    if @cycle == 'a'
+      @cycle = 'b'
+      even
+    else
+      @cycle = 'a'
+      odd
+    end
+  end
+
+  def link_to_function(title, javascript)
+    "<a href=\"#\" onclick=\"#{javascript}; return false;\">#{title}</a>"
+  end
+
+  def mime_type_from_extension(extension)
+    extension = extension[/[^.]*$/].dncase
+    case extension
+      when 'png'; 'image/png'
+      when 'gif'; 'image/gif'
+      when 'jpg'; 'image/jpg'
+      when 'css'; 'text/css'
+      when 'js'; 'text/javascript'
+    else 'text/plain'
+    end
+  end
+  def to_ms(number)
+   (number*1000).round
+  end
+  def to_percentage(value)
+   (value * 100).round if value
+  end
+  def with_delimiter(val)
+    return '0' if val.nil?
+    parts = val.to_s.split('.')
+    parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+    parts.join '.'
+  end
+
+  def profile_table(profile)
+    out = StringIO.new
+    printer = RubyProf::GraphHtmlPrinter.new(profile)
+    printer.print(out, :min_percent=>0.5)
+    out.string[/<body>(.*)<\/body>/im, 0].gsub('<table>', '<table class=profile>')
+  end
+end

data/ui/helpers/google_pie_chart.rb

@@ -0,0 +1,48 @@
+
+# A wrapper around the google charts service.
+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