newrelic_rpm 2.8.11 → 2.9.2

data/lib/new_relic/local_environment.rb

@@ -1,140 +1,262 @@
-# 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
+require 'set'
+
 module NewRelic 
+  # An instance of LocalEnvironment is responsible for determining
+  # three things: 
+  #
+  # * Framework - :rails, :merb, :ruby, :test
+  # * Dispatcher - A supported dispatcher, or nil (:mongrel, :thin, :passenger, :webrick, etc)
+  # * Dispatcher Instance ID, which distinguishes agents on a single host from each other
+  #
+  # If the environment can't be determined, it will be set to
+  # nil and dispatcher_instance_id will have nil.
+  # 
+  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
   class LocalEnvironment
+
+    attr_accessor :dispatcher # mongrel, thin, webrick, or possibly nil
+    attr_accessor :dispatcher_instance_id # used to distinguish instances of a dispatcher from each other, may be nil
+    attr_accessor :framework # rails, merb, :ruby, test
+    attr_reader :mongrel    # The mongrel instance, if there is one, captured as a convenience
+    attr_reader :processors # The number of cpus, if detected, or nil
+    alias environment dispatcher
     
-    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 thin mongrel litespeed passenger fastcgi daemon]
-      while environments.any? && @identifier.nil?
-        send 'check_for_'+(environments.shift)
+      discover_framework
+      discover_dispatcher
+      @dispatcher = nil if @dispatcher == :none
+      @gems = Set.new
+      @plugins = Set.new
+      @config = Hash.new
+    end
+
+    # Add the given key/value pair to the app environment 
+    # settings.  Must pass either a value or a block.  Block
+    # is called to get the value and any raised errors are
+    # silently ignored.
+    def append_environment_value name, value = nil
+      value = yield if block_given? 
+      @config[name] = value if value
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}" 
+      raise if @framework == :test 
+    end
+
+    def append_gem_list
+      @gems += yield
+    rescue Exception => e
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test 
+    end
+  
+    def append_plugin_list
+      @plugins += yield
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}" 
+      raise if @framework == :test 
+    end
+    
+    def dispatcher_instance_id
+      if @dispatcher_instance_id.nil?
+        if @dispatcher.nil?
+          @dispatcher_instance_id = File.basename($0).split(".").first
+        end
       end
+      @dispatcher_instance_id
     end
-    def to_s
-      "LocalEnvironment[#{environment}:#{identifier}]"
+        
+    # Collect base statistics about the environment and record them for
+    # comparison and change detection.
+    def gather_environment_info
+      append_environment_value 'Framework', @framework.to_s
+      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
+      append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
+      append_environment_value('Application root') { File.expand_path(NewRelic::Control.instance.root) }
+      append_environment_value('Ruby version'){ RUBY_VERSION }
+      append_environment_value('Ruby platform') { RUBY_PLATFORM }
+      append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+      append_environment_value('OS') { ENV['OS'] } 
+      append_environment_value('Arch') { `uname -p` } ||
+      append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
+      # See what the number of cpus is, works only on linux.
+      @processors = append_environment_value('Processors') do
+        processors = 0
+        File.read('/proc/cpuinfo').each_line do | line |
+          processors += 1 if line =~ /^processor\s*:/
+        end 
+        raise unless processors > 0
+        processors
+      end if File.readable? '/proc/cpuinfo'
+      # The current Rails environment (development, test, or production).
+      append_environment_value('Environment') { NewRelic::Control.instance.env }
+      # Look for a capistrano file indicating the current revision:
+      rev_file = File.join(NewRelic::Control.instance.root, "REVISION")
+      if File.readable?(rev_file) && File.size(rev_file) < 64
+        append_environment_value('Revision') do
+          File.open(rev_file) { | file | file.readline.strip }
+        end
+      end
+      # The name of the database adapter for the current environment.
+      if defined? ActiveRecord
+        append_environment_value 'Database adapter' do
+          ActiveRecord::Base.configurations[RAILS_ENV]['adapter']
+        end
+        append_environment_value 'Database schema version' do
+          ActiveRecord::Migrator.current_version
+        end
+      end
+      if defined? DataMapper
+        append_environment_value 'DataMapper version' do
+          require 'dm-core/version'
+          DataMapper::VERSION
+        end
+      end
     end
