honkster-newrelic_rpm 2.13.1

data/lib/new_relic/metric_parser/external.rb

@@ -0,0 +1,50 @@
+class NewRelic::MetricParser::External < NewRelic::MetricParser
+
+  def all?
+    host == 'all' || host == 'allWeb' || host == 'allOther'
+  end
+  def hosts_all?
+    library == 'all'
+  end
+  def host
+    segments[1]
+  end
+  def library
+    segments[2]
+  end
+  def operation
+    segments[3] && segments[3..-1].join("/")
+  end
+  def legend_name
+    case
+    when all?
+      "External Services"
+    when hosts_all?
+      "All #{host} calls"
+    else
+      developer_name
+    end
+  end
+  def tooltip_name
+    case
+    when all?
+      "calls to external systems"
+    when hosts_all?
+      "calls to #{host}"
+    else
+      "calls to #{developer_name}"
+    end
+  end
+  def developer_name
+    case
+    when all?
+      'All External'
+    when hosts_all?
+      host
+    when operation
+      "#{library}[#{host}]: #{operation}"
+    else
+      "#{library}[#{host}]"
+    end
+  end
+end

data/lib/new_relic/metric_parser/mem_cache.rb

@@ -0,0 +1,50 @@
+class NewRelic::MetricParser::MemCache < NewRelic::MetricParser
+  def is_memcache?; true; end
+
+  # for MemCache metrics, the short name is actually
+  # the full name
+  def short_name
+    name
+  end
+  def developer_name
+    "MemCache #{segments[1..-1].join '/'}"
+  end
+
+  def all?
+    segments[1].index('all') == 0
+  end
+  def operation
+    all? ? 'All Operations' : segments[1]
+  end
+  def legend_name
+    case segments[1]
+    when 'allWeb'
+      "MemCache"
+    when 'allOther'
+      "Non-web MemCache"
+    else
+      "MemCache #{operation} operations"
+    end
+  end
+  def tooltip_name
+    case segments[1]
+    when 'allWeb'
+      "MemCache calls from web transactions"
+    when 'allOther'
+      "MemCache calls from non-web transactions"
+    else
+      "MemCache #{operation} operations"
+    end
+
+  end
+  def developer_name
+    case segments[1]
+    when 'allWeb'
+      "Web MemCache"
+    when 'allOther'
+      "Non-web MemCache"
+    else
+      "MemCache #{operation}"
+    end
+  end
+end

data/lib/new_relic/metric_parser/other_transaction.rb

@@ -0,0 +1,36 @@
+# OtherTransaction metrics must have at least three segments: /OtherTransaction/<task>/*
+# Task is "Background", "Resque", "DelayedJob" etc.
+
+class NewRelic::MetricParser::OtherTransaction < NewRelic::MetricParser
+
+  def is_transaction?
+    true
+  end
+  def task
+    segments[1]
+  end
+
+  def developer_name
+    segments[2..-1].join(NewRelic::MetricParser::SEPARATOR)
+  end
+
+  def short_name
+    developer_name
+  end
+
+  def drilldown_url(metric_id)
+    {:controller => '/v2/background_tasks', :action => 'index', :task => task, :anchor => "id=#{metric_id}"}
+  end
+
+  def path
+    segments[2..-1].join "/"
+  end
+
+  def summary_metrics
+    if segments.size > 2
+      %W[OtherTransaction/#{task}/all OtherTransaction/all]
+    else
+      []
+    end
+  end
+end

data/lib/new_relic/metric_parser/view.rb

@@ -0,0 +1,61 @@
+class NewRelic::MetricParser::View < NewRelic::MetricParser
+  def is_view?; true; end
+
+  def is_render?
+    segments.last == "Rendering"
+  end
+  def is_compiler?
+    segments.last == "Compile"
+  end
+  def pie_chart_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[-2])} Template"
+      when "Partial"
+        "#{file_name(segments[-2])} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else
+        segments[1..-1]
+    end
+  end
+  def template_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Template"
+      when "Partial"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else
+        segments[1..-1].join("/")
+    end
+  end
+
+  def short_name
+    segments[1..-2].join(NewRelic::MetricParser::SEPARATOR)
+  end
+
+  def controller_name
+    template_label
+  end
+
+  def action_name
+    # Strip the extension
+    segments[-2].gsub(/\..*$/, "")
+  end
+
+  def developer_name
+    template_label
+  end
+
+  def url
+    '/' + file_name(segments[1..-2].join('/'))
+  end
+  private
+  def file_name(path)
+    label = path.gsub /\.html\.rhtml/, '.rhtml'
+    label = segments[1] if label.empty?
+    label
+  end
+end

