newrelic_rpm 2.8.0

data/lib/new_relic/config/rails.rb

@@ -0,0 +1,113 @@
+class NewRelic::Config::Rails < NewRelic::Config
+  
+  def app; :rails; end
+  
+  def env
+    RAILS_ENV
+  end
+  def root
+    RAILS_ROOT
+  end
+  
+  def log_path
+    path = ::RAILS_DEFAULT_LOGGER.instance_eval do
+      File.dirname(@log.path) rescue File.dirname(@logdev.filename) 
+    end rescue "#{root}/log"
+    File.expand_path(path)
+  end
+  
+  def start_plugin(rails_config=nil)
+    if !tracers_enabled?
+      require 'new_relic/shim_agent'
+      return
+    end
+    app_config_info
+    start_agent
+    install_developer_mode rails_config if developer_mode?
+  end
+  
+  def install_developer_mode(rails_config)
+    controller_path = File.join(newrelic_root, 'ui', 'controllers')
+    helper_path = File.join(newrelic_root, 'ui', 'helpers')
+    $LOAD_PATH << controller_path
+    $LOAD_PATH << helper_path
+ 
+    if defined? ActiveSupport::Dependencies
+      ActiveSupport::Dependencies.load_paths << controller_path
+      ActiveSupport::Dependencies.load_paths << helper_path
+    elsif defined? Dependencies.load_paths
+      Dependencies.load_paths << controller_path
+      Dependencies.load_paths << helper_path
+    else
+      to_stderr "ERROR: Rails version #{(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION : ''} too old for developer mode to work."
+      return
+    end
+    
+    # This is a monkey patch to inject the developer tool route into the
+    # parent app without requiring users to modify their routes. Of course this 
+    # has the effect of adding a route indiscriminately which is frowned upon by 
+    # some: http://www.ruby-forum.com/topic/126316#563328
+    ActionController::Routing::RouteSet.class_eval do
+      next if defined? draw_with_newrelic_map
+      def draw_with_newrelic_map
+        draw_without_newrelic_map do | map |
+          map.named_route 'newrelic_developer', '/newrelic/:action/:id', :controller => 'newrelic' unless NewRelic::Config.instance['skip_developer_route']
+          yield map        
+        end
+      end
+      alias_method_chain :draw, :newrelic_map
+    end
+    
+    # If we have the config object then add the controller path to the list.
+    # Otherwise we have to assume the controller paths have already been
+    # set and we can just append newrelic.
+    
+    if rails_config
+      rails_config.controller_paths << controller_path
+    else
+      current_paths = ActionController::Routing.controller_paths
+      if current_paths.nil? || current_paths.empty?
+        to_stderr "WARNING: Unable to modify the routes in this version of Rails.  Developer mode not available."
+      end
+      current_paths << controller_path
+    end
+    
+    #ActionController::Routing::Routes.reload! unless NewRelic::Config.instance['skip_developer_route']
+    
+    # inform user that the dev edition is available if we are running inside
+    # a webserver process
+    if local_env.identifier
+      port = local_env.identifier.to_s =~ /^\d+/ ? ":#{local_env.identifier}" : ":port" 
+      to_stderr "NewRelic Agent (Developer Mode) enabled."
+      to_stderr "To view performance information, go to http://localhost#{port}/newrelic"
+    end
+  end
+  
+  protected 
+  
+  # Collect the Rails::Info into an associative array as well as the list of plugins
+  def gather_info
+    i = [[:app, app]]
+    begin 
+      begin
+        require 'rails/info'
+      rescue LoadError
+        require 'builtin/rails_info/rails/info'
+      end
+      i += ::Rails::Info.properties
+    rescue SecurityError, ScriptError, StandardError => e
+      log.debug "Unable to get the Rails info: #{e.inspect}"
+    end
+    
+    # Would like to get this from config, but how?
+    plugins = Dir[File.join(File.expand_path(__FILE__+"/../../../../.."),"/*")].collect { |p| File.basename p }
+    i << ['Plugin List', plugins]
+    
+    # Look for a capistrano file indicating the current revision:
+    rev_file = File.expand_path(File.join(RAILS_ROOT, "REVISION"))
+    if File.readable?(rev_file) && File.size(rev_file) < 64
+      File.open(rev_file) { | file | i << ['Revision', file.read] } rescue nil
+    end
+    i
+  end
+end

