factorylabs-newrelic_rpm 2.10.2.2

data/lib/new_relic/agent/worker_loop.rb

@@ -0,0 +1,118 @@
+module NewRelic::Agent
+  
+  # A worker loop executes a set of registered tasks on a single thread.  
+  # A task is a proc or block with a specified call period in seconds.  
+  class WorkerLoop
+    
+    attr_reader :log
+    attr_reader :pid
+    
+    def initialize(log = Logger.new(STDERR))
+      @tasks = []
+      @log = log
+      @should_run = true
+      @pid = $$
+    end
+    
+    # Run infinitely, calling the registered tasks at their specified
+    # call periods.  The caller is responsible for creating the thread
+    # that runs this worker loop
+    def run
+      while keep_running do
+        run_next_task
+      end
+    end
+    
+    def keep_running
+      @should_run && (@pid == $$)
+    end
+    
+    def stop
+      @should_run = false
+    end
+    
+    MIN_CALL_PERIOD = 0.1
+    
+    # add a task to the worker loop.  The task will be called approximately once
+    # every call_period seconds.  The task is passed as a block
+    def add_task(call_period, desc="", &task_proc)
+      if call_period < MIN_CALL_PERIOD
+        raise ArgumentError, "Invalid Call Period (must be > #{MIN_CALL_PERIOD}): #{call_period}" 
+      end
+      @tasks << LoopTask.new(call_period, desc, &task_proc)
+    end
+    
+    private 
+    def next_task
+      @tasks.inject do |soonest, task|
+       (task.next_invocation_time < soonest.next_invocation_time) ? task : soonest
+      end
+    end
+    
+    def run_next_task
+      if @tasks.empty?
+        sleep 5.0
+        return
+      end
+      
+      # get the next task to be executed, which is the task with the lowest (ie, soonest)
+      # next invocation time.
+      task = next_task
+      
+      # sleep in chunks no longer than 1 second
+      while Time.now < task.next_invocation_time
+        
+        # sleep until this next task's scheduled invocation time
+        sleep_time = task.next_invocation_time - Time.now
+        sleep sleep_time if sleep_time > 0
+        return if !keep_running
+      end
+      
+      begin
+        task.execute
+      rescue ServerError => e
+        log.debug "Server Error: #{e}"
+      rescue NewRelic::Agent::ForceRestartException => e
+        # blow out the loop
+        raise
+      rescue RuntimeError => e
+        # This is probably a server error which has been logged in the server along
+        # with your account name.  Check and see if the agent listener is in the
+        # stack trace and log it quietly if it is.
+        message = "Error running task in worker loop, likely a server error (#{e})"
+        if e.backtrace.grep(/agent_listener/).empty?
+          log.error message
+        else
+          log.debug message
+          log.debug e.backtrace.join("\n")
+        end
+      rescue Timeout::Error, NewRelic::Agent::IgnoreSilentlyException
+        # Want to ignore these because they are handled already
+      rescue ScriptError, StandardError => e 
+        log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}" 
+        log.debug e.backtrace.join("\n")
+      end
+    end
+    
+    class LoopTask
+      
+      def initialize(call_period, desc="", &task_proc) 
+        @call_period = call_period
+        @last_invocation_time = Time.now
+        @task = task_proc
+        @desc = desc
+      end
+      def to_s
+        "Task[#{@desc}]"
+      end
+      def next_invocation_time
+        @last_invocation_time + @call_period
+      end
+      
+      def execute
+        @last_invocation_time = Time.now
+        @task.call
+      end
+    end
+  end
+end

data/lib/new_relic/commands/deployments.rb

