newrelic_rpm 2.12.3 → 2.13.0.beta3

data/lib/new_relic/control/profiling.rb

@@ -0,0 +1,24 @@
+module NewRelic
+  class Control
+    module Profiling
+
+      # A flag used in dev mode to indicate if profiling is available
+      def profiling?
+        @profiling
+      end
+      
+      def profiling_available?
+        @profiling_available ||= 
+          begin
+            require 'ruby-prof'
+            true
+          rescue LoadError; end
+      end
+      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+      # loaded a true value is ignored.
+      def profiling=(val)
+        @profiling = profiling_available? && val && defined?(RubyProf)
+      end
+    end
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,88 @@
+module NewRelic
+  class Control
+    
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+    
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+    
+    module ServerMethods
+
+      def server
+        @remote_server ||= server_from_host(nil)  
+      end
+      
+      def api_server
+        api_host = self['api_host'] || 'rpm.newrelic.com' 
+        @api_server ||= 
+          NewRelic::Control::Server.new \
+        api_host, 
+        (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i, 
+        nil
+      end
+      
+      def proxy_server
+        @proxy_server ||=
+          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass'] 
+      end
+      
+      def server_from_host(hostname=nil)
+        host = hostname || self['host'] || 'collector.newrelic.com'
+        
+        # if the host is not an IP address, turn it into one
+        NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host) 
+      end
+
+      # Look up the ip address of the host using the pure ruby lookup 
+      # to prevent blocking.  If that fails, fall back to the regular
+      # IPSocket library.  Return nil if we can't find the host ip
+      # address and don't have a good default.
+      def convert_to_ip_address(host)
+        # here we leave it as a host name since the cert verification
+        # needs it in host form
+        return host if verify_certificate?
+        return nil if host.nil? || host.downcase == "localhost"
+        # Fall back to known ip address in the common case
+        ip_address = '65.74.177.195' if host.downcase == 'collector.newrelic.com'
+        begin
+          ip_address = Resolv.getaddress(host)
+          log.info "Resolved #{host} to #{ip_address}"
+        rescue => e
+          log.warn "DNS Error caching IP address: #{e}"
+          log.debug e.backtrace.join("\n   ")
+          ip_address = IPSocket::getaddress host rescue ip_address
+        end
+        ip_address
+      end
+      
+      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+      # Default is the collector but for api calls you need to pass api_server
+      #
+      # Experimental support for SSL verification:
+      # swap 'VERIFY_NONE' for 'VERIFY_PEER' line to try it out
+      # If verification fails, uncomment the 'http.ca_file' line
+      # and it will use the included certificate.
+      def http_connection(host = nil)
+        host ||= server
+        # Proxy returns regular HTTP if @proxy_host is nil (the default)
+        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port, 
+                                      proxy_server.user, proxy_server.password)
+        http = http_class.new(host.ip || host.name, host.port)
+        log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
+        if use_ssl?
+          http.use_ssl = true
+          if verify_certificate?
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+        http
+      end
+    end
+  end
+end
+

data/lib/new_relic/local_environment.rb

@@ -152,10 +152,10 @@ module NewRelic
       @unicorn
     end
 
-    # Obsolete method for DelayedJob instrumentation support, which is
-    # now in the rpm_contrib gem.
+    # Obsolete method for DelayedJob instrumentation support.  Now all DJ instrumentation
+    # is bundled in the newrelic_rpm gem and nobody should be invoking this method.
     def delayed_worker=(worker)
-      $stderr.puts "WARNING: DelayedJob instrumentation has been moved to the rpm_contrib gem."
+      $stderr.puts "WARNING: obsolete call to delayed_worker=(worker).  Please remove custom DJ instrumentation."
     end
 
     private

data/lib/new_relic/metric_parser.rb

@@ -67,7 +67,7 @@ module NewRelic
     end
     
     def apdex_metric_path
