honkster-newrelic_rpm 2.13.1

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/frameworks/external.rb

@@ -0,0 +1,13 @@
+# This is the control used when starting up in the context of
+# 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/frameworks/ruby'
+
+class NewRelic::Control::Frameworks::External < NewRelic::Control::Frameworks::Ruby
+
+  def init_config(options={})
+    super
+  end
+
+end

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

@@ -0,0 +1,24 @@
+class NewRelic::Control::Frameworks::Merb < NewRelic::Control
+
+  def env
+    @env ||= ::Merb.env
+  end
+  def root
+    ::Merb.root
+  end
+
+  def to_stdout(msg)
+    Merb.logger.info("NewRelic ~ " + msg)
+  rescue Exception => e
+    STDOUT.puts "NewRelic ~ " + msg
+  end
+
+  def init_config options={}
+    ::Merb::Plugins.add_rakefiles File.join(newrelic_root,"lib/tasks/all.rb")
+
+    # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+    ::Merb::Plugins.config[:newrelic] = {
+      :config => self
+    }
+  end
+end

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/frameworks/rails3.rb

@@ -0,0 +1,60 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values,
+# etc.
+require 'new_relic/control/frameworks/rails'
+class NewRelic::Control::Frameworks::Rails3 < NewRelic::Control::Frameworks::Rails
+
+  def env
+    @env ||= ::Rails.env.to_s
+  end
+
+  def root
+    @root ||= Rails.root.to_s
+  end
+
+  def logger
+    ::Rails.logger
+  end
+
+
+  def log!(msg, level=:info)
+    return unless should_log?
+    logger.send(level, msg)
+  rescue Exception => e
+    super
+  end
+
+  def to_stdout(msg)
+    logger.info(msg)
+  rescue
+    super
+  end
+
+  def vendor_root
+    @vendor_root ||= File.join(root,'vendor','rails')
+  end
+
+  def version
+    @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
+  end
+
+  protected
+
+  # 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'){ version }
+    local_env.append_environment_value('Rails threadsafe') do
+      ::Rails.configuration.action_controller.allow_concurrency == true
+    end
+    local_env.append_environment_value('Rails Env') { env }
+    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
+    local_env.append_plugin_list { ::Rails.configuration.plugins }
+  end
+
+end

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

@@ -0,0 +1,36 @@
+# A control used when no framework is detected.
+# Looks for a newrelic.yml file in several locations
+# 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::Frameworks::Ruby < NewRelic::Control
+
+  def env
+    @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+  end
+  def root
+    @root ||= ENV['APP_ROOT'] || Dir['.']
+  end
+  # Check a sequence of file locations for newrelic.yml
+  def config_file
+    files = []
+    files << File.join(root,"config","newrelic.yml")
+    files << File.join(root,"newrelic.yml")
+    if ENV["HOME"]
+      files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
+      files << File.join(ENV["HOME"], "newrelic.yml")
+    end
+    files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
+    files.each do | file |
+      return File.expand_path(file) if File.exists? file
+    end
+    return File.expand_path(files.first)
+  end
+  def to_stdout(msg)
+    STDOUT.puts msg
+  end
+
+  def init_config(options={})
+  end
+
+end

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

@@ -0,0 +1,18 @@
+
+require 'new_relic/control/frameworks/ruby'
+
+class NewRelic::Control::Frameworks::Sinatra < NewRelic::Control::Frameworks::Ruby
+
+  def env
+    @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+  end
+
+  # This is the control used when starting up in the context of
+  # 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.
+  def init_config(options={})
+    super
+  end
+
+end

data/lib/new_relic/control/instrumentation.rb

@@ -0,0 +1,95 @@
+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 _delayed_instrumentation
+        Rails.configuration.after_initialize do
+          _install_instrumentation
+        end
+      rescue
+        _install_instrumentation
+      end
+
+      def install_instrumentation
+        if defined?(Rails) && !Rails.initialized?
+          _delayed_instrumentation
+        else
+          _install_instrumentation
+        end
+      rescue NameError
+        # needed in the rails 3 case, where Rails.initialized? raises
+        # an error if rails has not been initialised. which is totally sane.
+        _delayed_instrumentation
+      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