newrelic_rpm 2.12.3 → 2.13.0.beta3

data/lib/new_relic/control/configuration.rb

@@ -0,0 +1,149 @@
+module NewRelic
+  class Control
+    module Configuration
+      def settings
+        unless @settings
+          @settings = (@yaml && merge_defaults(@yaml[env])) || {}
+          # At the time we bind the settings, we also need to run this little piece
+          # of magic which allows someone to augment the id with the app name, necessary
+          if self['multi_homed'] && app_names.size > 0
+            if @local_env.dispatcher_instance_id
+              @local_env.dispatcher_instance_id << ":#{app_names.first}"
+            else
+              @local_env.dispatcher_instance_id = app_names.first
+            end
+          end
+          
+        end
+        @settings
+      end
+
+      def merge_defaults(settings_hash)
+        s = {
+          'host' => 'collector.newrelic.com',
+          'ssl' => false,
+          'log_level' => 'info',
+          'apdex_t' => 1.0
+        }
+        s.merge! settings_hash if settings_hash
+        # monitor_daemons replaced with agent_enabled
+        s['agent_enabled'] = s.delete('monitor_daemons') if s['agent_enabled'].nil? && s.include?('monitor_daemons')
+        s
+      end
+
+      # Merge the given options into the config options.
+      # They might be a nested hash
+      def merge_options(options, hash=self)
+        options.each do |key, val |
+          case
+          when key == :config then next 
+          when val.is_a?(Hash)
+            merge_options(val, hash[key.to_s] ||= {})
+          when val.nil?
+            hash.delete(key.to_s)
+          else 
+            hash[key.to_s] = val
+          end
+        end
+      end
+      
+      def [](key)
+        fetch(key)
+      end
+      
+      def []=(key, value)
+        settings[key] = value
+      end
+      
+      def fetch(key, default=nil)
+        settings.fetch(key, default)
+      end
+      
+      def apdex_t
+        # Always initialized with a default
+        fetch('apdex_t').to_f
+      end
+      def license_key
+        fetch('license_key')
+      end
+      def capture_params
+        fetch('capture_params')
+      end
+      # True if we are sending data to the server, monitoring production
+      def monitor_mode?
+        fetch('monitor_mode', fetch('enabled'))
+      end
+      
+      # True if we are capturing data and displaying in /newrelic
+      def developer_mode?
+        fetch('developer_mode', fetch('developer'))
+      end
+      
+      def episodes_enabled?
+        fetch('episodes_enabled', true)
+      end
+      # True if the app runs in multi-threaded mode
+      def multi_threaded?
+        fetch('multi_threaded')
+      end
+      # True if we should view files in textmate
+      def use_textmate?
+        fetch('textmate')
+      end
+      def post_size_limit
+        fetch('post_size_limit', 2 * 1024 * 1024)
+      end
+    
+      # Configuration option of the same name to indicate that we should connect
+      # to RPM synchronously on startup.  This means when the agent is loaded it 
+      # won't return without trying to set up the server connection at least once
+      # which can make startup take longer.  Defaults to false.
+      def sync_startup
+        fetch('sync_startup', false)
+      end
+    
+      # Configuration option of the same name to indicate that we should flush
+      # data to the server on exiting.  Defaults to true.
+      def send_data_on_exit
+        fetch('send_data_on_exit', true)
+      end
+        
+      def dispatcher_instance_id
+        self['dispatcher_instance_id'] || @local_env.dispatcher_instance_id
+      end
+      
+      def dispatcher
+        (self['dispatcher'] && self['dispatcher'].to_sym) || @local_env.dispatcher
+      end
+      def app_names
+        case self['app_name']
+        when Array then self['app_name']
+        when String then self['app_name'].split(';')
+        else [ env ]
+        end
+      end
+      def validate_seed
+        self['validate_seed'] || ENV['NR_VALIDATE_SEED']   
+      end
+      def validate_token
+        self['validate_token'] || ENV['NR_VALIDATE_TOKEN']
+      end
+      
+      def use_ssl?
+        @use_ssl = fetch('ssl', false) unless @use_ssl
+        @use_ssl
+      end
+      
+      def verify_certificate?
+        unless @verify_certificate
+          unless use_ssl?
+            @verify_certificate = false
+          else
+            @verify_certificate = fetch('verify_certificate', false)
+          end
+        end
+        @verify_certificate
+      end
+    end
+  end
+end