-    def check_for_fastcgi
-      return unless defined? FCGI
-      @environment = :fastcgi
-      @identifier = 'fastcgi'
+    # Take a snapshot of the environment information for this application
+    # Returns an associative array
+    def snapshot
+      i = @config.to_a
+      i << [ 'Plugin List', @plugins.to_a] if not @plugins.empty? 
+      i << [ 'Gems', @gems.to_a] if not @gems.empty?
+      i
     end
-    def check_for_merb
-      if config.app == :merb
-        @identifier = 'merb'
+    
+    def mongrel
+      return @mongrel if @mongrel || ! defined? Mongrel::HttpServer 
+      ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel|
+        @mongrel = mongrel
+      end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
+      @mongrel
+    end
+
+    private
+    
+    # Although you can override the framework with NEWRELIC_DISPATCHER this
+    # is not advisable since it implies certain api's being available.
+    def discover_dispatcher
+      @dispatcher = ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
+      dispatchers = %w[webrick thin mongrel glassfish litespeed passenger fastcgi]
+      while dispatchers.any? && @dispatcher.nil?
+        send 'check_for_'+(dispatchers.shift)
       end
     end
+    
+    def discover_framework
+      # Although you can override the framework with NEWRELIC_FRAMEWORK this
+      # is not advisable since it implies certain api's being available.
+      @framework = case
+        when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym 
+        when defined? NewRelic::TEST then :test
+        when defined? Merb::Plugins then :merb
+        when defined? Rails then :rails
+      else :ruby
+      end      
+    end
+
+    def check_for_glassfish
+      return unless defined?(Java) &&
+         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+         defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
+         ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+         defined?(org::jruby::rack::DefaultRackApplicationFactory)))
+      @dispatcher = :glassfish
+    end
+
     def check_for_webrick
-      # Some indication this is causing problems.  To be fixed in 2.9.0
-      return
-      # This will not succeed on rails 2.2 and later
-      if defined?(WEBrick) && defined?(OPTIONS) && ::OPTIONS.respond_to?(:fetch) 
-        # OPTIONS is set by script/server 
-        @identifier = default_port unless @identifier
-        @identifier = OPTIONS.fetch(:port)
+      return unless defined?(WEBrick::VERSION)
+      @dispatcher = :webrick
+      if defined?(OPTIONS) && OPTIONS.respond_to?(:fetch) 
+        # OPTIONS is set by script/server
+        @dispatcher_instance_id = OPTIONS.fetch(:port)
       end
+      @dispatcher_instance_id = default_port unless @dispatcher_instance_id
     end
+    
+    def check_for_fastcgi
+      return unless defined? FCGI
+      @dispatcher = :fastcgi
+    end
+
     # this case covers starting by mongrel_rails
     def check_for_mongrel
       return unless defined?(Mongrel::HttpServer) 
-      @environment = :mongrel
+      @dispatcher = :mongrel
       
       # Get the port from the server if it's started
-      ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel|
-        next if not mongrel.respond_to? :port
-        @identifier = mongrel.port.to_s
+
+      if mongrel && mongrel.respond_to?(:port)
+        @dispatcher_instance_id = mongrel.port.to_s
       end
       
       # Get the port from the configurator if one was created
-      if @identifier.nil? && defined?(Mongrel::Configurator)
+      if @dispatcher_instance_id.nil? && defined?(Mongrel::Configurator)
         ObjectSpace.each_object(Mongrel::Configurator) do |mongrel|
-          @identifier = mongrel.defaults[:port] && mongrel.defaults[:port].to_s
-        end
+          @dispatcher_instance_id = mongrel.defaults[:port] && mongrel.defaults[:port].to_s
+        end unless defined?(JRuby) && !JRuby.runtime.is_object_space_enabled
       end
+      @mongrel
       
       # Still can't find the port.  Let's look at ARGV to fall back
-      @identifier = default_port if @identifier.nil?
+      @dispatcher_instance_id = default_port if @dispatcher_instance_id.nil?
     end