data/lib/new_relic/config/ruby.rb

@@ -0,0 +1,9 @@
+class NewRelic::Config::Ruby < NewRelic::Config
+  def app; :ruby; end
+  def env
+    ENV['RUBY_ENV'] || 'development'
+  end
+  def root
+    Dir['.']
+  end
+end

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,108 @@
+# An instance of LocalEnvironment will provide the environment name
+# and locally unique identifier for this agent's host.
+# If the environment can't be determined, it will be set to
+# :unknown and identifier will have nil
+module NewRelic 
+  class LocalEnvironment
+    
+    attr_reader :environment, :identifier
+    
+    # determine the environment we are running in (one of :webrick,
+    # :mongrel, :thin, or :unknown) and if the process is listening
+    # on a port, use the port # that we are listening on. 
+    def initialize
+      # Note: log won't be available yet.
+      @identifier = nil
+      @environment = :unknown
+      environments = %w[merb jruby webrick mongrel thin litespeed passenger daemon]
+      while environments.any? && @identifier.nil?
+        send 'check_for_'+(environments.shift)
+      end
+    end
+    def to_s
+      "LocalEnvironment[#{environment}:#{identifier}]"
+    end
+    def check_for_merb
+      if config.app == :merb
+        @identifier = 'merb'
+      end
+    end
+    def check_for_webrick
+      if defined?(OPTIONS) && OPTIONS.respond_to?(:fetch) 
+        # OPTIONS is set by script/server 
+        @identifier = OPTIONS.fetch(:port)
+        @environment = :webrick
+      end
+    end
+    
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      if defined? Mongrel::HttpServer
+        ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel|
+          next if not mongrel.respond_to? :port
+          @environment = :mongrel
+          @identifier = mongrel.port
+        end
+      end
+    end
+    
+    def check_for_thin
+      if defined? Thin::Server
+        # This case covers the thin web server
+        # Same issue as above- we assume only one instance per process
+        ObjectSpace.each_object(Thin::Server) do |thin_server|
+          @environment = :thin
+          backend = thin_server.backend
+          # We need a way to uniquely identify and distinguish agents.  The port
+          # works for this.  When using sockets, use the socket file name.
+          if backend.respond_to? :port
+            @identifier = backend.port
+          elsif backend.respond_to? :socket
+            @identifier = backend.socket
+          else
+            raise "Unknown thin backend: #{backend}"
+          end
+        end # each thin instance
+      end
+    end
+    
+    def check_for_jruby
+      if RUBY_PLATFORM =~ /java/
+        # Check for JRuby environment.  Not sure how this works in different appservers
+        require 'java'
+        require 'jruby'
+        @environment = :jruby
+        @identifier = 'jruby'
+        @identifier += ":#{config['app_name']}" if config['app_name']
+      end
+    end
+    
+    def check_for_litespeed
+      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+        @environment = :litespeed
+        @identifier = 'litespeed'
+        @identifier += ":#{config['app_name']}" if config['app_name']
+      end
+    end
+    
+    def check_for_passenger
+      if defined? Passenger::AbstractServer || defined? IN_PHUSION_PASSENGER 
+        @environment = :passenger
+        @identifier = 'passenger'
+        @identifier += ":#{config['app_name']}" if config['app_name']
+      end
+    end
+    
+    def check_for_daemon
+      if config['monitor_daemons']
+        @environment = :daemon
+        # return the base part of the file name
+        @identifier = File.basename($0).split(".").first
+      end
+    end
+    private 
+    def config
+      NewRelic::Config.instance
+    end
+  end
+end