data/lib/new_relic/control/{external.rb → frameworks/external.rb}

@@ -2,9 +2,9 @@
 # The New Relic Infrastructure Agent.  We want to call this
 # out specifically because in this context we are not monitoring
 # the running process, but actually external things.
-require 'new_relic/control/ruby'
+require 'new_relic/control/frameworks/ruby'
 
-class NewRelic::Control::External < NewRelic::Control::Ruby
+class NewRelic::Control::Frameworks::External < NewRelic::Control::Frameworks::Ruby
 
   def init_config(options={})
     super

data/lib/new_relic/control/{merb.rb → frameworks/merb.rb}

@@ -1,4 +1,4 @@
-class NewRelic::Control::Merb < NewRelic::Control
+class NewRelic::Control::Frameworks::Merb < NewRelic::Control
   
   def env
     @env ||= ::Merb.env

data/lib/new_relic/control/frameworks/rails.rb

@@ -0,0 +1,126 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values, 
+# etc.
+class NewRelic::Control::Frameworks::Rails < NewRelic::Control
+
+  def env
+    @env ||= RAILS_ENV.dup
+  end
+  def root
+    RAILS_ROOT
+  end
+  
+  # In versions of Rails prior to 2.0, the rails config was only available to 
+  # the init.rb, so it had to be passed on from there.  
+  def init_config(options={})
+    rails_config=options[:config]
+    if !agent_enabled?
+      # Might not be running if it does not think mongrel, thin, passenger, etc
+      # is running, if it things it's a rake task, or if the agent_enabled is false.
+      log! "New Relic Agent not running."
+    else
+      log! "Starting the New Relic Agent."
+      install_developer_mode rails_config if developer_mode?
+      install_episodes rails_config
+    end
+  end
+  
+  def install_episodes(config)
+    return if config.nil? || !config.respond_to?(:middleware) || !episodes_enabled?
+    config.after_initialize do 
+      if defined?(NewRelic::Rack::Episodes)
+        config.middleware.use NewRelic::Rack::Episodes 
+        log! "Installed episodes middleware"
+        ::RAILS_DEFAULT_LOGGER.info "Installed episodes middleware"
+      end
+    end
+  end
+  
+  def install_developer_mode(rails_config)
+    return if @installed
+    @installed = true
+    if rails_config && rails_config.respond_to?(:middleware)
+      begin
+        require 'new_relic/rack/developer_mode'
+        rails_config.middleware.use NewRelic::Rack::DeveloperMode
+        
+        # inform user that the dev edition is available if we are running inside
+        # a webserver process
+        if @local_env.dispatcher_instance_id
+          port = @local_env.dispatcher_instance_id.to_s =~ /^\d+/ ? ":#{local_env.dispatcher_instance_id}" : ":port" 
+          log!("NewRelic Agent Developer Mode enabled.")
+          log!("To view performance information, go to http://localhost#{port}/newrelic")
+        end
+      rescue Exception => e
+        log!("Error installing New Relic Developer Mode: #{e.inspect}", :error)
+      end
+    else
+      log!("Developer mode not available for Rails versions prior to 2.2", :warn)
+    end
+  end
+  
+  def log!(msg, level=:info)
+    return unless should_log?
+    begin
+      ::RAILS_DEFAULT_LOGGER.send(level, msg)
+    rescue Exception => e
+      super
+    end
+  end
+  
+  def to_stdout(message)
+    ::RAILS_DEFAULT_LOGGER.info(message)
+  rescue Exception => e
+    super
+  end
+  
+  def rails_version
+    @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
+  end
+  
+  protected 
+
+  def rails_vendor_root
+    File.join(root,'vendor','rails')
+  end
+  
+  # Collect the Rails::Info into an associative array as well as the list of plugins
+  def append_environment_info
+    local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
+    if rails_version >= NewRelic::VersionNumber.new('2.2.0')
+      local_env.append_environment_value('Rails threadsafe') do
+        ::Rails.configuration.action_controller.allow_concurrency == true
+      end
+    end
+    local_env.append_environment_value('Rails Env') { ENV['RAILS_ENV'] }
+    if rails_version >= NewRelic::VersionNumber.new('2.1.0')
+      local_env.append_gem_list do
+        ::Rails.configuration.gems.map do | gem |
+          version = (gem.respond_to?(:version) && gem.version) ||
+            (gem.specification.respond_to?(:version) && gem.specification.version)
+          gem.name + (version ? "(#{version})" : "")
+        end
+      end
+      # The plugins is configured manually.  If it's nil, it loads everything non-deterministically
+      if ::Rails.configuration.plugins
+        local_env.append_plugin_list { ::Rails.configuration.plugins }
+      else
+        ::Rails.configuration.plugin_paths.each do |path|
+          local_env.append_plugin_list { Dir[File.join(path, '*')].collect{ |p| File.basename p if File.directory? p }.compact }
+        end
+      end
+    else
+      # Rails prior to 2.1, can't get the gems.  Find plugins in the default location
+      local_env.append_plugin_list do
+        Dir[File.join(root, 'vendor', 'plugins', '*')].collect{ |p| File.basename p if File.directory? p }.compact
+      end
+    end
+  end
+
+  def install_shim
+    super
+    require 'new_relic/agent/instrumentation/controller_instrumentation'
+    ActionController::Base.send :include, NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+  end
+  
+end

