factorylabs-newrelic_rpm 2.10.2.2

data/bin/mongrel_rpm

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rack'
+require 'rack/handler/mongrel'
+require 'optparse'
+
+port = 3000
+options = { }
+appname = nil
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] [app_name]"
+  opts.on("-p", "--port=port", Integer, "default: #{port}") { | port | }
+  opts.on("--[no-]logging", "turn off request logging" ) { | l | options[:logging] = l }
+  opts.on("--license=rpm_license_key", "override license key" ) { | l | options[:license_key] = l }
+  opts.on("--install", "install a newrelic.yml template" ) { | l | options[:install] = true }
+  opts.separator ""
+  opts.separator "app_name is the name of the application where the metrics will be stored"
+  opts.separator ""
+  # The rackup file references this var
+  appname = opts.parse!(ARGV.clone).first
+end
+
+options[:app_name] = appname if appname
+
+ru_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "new_relic", "rack", "mongrel_rpm.ru"))
+rackup_code = File.read ru_file
+builder = Rack::Builder.new { eval rackup_code, binding, ru_file }
+
+options = { :Host => '127.0.0.1', :Port => port }
+Rack::Handler::Mongrel.run(builder.to_app, options) do | server |
+  NewRelic::Control.instance.log! "Started Mongrel listening for '#{NewRelic::Control.instance.app_names.join(" and ")}' data at #{server.host}:#{server.port}" 
+end
+

data/bin/newrelic_cmd

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# executes one of the commands in the new_relic/commands directory
+# pass the name of the command as an argument
+require File.dirname(__FILE__) + '/../lib/new_relic/commands/new_relic_commands'

data/cert/cacert.pem

@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRp
+b24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZh
+bGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIy
+MjM0OFoXDTE5MDYyNTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0
+d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEg
+UG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0
+LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMIGfMA0GCSqGSIb3DQEBAQUA
+A4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9YLqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIi
+GQj4/xEjm84H9b9pGib+TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCm
+DuJWBQ8YTfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0LBwG
+lN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLWI8sogTLDAHkY7FkX
+icnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPwnXS3qT6gpf+2SQMT2iLM7XGCK5nP
+Orf1LXLI
+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRp
+b24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZh
+bGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAw
+MTk1NFoXDTE5MDYyNjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0
+d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIg
+UG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0
+LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMIGfMA0GCSqGSIb3DQEBAQUA
+A4GNADCBiQKBgQDOOnHK5avIWZJV16vYdA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVC
+CSRrCl6zfN1SLUzm1NZ9WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7Rf
+ZHM047QSv4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9vUJSZ
+SWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTuIYEZoDJJKPTEjlbV
+UjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwCW/POuZ6lcg5Ktz885hZo+L7tdEy8
+W9ViH0Pd
+-----END CERTIFICATE-----
+

data/install.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+require 'erb'
+
+def install_newrelic_config_file(license_key="PASTE_YOUR_LICENSE_KEY_HERE")
+  # Install a newrelic.yml file into the local config directory.
+  if File.directory? "config"
+    dest_dir = "config"
+  else
+    dest_dir = File.join(ENV["HOME"],".newrelic") rescue nil
+    FileUtils.mkdir(dest_dir) if dest_dir
+  end
+  
+  src_config_file = File.join(File.dirname(__FILE__),"newrelic.yml")
+  dest_config_file = File.join(dest_dir, "newrelic.yml") if dest_dir
+  
+  if !dest_dir
+    STDERR.puts "Could not find a config or ~/.newrelic directory to locate the default newrelic.yml file"
+  elsif File::exists? dest_config_file
+    STDERR.puts "\nA config file already exists at #{dest_config_file}.\n"
+  else
+    generated_for_user = ""
+    yaml = ERB.new(File.read(src_config_file)).result(binding)
+    File.open( dest_config_file, 'w' ) do |out|
+      out.puts yaml
+    end
+    
+    puts <<-EOF
+
+Installed a default configuration file in #{dest_dir}.
+
+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.
+
+Please review the README.md file for more information.
+
+E-mail support@newrelic.com with any problems or questions.
+
+    EOF
+  end  
+end
+
+if __FILE__ == $0 || $0 =~ /script\/plugin/
+  install_newrelic_config_file
+end

data/lib/new_relic/agent.rb