data/lib/new_relic/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :newrelic do
+  desc "Install the developer mode newrelic.yml file"
+  task :default do
+    load File.expand_path(File.join(__FILE__,"..","..","install.rb"))
+  end
+end

data/lib/new_relic/metric_data.rb

@@ -0,0 +1,26 @@
+module NewRelic
+  class MetricData
+    attr_accessor :metric_spec
+    attr_accessor :metric_id
+    attr_accessor :stats
+    
+    def initialize(metric_spec, stats, metric_id)
+      self.metric_spec = metric_spec
+      self.stats = stats
+      self.metric_id = metric_id
+    end
+    
+    def eql?(o)
+     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+    end
+    
+    def hash
+      metric_spec.hash + stats.hash
+    end
+    
+    def to_s
+      "#{metric_spec.name}(#{metric_spec.scope}): #{stats}" if metric_spec
+      "#{metric_id}: #{stats}" if metric_spec.nil?
+    end
+  end
+end

data/lib/new_relic/metric_spec.rb

@@ -0,0 +1,39 @@
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+class NewRelic::MetricSpec
+  attr_accessor   :name
+  attr_accessor   :scope
+  
+  def initialize (name, scope = '')
+    self.name = name
+    self.scope = scope
+  end
+  
+  def eql? (o)
+    scope_equal = scope.nil? ? o.scope.nil? : scope.eql?(o.scope) 
+    name.eql?(o.name) && scope_equal
+  end
+  
+  def hash
+    h = name.hash
+    h += scope.hash unless scope.nil?
+    h
+  end
+  
+  def <=>(o)
+    namecmp = name <=> o.name
+    return namecmp if namecmp != 0
+    
+    # i'm sure there's a more elegant way to code this correctly, but at least this passes
+    # my unit test
+    if scope.nil? && o.scope.nil?
+      return 0
+    elsif scope.nil?
+      return -1
+    elsif o.scope.nil?
+      return 1
+    else
+      return scope <=> o.scope
+    end
+  end
+end

data/lib/new_relic/metrics.rb

@@ -0,0 +1,7 @@
+module NewRelic::Metrics
+  CONTROLLER = "Controller"
+  DISPATCHER = "Rails/HTTP Dispatch"
+  ACTIVE_RECORD = "ActiveRecord"
+  USER_TIME = "CPU/User Time"
+  MEMORY = "Memory/Physical"
+end

data/lib/new_relic/noticed_error.rb

@@ -0,0 +1,21 @@
+# this class encapsulates an error that was noticed by RPM in a managed app.
+# Unfortunately it was put in the agent in the global namespace early on and
+# for backward compatibility it needs to remain here.
+class NewRelic::NoticedError
+  attr_accessor :path, :timestamp, :params, :exception_class, :message
+  
+  def initialize(path, data, exception)
+    self.path = path
+    self.params = data
+    
+    self.exception_class = exception.class.name
+    
+    if exception.respond_to?('original_exception')
+      self.message = exception.original_exception.message
+    else
+      self.message = exception.message
+    end
+
+    self.timestamp = Time.now
+  end
+end

data/lib/new_relic/shim_agent.rb