data/lib/new_relic/control/{rails3.rb → frameworks/rails3.rb}

@@ -1,7 +1,7 @@
 # Control subclass instantiated when Rails is detected.  Contains
 # Rails specific configuration, instrumentation, environment values, 
 # etc.
-class NewRelic::Control::Rails3 < NewRelic::Control
+class NewRelic::Control::Frameworks::Rails3 < NewRelic::Control
   
   def env
     @env ||= ::Rails.env.to_s
@@ -15,17 +15,18 @@ class NewRelic::Control::Rails3 < NewRelic::Control
     ::Rails.logger
   end
   
-  def base_log_file
-    logger.instance_eval {
-      @log.path
-    }
-  rescue
-    File.join(root, 'log')
+  
+  def log!(msg, level=:info)
+    return unless should_log?
+    logger.send(level, msg)
+  rescue Exception => e
+    super
   end
-  private :base_log_file
 
-  def log_path
-    @log_path ||= File.expand_path(File.dirname(base_log_file))
+  def to_stdout(msg)
+    logger.info(msg)
+  rescue
+    super
   end
 
   def vendor_root

data/lib/new_relic/control/{ruby.rb → frameworks/ruby.rb}

@@ -3,7 +3,7 @@
 # including ./, ./config, $HOME/.newrelic and $HOME/.
 # It loads the settings from the newrelic.yml section
 # based on the value of RUBY_ENV or RAILS_ENV. 
-class NewRelic::Control::Ruby < NewRelic::Control
+class NewRelic::Control::Frameworks::Ruby < NewRelic::Control
   
   def env
     @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'

data/lib/new_relic/control/{sinatra.rb → frameworks/sinatra.rb}

@@ -1,7 +1,7 @@
 
-require 'new_relic/control/ruby'
+require 'new_relic/control/frameworks/ruby'
 
-class NewRelic::Control::Sinatra < NewRelic::Control::Ruby
+class NewRelic::Control::Frameworks::Sinatra < NewRelic::Control::Frameworks::Ruby
   
   def env
     @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'

data/lib/new_relic/control/instrumentation.rb