@@ -0,0 +1,315 @@
+# = New Relic Agent
+#
+# New Relic RPM is a performance monitoring application for Ruby
+# applications running in production.  For more information on RPM
+# please visit http://www.newrelic.com.
+#
+# The New Relic Agent can be installed in Rails applications to gather
+# runtime performance metrics, traces, and errors for display in a
+# Developer Mode UI (mapped to /newrelic in your application server)
+# or for monitoring and analysis at http://rpm.newrelic.com with just
+# about any Ruby application.
+#
+# For detailed information on configuring or customizing the RPM Agent
+# please visit our {support and documentation site}[http://support.newrelic.com].
+#
+# == Starting the Agent as a Gem
+#
+# For Rails, add:
+#    config.gem 'newrelic_rpm'
+# to your initialization sequence.
+#
+# For merb, do 
+#    dependency 'newrelic_rpm'
+# in the Merb config/init.rb
+#
+# For Sinatra, just require the +newrelic_rpm+ gem and it will
+# automatically detect Sinatra and instrument all the handlers.
+#
+# For other frameworks, or to manage the agent manually, 
+# invoke NewRelic::Agent#manual_start directly.
+#
+# == Configuring the Agent
+# 
+# All agent configuration is done in the <tt>newrelic.yml</tt> file.  This
+# file is by default read from the +config+ directory of the
+# application root and is subsequently searched for in the application
+# root directory, and then in a <tt>~/.newrelic</tt> directory
+#
+# == Using with Rack/Metal
+#
+# To instrument middlewares, refer to the docs in 
+# NewRelic::Agent::Instrumentation::Rack.
+#
+# == Agent API
+#
+# For details on the Agent API, refer to NewRelic::Agent.
+# 
+#
+# :main: lib/new_relic/agent.rb
+module NewRelic
+  # == Agent APIs
+  # This module contains the public API methods for the Agent.
+  #
+  # For adding custom instrumentation to method invocations, refer to 
+  # the docs in the class NewRelic::Agent::MethodTracer.
+  #
+  # For information on how to customize the controller
+  # instrumentation, or to instrument something other than Rails so
+  # that high level dispatcher actions or background tasks show up as
+  # first class operations in RPM, refer to
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation and
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods.
+  #
+  # Methods in this module as well as documented methods in
+  # NewRelic::Agent::MethodTracer and
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation are
+  # available to applications.  When the agent is not enabled the
+  # method implementations are stubbed into no-ops to reduce overhead.
+  #
+  # Methods and classes in other parts of the agent are not guaranteed
+  # to be available between releases.
+  #
+  # Refer to the online docs at support.newrelic.com to see how to
+  # access the data collected by custom instrumentation, or e-mail
+  # support at New Relic for help.
+  module Agent
+    extend self
+    
+    require 'new_relic/version'
+    require 'new_relic/local_environment'
+    require 'new_relic/stats'
+    require 'new_relic/metric_spec'
+    require 'new_relic/metric_data'
+    require 'new_relic/metric_parser'
+    require 'new_relic/transaction_analysis'
+    require 'new_relic/transaction_sample'
+    require 'new_relic/noticed_error'
+    require 'new_relic/histogram'
+    
+    require 'new_relic/agent/chained_call'
+    require 'new_relic/agent/agent'
+    require 'new_relic/agent/shim_agent'
+    require 'new_relic/agent/method_tracer'
+    require 'new_relic/agent/worker_loop'
+    require 'new_relic/agent/stats_engine'
+    require 'new_relic/agent/collection_helper'
+    require 'new_relic/agent/transaction_sampler'
+    require 'new_relic/agent/error_collector'
+    require 'new_relic/agent/busy_calculator'
+    require 'new_relic/agent/sampler'
+    
+    require 'new_relic/agent/samplers/cpu_sampler'
+    require 'new_relic/agent/samplers/memory_sampler'
+    require 'new_relic/agent/samplers/mongrel_sampler'
+    require 'new_relic/agent/samplers/object_sampler'
+    require 'set'
+    require 'sync'
+    require 'thread'
+    require 'resolv'
+    require 'timeout'
+    
+    # An exception that is thrown by the server if the agent license is invalid.
+    class LicenseException < StandardError; end
+    
+    # An exception that forces an agent to stop reporting until its mongrel is restarted.
+    class ForceDisconnectException < StandardError; end
+      
+    # An exception that forces an agent to restart.
+    class ForceRestartException < StandardError; end
+    
+    # Used to blow out of a periodic task without logging a an error, such as for routine
+    # failures.
+    class IgnoreSilentlyException < StandardError; end
+    
+    # Used for when a transaction trace or error report has too much
+    # data, so we reset the queue to clear the extra-large item
+    class PostTooBigException < IgnoreSilentlyException; end
+    
+    # Reserved for future use.  Meant to represent a problem on the server side.
+    class ServerError < StandardError; end
+
+    class BackgroundLoadingError < StandardError; end
+    
+    @agent = nil
+
+    # The singleton Agent instance.  Used internally.
+    def agent #:nodoc:
+      raise "Plugin not initialized!" if @agent.nil?
+      @agent
+    end
+    
+    def agent= new_instance #:nodoc:
+      @agent = new_instance
+    end
+    
+    alias instance agent #:nodoc:
+
+    # Get or create a statistics gatherer that will aggregate numerical data
+    # under a metric name.
+    #
+    # +metric_name+ should follow a slash separated path convention.  Application
+    # specific metrics should begin with "Custom/".
+    #
+    # Return a NewRelic::Stats that accepts data
+    # via calls to add_data_point(value).
+    def get_stats(metric_name, use_scope=false)
+      @agent.stats_engine.get_stats(metric_name, use_scope)
+    end
+    
+    alias get_stats_no_scope get_stats 
+    
+    # Call this to manually start the Agent in situations where the Agent does
+    # not auto-start.
+    # 
+    # When the app environment loads, so does the Agent. However, the Agent will
+    # only connect to RPM if a web front-end is found. If you want to selectively monitor
+    # ruby processes that don't use web plugins, then call this method in your
+    # code and the Agent will fire up and start reporting to RPM.
+    #
+    # Options are passed in as overrides for values in the newrelic.yml, such
+    # as app_name.  In addition, the option +log+ will take a logger that
+    # will be used instead of the standard file logger.  The setting for
+    # the newrelic.yml section to use (ie, RAILS_ENV) can be overridden
+    # with an :env argument.
+    #
+    def manual_start(options={})
+      raise unless Hash === options
+      # Ignore all args but hash options
+      options.merge! :agent_enabled => true 
+      NewRelic::Control.instance.init_plugin options
+    end
+    
+    # Shutdown the agent.  Call this before exiting.  Sends any queued data
+    # and kills the background thread.
+    def shutdown
+      @agent.shutdown
+    end        
+
+    # Add instrumentation files to the agent.  The argument should be a glob
+    # matching ruby scripts which will be executed at the time instrumentation 
+    # is loaded.  Since instrumentation is not loaded when the agent is not
+    # running it's better to use this method to register instrumentation than
+    # just loading the files directly, although that probably also works. 
+    def add_instrumentation file_pattern
+      NewRelic::Control.instance.add_instrumentation file_pattern
+    end
+
+    # This method sets the block sent to this method as a sql obfuscator. 
+    # The block will be called with a single String SQL statement to obfuscate.
+    # The method must return the obfuscated String SQL. 
+    # If chaining of obfuscators is required, use type = :before or :after
+    #
+    # type = :before, :replace, :after
+    #
+    # Example:
+    #
+    #    NewRelic::Agent.set_sql_obfuscator(:replace) do |sql|
+    #       my_obfuscator(sql)
+    #    end
+    # 
+    def set_sql_obfuscator(type = :replace, &block)
+      agent.set_sql_obfuscator type, &block
+    end
+    
+    
+    # This method sets the state of sql recording in the transaction
+    # sampler feature. Within the given block, no sql will be recorded
+    #
+    # usage:
+    #
+    #   NewRelic::Agent.disable_sql_recording do
+    #     ...  
+    #   end
+    #     
+    def disable_sql_recording
+      state = agent.set_record_sql(false)
+      begin
+        yield
+      ensure
+        agent.set_record_sql(state)
+      end
+    end
+    
+    # This method disables the recording of transaction traces in the given
+    # block.  See also #disable_all_tracing  
+    def disable_transaction_tracing
+      state = agent.set_record_tt(false)
+      begin
+        yield
+      ensure
+        agent.set_record_tt(state)
+      end
+    end
+    
+    # Cancel the collection of the current transaction in progress, if any.
+    # Only affects the transaction started on this thread once it has started
+    # and before it has completed.
+    def abort_transaction!
+      # The class may not be loaded if the agent is disabled
+      if defined? NewRelic::Agent::Instrumentation::MetricFrame
+        NewRelic::Agent::Instrumentation::MetricFrame.abort_transaction!
+      end
+    end
+    
+    # Yield to the block without collecting any metrics or traces in any of the
+    # subsequent calls.  If executed recursively, will keep track of the first
+    # entry point and turn on tracing again after leaving that block.
+    # This uses the thread local +newrelic_untrace+
+    def disable_all_tracing
+      agent.push_trace_execution_flag(false)
+      yield
+    ensure
+      agent.pop_trace_execution_flag
+    end
+    
+    # Check to see if we are capturing metrics currently on this thread.
+    def is_execution_traced?
+      Thread.current[:newrelic_untraced].nil? || Thread.current[:newrelic_untraced].last != false      
+    end
+
+    # Set a filter to be applied to errors that RPM will track.
+    # The block should return the exception to track (which could be different from
+    # the original exception) or nil to ignore this exception.
+    #
+    # The block is yielded to with the exception to filter.
+    #
+    def ignore_error_filter(&block)
+      agent.error_collector.ignore_error_filter(&block)
+    end
+    
+    # Record the given error in RPM.  It will be passed through the #ignore_error_filter
+    # if there is one.
+    # 
+    # * <tt>exception</tt> is the exception which will be recorded
+    # * <tt>extra_params</tt> is a hash of name value pairs to appear alongside
+    #   the exception in RPM.
+    #
+    def notice_error(exception, extra_params = {})
+      NewRelic::Agent::Instrumentation::MetricFrame.notice_error(exception, extra_params)
+    end
+
+    # Add parameters to the current transaction trace on the call stack.
+    #
+    def add_custom_parameters(params)
+      agent.add_custom_parameters(params)
+    end
+    
+    alias add_request_parameters add_custom_parameters
+    
+    # Yield to a block that is run with a database metric name context.  This means
+    # the Database instrumentation will use this for the metric name if it does not
+    # otherwise know about a model.  This is re-entrant.
+    #
+    # * <tt>model</tt> is the DB model class
+    # * <tt>method</tt> is the name of the finder method or other method to identify the operation with.
+    #
+    def with_database_metric_name(model, method, &block)
+      if frame = NewRelic::Agent::Instrumentation::MetricFrame.current
+        frame.with_database_metric_name(model, method, &block)
+      else
+        yield
+      end
+    end
+  end 
+end  