data/lib/new_relic/metric_parser/web_frontend.rb

@@ -0,0 +1,14 @@
+# The metric where the mongrel queue time is stored
+
+class NewRelic::MetricParser::WebFrontend < NewRelic::MetricParser
+  def short_name
+    if segments.last == 'Average Queue Time'
+      'Mongrel Average Queue Time'
+    else
+      super
+    end
+  end
+  def legend_name
+    'Mongrel Wait'
+  end
+end

data/lib/new_relic/metric_parser/web_service.rb

@@ -0,0 +1,9 @@
+class NewRelic::MetricParser::WebService < NewRelic::MetricParser
+  def is_web_service?
+    segments[1] != 'Soap' && segments[1] != 'Xml Rpc'
+  end
+
+  def webservice_call_rate_suffix
+    'rpm'
+  end
+end

data/lib/new_relic/metric_spec.rb

@@ -0,0 +1,67 @@
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+class NewRelic::MetricSpec
+  attr_accessor   :name
+  attr_accessor   :scope
+
+  MAX_LENGTH = 255
+  # Need a "zero-arg" constructor so it can be instantiated from java (using
+  # jruby) for sending responses to ruby agents from the java collector.
+  #
+  def initialize(metric_name = '', metric_scope = '')
+    self.name = (metric_name || '') && metric_name[0...MAX_LENGTH]
+    self.scope = metric_scope && metric_scope[0...MAX_LENGTH]
+  end
+
+  def truncate!
+    self.name = name[0...MAX_LENGTH] if name && name.size > MAX_LENGTH
+    self.scope = scope[0...MAX_LENGTH] if scope && scope.size > MAX_LENGTH
+  end
+
+  def ==(o)
+    self.eql?(o)
+  end
+
+  def eql? o
+    self.class == o.class &&
+    name.eql?(o.name) &&
+    # coerce scope to a string and compare
+     (scope || '') == (o.scope || '')
+  end
+
+  def hash
+    h = name.hash
+    h ^= scope.hash unless scope.nil?
+    h
+  end
+  # return a new metric spec if the given regex
+  # matches the name or scope.
+  def sub(pattern, replacement, apply_to_scope = true)
+    return nil if name !~ pattern &&
+     (!apply_to_scope || scope.nil? || scope !~ pattern)
+    new_name = name.sub(pattern, replacement)[0...MAX_LENGTH]
+
+    if apply_to_scope
+      new_scope = (scope && scope.sub(pattern, replacement)[0...MAX_LENGTH])
+    else
+      new_scope = scope
+    end
+
+    self.class.new new_name, new_scope
+  end
+
+  def to_s
+    "#{name}:#{scope}"
+  end
+
+  def to_json(*a)
+    {'name' => name,
+    'scope' => scope}.to_json(*a)
+  end
+
+  def <=>(o)
+    namecmp = self.name <=> o.name
+    return namecmp if namecmp != 0
+    return (self.scope || '') <=> (o.scope || '')
+  end
+end

data/lib/new_relic/metrics.rb

@@ -0,0 +1,9 @@
+module NewRelic
+  module Metrics
+    CONTROLLER = "Controller"
+    DISPATCHER = "HttpDispatcher"
+    ACTIVE_RECORD = "ActiveRecord"
+    USER_TIME = "CPU/User Time"
+    MEMORY = "Memory/Physical"
+  end
+end

data/lib/new_relic/noticed_error.rb

@@ -0,0 +1,24 @@
+# This class encapsulates an error that was noticed by RPM in a managed app.
+class NewRelic::NoticedError
+  extend NewRelic::CollectionHelper
+  attr_accessor :path, :timestamp, :params, :exception_class, :message
+
+  def initialize(path, data, exception, timestamp = Time.now)
+    self.path = path
+    self.params = NewRelic::NoticedError.normalize_params(data)
+
+    self.exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
+
+    if exception.respond_to?('original_exception')
+      self.message = exception.original_exception.message.to_s
+    else
+      self.message = (exception || '<no message>').to_s
+    end
+
+    # clamp long messages to 4k so that we don't send a lot of
+    # overhead across the wire
+    self.message = self.message[0..4095] if self.message.length > 4096
+
+    self.timestamp = timestamp
+  end
+end