@@ -0,0 +1,84 @@
+module NewRelic
+  class Control
+    module Instrumentation
+      def load_instrumentation_files pattern
+        Dir.glob(pattern) do |file|
+          begin
+            log.debug "Processing instrumentation file '#{file}'"
+            require file
+          rescue => e
+            log.error "Error loading instrumentation file '#{file}': #{e}"
+            log.debug e.backtrace.join("\n")
+          end
+        end
+      end
+      
+      # Install stubs to the proper location so the app code will not fail
+      # if the agent is not running.
+      def install_shim
+        # Once we install instrumentation, you can't undo that by installing the shim.
+        raise "Cannot install the Agent shim after instrumentation has already been installed!" if @instrumented
+        NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
+      end
+      
+      # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
+      # This will load the file synchronously if we've already loaded the default
+      # instrumentation.
+      #
+      def add_instrumentation pattern
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+      def install_instrumentation
+        if defined?(Rails.initialized?) && !Rails.initialized?
+          Rails.configuration.after_initialize do
+            _install_instrumentation
+          end
+        else
+          _install_instrumentation
+        end
+      end
+      
+      def load_samplers
+        agent = NewRelic::Agent.instance
+        NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
+          begin
+            log.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+            sampler = subclass.new
+            if subclass.use_harvest_sampler?
+              agent.stats_engine.add_harvest_sampler sampler
+              log.debug "Registered #{subclass.name} for harvest time sampling"
+            else            
+              agent.stats_engine.add_sampler sampler
+              log.debug "Registered #{subclass.name} for periodic sampling"
+            end
+          rescue NewRelic::Agent::Sampler::Unsupported => e
+            log.info "#{subclass} sampler not available: #{e}"
+          rescue => e
+            log.error "Error registering sampler: #{e}, #{e.backtrace.join("\n")}"
+          end
+        end
+      end
+      
+      private
+      
+      def _install_instrumentation
+        return if @instrumented
+        
+        @instrumented = true
+        
+        # Instrumentation for the key code points inside rails for monitoring by NewRelic.
+        # note this file is loaded only if the newrelic agent is enabled (through config/newrelic.yml)
+        instrumentation_path = File.join(File.dirname(__FILE__), '..', 'agent','instrumentation')
+        @instrumentation_files <<
+        File.join(instrumentation_path, '*.rb') <<
+        File.join(instrumentation_path, app.to_s, '*.rb')
+        @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
+        log.debug "Finished instrumentation"
+      end
+    end
+  end
+end

data/lib/new_relic/control/logging_methods.rb

@@ -0,0 +1,74 @@
+
+module NewRelic
+  class Control
+    module LoggingMethods
+      
+      attr_accessor :log_file
+      
+      def log
+        # If we try to get a log before one has been set up, return a stdout log
+        unless @log
+          l = Logger.new(STDOUT)
+          l.level = Logger::INFO
+          return l
+        end
+        @log
+      end
+      
+      # send the given message to STDOUT so that it shows
+      # up in the console.  This should be used for important informational messages at boot.
+      # The to_stdout may be implemented differently by different config subclasses.
+      # This will NOT print anything if tracers are not enabled
+      def log!(msg, level=:info)
+        return unless should_log?
+        to_stdout msg
+        log.send level, msg if @log
+      end
+      
+      def should_log?
+        @settings && agent_enabled?
+      end
+      
+      # Control subclasses may override this, but it can be called multiple times.
+      def setup_log
+        @log_file = "#{log_path}/#{log_file_name}"
+        @log = Logger.new(@log_file) rescue nil
+        
+        # change the format just for our logger
+
+        def log.format_message(severity, timestamp, progname, msg)
+          "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n" 
+        end
+
+        # set the log level as specified in the config file
+        
+        case fetch("log_level","info").downcase
+          when "debug" then log.level = Logger::DEBUG
+          when "info" then log.level = Logger::INFO
+          when "warn" then log.level = Logger::WARN
+          when "error" then log.level = Logger::ERROR
+          when "fatal" then log.level = Logger::FATAL
+        else log.level = Logger::INFO
+        end
+        log
+      end
+      
+      def to_stdout(msg)
+        STDOUT.puts "** [NewRelic] " + msg 
+      end
+      
+      def log_path
+        return if @log_path
+        @log_path = File.expand_path(fetch('log_file_path', 'log/'))
+        if !File.directory?(@log_path) && ! (Dir.mkdir(@log_path) rescue nil) 
+          log!("Error creating New Relic log directory '#{@log_path}'", :error)
+        end
+        @log_path
+      end
+      
+      def log_file_name
+        fetch('log_file_name', 'newrelic_agent.log')
+      end
+    end
+  end
+end