data/lib/new_relic/agent/agent.rb

@@ -0,0 +1,647 @@
+require 'socket'
+require 'net/https' 
+require 'net/http'
+require 'logger'
+require 'zlib'
+require 'stringio'
+
+# The NewRelic Agent collects performance data from ruby applications
+# in realtime as the application runs, and periodically sends that
+# data to the NewRelic server.
+module NewRelic::Agent
+  
+  # The Agent is a singleton that is instantiated when the plugin is
+  # activated.
+  class Agent
+    
+    # Specifies the version of the agent's communication protocol with
+    # the NewRelic hosted site.
+    
+    PROTOCOL_VERSION = 8
+    
+    attr_reader :obfuscator
+    attr_reader :stats_engine
+    attr_reader :transaction_sampler
+    attr_reader :error_collector
+    attr_reader :task_loop
+    attr_reader :record_sql
+    attr_reader :histogram
+    attr_reader :metric_ids
+    attr_reader :should_send_errors
+    
+    # Should only be called by NewRelic::Control
+    def self.instance
+      @instance ||= self.new
+    end
+    # This method is deprecated.  Use NewRelic::Agent.manual_start
+    def manual_start(ignored=nil, also_ignored=nil)
+      raise "This method no longer supported.  Instead use the class method NewRelic::Agent.manual_start"
+    end
+    
+    # this method makes sure that the agent is running. it's important
+    # for passenger where processes are forked and the agent is
+    # dormant
+    #
+    def ensure_worker_thread_started
+      return unless control.agent_enabled? && control.monitor_mode? && !@invalid_license
+      if !running?
+        log.info "Detected that the worker loop is not running.  Restarting."
+        # Assume we've been forked, clear out stats that are left over from parent process
+        reset_stats
+        launch_worker_thread
+        @stats_engine.spawn_sampler_thread
+      end
+    end
+    
+    # True if the worker thread has been started.  Doesn't necessarily
+    # mean we are connected
+    def running?
+      control.agent_enabled? && control.monitor_mode? && @task_loop && @task_loop.pid == $$
+    end
+    
+    # True if we have initialized and completed 'start'
+    def started?
+      @started
+    end
+    
+    # Attempt a graceful shutdown of the agent.  
+    def shutdown
+      return if not started?
+      if @task_loop
+        @task_loop.stop
+        
+        log.debug "Starting Agent shutdown"
+        
+        # if litespeed, then ignore all future SIGUSR1 - it's
+        # litespeed trying to shut us down
+        
+        if control.dispatcher == :litespeed
+          Signal.trap("SIGUSR1", "IGNORE")
+          Signal.trap("SIGTERM", "IGNORE")
+        end
+        
+        begin
+          graceful_disconnect
+        rescue => e
+          log.error e
+          log.error e.backtrace.join("\n")
+        end
+      end
+      @started = nil
+    end
+    
+    def start_transaction
+      Thread::current[:custom_params] = nil
+      @stats_engine.start_transaction
+    end
+    
+    def end_transaction
+      Thread::current[:custom_params] = nil
+      @stats_engine.end_transaction
+    end
+    
+    def set_record_sql(should_record)
+      prev = Thread::current[:record_sql]
+      Thread::current[:record_sql] = should_record
+      prev.nil? || prev
+    end
+    
+    def set_record_tt(should_record)
+      prev = Thread::current[:record_tt]
+      Thread::current[:record_tt] = should_record
+      prev.nil? || prev
+    end
+    # Push flag indicating whether we should be tracing in this
+    # thread.  
+    def push_trace_execution_flag(should_trace=false)
+      (Thread.current[:newrelic_untraced] ||= []) << should_trace 
+    end
+
+    # Pop the current trace execution status.  Restore trace execution status
+    # to what it was before we pushed the current flag.
+    def pop_trace_execution_flag
+      Thread.current[:newrelic_untraced].pop if Thread.current[:newrelic_untraced]
+    end
+    
+    def add_custom_parameters(params)
+      p = Thread::current[:custom_params] || (Thread::current[:custom_params] = {})
+      
+      p.merge!(params)
+    end
+    
+    def custom_params
+      Thread::current[:custom_params] || {}
+    end
+    
+    def set_sql_obfuscator(type, &block)
+      if type == :before
+        @obfuscator = NewRelic::ChainedCall.new(block, @obfuscator)
+      elsif type == :after
+        @obfuscator = NewRelic::ChainedCall.new(@obfuscator, block)
+      elsif type == :replace
+        @obfuscator = block
+      else
+        fail "unknown sql_obfuscator type #{type}"
+      end
+    end
+
+    def log
+      NewRelic::Control.instance.log
+    end  
+    
+    # Start up the agent.  This verifies that the agent_enabled? is
+    # true and initializes the sampler based on the current
+    # controluration settings.  Then it will fire up the background
+    # thread for sending data to the server if applicable.
+    def start
+      if started?
+        control.log! "Agent Started Already!", :error
+        return
+      end
+      return if !control.agent_enabled? 
+
+      @local_host = determine_host
+      
+      log.info "Web container: #{control.dispatcher.to_s}"
+      
+      @started = true
+      
+      sampler_config = control.fetch('transaction_tracer', {})
+      @use_transaction_sampler = sampler_config.fetch('enabled', true)
+      
+      @record_sql = sampler_config.fetch('record_sql', :obfuscated).to_sym
+      
+      # use transaction_threshold: 4.0 to force the TT collection
+      # threshold to 4 seconds
+      # use transaction_threshold: apdex_f to use your apdex t value
+      # multiplied by 4
+      # undefined transaction_threshold defaults to 2.0
+      apdex_f = 4 * NewRelic::Control.instance.apdex_t
+      @slowest_transaction_threshold = sampler_config.fetch('transaction_threshold', 2.0)
+      if @slowest_transaction_threshold =~ /apdex_f/i
+        @slowest_transaction_threshold = apdex_f
+      end
+      @slowest_transaction_threshold = @slowest_transaction_threshold.to_f
+      
+      if @use_transaction_sampler
+        log.info "Transaction tracing threshold is #{@slowest_transaction_threshold} seconds." 
+      else
+        log.info "Transaction tracing not enabled."
+      end
+      @explain_threshold = sampler_config.fetch('explain_threshold', 0.5).to_f
+      @explain_enabled = sampler_config.fetch('explain_enabled', true)
+      @random_sample = sampler_config.fetch('random_sample', false)
+      log.warn "Agent is configured to send raw SQL to RPM service" if @record_sql == :raw
+      # Initialize transaction sampler
+      @transaction_sampler.random_sampling = @random_sample
+
+      if control.monitor_mode?
+        if !control.license_key
+          @invalid_license = true
+          control.log! "No license key found.  Please edit your newrelic.yml file and insert your license key.", :error
+        elsif  control.license_key.length != 40
+          @invalid_license = true
+          control.log! "Invalid license key: #{control.license_key}", :error
+        else     
+          launch_worker_thread
+          # When the VM shuts down, attempt to send a message to the
+          # server that this agent run is stopping, assuming it has
+          # successfully connected
+          # This shutdown handler doesn't work if Sinatra is running
+          # because it executes in the shutdown handler!
+          at_exit { shutdown } unless [:sinatra, :unicorn].include? NewRelic::Control.instance.dispatcher
+        end
+      end
+      control.log! "New Relic RPM Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
+      control.log! "Agent Log found in #{NewRelic::Control.instance.log_file}" if NewRelic::Control.instance.log_file
+    end
+
+    private
+    def collector
+      @collector ||= control.server
+    end
+    
+    # Connect to the server, and run the worker loop forever.
+    # Will not return.
+    def run_task_loop
+      # determine the reporting period (server based)          
+      # note if the agent attempts to report more frequently than
+      # the specified report data, then it will be ignored.
+      
+      control.log! "Reporting performance data every #{@report_period} seconds."        
+      @task_loop.add_task(@report_period, "Timeslice Data Send") do 
+        harvest_and_send_timeslice_data
+      end
+      
+      if @should_send_samples && @use_transaction_sampler
+        @task_loop.add_task(@report_period, "Transaction Sampler Send") do 
+          harvest_and_send_slowest_sample
+        end
+      elsif !control.developer_mode?
+        # We still need the sampler for dev mode.
+        @transaction_sampler.disable
+      end
+      
+      if @should_send_errors && @error_collector.enabled
+        @task_loop.add_task(@report_period, "Error Send") do 
+          harvest_and_send_errors
+        end
+      end
+      log.debug("Running worker loop")
+      @task_loop.run
+    rescue StandardError
+      log.debug("Error in worker loop: #{$!}")
+      @connected = false
+      raise
+    end
+    
+    def launch_worker_thread
+      if (control.dispatcher == :passenger && $0 =~ /ApplicationSpawner/)
+        log.debug "Process is passenger spawner - don't connect to RPM service"
+        return
+      end
+      
+      @task_loop = WorkerLoop.new(log)
+      
+      if control['check_bg_loading']
+        log.warn "Agent background loading checking turned on"
+        require 'new_relic/agent/patch_const_missing'
+        ClassLoadingWatcher.enable_warning
+      end
+      log.debug "Creating RPM worker thread."
+      @worker_thread = Thread.new do
+        begin
+          ClassLoadingWatcher.background_thread=Thread.current if control['check_bg_loading']
+          NewRelic::Agent.disable_all_tracing do
+            connect
+            run_task_loop if @connected
+          end
+        rescue NewRelic::Agent::ForceRestartException => e
+          log.info e.message
+          # disconnect and start over.
+          # clear the stats engine
+          reset_stats
+          @connected = false
+          # Wait a short time before trying to reconnect
+          sleep 30
+          retry
+        rescue IgnoreSilentlyException
+          control.log! "Unable to establish connection with the server.  Run with log level set to debug for more information."
+        rescue Exception => e
+          @connected = false
+          control.log! e, :error
+          control.log! e.backtrace.join("\n  "), :error
+        end
+      end
+      @worker_thread['newrelic_label'] = 'Worker Loop'
+    end
+    
+    def control
+      NewRelic::Control.instance
+    end
+    
+    def initialize
+      @connected = false
+      @launch_time = Time.now
+      
+      @metric_ids = {}
+      @histogram = NewRelic::Histogram.new(NewRelic::Control.instance.apdex_t / 10)
+      @stats_engine = NewRelic::Agent::StatsEngine.new
+      @transaction_sampler = NewRelic::Agent::TransactionSampler.new
+      @stats_engine.transaction_sampler = @transaction_sampler
+      @error_collector = NewRelic::Agent::ErrorCollector.new
+      
+      @request_timeout = NewRelic::Control.instance.fetch('timeout', 2 * 60)
+      
+      @invalid_license = false
+      
+      @last_harvest_time = Time.now
+      @obfuscator = method(:default_sql_obfuscator)
+    end
+    
+    # Connect to the server and validate the license.  If successful,
+    # @connected has true when finished.  If not successful, you can
+    # keep calling this.  Return false if we could not establish a
+    # connection with the server and we should not retry, such as if
+    # there's a bad license key.
+    def connect
+      # wait a few seconds for the web server to boot, necessary in development
+      connect_retry_period = 5
+      connect_attempts = 0
+      @agent_id = nil
+      begin
+        sleep connect_retry_period.to_i
+        environment = control['send_environment_info'] != false ? control.local_env.snapshot : []
+        @agent_id ||= invoke_remote :start, @local_host, {
+          :pid => $$, 
+          :launch_time => @launch_time.to_f, 
+          :agent_version => NewRelic::VERSION::STRING, 
+          :environment => environment,
+          :settings => control.settings,
+          :validate_seed => ENV['NR_VALIDATE_SEED'],
+          :validate_token => ENV['NR_VALIDATE_TOKEN'] }
+        
+        host = invoke_remote(:get_redirect_host)
+        
+        @collector = control.server_from_host(host) if host        
+            
+        @report_period = invoke_remote :get_data_report_period, @agent_id
+ 
+        control.log! "Connected to NewRelic Service at #{@collector}"
+        log.debug "Agent ID = #{@agent_id}."
+        
+        # Ask the server for permission to send transaction samples.
+        # determined by subscription license.
+        @should_send_samples = invoke_remote :should_collect_samples, @agent_id
+        
+        if @should_send_samples
+          sampling_rate = invoke_remote :sampling_rate, @agent_id if @random_sample
+          @transaction_sampler.sampling_rate = sampling_rate
+          log.info "Transaction sample rate: #{@transaction_sampler.sampling_rate}" if sampling_rate
+        end
+        
+        # Ask for permission to collect error data
+        @should_send_errors = invoke_remote :should_collect_errors, @agent_id
+        
+        log.info "Transaction traces will be sent to the RPM service" if @use_transaction_sampler && @should_send_samples
+        log.info "Errors will be sent to the RPM service" if @error_collector.enabled && @should_send_errors
+        
+        @connected = true
+        
+      rescue LicenseException => e
+        control.log! e.message, :error
+        control.log! "Visit NewRelic.com to obtain a valid license key, or to upgrade your account."
+        @invalid_license = true
+        return false
+        
+      rescue Timeout::Error, StandardError => e
+        log.info "Unable to establish connection with New Relic RPM Service at #{control.server}"
+        unless e.instance_of? IgnoreSilentlyException
+          log.error e.message
+          log.debug e.backtrace.join("\n")
+        end
+        # retry logic
+        connect_attempts += 1
+        case connect_attempts
+          when 1..2
+          connect_retry_period, period_msg = 60, "1 minute"
+          when 3..5 then
+          connect_retry_period, period_msg = 60 * 2, "2 minutes"
+        else 
+          connect_retry_period, period_msg = 10*60, "10 minutes"
+        end
+        log.info "Will re-attempt in #{period_msg}" 
+        retry
+      end
+    end
+      
+    def determine_host
+      Socket.gethostname
+    end
+    
+    def determine_home_directory
+      control.root
+    end
+    def reset_stats
+      @stats_engine.reset_stats
+      @metric_ids = {}
+      @unsent_errors = []
+      @traces = nil
+      @unsent_timeslice_data = {}
+      @last_harvest_time = Time.now
+      @launch_time = Time.now
+      @histogram = NewRelic::Histogram.new(NewRelic::Control.instance.apdex_t / 10)
+    end
+    
+    def harvest_and_send_timeslice_data
+      
+      NewRelic::Agent::BusyCalculator.harvest_busy
+      
+      now = Time.now
+            
+      @unsent_timeslice_data ||= {}
+      @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data, @metric_ids)
+      
+      begin
+        # In this version of the protocol, we get back an assoc array of spec to id.
+        metric_ids = invoke_remote(:metric_data, @agent_id, 
+                                   @last_harvest_time.to_f, 
+                                   now.to_f, 
+                                   @unsent_timeslice_data.values)
+        
+      rescue Timeout::Error
+        # assume that the data was received. chances are that it was
+        metric_ids = nil
+      end
+      
+      metric_ids.each do | spec, id |
+        @metric_ids[spec] = id
+      end if metric_ids 
+      
+      log.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@agent_id}) in #{Time.now - now} seconds"
+      
+      # if we successfully invoked this web service, then clear the unsent message cache.
+      @unsent_timeslice_data = {}
+      @last_harvest_time = now
+      
+      # handle_messages 
+      
+      # note - exceptions are logged in invoke_remote.  If an exception is encountered here,
+      # then the metric data is downsampled for another timeslices
+    end
+    
+    def harvest_and_send_slowest_sample
+      @traces = @transaction_sampler.harvest(@traces, @slowest_transaction_threshold)
+      
+      unless @traces.empty?
+        now = Time.now
+        log.debug "Sending (#{@traces.length}) transaction traces"
+        begin        
+          # take the traces and prepare them for sending across the
+          # wire.  This includes gathering SQL explanations, stripping
+          # out stack traces, and normalizing SQL.  note that we
+          # explain only the sql statements whose segments' execution
+          # times exceed our threshold (to avoid unnecessary overhead
+          # of running explains on fast queries.)
+          traces = @traces.collect {|trace| trace.prepare_to_send(:explain_sql => @explain_threshold, :record_sql => @record_sql, :keep_backtraces => true, :explain_enabled => @explain_enabled)} 
+          invoke_remote :transaction_sample_data, @agent_id, traces
+        rescue PostTooBigException
+          # we tried to send too much data, drop the first trace and
+          # try again
+          retry if @traces.shift
+        end
+        
+        log.debug "#{now}: sent slowest sample (#{@agent_id}) in #{Time.now - now} seconds"
+      end
+      
+      # if we succeed sending this sample, then we don't need to keep
+      # the slowest sample around - it has been sent already and we
+      # can collect the next one
+      @traces = nil
+      
+      # note - exceptions are logged in invoke_remote.  If an
+      # exception is encountered here, then the slowest sample of is
+      # determined of the entire period since the last reported
+      # sample.
+    end
+    
+    def harvest_and_send_errors
+      @unsent_errors = @error_collector.harvest_errors(@unsent_errors)
+      if @unsent_errors && @unsent_errors.length > 0
+        log.debug "Sending #{@unsent_errors.length} errors"
+        begin        
+          invoke_remote :error_data, @agent_id, @unsent_errors
+        rescue PostTooBigException
+          @unsent_errors.shift
+          retry
+        end
+        # if the remote invocation fails, then we never clear
+        # @unsent_errors, and therefore we can re-attempt to send on
+        # the next heartbeat.  Note the error collector maxes out at
+        # 20 instances to prevent leakage
+        @unsent_errors = []
+      end
+    end
+
+    def compress_data(object)
+      dump = Marshal.dump(object)
+      
+      # this checks to make sure mongrel won't choke on big uploads
+      check_post_size(dump)
+      
+      # we currently optimize for CPU here since we get roughly a 10x
+      # reduction in message size with this, and CPU overhead is at a
+      # premium. For extra-large posts, we use the higher compression
+      # since otherwise it actually errors out.
+      
+      dump_size = dump.size
+      
+      # small payloads don't need compression      
+      return [dump, 'identity'] if dump_size < 2000
+      
+      # medium payloads get fast compression, to save CPU
+      # big payloads get all the compression possible, to stay under
+      # the 2,000,000 byte post threshold      
+      compression = dump_size < 2000000 ? Zlib::BEST_SPEED : Zlib::BEST_COMPRESSION
+      
+      [Zlib::Deflate.deflate(dump, compression), 'deflate']
+    end
+    
+    def check_post_size(post_string)
+      # TODO: define this as a config option on the server side
+      return if post_string.size < control.post_size_limit
+      log.warn "Tried to send too much data: #{post_string.size} bytes"
+      raise PostTooBigException
+    end
+
+    def send_request(opts)
+      request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'ACCEPT-ENCODING' => 'gzip', 'HOST' => opts[:collector].name)
+      request.content_type = "application/octet-stream"
+      request.body = opts[:data]
+      
+      log.debug "connect to #{opts[:collector]}#{opts[:uri]}"
+      
+      response = nil
+      http = control.http_connection(collector)      
+      begin
+        timeout(@request_timeout) do      
+          response = http.request(request)
+        end
+      rescue Timeout::Error
+        log.warn "Timed out trying to post data to RPM (timeout = #{@request_timeout} seconds)" unless @request_timeout < 30
+        raise
+      end
+      if response.is_a? Net::HTTPServiceUnavailable
+        log.debug(response.body || response.message)
+        raise IgnoreSilentlyException
+      elsif response.is_a? Net::HTTPGatewayTimeOut
+        log.debug("Timed out getting response: #{response.message}")
+        raise Timeout::Error, response.message
+      elsif !(response.is_a? Net::HTTPSuccess)
+        log.debug "Unexpected response from server: #{response.code}: #{response.message}"
+        raise IgnoreSilentlyException
+      end
+      response
+    end
+
+    def decompress_response(response)
+      if response['content-encoding'] != 'gzip'
+        log.debug "Uncompressed content returned"
+        return response.body
+      end
+      log.debug "Decompressing return value"
+      i = Zlib::GzipReader.new(StringIO.new(response.body))
+      i.read
+    end
+
+    def check_for_exception(response)
+      dump = decompress_response(response)
+      value = Marshal.load(dump)
+      raise value if value.is_a? Exception
+      value
+    end
+    
+    def remote_method_uri(method)
+      uri = "/agent_listener/#{PROTOCOL_VERSION}/#{control.license_key}/#{method}"
+      uri << "?run_id=#{@agent_id}" if @agent_id
+      uri
+    end
+      
+    # send a message via post
+    def invoke_remote(method, *args)
+      #determines whether to zip the data or send plain
+      post_data, encoding = compress_data(args)
+      
+      response = send_request({:uri => remote_method_uri(method), :encoding => encoding, :collector => collector, :data => post_data})
+
+      # raises the right exception if the remote server tells it to die
+      return check_for_exception(response)
+    rescue ForceRestartException => e
+      log.info e.message
+      raise
+    rescue ForceDisconnectException => e
+      log.error "RPM forced this agent to disconnect (#{e.message})\n" \
+      "Restart this process to resume monitoring via rpm.newrelic.com."
+      # when a disconnect is requested, stop the current thread, which
+      # is the worker thread that gathers data and talks to the
+      # server.
+      @connected = false
+      Thread.exit
+    rescue SystemCallError, SocketError => e
+      # These include Errno connection errors 
+      log.debug "Recoverable error connecting to the server: #{e}"
+      raise IgnoreSilentlyException
+    end
+    
+    def graceful_disconnect
+      if @connected && !control.developer_mode?
+        begin
+          log.debug "Sending graceful shutdown message to #{control.server}"
+          
+          @request_timeout = 10
+          
+          log.debug "Sending RPM service agent run shutdown message"
+          invoke_remote :shutdown, @agent_id, Time.now.to_f
+          
+          log.debug "Graceful shutdown complete"
+          
+        rescue Timeout::Error, StandardError 
+        end
+      else
+        log.debug "Bypassing graceful shutdown - agent not connected"
+      end
+    end
+    def default_sql_obfuscator(sql)
+      sql = sql.dup
+      # This is hardly readable.  Use the unit tests.
+      # remove single quoted strings:
+      sql.gsub!(/'(.*?[^\\'])??'(?!')/, '?')
+      # remove double quoted strings:
+      sql.gsub!(/"(.*?[^\\"])??"(?!")/, '?')
+      # replace all number literals
+      sql.gsub!(/\d+/, "?")
+      sql
+    end
+  end
+  
+end