@@ -0,0 +1,95 @@
+#require 'new_relic/stats'
+
+# This agent is loaded by the plug when the plug-in is disabled
+# It recreates just enough of the API to not break any clients that
+# invoke the Agent
+
+
+# from method_tracer.rb
+
+class Module
+  
+  def trace_method_execution (*args)
+    yield
+  end
+  
+  def add_method_tracer (*args)
+  end
+  
+  def remove_method_tracer(*args)
+  end
+  
+end
+
+
+# from agent.rb
+
+module NewRelic
+  module Agent
+    
+    class << self
+      @@dummy_stats = MethodTraceStats.new
+      def agent
+        NewRelic::Agent::Agent.instance
+      end
+      
+      alias instance agent
+      
+      def get_stats(*args)
+        @@dummy_stats
+      end
+      def get_stats_no_scope(*args)
+        @@dummy_stats
+      end
+      
+      def manual_start(*args)
+      end
+      
+      def set_sql_obfuscator(*args)
+      end
+      
+      def disable_sql_recording
+        yield
+      end
+      
+      def disable_transaction_tracing
+        yield
+      end
+      
+      def add_request_parameters(*args)
+      end
+      
+      def should_ignore_error
+      end
+    end  
+    
+    class Agent
+      
+      def initialize
+        @error_collector = ErrorCollector.new
+      end
+      def self.instance
+        @@agent ||= new
+      end      
+    end
+    
+    class ErrorCollector
+      def notice_error(*args)
+      end
+    end
+    
+  end
+end
+
+
+module ActionController
+  class Base
+    def newrelic_notice_error(*args); end
+    def self.newrelic_ignore(*args); end
+    def new_relic_trace_controller_action(name); yield; end
+    def newrelic_metric_path; end
+    def perform_action_with_newrelic_trace(path=nil)
+      yield
+    end
+  end
+end if defined? ActionController::Base

data/lib/new_relic/stats.rb