@@ -0,0 +1,145 @@
+# This is a class for executing commands related to deployment 
+# events.  It runs without loading the rails environment
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__),"..",".."))
+require 'yaml'
+require 'net/http'
+require 'rexml/document'
+
+# We need to use the Control object but we don't want to load 
+# the rails/merb environment.  The defined? clause is so that
+# it won't load it twice, something it does when run inside a test
+require 'new_relic/control' unless defined? NewRelic::Control
+
+module NewRelic
+  module Commands
+    # Capture a failure to execute the command.
+    # Ask it for a return status to exit the vm with,
+    # if appropriate.
+    class CommandFailure < StandardError
+      attr_reader :exit_code
+      def initialize message, return_status=nil
+        super message
+        @exit_code = return_status || 0
+      end
+    end
+    
+    class Deployments
+      
+      attr_reader :config
+      def self.command; "deployments"; end 
+      
+      # Initialize the deployment uploader with command line args.
+      # Use -h to see options.
+      # When command_line_args is a hash, we are invoking directly and
+      # it's treated as an options with optional sttring values for
+      # :user, :description, :appname, :revision, :environment,
+      # and :changes.
+      #
+      # Will throw CommandFailed exception if there's any error.
+      # 
+      def initialize command_line_args
+        @config = NewRelic::Control.instance
+        @user = ENV['USER']
+        if Hash === command_line_args
+          # command line args is an options hash
+          command_line_args.each do | key, value |
+            if %w[user environment description appname revision changelog].include? key.to_s
+              instance_variable_set "@#{key}", value.to_s if value
+            else
+              raise "Unrecognized option #{key}=#{value}"
+            end
+          end
+        else
+          # parse command line args.  Throw an exception on a bad arg.
+          @description = options.parse(command_line_args).join " "
+        end
+        config.env = @environment if @environment
+        @appname ||= config.app_names[0] || config.env || 'development'
+      end
+      
+      # Run the Deployment upload in RPM via Active Resource.
+      # Will possibly print errors and exit the VM
+      def run
+        begin
+          @description = nil if @description && @description.strip.empty?
+          create_params = {}
+          {
+            :application_id => @appname, 
+            :host => Socket.gethostname, 
+            :description => @description,
+            :user => @user,
+            :revision => @revision,
+            :changelog => @changelog
+          }.each do |k, v|
+            create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
+          end
+          http = config.http_connection(config.api_server)
+          
+          uri = "/deployments.xml"
+          
+          raise "license_key was not set in newrelic.yml for #{config.env}" if config['license_key'].nil?
+          request = Net::HTTP::Post.new(uri, {'x-license-key' => config['license_key']})
+          request.content_type = "application/octet-stream"
+          
+          request.set_form_data(create_params)
+          
+          response = http.request(request)
+          
+          if response.is_a? Net::HTTPSuccess
+            info "Recorded deployment to '#{@appname}' (#{@description || Time.now })"
+          else
+            err_string = [ "Unexpected response from server: #{response.code}: #{response.message}" ]
+            begin
+              doc = REXML::Document.new(response.body)
+              doc.elements.each('errors/error') do |error|
+                err_string << "Error: #{error.text}"
+              end
+            rescue
+            end
+            raise CommandFailure.new(err_string.join("\n"), -1)
+          end 
+        rescue SystemCallError, SocketError => e
+          # These include Errno connection errors 
+          err_string = "Transient error attempting to connect to #{config.api_server} (#{e})"
+          raise CommandFailure.new(err_string, -1)
+        rescue CommandFailure
+          raise
+        rescue Exception => e
+          err "Unexpected error attempting to connect to #{config.api_server}"
+          info "#{e}: #{e.backtrace.join("\n   ")}"
+          raise CommandFailure.new(e.to_s, -1)
+        end
+      end
+      
+      private
+      
+      def options
+        OptionParser.new %Q{Usage: #{$0} [OPTIONS] ["description"] }, 40 do |o|
+          o.separator "OPTIONS:"
+          o.on("-a", "--appname=NAME", String,
+             "Set the application name.",
+             "Default is app_name setting in newrelic.yml") { | e | @appname = e }
+          o.on("-e", "--environment=name", String,
+               "Override the (RAILS|MERB|RUBY)_ENV setting",
+               "currently: #{config.env}") { | e | @environment = e }
+          o.on("-u", "--user=USER", String,
+             "Specify the user deploying.",
+             "Default: #{@user}") { | u | @user = u }
+          o.on("-r", "--revision=REV", String,
+             "Specify the revision being deployed") { | r | @revision = r }
+          o.on("-c", "--changes", 
+             "Read in a change log from the standard input") { @changelog = STDIN.read }
+          o.on("-h", "--help", "Print this help") { raise CommandFailure.new(o.help, 0) }
+        end
+      end
+      
+      def info message
+        STDOUT.puts message
+      end
+      def err message
+        STDERR.puts message
+      end  
+    end
+  end
+end

data/lib/new_relic/commands/new_relic_commands.rb

@@ -0,0 +1,30 @@
+require 'optparse'
+
+# Run the command given by the first argument.  Right
+# now all we have is deployments. We hope to have other
+# kinds of events here later.
+
+libdir = File.expand_path(File.join(File.dirname(__FILE__), '..','..'))
+command_list = Dir[File.join(libdir,'new_relic','commands','*.rb')].map{|command| command =~ /.*\/(.*)\.rb/ && $1}
+command_list.delete 'new_relic_commands'
+extra = []
+options = ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: #{__FILE__} #{ command_list.join(" | ")} [options]"
+  opts.separator "use -h to see detailed command options"
+  opts
+end
+extra = options.order!
+command = extra.shift
+if !command_list.include?(command)
+  STDERR.puts options
+else
+  require File.join(libdir, 'new_relic','commands', command + ".rb")
+  command_class = NewRelic::Commands.const_get(command.capitalize) 
+  begin
+    command_class.new(extra).run
+  rescue NewRelic::Commands::CommandFailure => failure
+    STDERR.puts failure.message
+    exit failure.exit_code
+  end
+end

data/lib/new_relic/control.rb

@@ -0,0 +1,484 @@
+require 'yaml'
+require 'new_relic/local_environment'
+require 'singleton'
+require 'erb'
+require 'socket'
+require 'net/https'
+require 'logger'
+
+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
+    
+    # A flag used in dev mode to indicate if profiling is available
+    def profiling?
+      @profiling
+    end
+    
+    def profiling_available?
+      @profiling_available ||= 
+      begin
+        require 'ruby-prof'
+        true
+      rescue LoadError; end
+    end
+    # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+    # loaded a true value is ignored.
+    def profiling=(val)
+      @profiling = profiling_available? && val && defined?(RubyProf)
+    end
+    
+    attr_accessor :log_file
+    # 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
+    attr_reader :local_env
+    
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+    
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+    
+    # Access the Control singleton, lazy initialized
+    def self.instance
+      @instance ||= new_instance
+    end
+    
+    # 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 at most once.
+    #
+    def init_plugin(options={})
+      require 'new_relic/agent'
+      # Merge the stringified options into the config as overrides:
+      logger_override = options.delete(:log)
+      environment_name = options.delete(:env)
+      self.env = environment_name if environment_name
+      # 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
+      
+      options.each { |sym, val | self[sym.to_s] = val unless sym == :config }
+      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)
+      if agent_enabled? && !@started
+        setup_log unless logger_override
+        start_agent
+        install_instrumentation
+        load_samplers unless self['disable_samplers']
+        local_env.gather_environment_info
+        append_environment_info
+        @started = true
+      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 = NewRelic::Agent::Agent.instance
+      NewRelic::Agent.agent.start
+    end
+    
+    def [](key)
+      fetch(key)
+    end
+    
+    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 []=(key, value)
+      settings[key] = value
+    end
+    
+    def fetch(key, default=nil)
+      settings.fetch(key, default)
+    end
+    # Add your own environment value to track for change detection.
+    # The name and value should be stable and not vary across app processes on 
+    # the same host.
+    def append_environment_info(name, value)
+      local_env.record_environment_info(name,value)
+    end
+    
+    ###################################
+    # Agent config conveniences
+    
+    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
+    # 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
+    # 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
+    
+    def app
+      @local_env.framework
+    end
+    alias framework app
+    
+    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
+      self['app_name'] ? self['app_name'].split(';') : []
+    end
+    
+    def use_ssl?
+      @use_ssl ||= fetch('ssl', false)
+    end
+    
+    def verify_certificate?
+      #this can only be on when SSL is enabled
+      @verify_certificate ||= ( use_ssl? ? fetch('verify_certificate', false) : false)
+    end
+    
+    def server
+      @remote_server ||= server_from_host(nil)  
+    end
+    
+    def api_server
+      api_host = self['api_host'] || 'rpm.newrelic.com' 
+      @api_server ||= 
+      NewRelic::Control::Server.new \
+      api_host, 
+       (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i, 
+      nil
+    end
+    
+    def proxy_server
+      @proxy_server ||=
+      NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass'] 
+    end
+    
+    def server_from_host(hostname=nil)
+      host = hostname || self['host'] || 'collector.newrelic.com'
+      
+      # if the host is not an IP address, turn it into one
+      NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host) 
+    end
+    
+    # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+    # Default is the collector but for api calls you need to pass api_server
+    #
+    # Experimental support for SSL verification:
+    # swap 'VERIFY_NONE' for 'VERIFY_PEER' line to try it out
+    # If verification fails, uncomment the 'http.ca_file' line
+    # and it will use the included certificate.
+    def http_connection(host = nil)
+      host ||= server
+      # Proxy returns regular HTTP if @proxy_host is nil (the default)
+      http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port, 
+                                    proxy_server.user, proxy_server.password)
+      http = http_class.new(host.ip || host.name, host.port)
+      if use_ssl?
+        http.use_ssl = true
+        if verify_certificate?
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.ca_file = File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+      http
+    end
+    def to_s
+      "Control[#{self.app}]"
+    end
+    
+    def log
+      # If we try to get a log before one has been set up, return a stdout log
+      unless @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)
+      return if @settings && !agent_enabled?
+      to_stdout msg
+      log.send level, msg if @log
+    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 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
+    
+    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.info "Registered #{subclass.name} for harvest time sampling"
+          else            
+            agent.stats_engine.add_sampler sampler
+            log.info "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
+    
+    protected
+    
+    # Append framework specific environment information for uploading to
+    # the server for change detection.  Override in subclasses
+    def append_environment_info; end
+    
+    # Look up the ip address of the host using the pure ruby lookup 
+    # to prevent blocking.  If that fails, fall back to the regular
+    # IPSocket library.  Return nil if we can't find the host ip
+    # address and don't have a good default.
+    def convert_to_ip_address(host)
+      # here we leave it as a host name since the cert verification
+      # needs it in host form
+      return host if verify_certificate?
+      return nil if host.nil? || host.downcase == "localhost"
+      # Fall back to known ip address in the common case
+      ip_address = '65.74.177.195' if host.downcase == 'collector.newrelic.com'
+      begin
+        ip_address = Resolv.getaddress(host)
+        log.info "Resolved #{host} to #{ip_address}"
+      rescue => e
+        log.warn "DNS Error caching IP address: #{e}"
+        log.debug e.backtrace.join("\n   ")
+        ip_address = IPSocket::getaddress host rescue ip_address
+      end
+      ip_address
+    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
+    
+    # Control subclasses may override this, but it can be called multiple times.
+    def setup_log
+      @log_file = "#{log_path}/newrelic_agent.log"
+      @log = Logger.new @log_file
+      
+      # change the format just for our logger
+      
+      def @log.format_message(severity, timestamp, progname, msg)
+        "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n" 
+      end
+      
+      # set the log level as specified in the config file
+      case fetch("log_level","info").downcase
+      when "debug" then @log.level = Logger::DEBUG
+      when "info" then @log.level = Logger::INFO
+      when "warn" then @log.level = Logger::WARN
+      when "error" then @log.level = Logger::ERROR
+      when "fatal" then @log.level = Logger::FATAL
+      else @log.level = Logger::INFO
+      end
+      @log
+    end
+    
+    def to_stdout(msg)
+      STDOUT.puts "** [NewRelic] " + msg 
+    end
+    
+    def config_file
+      File.expand_path(File.join(root,"config","newrelic.yml"))
+    end
+    
+    def log_path
+      path = File.join(root,'log')
+      unless File.directory? path
+        path = '.'
+      end
+      File.expand_path(path)
+    end
+    
+    # Create the concrete class for environment specific behavior:
+    def self.new_instance
+      @local_env = NewRelic::LocalEnvironment.new
+      if @local_env.framework == :test
+        require File.join(newrelic_root, "test", "config", "test_control.rb")
+        NewRelic::Control::Test.new @local_env
+      else
+        require "new_relic/control/#{@local_env.framework}.rb"
+        NewRelic::Control.const_get(@local_env.framework.to_s.capitalize).new @local_env
+      end
+    end
+    
+    def initialize local_env
+      @local_env = local_env
+      @instrumentation_files = []
+      newrelic_file = 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?(config_file)
+        log! "Cannot find newrelic.yml file at #{config_file}."
+        @yaml = {}
+      else
+        @yaml = YAML.load(ERB.new(File.read(config_file)).result(binding))
+      end
+    rescue ScriptError, StandardError => e
+      puts e
+      puts e.backtrace.join("\n")
+      raise "Error reading newrelic.yml file: #{e}"
+    end
+    
+    # The root directory for the plugin or gem
+    def self.newrelic_root
+      File.expand_path(File.join(File.dirname(__FILE__),"..",".."))
+    end
+    def newrelic_root
+      self.class.newrelic_root
+    end
+    
+    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
+    
+  end
+end