-      "Apdex/#{segments[1..-1].join('/')}"
+      %Q[Apdex/#{segments[1..-1].join('/')}]
     end
     
     # A short name for legends in the graphs
@@ -81,6 +81,8 @@ module NewRelic
       nil
     end
     
+    # Category is a UI description of the general 
+    # category of metrics for this metric.
     def category
       segments[0]
     end
@@ -112,7 +114,11 @@ module NewRelic
     def url
     ''
     end
-    
+    # Return the list of dispatcher metrics that correspond to this metric.  That is, 
+    # the summary metrics which should also be recorded when this metric is recorded.
+    def summary_metrics
+      []
+    end
     # returns a hash of params for url_for(), giving you a drilldown URL to an RPM page for this metric
     # define in subclasses - TB 2009-12-18
     # def drilldown_url(metric_id); end
@@ -121,5 +127,10 @@ module NewRelic
       @name = name
     end
     
+    # These would be reflected properly by method missing; consider
+    # this an optimization
+    def is_controller?; false; end
+    def is_transaction?; false; end
+    
   end  
 end

data/lib/new_relic/metric_parser/active_record.rb

@@ -4,7 +4,10 @@ class NewRelic::MetricParser::ActiveRecord < NewRelic::MetricParser
   def model_class
     return segments[1]
   end
-  
+
+  def is_database?
+    true
+  end
   def legend_name
     if name == 'ActiveRecord/all'
       'Database'

data/lib/new_relic/metric_parser/apdex.rb

@@ -0,0 +1,53 @@
+class NewRelic::MetricParser::Apdex < NewRelic::MetricParser
+  
+  CLIENT = 'Client'
+  
+  # Convenience method for creating the appropriate client
+  # metric name.
+  def self.client_metric(apdex_t)
+    "Apdex/#{CLIENT}/#{apdex_t}"
+  end
+  
+  def is_client?
+    segments[1] == CLIENT
+  end
+  def is_summary?
+    segments.size == 1
+  end
+  
+  # Apdex/Client/N
+  def apdex_t
+    is_client? && segments[2].to_f
+  end
+  
+  def developer_name
+    case
+      when is_client? then "Apdex Client (#{apdex_t})"
+      when is_summary? then "Apdex"
+      else "Apdex #{segments[1..-1].join("/")}"
+    end
+  end
+  
+  def short_name
+    # standard controller actions
+    if segments.length > 1
+      url
+    else
+      'All Frontend Urls'
+    end
+  end
+  
+  def url
+    '/' + segments[1..-1].join('/')
+  end
+  
+  # this is used to match transaction traces to controller actions.  
+  # TT's don't have a preceding slash :P
+  def tt_path
+    segments[1..-1].join('/')
+  end
+
+  def call_rate_suffix
+    'rpm'
+  end
+end

data/lib/new_relic/metric_parser/controller.rb

@@ -1,11 +1,12 @@
 class NewRelic::MetricParser::Controller < NewRelic::MetricParser
 
-  def is_controller?
-    true
-  end
-  
+  def is_controller?; true; end
+  def is_transaction?; true; end
+
   # If the controller name segments look like a file path, convert it to the controller
-  # class name.  If it begins with a capital letter, assume it's already a class name
+  # class name.  If it begins with a capital letter, assume it's already a class name.
+  # We only expect a lower case letter with Rails, so we'll be able to use camelize for 
+  # that.
   def controller_name
     path = segments[1..-2].join('/')
     path < 'a' ? path : path.camelize+"Controller" 
@@ -23,6 +24,9 @@ class NewRelic::MetricParser::Controller < NewRelic::MetricParser
     "#{controller_name}##{action_name}"
   end
   
+  def is_web_transaction?
+    true
+  end
   # return the cpu measuring equivalent.  It may be nil since this metric was not
   # present in earlier versions of the agent.
   def cpu_metric
@@ -51,4 +55,8 @@ class NewRelic::MetricParser::Controller < NewRelic::MetricParser
   def call_rate_suffix
     'rpm'
   end
+  
+  def summary_metrics
+    %w[HttpDispatcher]
+  end
 end

data/lib/new_relic/metric_parser/mem_cache.rb

@@ -11,7 +11,7 @@ class NewRelic::MetricParser::MemCache < NewRelic::MetricParser
   end
 
   def all?
-    segments[1]['all'] == 0
+    segments[1].index('all') == 0
   end
   def operation
     all? ? 'All Operations' : segments[1]

data/lib/new_relic/metric_parser/other_transaction.rb

@@ -1,6 +1,11 @@
 # 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
@@ -9,7 +14,23 @@ class NewRelic::MetricParser::OtherTransaction < NewRelic::MetricParser
     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_spec.rb

@@ -4,7 +4,7 @@ class NewRelic::MetricSpec
   attr_accessor   :name
   attr_accessor   :scope
   
-  MAX_LENGTH = 100
+  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.
   #
@@ -14,8 +14,8 @@ class NewRelic::MetricSpec
   end
   
   def truncate!
-    self.name = name[0...100] if name && name.size > 100
-    self.scope = scope[0...100] if scope && scope.size > 100
+    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)

data/lib/new_relic/noticed_error.rb

@@ -7,7 +7,7 @@ class NewRelic::NoticedError
     self.path = path
     self.params = NewRelic::NoticedError.normalize_params(data)
     
-    self.exception_class = exception ? exception.class.name : '<no exception>'
+    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

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 {}
+    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 {})
+  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