newrelic_rpm 2.12.3 → 2.13.0.beta3

data/lib/new_relic/commands/deployments.rb

@@ -1,7 +1,6 @@
 # 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'
@@ -11,135 +10,96 @@ require 'rexml/document'
 # 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 = {}
-          {
+class NewRelic::Command::Deployments < NewRelic::Command
+  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
+    super(command_line_args)
+    @description ||= @leftover && @leftover.join(" ")
+    @user ||= ENV['USER']
+    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
+      }.each do |k, v|
+        create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
       end
+      http = config.http_connection(config.api_server)
+      
+      uri = "/deployments.xml"
       
-      private
+      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"
       
-      def options
-        OptionParser.new %Q{Usage: #{$0} [OPTIONS] ["description"] }, 40 do |o|
-          o.separator "OPTIONS:"
-          o.on("-a", "--appname=NAME", String,
+      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 = REXML::Document.new(response.body).elements['errors/error'].map(&:to_s).join("; ") rescue  response.message
+        raise NewRelic::Command::CommandFailure, "Deployment not recorded: #{err_string}"
+      end 
+    rescue SystemCallError, SocketError => e
+      # These include Errno connection errors 
+      err_string = "Transient error attempting to connect to #{config.api_server} (#{e})"
+      raise NewRelic::Command::CommandFailure.new(err_string)
+    rescue NewRelic::Command::CommandFailure
+      raise
+    rescue Exception => e
+      err "Unexpected error attempting to connect to #{config.api_server}"
+      info "#{e}: #{e.backtrace.join("\n   ")}"
+      raise NewRelic::Command::CommandFailure.new(e.to_s)
+    end
+  end
+  
+  private
+  
+  def options
+    OptionParser.new %Q{Usage: #{$0} #{self.class.command} [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,
+      o.on("-e", "--environment=name", String,
                "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
                "currently: #{config.env}") { | e | @environment = e }
-          o.on("-u", "--user=USER", String,
+      o.on("-u", "--user=USER", String,
              "Specify the user deploying, for information only",
              "Default: #{@user || '<none>'}") { | u | @user = u }
-          o.on("-r", "--revision=REV", String,
+      o.on("-r", "--revision=REV", String,
              "Specify the revision being deployed") { | r | @revision = r }
-          o.on("-c", "--changes", 
+      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  
+      yield o if block_given?
     end
   end
-end
+  
+
+end

data/lib/new_relic/commands/install.rb

@@ -0,0 +1,81 @@
+require 'fileutils'
+require 'new_relic/version'
+require 'erb'
+
+class NewRelic::Command::Install < NewRelic::Command
+
+  NO_LICENSE_KEY = "<PASTE LICENSE KEY HERE>"
+  
+  def self.command; "install"; end 
+  
+  # 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 string values for
+  # :user, :description, :appname, :revision, :environment,
+  # and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  # 
+  attr_reader :dest_dir, :license_key, :generated_for_user, :quiet, :src_file, :app_name
+  def initialize command_line_args={}
+    super command_line_args
+    if !@dest_dir
+      # Install a newrelic.yml file into the local config directory.
+      if File.directory? "config"
+        @dest_dir = "config"
+      else
+        @dest_dir = "."
+      end
+    end
+    @license_key ||= NO_LICENSE_KEY
+    @app_name ||= @leftover
+    raise CommandFailure.new("Application name required.", @options) unless @app_name && @app_name.size > 0
+    @generated_for_user ||= @user_string || ""
+  end
+  
+  def run
+    dest_file = File.expand_path(@dest_dir + "/newrelic.yml")
+    if File.exist?(dest_file)
+      raise NewRelic::Command::CommandFailure, "newrelic.yml file already exists.  Move it out of the way."
+    end
+    File.open(dest_file, 'w') { | out | out.puts(content) }
+    
+    puts <<-EOF unless quiet
+
+Installed a default configuration file at 
+#{dest_file}.
+    EOF
+    puts <<-EOF unless quiet || @license_key != NO_LICENSE_KEY 
+
+To monitor your application in production mode, sign up for an account
+at www.newrelic.com, and replace the newrelic.yml file with the one
+you receive upon registration.
+    EOF
+    puts <<-EOF unless quiet
+
+E-mail support@newrelic.com with any problems or questions.
+
+    EOF
+    
+  end
+  
+  def content
+    @src_file ||= File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","newrelic.yml")) 
+    template = File.read(@src_file)
+    ERB.new(template).result(binding)
+  end
+  
+  private
+  
+  def options
+    OptionParser.new "Usage: #{$0} #{self.class.command} [ OPTIONS] 'application name'", 40 do |o|
+      o.on("-l", "--license_key=NAME", String,
+             "Use the given license key") { | e | @license_key = e }
+      o.on("-d", "--destdir=name", String,
+               "Write the newrelic.yml to the given directory, default is '.'") { | e | @dest_dir = e }
+      yield o if block_given?
+    end
+  end
+  
+  
+end

data/lib/new_relic/control.rb

@@ -5,6 +5,11 @@ require 'erb'
 require 'socket'
 require 'net/https'
 require 'logger'
+require 'new_relic/control/profiling'
+require 'new_relic/control/logging_methods'
+require 'new_relic/control/configuration'
+require 'new_relic/control/server_methods'
+require 'new_relic/control/instrumentation'
 
 module NewRelic 
   
@@ -16,43 +21,57 @@ module NewRelic
   # The Control also implements some of the public API for the agent.
   # 
   class Control
+    # used for framework-specific subclasses
+    module Frameworks; end
     
-    # 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
+    include Profiling
+    include LoggingMethods
+    include Configuration
+    include ServerMethods
+    include Instrumentation
     
-    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
+    attr_reader :local_env
+
+    module ClassMethods
+      # Access the Control singleton, lazy initialized
+      def instance
+        @instance ||= new_instance
+      end
+      
+      # Create the concrete class for environment specific behavior:
+      def new_instance
+        @local_env = NewRelic::LocalEnvironment.new
+        if @local_env.framework == :test
+          # You can set this env var if you want to run the tests
+          # without Rails.
+          config = File.expand_path("../../../test/config/newrelic.yml", __FILE__)
+          if ENV['SKIP_RAILS']
+            require "new_relic/control/frameworks/ruby.rb"
+            NewRelic::Control::Frameworks::Ruby.new @local_env, config
+          else
+            require "config/test_control"
+            NewRelic::Control::Frameworks::Test.new @local_env, config
+          end
+        else
+          begin
+            require "new_relic/control/frameworks/#{@local_env.framework}.rb"
+          rescue LoadError
+          end
+          NewRelic::Control::Frameworks.const_get(@local_env.framework.to_s.capitalize).new @local_env
+        end
+      end
+
+      # The root directory for the plugin or gem
+      def newrelic_root
+        File.expand_path("../../..", __FILE__)
+      end
     end
+    extend ClassMethods
     
     # 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
@@ -75,7 +94,7 @@ module NewRelic
     #
     def init_plugin(options={})
       options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
- 
+      
       require 'new_relic/agent'
       
       # Load the DJ injection now.  If you do it sooner, DJ might not be loaded and
@@ -122,77 +141,6 @@ module NewRelic
       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
-    
-    def sync_startup
-      fetch('sync_startup', false)
-    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
@@ -212,275 +160,34 @@ module NewRelic
       @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 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)
-    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)
-      log.debug("Http Connection opened to #{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.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
-    
     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}/#{log_file_name}"
-      @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
-      @log_path ||= begin
-                      path = self['log_file_path'] || File.join(root,'log')
-                      unless File.directory? path
-                        path = '.'
-                      end
-                      File.expand_path(path)
-                    end
-    end
-
-    def log_file_name
-      @log_file_name ||= fetch('log_file_name', 'newrelic_agent.log')
-    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
-        begin
-          require "new_relic/control/#{@local_env.framework}.rb"
-        rescue LoadError
-        end
-        NewRelic::Control.const_get(@local_env.framework.to_s.capitalize).new @local_env
-      end
-    end
-    
-    def initialize local_env
+    def initialize local_env, config_file_override=nil
       @local_env = local_env
       @instrumentation_files = []
-      newrelic_file = config_file
+      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?(config_file)
-        log! "Cannot find newrelic.yml file at #{config_file}."
+      if !File.exists?(newrelic_file)
+        log! "Cannot find read #{newrelic_file}."
         @yaml = {}
       else
-        @yaml = YAML.load(ERB.new(File.read(config_file)).result(binding))
+        @yaml = YAML.load(ERB.new(File.read(newrelic_file)).result(binding))
       end
     rescue ScriptError, StandardError => e
       puts e
@@ -488,41 +195,9 @@ module NewRelic
       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
     
-    # 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 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