-    def check_for_thin    
+    
+    def check_for_thin
       if defined? Thin::Server
         # This case covers the thin web dispatcher
         # 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
+        ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+          @dispatcher = :thin
+          backend = thin_dispatcher.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
+            @dispatcher_instance_id = backend.port
           elsif backend.respond_to? :socket
-            @identifier = backend.socket
+            @dispatcher_instance_id = backend.socket
           else
             raise "Unknown thin backend: #{backend}"
           end
         end # each thin instance
       end
-      if defined?(Thin::VERSION) && !@identifier
-        @environment = :thin
-        @identifier = default_port
-      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']
+      if defined?(Thin::VERSION) && !@dispatcher
+        @dispatcher = :thin
+        @dispatcher_instance_id = default_port
       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']
+        @dispatcher = :litespeed
       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
+        @dispatcher = :passenger
       end
     end
-    private 
-    def config
-      NewRelic::Config.instance
-    end
-    
+  
     def default_port
       require 'optparse'
       # If nothing else is found, use the 3000 default
       default_port = 3000
       OptionParser.new do |opts|
-        opts.on("-p", "--port=port", String) { | default_port | }
+        opts.on("-p", "--port=port", String) { | p | default_port = p }
         opts.parse(ARGV.clone) rescue nil
       end
       default_port
     end
+    
+    public 
+    def to_s
+      s = "LocalEnvironment["
+      s << @framework.to_s
+      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
+      s << "]"
+    end
+
   end
 end

data/lib/new_relic/metric_data.rb

@@ -18,6 +18,13 @@ module NewRelic
       metric_spec.hash + stats.hash
     end
     
+    def to_json(*a)
+      {'metric_spec' => metric_spec,
+      'stats' => stats,
+      'metric_id' => metric_id
+      }.to_json(*a)
+    end
+    
     def to_s
       "#{metric_spec.name}(#{metric_spec.scope}): #{stats}" if metric_spec
       "#{metric_id}: #{stats}" if metric_spec.nil?

data/lib/new_relic/metric_parser/action_mailer.rb

@@ -0,0 +1,9 @@
+class NewRelic::MetricParser::ActionMailer < NewRelic::MetricParser
+  
+  def is_action_mailer?; true; end
+    
+  def short_name
+    "ActionMailer - #{segments[1]}"
+  end
+  
+end

data/lib/new_relic/metric_parser/active_merchant.rb

@@ -0,0 +1,26 @@
+class NewRelic::MetricParser::ActiveMerchant < NewRelic::MetricParser
+  
+  def is_active_merchant?; true; end
+  
+  def is_active_merchant_gateway?
+    segments[1] == 'gateway'
+  end
+  
+  def is_active_merchant_operation?
+    segments[1] == 'operation'
+  end
+  
+  def gateway_name
+    # ends in "Gateway" - trim that off
+    segments[2][0..-8].titleize
+  end
+  
+  def operation_name
+    segments[2]
+  end
+  
+  def short_name
+    segments[2]
+  end
+  
+end

data/lib/new_relic/metric_parser/active_record.rb

@@ -0,0 +1,11 @@
+class NewRelic::MetricParser::ActiveRecord < NewRelic::MetricParser
+  def is_active_record? ; true; end
+  
+  def model_class
+    return segments[1]
+  end
+  
+  def developer_name
+    "#{model_class}##{segments.last}"
+  end
+end

data/lib/new_relic/metric_parser/controller.rb

@@ -0,0 +1,51 @@
+class NewRelic::MetricParser::Controller < NewRelic::MetricParser
+  
+  def is_controller?
+    true
+  end
+  
+  def controller_name
+    segments[1..-2].join('/').camelize+"Controller"
+  end
+
+  def action_name
+    if segments[-1] =~ /^\(other\)$/
+      '(template only)'
+    else
+      segments[-1]
+    end
+  end
+  
+  def developer_name
+    "#{controller_name}##{action_name}"
+  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
+    Metric.lookup((["ControllerCPU"] + segments[1..-1]).join('/'), "", :create => false)
+  end
+  
+  def short_name
+    # standard controller actions
+    if segments.length > 1
+      url
+    else
+      'All Controller Actions'
+    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