@@ -0,0 +1,359 @@
+
+module NewRelic
+  module Stats
+    
+    def absent?
+      # guess on absent values
+      call_count == 0
+    end  
+
+    def average_call_time
+      return 0 if call_count == 0
+      total_call_time / call_count
+    end
+    def average_exclusive_time
+      return 0 if call_count == 0
+      total_exclusive_time / call_count
+    end
+    
+    def merge! (other_stats)
+      Array(other_stats).each do |s|
+        self.total_call_time += s.total_call_time
+        self.total_exclusive_time += s.total_exclusive_time
+        self.min_call_time = s.min_call_time if (s.min_call_time < min_call_time && s.call_count > 0) || call_count == 0
+        self.max_call_time = s.max_call_time if s.max_call_time > max_call_time
+        self.call_count += s.call_count
+        self.sum_of_squares += s.sum_of_squares if s.sum_of_squares
+        self.begin_time = s.begin_time if s.begin_time.to_f < begin_time.to_f || begin_time.to_f == 0.0
+        self.end_time = s.end_time if s.end_time.to_f > end_time.to_f
+      end
+      
+      self
+    end
+    
+    def merge (other_stats)
+      stats = self.clone
+      stats.merge! other_stats
+    end
+    
+    # split into an array of timesclices whose
+    # time boundaries start on (begin_time + (n * duration)) and whose
+    # end time ends on (begin_time * (n + 1) * duration), except for the
+    # first and last elements, whose begin time and end time are the begin
+    # and end times of this stats instance, respectively.  Yield to caller
+    # for the code that creates the actual stats instance
+    def split(rollup_begin_time, rollup_period)
+      rollup_begin_time = rollup_begin_time.to_f
+      rollup_begin_time += ((self.begin_time - rollup_begin_time) / rollup_period).floor * rollup_period
+
+      current_begin_time = self.begin_time
+      current_end_time = rollup_begin_time + rollup_period
+
+      return [self] if current_end_time >= self.end_time
+      
+      timeslices = []
+      while current_end_time < self.end_time do
+        ts = yield(current_begin_time, current_end_time)
+        
+        ts.fraction_of(self)
+        timeslices << ts
+        current_begin_time = current_end_time
+        current_end_time = current_begin_time + rollup_period
+      end
+      
+      if self.end_time > current_begin_time
+        percentage = rollup_period / self.duration + (self.begin_time - rollup_begin_time) / rollup_period
+        ts = yield(current_begin_time, self.end_time)
+        ts.fraction_of(self)
+        timeslices << ts
+      end
+      
+      timeslices
+    end
+    
+    def reset
+      self.call_count = 0
+      self.total_call_time = 0.0
+      self.total_exclusive_time = 0.0
+      self.min_call_time = 0.0
+      self.max_call_time = 0.0
+      self.sum_of_squares = 0.0
+      self.begin_time = Time.at(0)
+      self.end_time = Time.at(0)
+    end
+    
+    def as_percentage_of(other_stats)
+      return 0 if other_stats.total_call_time == 0
+      return (total_call_time / other_stats.total_call_time).to_percentage
+    end
+    
+    # the stat total_call_time is a percent
+    def as_percentage
+      return 0 if call_count == 0
+      (total_call_time / call_count).to_percentage
+    end
+    
+    def duration
+      end_time - begin_time
+    end
+
+    def calls_per_minute
+      return 0 if duration.zero?
+      ((call_count / duration.to_f * 6000).round).to_f / 100
+    end
+    
+    def calls_per_second
+      (calls_per_minute / 60).round_to(2)
+    end
+    
+    def standard_deviation
+      return 0 if call_count < 2 || self.sum_of_squares.nil?
+      
+      # Convert sum of squares into standard deviation based on
+      # formula for the standard deviation for the entire population
+      x = self.sum_of_squares - (self.call_count * (self.average_value**2))
+      return 0 if x <= 0
+      
+      Math.sqrt(x / self.call_count)
+    end
+    
+    # returns the time spent in this component as a percentage of the total
+    # time window.
+    def time_percentage
+      return 0 if duration == 0
+      total_call_time / duration
+    end
+
+    def exclusive_time_percentage
+      return 0 if duration == 0
+      total_exclusive_time / duration
+    end
+
+    alias average_value average_call_time
+    alias average_response_time average_call_time 
+    
+    def to_s
+      s = "Begin=#{begin_time}, "
+      s << "Duration=#{duration} s, "
+      s << "Count=#{call_count}, "
+      s << "Total=#{total_call_time.to_ms}, "
+      s << "Total Exclusive=#{total_exclusive_time.to_ms}, "
+      s << "Avg=#{average_call_time.to_ms}, "
+      s << "Min=#{min_call_time.to_ms}, "
+      s << "Max=#{max_call_time.to_ms}, "
+      s << "StdDev=#{standard_deviation.to_ms}"
+    end
+    
+    # Summary string to facilitate testing
+    def summary
+      format = "%m/%d %I:%M%p"
+      "[#{Time.at(begin_time).strftime(format)}, #{duration}s. #{call_count} calls; #{average_call_time.to_ms}ms]"
+    end
+    
+    # round all of the values to n decimal points
+    def round!(decimal_places = 3)
+      self.total_call_time = total_call_time.round_to(decimal_places)
+      self.total_exclusive_time = total_exclusive_time.round_to(decimal_places)
+      self.min_call_time = min_call_time.round_to(decimal_places)
+      self.max_call_time = max_call_time.round_to(decimal_places)
+      self.sum_of_squares = sum_of_squares.round_to(decimal_places)
+      self.begin_time = begin_time.round
+      self.end_time = end_time.round
+    end
+
+    # calculate this set of stats to be a percentage fraction 
+    # of the provided stats, which has an overlapping time window.
+    # used as a key part of the split algorithm
+    def fraction_of(s)
+      min_end = (end_time < s.end_time ? end_time : s.end_time)
+      max_begin = (begin_time > s.begin_time ? begin_time : s.begin_time)
+      percentage = (min_end - max_begin) / s.duration
+      
+      self.total_call_time = s.total_call_time * percentage
+      self.min_call_time = s.min_call_time
+      self.max_call_time = s.max_call_time
+      self.call_count = s.call_count * percentage
+      self.sum_of_squares = (s.sum_of_squares || 0) * percentage
+    end
+    
+    # multiply the total time and rate by the given percentage 
+    def multiply_by(percentage)
+      self.total_call_time = total_call_time * percentage
+      self.call_count = call_count * percentage
+      self.sum_of_squares = sum_of_squares * percentage
+      
+      self
+    end
+    
+    def get_apdex
+      [@call_count, @total_call_time, @total_exclusive_time, @sum_of_squares]
+    end    
+    
+  end
+  
+  # Statistics used to track the performance of traced methods
+  class MethodTraceStats
+    include Stats
+    
+    attr_accessor :call_count
+    attr_accessor :min_call_time
+    attr_accessor :max_call_time
+    attr_accessor :total_call_time
+    attr_accessor :total_exclusive_time
+    attr_accessor :sum_of_squares
+    
+    alias data_point_count call_count
+    
+    def initialize 
+      reset
+    end
+    
+    # record a single data point into the statistical gatherer.  The gatherer
+    # will aggregate all data points collected over a specified period and upload
+    # its data to the NewRelic server
+    def record_data_point(value, exclusive_time = value)
+      @call_count += 1
+      @total_call_time += value
+      @min_call_time = value if value < @min_call_time || @call_count == 1
+      @max_call_time = value if value > @max_call_time
+      @total_exclusive_time += exclusive_time
+
+      @sum_of_squares += (value * value)
+      self
+    end
+    
+    alias trace_call record_data_point
+    
+    def record_apdex_s(cpu)
+      @call_count += 1
+      @sum_of_squares += cpu
+    end
+    
+    def record_apdex_t(cpu)
+      @total_call_time += 1
+      @sum_of_squares += cpu
+    end
+    
+    def record_apdex_f(cpu)
+      @total_exclusive_time += 1
+      @sum_of_squares += cpu
+    end
+    
+    def increment_count(value = 1)
+      @call_count += value
+    end
+
+
+    def freeze
+      @end_time = Time.now
+      super
+    end
+    
+    # In this class, we explicitly don't track begin and end time here, to save space during
+    # cross process serialization via xml.  Still the accessor methods must be provided for merge to work.
+    def begin_time=(t)
+    end
+    
+    def end_time=(t)
+    end
+    
+    def begin_time
+      0.0
+    end
+    
+    def end_time
+      0.0
+    end
+  end
+  
+  class ScopedMethodTraceStats < MethodTraceStats
+    def initialize(unscoped_stats)
+      super()
+      
+      @unscoped_stats = unscoped_stats
+    end
+    
+    def trace_call(call_time, exclusive_time = call_time)
+      @unscoped_stats.trace_call call_time, exclusive_time
+      super call_time, exclusive_time
+    end
+  end
+end
+
+class Numeric
+  
+  # copied from rails
+  def with_delimiter(delimiter=",", separator=".")
+    begin
+      parts = self.to_s.split('.')
+      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+      parts.join separator
+    rescue
+      self
+    end
+  end
+  
+  # utlity method that converts floating point time values in seconds
+  # to integers in milliseconds, to improve readability in ui
+  def to_ms(decimal_places = 0)
+    (self * 1000).round_to(decimal_places)
+  end
+  
+  # return the number of decimal points that this number would best render in
+  #
+  def get_number_decimals_ms
+    base = 0.010
+    decimal = 0
+    
+    while decimal <= 6 && self < base do
+      base /= 10.0
+      decimal += 1
+    end
+    
+    decimal
+  end
+  
+  # auto-adjust the precision based on the value
+  def to_smart_ms
+    to_ms get_number_decimals_ms
+  end
+  
+  
+  def to_ns(decimal_places = 0)
+    (self * 1000000).round_to(decimal_places)
+  end
+  
+  def to_minutes(decimal_places = 0)
+    (self / 60).round_to(decimal_places)
+  end
+  
+  # utility method that converts floating point percentage values
+  # to integers as a percentage, to improve readability in ui
+  def to_percentage(decimal_places = 2)
+    (self * 100).round_to(decimal_places)
+  end
+  
+  def round_to(decimal_places)
+    x = self
+    decimal_places.times do
+      x = x * 10
+    end
+    x = x.round
+    decimal_places.times do
+      x = x.to_f / 10
+    end
+    x
+  end
+  
+  def round_to_1
+    round_to(1)
+  end
+
+  def round_to_2
+    round_to(2)
+  end
+
+  def round_to_3
+    round_to(3)
+  end
+end