wd_newrelic_rpm 3.3.4.1

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

@@ -0,0 +1,75 @@
+require 'new_relic/control/frameworks/rails'
+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
+        
+        # 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)
+          if should_log?
+            logger.send(level, msg)
+          else
+            super
+          end
+        rescue => 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

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

@@ -0,0 +1,42 @@
+module NewRelic
+  class Control
+    module Frameworks
+      # A control used when no framework is detected - the default.
+      # 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 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
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Sinatra
+      class Sinatra < NewRelic::Control::Frameworks::Ruby
+
+        def env
+          @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+        end
+
+        def init_config(options={})
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/control/instance_methods.rb

@@ -0,0 +1,179 @@
+require 'new_relic/language_support'
+
+module NewRelic
+  class Control
+    include NewRelic::LanguageSupport::Control
+
+    # Contains methods that relate to the runtime usage of the control
+    # object. Note that these are subject to override in the
+    # NewRelic::Control::Framework classes that are actually instantiated
+    module InstanceMethods
+      # The env is the setting used to identify which section of the newrelic.yml
+      # to load.  This defaults to a framework specific value, such as ENV['RAILS_ENV']
+      # but can be overridden as long as you set it before calling #init_plugin
+      attr_writer :env
+
+      # The local environment contains all the information we report
+      # to the server about what kind of application this is, what
+      # gems and plugins it uses, and many other kinds of
+      # machine-dependent information useful in debugging
+      attr_reader :local_env
+
+
+      # Initialize the plugin/gem and start the agent.  This does the
+      # necessary configuration based on the framework environment and
+      # determines whether or not to start the agent.  If the agent is
+      # not going to be started then it loads the agent shim which has
+      # stubs for all the external api.
+      #
+      # This may be invoked multiple times, as long as you don't attempt
+      # to uninstall the agent after it has been started.
+      #
+      # If the plugin is initialized and it determines that the agent is
+      # not enabled, it will skip starting it and install the shim.  But
+      # if you later call this with <tt>:agent_enabled => true</tt>,
+      # then it will install the real agent and start it.
+      #
+      # What determines whether the agent is launched is the result of
+      # calling agent_enabled?  This will indicate whether the
+      # instrumentation should/will be installed.  If we're in a mode
+      # where tracers are not installed then we should not start the
+      # agent.
+      #
+      # Subclasses are not allowed to override, but must implement
+      # init_config({}) which is called one or more times.
+      #
+      def init_plugin(options={})
+        options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
+        options['app_name'] ||= ENV['NEW_RELIC_APP_NAME'] if ENV['NEW_RELIC_APP_NAME']
+
+        # Merge the stringified options into the config as overrides:
+        logger_override = options.delete(:log)
+        environment_name = options.delete(:env) and self.env = environment_name
+        dispatcher = options.delete(:dispatcher) and @local_env.dispatcher = dispatcher
+        dispatcher_instance_id = options.delete(:dispatcher_instance_id) and @local_env.dispatcher_instance_id = dispatcher_instance_id
+
+
+        # Clear out the settings, if they've already been loaded.  It may be that
+        # between calling init_plugin the first time and the second time, the env
+        # has been overridden
+        @settings = nil
+        settings
+        merge_options(options)
+        if logger_override
+          @log = logger_override
+          # Try to grab the log filename
+          @log_file = @log.instance_eval { @logdev.filename rescue nil }
+        end
+        # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
+        # methods in the module methods.
+        Module.send :include, NewRelic::Agent::MethodTracer::ClassMethods
+        Module.send :include, NewRelic::Agent::MethodTracer::InstanceMethods
+        init_config(options)
+        NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
+        if agent_enabled? && !NewRelic::Agent.instance.started?
+          setup_log unless logger_override
+          start_agent
+          install_instrumentation
+          load_samplers unless self['disable_samplers']
+          local_env.gather_environment_info
+          append_environment_info
+        elsif !agent_enabled?
+          install_shim
+        end
+      end
+
+      # Install the real agent into the Agent module, and issue the start command.
+      def start_agent
+        NewRelic::Agent.agent.start
+      end
+
+      # True if dev mode or monitor mode are enabled, and we are running
+      # inside a valid dispatcher like mongrel or passenger.  Can be overridden
+      # by NEWRELIC_ENABLE env variable, monitor_daemons config option when true, or
+      # agent_enabled config option when true or false.
+      def agent_enabled?
+        return false if !developer_mode? && !monitor_mode?
+        return self['agent_enabled'].to_s =~ /true|on|yes/i if !self['agent_enabled'].nil? && self['agent_enabled'] != 'auto'
+        return false if ENV['NEWRELIC_ENABLE'].to_s =~ /false|off|no/i
+        return true if self['monitor_daemons'].to_s =~ /true|on|yes/i
+        return true if ENV['NEWRELIC_ENABLE'].to_s =~ /true|on|yes/i
+        # When in 'auto' mode the agent is enabled if there is a known
+        # dispatcher running
+        return true if @local_env.dispatcher != nil
+      end
+      
+      # Asks the LocalEnvironment instance which framework should be loaded
+      def app
+        @local_env.framework
+      end
+      alias framework app
+      
+      def to_s #:nodoc:
+        "Control[#{self.app}]"
+      end
+
+      protected
+
+      # Append framework specific environment information for uploading to
+      # the server for change detection.  Override in subclasses
+      def append_environment_info; end
+      
+      # Asks bundler to tell us which gemspecs are loaded in the
+      # current process
+      def bundler_gem_list
+        if defined?(Bundler) && Bundler.instance_eval do @load end
+          Bundler.load.specs.map do | spec |
+            version = (spec.respond_to?(:version) && spec.version)
+            spec.name + (version ? "(#{version})" : "")
+          end
+        else
+          []
+        end
+      end
+      
+      # path to the config file, defaults to the "#{root}/config/newrelic.yml"
+      def config_file
+        File.expand_path(File.join(root,"config","newrelic.yml"))
+      end
+      
+      # initializes the control instance with a local environment and
+      # an optional config file override. Checks for the config file
+      # and loads it.
+      def initialize local_env, config_file_override=nil
+        @local_env = local_env
+        @instrumentation_files = []
+        newrelic_file = config_file_override || config_file
+        # Next two are for populating the newrelic.yml via erb binding, necessary
+        # when using the default newrelic.yml file
+        generated_for_user = ''
+        license_key=''
+        if !File.exists?(newrelic_file)
+          puts "Cannot find or read #{newrelic_file}"
+          @yaml = {}
+        else
+          @yaml = load_newrelic_yml(newrelic_file, binding)
+        end
+      rescue ScriptError, StandardError => e
+        new_err = e.class.new("Error reading newrelic.yml file: #{e}")
+        new_err.set_backtrace(e.backtrace)
+        raise new_err
+      end
+      
+      def load_newrelic_yml(path, binding)
+        YAML.load(ERB.new(File.read(path)).result(binding))
+      end
+      
+      def root
+        '.'
+      end
+
+      # Delegates to the class method newrelic_root, implemented by
+      # each subclass
+      def newrelic_root
+        self.class.newrelic_root
+      end
+    end
+    include InstanceMethods
+  end
+end

