ghazel-newrelic_rpm 3.1.0.1

data/lib/new_relic/control/class_methods.rb

@@ -0,0 +1,47 @@
+module NewRelic
+  class Control
+    module ClassMethods
+      # Access the Control singleton, lazy initialized
+      def instance
+        @instance ||= new_instance
+      end
+
+      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
+
+      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,157 @@
+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' => 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 [](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 browser_monitoring_auto_instrument?
+        fetch('browser_monitoring', {}).fetch('auto_instrument', true)
+      end
+
+      # True if the app runs in multi-threaded mode
+      def multi_threaded?
+        fetch('multi_threaded')
+      end
+
+      def disable_serialization?
+        fetch('disable_serialization', false)
+      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 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 verify_certificate?
+        unless @verify_certificate
+          unless use_ssl?
+            @verify_certificate = false
+          else
+            @verify_certificate = fetch('verify_certificate', false)
+          end
+        end
+        @verify_certificate
+      end
+    end
+    include Configuration
+  end
+end

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

@@ -0,0 +1,16 @@
+# 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'
+module NewRelic
+  class Control
+    module Frameworks
+      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,30 @@
+module NewRelic
+  class Control
+    module Frameworks
+      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 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
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values,
+# etc.
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      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
+
+        # 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_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 Exception => 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 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)
+          super unless should_log?
+          ::RAILS_DEFAULT_LOGGER.send(level, msg)
+        rescue Exception => e
+          super
+        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
+
+        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
+
+        def _install_instrumentation
+          super
+          if defined?(Rails) && Rails.respond_to?(:configuration) && Rails.configuration.respond_to?(:after_initialize)
+            Rails.configuration.after_initialize do
+              DependencyDetection.detect!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# Control subclass instantiated when Rails is detected.  Contains
+# Rails specific configuration, instrumentation, environment values,
+# etc.
+require 'new_relic/control/frameworks/rails'
+module NewRelic
+  class Control
+    module Frameworks
+      class Rails3 < NewRelic::Control::Frameworks::Rails
+
+        def env
+          ::Rails.env.to_s
+        end
+        
+        # Rails can return an empty string from this method, causing
+        # the agent not to start even when it is properly in a rails 3
+        # application, so we test the value to make sure it actually
+        # has contents, and bail to the parent class if it is empty.
+        def root
+          value = ::Rails.root.to_s
+          if value.empty?
+            super
+          else
+            value
+          end
+        end
+
+        def logger
+          ::Rails.logger
+        end
+
+
+        def log!(msg, level=:info)
+          super 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
+            true == ::Rails.configuration.action_controller.allow_concurrency
+          end
+          local_env.append_environment_value('Rails Env') { env }
+          local_env.append_gem_list do
+            bundler_gem_list
+          end
+          local_env.append_plugin_list { ::Rails.configuration.plugins.to_a }
+        end
+      end
+    end
+  end
+end