data/lib/new_relic/rack/developer_mode.rb

@@ -0,0 +1,257 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'rack/file'
+
+module NewRelic::Rack
+class DeveloperMode
+
+  VIEW_PATH = File.expand_path('../../../../ui/views/', __FILE__)
+  HELPER_PATH = File.expand_path('../../../../ui/helpers/', __FILE__)
+  require File.join(HELPER_PATH, 'developer_mode_helper.rb')
+
+  include NewRelic::DeveloperModeHelper
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    return @app.call(env) unless /^\/newrelic/ =~ Rack::Request.new(env).path_info
+    dup._call(env)
+  end
+
+  protected
+
+  def _call(env)
+    @req = Rack::Request.new(env)
+    @rendered = false
+    case @req.path_info
+    when /profile/
+      profile
+    when /file/
+      Rack::File.new(VIEW_PATH).call(env)
+    when /index/
+      index
+    when /threads/
+      threads
+    when /reset/
+      reset
+    when /show_sample_detail/
+      show_sample_data
+    when /show_sample_summary/
+      show_sample_data
+    when /show_sample_sql/
+      show_sample_data
+    when /explain_sql/
+      explain_sql
+    when /show_source/
+      show_source
+    when /^\/newrelic\/?$/
+      index
+    else
+      @app.call(env)
+    end
+  end
+
+  private
+
+  def index
+    get_samples
+    render(:index)
+  end
+
+  def reset
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
+  end
+
+  def explain_sql
+    get_segment
+
+    return render(:sample_not_found) 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
+    render(:explain_sql)
+  end
+
+  def profile
+    NewRelic::Control.instance.profiling = params['start'] == 'true'
+    index
+  end
+
+  def threads
+    render(:threads)
+  end
+
+  def render(view, layout=true)
+    add_rack_array = true
+    if view.is_a? Hash
+      layout = false
+      if view[:object]
+        object = view[:object]
+      end
+
+      if view[:collection]
+        return view[:collection].map do |object|
+          render({:partial => view[:partial], :object => object})
+        end.join(' ')
+      end
+
+      if view[:partial]
+        add_rack_array = false
+        view = "_#{view[:partial]}"
+      end
+    end
+    binding = Proc.new {}.binding
+    if layout
+      body = render_with_layout(view) do
+        render_without_layout(view, binding)
+      end
+    else
+      body = render_without_layout(view, binding)
+    end
+    if add_rack_array
+      Rack::Response.new(body).finish
+    else
+      body
+    end
+  end
+
+  # You have to call this with a block - the contents returned from
+  # that block are interpolated into the layout
+  def render_with_layout(view)
+    body = ERB.new(File.read(File.join(VIEW_PATH, 'layouts/newrelic_default.rhtml')))
+    body.result(Proc.new {}.binding)
+  end
+
+  # you have to pass a binding to this (a proc) so that ERB can have
+  # access to helper functions and local variables
+  def render_without_layout(view, binding)
+    ERB.new(File.read(File.join(VIEW_PATH, 'newrelic', view.to_s + '.rhtml')), nil, nil, 'frobnitz').result(binding)
+  end
+
+  def content_tag(tag, contents, opts={})
+    opt_values = opts.map {|k, v| "#{k}=\"#{v}\"" }.join(' ')
+    "<#{tag} #{opt_values}>#{contents}</#{tag}>"
+  end
+
+  def sample
+    @sample || @samples[0]
+  end
+
+  def params
+    @req.params
+  end
+
+  def segment
+    @segment
+  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
+    render(:show_source)
+  end
+
+  def show_sample_data
+    get_sample
+
+    return render(:sample_not_found) unless @sample
+
+    @request_params = @sample.params['request_params'] || {}
+    @custom_params = @sample.params['custom_params'] || {}
+
+    controller_metric = @sample.root_segment.called_segments.first.metric_name
+
+    metric_parser = NewRelic::MetricParser.for_metric_named controller_metric
+    @sample_controller_name = metric_parser.controller_name
+    @sample_action_name = metric_parser.action_name
+
+    render(: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
+    id = params['id']
+    sample_id = 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
+end