data/lib/new_relic/control/instrumentation.rb

@@ -0,0 +1,100 @@
+module NewRelic
+  class Control
+    # Contains methods that relate to adding and executing files that
+    # contain instrumentation for the Ruby Agent
+    module Instrumentation
+
+      # Adds a list of files in Dir.glob format
+      # (e.g. '/app/foo/**/*_instrumentation.rb')
+      # This requires the files within a rescue block, so that any
+      # errors within instrumentation files do not affect the overall
+      # agent or application in which it runs.
+      #
+      # Logs at debug level for each file loaded, and logs errors in
+      # file loading at error level
+      def load_instrumentation_files pattern
+        Dir.glob(pattern) do |file|
+          begin
+            log.debug "Processing instrumentation file '#{file}'"
+            require file.to_s
+          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, otherwise instrumentation files specified
+      # here will be deferred until all instrumentation is run
+      #
+      # This happens after the agent has loaded and all dependencies
+      # are ready to be instrumented
+      def add_instrumentation pattern
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+      
+      # Signals the agent that it's time to actually load the
+      # instrumentation files. May be overridden by subclasses
+      def install_instrumentation
+        _install_instrumentation
+      end
+      
+      # adds samplers to the stats engine so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses NewRelic::Agent::Sampler
+      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.expand_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 }
+        DependencyDetection.detect!
+        log.debug "Finished instrumentation"
+      end
+    end
+    include Instrumentation
+  end
+end

