newrelic_rpm 2.8.0

data/test/ui/tc_newrelic_helper.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper')) 
+require 'newrelic_helper'
+require 'new_relic/agent/model_fixture'
+
+class NewRelic::Agent::NewrelicHelperTests < Test::Unit::TestCase
+  include NewrelicHelper
+  def setup
+    super
+    NewRelic::Agent::ModelFixture.setup
+    begin
+      # setup instrumentation
+      NewRelic::Agent.instance.start :test, :test
+      NewRelic::Agent::ModelFixture.find 0
+    rescue => e
+      @exception = e
+      return
+    end
+    flunk "should throw"
+  end
+  def teardown
+    NewRelic::Agent::ModelFixture.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 
+  
+  private
+  def assert_clean(backtrace, rails=false)
+    if !rails
+      assert_equal 0, backtrace.grep('/rails/').size, backtrace.grep(/newrelic_rpm/)
+    end
+    assert_equal 0, backtrace.grep(/trace/).size, backtrace.grep(/trace/)
+    assert_equal 0, backtrace.grep(/newrelic_rpm\/lib/).size, backtrace.grep(/newrelic_rpm\/lib/)
+  end
+end

data/ui/controllers/newrelic_controller.rb

@@ -0,0 +1,200 @@
+##require 'new_relic/agent'
+require 'google_pie_chart'
+
+class NewrelicController < ActionController::Base
+  include 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 public_methods.include? 'append_view_path' # rails 2.1+
+    self.append_view_path view_path
+  elsif public_methods.include? "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 css
+    forward_to_file '/newrelic/stylesheets/', 'text/css'
+  end
+  
+  def image
+    forward_to_file '/newrelic/images/', params[:content_type]
+  end
+  
+  def javascript
+    forward_to_file '/newrelic/javascript/', 'text/javascript'
+  end
+  
+  
+  
+  def index
+    get_samples
+  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
+      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] || {}
+    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.get_samples.select do |sample|
+      sample.params[:path] != nil
+    end
+    
+    @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,55 @@
+
+# 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 * 100 / @max).round.to_s + ","
+    end
+
+    # strip of the last separator char for labels and values
+    labels = labels[0..-2]
+    values = values[0..-2]
+      
+    params = {:cht => 'p', :chs => "#{width}x#{height}", :chd => "t:#{values}", :chl => labels }
+    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

data/ui/helpers/newrelic_helper.rb

@@ -0,0 +1,286 @@
+require 'pathname'
+require 'new_relic/agent/collection_helper'
+module NewrelicHelper
+  include NewRelic::Agent::CollectionHelper
+  # return the host that serves static content (css, metric documentation, images, etc)
+  # that supports the desktop edition.
+  def server
+    NewRelic::Agent.instance.config['desktop_server'] || "http://rpm.newrelic.com"
+  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)
+    if session[:newrelic_strip_code_loading] || true
+      sample.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)')
+    else
+      sample
+    end
+  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)
+    trace.each do |trace_line|
+      file = file_and_line(trace_line).first
+      unless exclude_file_from_stack_trace?(file, false)
+        return trace_line
+      end
+    end
+    trace.last
+  end
+  
+  def application_stack_trace(trace, include_rails = false)
+    trace = strip_nr_from_backtrace(trace)
+    trace.reject do |trace_line|
+      file = file_and_line(trace_line).first
+      exclude_file_from_stack_trace?(file, include_rails)
+    end
+  end
+  
+  def agent_views_path(path)
+    path
+  end
+  
+  def url_for_metric_doc(metric_name)
+    "#{server}/metric_doc?metric=#{CGI::escape(metric_name)}"
+  end
+  
+  def url_for_source(trace_line)
+    file, line = file_and_line(trace_line)
+    
+    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
+      url_for :action => 'show_source', :file => file, :line => line, :anchor => 'selected_line'
+    end
+  end
+  
+  
+  def dev_name(metric_name)
+    @@metric_parser_available ||= defined? MetricParser
+    
+    (@@metric_parser_available) ? MetricParser.parse(metric_name).developer_name : metric_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 h(trace_line), url_for_source(trace_line)
+  end
+
+  # write a link to the source for a trace
+  def link_to_source(trace)
+    image_url = "#{server}/images/"
+    image_url << (using_textmate? ? "textmate.png" : "file_icon.png")
+    
+    link_to image_tag(image_url, :alt => (title = 'View Source'), :title => title), 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)
+    if value > yellow_threshold
+      color = (value > red_threshold ? 'red' : 'orange')
+      "<font color=#{color}>#{value.to_ms}</font>"
+    else
+      "#{value.to_ms}"
+    end
+  end
+  
+  def expanded_image_path()
+    url_for(:controller => :newrelic, :action => :image, :file => 'arrow-open.png')
+  end
+  
+  def collapsed_image_path()
+    url_for(:controller => :newrelic, :action => :image, :file => 'arrow-close.png')
+  end
+  
+  def explain_sql_url(segment)
+    url_for(:action => :explain_sql, 
+      :id => @sample.sample_id, 
+      :segment => segment.segment_id)
+  end
+  
+  def segment_duration_value(segment)
+    link_to "#{segment.duration.to_ms.with_delimiter} 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) + render_indentation_classes(@indentation_depth)
+  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(tag('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), s.exclusive_time.to_ms }
+    
+    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.starts_with?('View')
+    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)
+  end
+  
+  def explain_sql_links(segment)
+    if segment[:sql_obfuscated] || segment[:sql]
+      explain_sql_link segment
+    else
+      links = []
+      segment.called_segments.each do |child|
+        if child[:sql_obfuscated] || child[:sql]
+          links << explain_sql_link(child, true)
+        end
+      end
+      links[0..1].join(', ') + (links.length > 2?', ...':'')
+    end
+  end
+  
+private
+  def file_and_line(stack_trace_line)
+    stack_trace_line.match(/(.*):(\d+)/)[1..2]
+  end
+  
+  def using_textmate?
+    # For now, disable textmate integration
+    false
+  end
+  
+
+  def render_segment_details(segment, depth=0)
+    
+    @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 => agent_views_path('segment'), :object => segment, :locals => {:indent => depth, :repeat => 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)
+    !include_rails && (
+      file =~ /\/active(_)*record\// ||
+      file =~ /\/action(_)*controller\// ||
+      file =~ /\/activesupport\// ||
+      file =~ /\/lib\/mongrel/ ||
+      file =~ /\/actionpack\// ||
+      file =~ /\/passenger\// ||
+      file =~ /\/benchmark.rb/ ||
+      file !~ /\.rb/)                  # must be a .rb file, otherwise it's a script of something else...we could have gotten trickier and tried to see if this file exists...
+  end
+  
+  def show_view_link(title, page_name)
+    link_to_function("[#{title}]", "show_view('#{page_name}')");
+  end
+  def mime_type_from_extension(extension)
+    extension = extension[/[^.]*$/].downcase
+    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
+end