wd_newrelic_rpm 3.3.4.1

data/lib/new_relic/control/class_methods.rb

@@ -0,0 +1,53 @@
+module NewRelic
+  class Control
+    # class-level methods for lazy creation of NewRelic::Control and
+    # NewRelic::LocalEnvironment instances.
+    module ClassMethods
+      # Access the Control singleton, lazy initialized.  Default will instantiate a new
+      # instance or pass false to defer
+      def instance(create=true)
+        @instance ||= create && new_instance
+      end
+      
+      # Access the LocalEnvironment singleton, lazy initialized
+      def local_env
+        @local_env ||= NewRelic::LocalEnvironment.new
+      end
+
+      # Create the concrete class for environment specific behavior
+      def new_instance
+        if local_env.framework == :test
+          load_test_framework
+        else
+          load_framework_class(local_env.framework).new(local_env)
+        end
+      end
+
+      # nb this does not 'load test' the framework, it loads the 'test framework'
+      def load_test_framework
+        config = File.expand_path(File.join('..','..','..','..', "test","config","newrelic.yml"), __FILE__)
+        require "config/test_control"
+        NewRelic::Control::Frameworks::Test.new(local_env, config)
+      end
+      
+      # Loads the specified framework class from the
+      # NewRelic::Control::Frameworks module
+      def load_framework_class(framework)
+        begin
+          require "new_relic/control/frameworks/#{framework}"
+        rescue LoadError
+          # maybe it is already loaded by some external system
+          # i.e. rpm_contrib or user extensions?
+        end
+        NewRelic::Control::Frameworks.const_get(framework.to_s.capitalize)
+      end
+
+      # The root directory for the plugin or gem
+      def newrelic_root
+        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
+      end
+    end
+    extend ClassMethods
+  end
+end
+

data/lib/new_relic/control/configuration.rb

@@ -0,0 +1,206 @@
+module NewRelic
+  class Control
+    # used to contain methods to look up settings from the
+    # configuration located in newrelic.yml
+    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' => 0.5
+        }
+        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 merge_server_side_config(data)
+        remove_server_controlled_configs
+        config = Hash.new
+        data.each_pair do |key, value|
+          if key.include?('.')
+            key = key.split('.')
+            config[key.first] ||= Hash.new
+            config[key.first][key[1]] = value
+          else
+            config[key] = value
+          end
+        end
+        merge_options(config)
+      end
+
+      def remove_server_controlled_configs
+        settings.delete('transaction_tracer')
+        settings.delete('slow_sql')
+        settings.delete('error_collector')
+        settings.delete('capture_params')
+      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
+        @apdex_t_float ||= fetch('apdex_t').to_f
+      end
+
+      def license_key
+        env_setting = ENV['NEW_RELIC_LICENSE_KEY'] || ENV['NEWRELIC_LICENSE_KEY']
+        fetch('license_key', env_setting)
+      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
+      
+      # whether we should install the
+      # NewRelic::Rack::BrowserMonitoring middleware automatically on
+      # Rails applications
+      def browser_monitoring_auto_instrument?
+        fetch('browser_monitoring', {}).fetch('auto_instrument', true)
+      end
+
+      def multi_threaded?
+        fetch('multi_threaded')
+      end
+
+      def disable_serialization?
+        fetch('disable_serialization', !DependencyDetection.installed?(:resque))
+      end
+      def disable_serialization=(b)
+        self['disable_serialization'] = b
+      end
+      
+      # True if we should view files in textmate
+      def use_textmate?
+        fetch('textmate')
+      end
+      
+      # defaults to 2MiB
+      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 New Relic 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 log_file_path
+        fetch('log_file_path', 'log/')
+      end
+      
+      # only verify certificates if you're very sure you want this
+      # level of security, it includes possibly app-crashing dns
+      # lookups every connection to the server
+      def verify_certificate?
+        unless @verify_certificate
+          unless use_ssl?
+            @verify_certificate = false
+          else
+            @verify_certificate = fetch('verify_certificate', false)
+          end
+        end
+        @verify_certificate
+      end
+
+      def disable_backtrace_cleanup?
+        fetch('disable_backtrace_cleanup')
+      end
+
+      def has_slow_sql_config?
+        self['slow_sql'] && self['slow_sql'].has_key?('enabled')
+      end
+    end
+    include Configuration
+  end
+end

data/lib/new_relic/control/frameworks.rb

@@ -0,0 +1,10 @@
+module NewRelic
+  class Control
+    # Contains subclasses of NewRelic::Control that are used when
+    # starting the agent within an application. Framework-specific
+    # logic should be included here, as documented within the Control
+    # abstract parent class
+    module Frameworks
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # 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.
+      class External < NewRelic::Control::Frameworks::Ruby
+        def init_config(options={})
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module NewRelic
+  class Control
+    module Frameworks
+      # Includes limited support for Merb
+      class Merb < NewRelic::Control
+
+        def env
+          @env ||= ::Merb.env
+        end
+        def root
+          ::Merb.root
+        end
+
+        def to_stdout(msg)
+          Merb.logger.info("NewRelic ~ " + msg)
+        rescue => 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
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails specific configuration, instrumentation, environment values,
+      # etc.
+      class Rails < NewRelic::Control::Frameworks::Ruby
+
+        def env
+          @env ||= RAILS_ENV.dup
+        end
+        def root
+          if defined?(RAILS_ROOT) && RAILS_ROOT.to_s != ''
+            RAILS_ROOT.to_s
+          else
+            super
+          end
+        end
+        def logger
+          ::RAILS_DEFAULT_LOGGER
+        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.  This is a best effort to 
+        # find a config and use that.
+        def init_config(options={})
+          rails_config = options[:config]
+          if !rails_config && defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            rails_config = ::Rails.configuration
+          end
+          # Install the dependency detection, 
+          if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+            rails_config.after_initialize do
+              # This will insure we load all the instrumentation as late as possible.  If the agent
+              # is not enabled, it will load a limited amount of instrumentation.  See 
+              # delayed_job_injection.rb
+              DependencyDetection.detect!
+            end
+          end          
+          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_browser_monitoring(rails_config)
+          end
+        end
+
+        def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
+          return if config.nil? || !config.respond_to?(:middleware) || ! browser_monitoring_auto_instrument?
+          begin
+            require 'new_relic/rack/browser_monitoring'
+            config.middleware.use NewRelic::Rack::BrowserMonitoring
+            log!("Installed New Relic Browser Monitoring middleware", :info)
+          rescue => e
+            log!("Error installing New Relic Browser Monitoring middleware: #{e.inspect}", :error)
+          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 => e
+              log!("Error installing New Relic Developer Mode: #{e.inspect}", :error)
+            end
+          elsif rails_config
+            log!("Developer mode not available for Rails versions prior to 2.2", :warn)
+          end
+        end
+
+        def log!(msg, level=:info)
+          if should_log?
+            logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
+            logger.send(level, msg)
+          else
+            super
+          end
+        rescue => e
+          super
+        end
+
+        def to_stdout(message)
+          logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
+          logger.info(message)
+        rescue => 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
+
+        def rails_gem_list
+          ::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
+
+        # 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
+              (bundler_gem_list + rails_gem_list).uniq
+            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.class_eval {
+            include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+          }
+        end
+
+      end
+    end
+  end
+end