data/lib/new_relic/control/logging_methods.rb

@@ -0,0 +1,143 @@
+
+module NewRelic
+  class Control
+    # Contains methods that relate to locating, creating, and writing
+    # to the log file and/or standard out
+    module LoggingMethods
+
+      attr_accessor :log_file
+      
+      # returns either the log set up with setup_log or else a new
+      # logger pointing to standard out, if we're trying to log before
+      # a log exists
+      def log
+        if !@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)
+        to_stdout msg
+        return unless should_log?
+        log.send level, msg if @log
+      end
+      
+      # true if the agent has settings, and the agent is enabled,
+      # otherwise false
+      def should_log?
+        @settings && agent_enabled?
+      end
+
+      # set the log level as specified in the config file
+      #
+      # Possible values are from the Logger class: debug, info, warn,
+      #error, and fatal
+      # Defaults to info
+      def set_log_level!(logger)
+        case fetch("log_level","info").downcase
+          when "debug" then logger.level = Logger::DEBUG
+          when "info" then logger.level = Logger::INFO
+          when "warn" then logger.level = Logger::WARN
+          when "error" then logger.level = Logger::ERROR
+          when "fatal" then logger.level = Logger::FATAL
+          else logger.level = Logger::INFO
+        end
+        logger
+      end
+
+      # patches the logger's format_message method to change the format just for our logger
+      def set_log_format!(logger)
+        def logger.format_message(severity, timestamp, progname, msg)
+          prefix = @logdev.dev == STDOUT ? '** [NewRelic]' : ''
+          prefix + "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+        logger
+      end
+
+      # Create the logger using the configuration variables
+      #
+      # Control subclasses may override this, but it can be called multiple times.
+      def setup_log
+        if log_to_stdout?
+          @log = Logger.new(STDOUT) 
+        else
+          @log_file = "#{log_path}/#{log_file_name}"
+          @log = Logger.new(@log_file) rescue nil
+          @log ||= Logger.new(STDOUT) # failsafe to STDOUT
+        end
+        
+        if @log
+          set_log_format!(@log)
+          set_log_level!(@log)
+        end
+        # note this is not the variable from above - it is the `log`
+        # method, which returns a default logger if none is setup
+        # above
+        log
+      end
+      
+      # simply puts a message to standard out, prepended with the
+      # '** [NewRelic]' sigil to make sure people know where the message
+      # comes from. This should be used sparingly
+      def to_stdout(msg)
+        STDOUT.puts "** [NewRelic] " + msg
+      end
+      
+      # Sets up and caches the log path, attempting to create it if it
+      # does not exist.  If it does not succeed, it prints an
+      # error and returns nil.
+      # This comes from the configuration variable 'log_file_path' in the configuration file.
+      def log_path
+        return @log_path if @log_path
+        if log_to_stdout?
+          @log_path = nil
+        else
+          if ENV['NEW_RELIC_LOG']
+            log_path_setting = File.dirname(ENV['NEW_RELIC_LOG'])
+          else
+            log_path_setting = fetch('log_file_path', 'log')
+          end
+          @log_path = find_or_create_file_path(log_path_setting)
+          log!("Error creating log directory #{log_path_setting}, using standard out for logging.", :warn) unless @log_path
+        end
+        @log_path
+      end
+        
+      def find_or_create_file_path(path_setting)
+        for abs_path in [ File.expand_path(path_setting),
+                          File.expand_path(File.join(root, path_setting)) ] do
+          if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
+            return abs_path[%r{^(.*?)/?$}]
+          end
+        end
+        nil
+      end
+
+      def log_to_stdout?
+        return true if @stdout
+        destination = ENV['NEW_RELIC_LOG'] || fetch('log_file_path', 'log')
+        if destination.upcase == 'STDOUT'
+          @stdout = true
+        end
+      end
+        
+      # Retrieves the log file's name from the config file option
+      #'log_file_name', defaulting to 'newrelic_agent.log'
+      def log_file_name
+        if ENV['NEW_RELIC_LOG']
+          File.basename(ENV['NEW_RELIC_LOG'])
+        else
+          fetch('log_file_name', 'newrelic_agent.log')
+        end
+      end
+    end
+    include LoggingMethods
+  end
+end