sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/control.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+require 'conditional_vendored_metric_parser'
+require 'conditional_vendored_dependency_detection'
+require 'new_relic/local_environment'
+require 'new_relic/helper'
+
+require 'singleton'
+require 'erb'
+require 'socket'
+require 'net/https'
+require 'logger'
+require 'new_relic/control/frameworks'
+require 'new_relic/control/profiling'
+require 'new_relic/control/server_methods'
+require 'new_relic/control/instrumentation'
+require 'new_relic/control/class_methods'
+require 'new_relic/control/instance_methods'
+
+require 'new_relic/agent'
+require 'new_relic/delayed_job_injection'
+
+
+module NewRelic
+
+  # The Control is a singleton responsible for the startup and
+  # initialization sequence.  The initializer uses a LocalEnvironment to
+  # detect the framework and instantiates the framework specific
+  # subclass.
+  #
+  # The Control also implements some of the public API for the agent.
+  #
+  class Control
+    # done in a subfile for load order purposes
+    # extend ClassMethods
+    # include InstanceMethods
+    # include Profiling
+    # include Configuration
+    # include ServerMethods
+    # include Instrumentation
+
+
+
+  end
+end

data/lib/new_relic/control/class_methods.rb

@@ -0,0 +1,58 @@
+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
+
+      # clear out memoized Control and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      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 Agent.config[:framework] == :test
+          load_test_framework
+        else
+          load_framework_class(Agent.config[: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/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,25 @@
+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 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,173 @@
+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
+
+        # 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
+          root = rails_root.to_s
+          if !root.empty?
+            root
+          else
+            super
+          end
+        end
+
+        def rails_root
+          RAILS_ROOT if defined?(RAILS_ROOT)
+        end
+
+        def rails_config
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            ::Rails.configuration
+          else
+            @config
+          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.  This is a best effort to
+        # find a config and use that.
+        def init_config(options={})
+          @config = options[:config]
+          # 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.config[:agent_enabled]
+            # Might not be running if it does not think mongrel, thin, passenger, etc
+            # is running, if it thinks it's a rake task, or if the agent_enabled is false.
+            ::NewRelic::Agent.logger.info("New Relic Agent not running.")
+          else
+            ::NewRelic::Agent.logger.info("Starting the New Relic Agent.")
+            install_developer_mode(rails_config) if Agent.config[:developer_mode]
+            install_browser_monitoring(rails_config)
+            install_agent_hooks(rails_config)
+          end
+        end
+
+        def install_agent_hooks(config)
+          return if @agent_hooks_installed
+          @agent_hooks_installed = true
+          return if config.nil? || !config.respond_to?(:middleware)
+          begin
+            require 'new_relic/rack/agent_hooks'
+            config.middleware.use NewRelic::Rack::AgentHooks
+            ::NewRelic::Agent.logger.debug("Installed New Relic Agent Hooks middleware")
+          rescue => e
+            ::NewRelic::Agent.logger.warn("Error installing New Relic Agent Hooks middleware", e)
+          end
+        end
+
+        def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
+          return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
+          begin
+            require 'new_relic/rack/browser_monitoring'
+            config.middleware.use NewRelic::Rack::BrowserMonitoring
+            ::NewRelic::Agent.logger.debug("Installed New Relic Browser Monitoring middleware")
+          rescue => e
+            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
+          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"
+                ::NewRelic::Agent.logger.debug("NewRelic Agent Developer Mode enabled.")
+                ::NewRelic::Agent.logger.debug("To view performance information, go to http://localhost#{port}/newrelic")
+              end
+            rescue => e
+              ::NewRelic::Agent.logger.warn("Error installing New Relic Developer Mode", e)
+            end
+          elsif rails_config
+            ::NewRelic::Agent.logger.warn("Developer mode not available for Rails versions prior to 2.2")
+          end
+        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'
+          if ActiveSupport.respond_to?(:on_load) # rails 3+
+            ActiveSupport.on_load(:action_controller) { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          else
+            ActionController::Base.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'new_relic/control/frameworks/rails'
+require 'new_relic/rack/error_collector'
+module NewRelic
+  class Control
+    module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails 3.0+  specific configuration, instrumentation, environment values,
+      # etc. Many methods are inherited from the
+      # NewRelic::Control::Frameworks::Rails class, where the two do
+      # not differ
+      class Rails3 < NewRelic::Control::Frameworks::Rails
+
+        def env
+          @env ||= ::Rails.env.to_s
+        end
+
+        def rails_root
+          ::Rails.root.to_s
+        end
+
+        def init_config(options={})
+          super
+          if Agent.config[:agent_enabled] && Agent.config[:'error_collector.enabled']
+            if !rails_config.middleware.respond_to?(:include?) ||
+                !rails_config.middleware.include?(NewRelic::Rack::ErrorCollector)
+              add_error_collector_middleware
+            end
+          end
+        end
+
+        def add_error_collector_middleware
+          rails_config.middleware.use NewRelic::Rack::ErrorCollector
+        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'){ ::Rails::VERSION::STRING }
+          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
+          append_plugin_list
+        end
+
+        def append_plugin_list
+          local_env.append_plugin_list { ::Rails.configuration.plugins.to_a }
+        end
+        
+        def install_shim
+          super
+          ActiveSupport.on_load(:action_controller) do
+            include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'new_relic/control/frameworks/rails3'
+require 'new_relic/rack/error_collector'
+module NewRelic
+  class Control
+    module Frameworks
+      class Rails4 < NewRelic::Control::Frameworks::Rails3
+        def rails_gem_list
+          Bundler.rubygems.all_specs.map do |gem|
+            "#{gem.name} (#{gem.version})"
+          end
+        end
+
+        def add_error_collector_middleware
+          # rails_config.middleware.use NewRelic::Rack::ErrorCollector
+        end
+
+        def append_plugin_list
+          # Rails 4 does not allow plugins
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module NewRelic
+  class Control
+    module Frameworks
+      # A control used when no framework is detected - the default.
+      class Ruby < NewRelic::Control
+
+        def env
+          @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+        end
+
+        def root
+          @root ||= ENV['APP_ROOT'] || '.'
+        end
+
+        def init_config(options={})
+        end
+
+      end
+    end
+  end
+end