wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/instrumentation/queue_time.rb

@@ -10,7 +10,7 @@ module NewRelic
           HEROKU_QUEUE_HEADER = 'HTTP_X_HEROKU_QUEUE_WAIT_TIME'
           APP_HEADER = 'HTTP_X_APPLICATION_START'
 
-          HEADER_REGEX = /([^\s\/,(t=)]+)? ?t=([0-9]+)/
+          HEADER_REGEX = /([^\s\/,(t=)]+)? ?t=([0-9\.]+)/
           SERVER_METRIC = 'WebFrontend/WebServer/'
           MIDDLEWARE_METRIC = 'Middleware/'
           # no individual queue metric - more than one queue?!
@@ -93,7 +93,7 @@ module NewRelic
         def get_matches_from_header(header, env)
           return [] if env.nil?
           get_matches(env[header]).map do |name, time|
-            convert_to_name_time_pair(name, time)
+            convert_to_name_time_pair(name, time.sub('.', ''))
           end
         end
 

data/lib/new_relic/agent/instrumentation/rack.rb

@@ -7,7 +7,7 @@ module NewRelic
       #
       # New Relic will instrument a #call method as if it were a controller
       # action, collecting transaction traces and errors.  The middleware will
-      # be identified only by it's class, so if you want to instrument multiple
+      # be identified only by its class, so if you want to instrument multiple
       # actions in a middleware, you need to use
       # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
       #

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -2,13 +2,13 @@ DependencyDetection.defer do
   @name = :rails21_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) && defined?(ActionView::PartialTemplate) && defined?(ActionView::Template) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.1\./   # Rails 2.1 &&
   end
   
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 2.1 View instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 2.1 View instrumentation'
   end
 
   executes do
@@ -26,13 +26,13 @@ DependencyDetection.defer do
   @name = :old_rails_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0 
   end
   
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 1.* - 2.0 View instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 1.* - 2.0 View instrumentation'
   end
   
   executes do
@@ -47,13 +47,13 @@ DependencyDetection.defer do
   @name = :rails23_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/ 
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 2.2 - 2.3 View instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 2.2 - 2.3 View instrumentation'
   end
   
   executes do    
@@ -78,7 +78,7 @@ DependencyDetection.defer do
   end
   
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 2 Controller instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 2 Controller instrumentation'
   end
   
   executes do

data/lib/new_relic/agent/instrumentation/rails/action_web_service.rb

@@ -6,7 +6,7 @@ DependencyDetection.defer do
   end
   
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails ActionWebService instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails ActionWebService instrumentation'
   end  
   
   executes do

data/lib/new_relic/agent/instrumentation/rails/errors.rb

@@ -10,7 +10,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 2 Error instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 2 Error instrumentation'
   end  
   
   executes do

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -78,7 +78,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 3 Controller instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3 Controller instrumentation'
   end
 
   executes do
@@ -96,11 +96,11 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 3.0 view instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
   end
 
   executes do
@@ -135,11 +135,11 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 3.1/3.2 view instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -6,7 +6,11 @@ module NewRelic
           def newrelic_notice_error(exception, custom_params = {})
             filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
             filtered_params.merge!(custom_params)
-            NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+            NewRelic::Agent::Instrumentation::MetricFrame.notice_error( \
+                exception, \
+                :request => request, \
+                :metric => newrelic_metric_path, \
+                :custom_params => filtered_params)
           end
         end
       end
@@ -26,7 +30,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails3 Error instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails3 Error instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/resque.rb

@@ -0,0 +1,81 @@
+DependencyDetection.defer do
+  @name = :resque
+  
+  depends_on do
+    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]  &&
+      !NewRelic::LanguageSupport.using_version?('1.9.1')
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
+  end
+  
+  executes do
+    # == Resque Instrumentation
+    #
+    # Installs a hook to ensure the agent starts manually when the worker
+    # starts and also adds the tracer to the process method which executes
+    # in the forked task.
+    
+    module Resque
+      module Plugins
+        module NewRelicInstrumentation
+          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+          
+          def around_perform_with_monitoring(*args)
+            begin
+              perform_action_with_newrelic_trace(:name => 'perform',
+                                   :class_name => self.name,
+                                   :category => 'OtherTransaction/ResqueJob') do
+                yield(*args)
+              end
+            ensure
+              NewRelic::Agent.shutdown if NewRelic::LanguageSupport.can_fork?
+            end
+          end
+        end
+      end
+    end
+    
+    module NewRelic
+      module Agent
+        module Instrumentation
+          module ResqueInstrumentationInstaller
+            def payload_class
+              klass = super
+              klass.instance_eval do
+                extend ::Resque::Plugins::NewRelicInstrumentation
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    ::Resque::Job.class_eval do
+      def self.new(*args)
+        super(*args).extend NewRelic::Agent::Instrumentation::ResqueInstrumentationInstaller
+      end
+    end
+    
+    if NewRelic::LanguageSupport.can_fork?
+      ::Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher   => :resque,
+                                     :sync_startup => true,
+                                     :start_channel_listener => true,
+                                     :report_instance_busy => false)
+      end
+      
+      ::Resque.before_fork do |job|
+        NewRelic::Agent.register_report_channel(job.object_id)
+      end
+      
+      ::Resque.after_fork do |job|
+        NewRelic::Agent.after_fork(:report_to_channel => job.object_id)
+      end
+    end
+  end
+end 
+
+# call this now so it is memoized before potentially forking worker processes
+NewRelic::LanguageSupport.can_fork?

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -1,13 +1,15 @@
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
 DependencyDetection.defer do
+  @name = :sinatra
+
   depends_on do
     defined?(::Sinatra) && defined?(::Sinatra::Base) && !defined?(::WeaselDiesel) &&
       Sinatra::Base.private_method_defined?(:dispatch!)
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Sinatra instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Sinatra instrumentation'
   end
 
   executes do
@@ -32,14 +34,14 @@ module NewRelic
       # will all be tracked as separate actions.
       module Sinatra
         include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-                
+
         def dispatch_with_newrelic
           txn_name = NewRelic.transaction_name(self.class.routes, @request) do |pattern, keys, conditions|
             process_route(pattern, keys, conditions) do
               pattern.source
             end
           end
-          
+
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => txn_name,
                                              :params => @request.params) do
@@ -47,28 +49,37 @@ module NewRelic
           end
         end
 
+        # Define Request Header accessor for Sinatra
+        def newrelic_request_headers
+          request.env
+        end
+
         module NewRelic
           extend self
-          
+
           def http_verb(request)
             request.request_method if request.respond_to?(:request_method)
           end
-          
+
           def transaction_name(routes, request)
             name = '(unknown)'
             verb = http_verb(request)
-            
+
             Array(routes[verb]).each do |pattern, keys, conditions, block|
-              if pattern = yield(pattern, keys, conditions)
-                name = pattern
+              if route = yield(pattern, keys, conditions)
+                name = route
+                # it's important we short circuit here.  Otherwise we risk
+                # applying conditions from lower priority routes which can
+                # break the action.
+                break
               end
             end
-            
+
             name.gsub!(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
             if verb
               name = verb + ' ' + name
             end
-            
+
             name
           end
         end

data/lib/new_relic/agent/instrumentation/sunspot.rb

@@ -6,7 +6,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails Sunspot instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails Sunspot instrumentation'
   end
   
   executes do

data/lib/new_relic/agent/instrumentation/unicorn_instrumentation.rb

@@ -4,15 +4,16 @@ DependencyDetection.defer do
   depends_on do
     defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
   end
-  
+
   executes do
-    NewRelic::Agent.logger.debug 'Installing Unicorn instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Unicorn instrumentation'
+    ::NewRelic::Agent.logger.info 'Detected Unicorn, please see additional documentation: https://newrelic.com/docs/troubleshooting/im-using-unicorn-and-i-dont-see-any-data'
   end
-  
+
   executes do
     Unicorn::HttpServer.class_eval do
       old_worker_loop = instance_method(:worker_loop)
-      define_method(:worker_loop) do | worker |
+      define_method(:worker_loop) do |worker|
         NewRelic::Agent.after_fork(:force_reconnect => true)
         old_worker_loop.bind(self).call(worker)
       end

data/lib/new_relic/agent/method_tracer.rb

@@ -175,13 +175,11 @@ module NewRelic
           end
           
           # helper for logging errors to the newrelic_agent.log
-          # properly. Logs the error at error level, and includes a
-          # backtrace if we're running at debug level
+          # properly. Logs the error at error level
           def log_errors(code_area, metric)
             yield
           rescue => e
-            NewRelic::Control.instance.log.error("Caught exception in #{code_area}. Metric name = #{metric}, exception = #{e}")
-            NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+            ::NewRelic::Agent.logger.error("Caught exception in #{code_area}. Metric name = #{metric}", e)
           end
           
           # provides the header for our traced execution scoped
@@ -327,7 +325,7 @@ module NewRelic
           # anything if the method doesn't exist.
           def newrelic_method_exists?(method_name)
             exists = method_defined?(method_name) || private_method_defined?(method_name)
-            NewRelic::Control.instance.log.warn("Did not trace #{self.name}##{method_name} because that method does not exist") unless exists
+            ::NewRelic::Agent.logger.error("Did not trace #{self.name}##{method_name} because that method does not exist") unless exists
             exists
           end
           
@@ -337,7 +335,7 @@ module NewRelic
           # to help with debugging custom instrumentation.
           def traced_method_exists?(method_name, metric_name_code)
             exists = method_defined?(_traced_method_name(method_name, metric_name_code))
-            NewRelic::Control.instance.log.warn("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}") if exists
+            ::NewRelic::Agent.logger.error("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}") if exists
             exists
           end
           
@@ -481,10 +479,14 @@ module NewRelic
 
           traced_method = code_to_eval(method_name, metric_name_code, options)
 
+          visibility = NewRelic::Helper.instance_method_visibility self, method_name
+
           class_eval traced_method, __FILE__, __LINE__
           alias_method _untraced_method_name(method_name, metric_name_code), method_name
           alias_method method_name, _traced_method_name(method_name, metric_name_code)
-          NewRelic::Control.instance.log.debug("Traced method: class = #{self.name},"+
+          send visibility, method_name
+          send visibility, _traced_method_name(method_name, metric_name_code)
+          ::NewRelic::Agent.logger.debug("Traced method: class = #{self.name},"+
                     "method = #{method_name}, "+
                     "metric = '#{metric_name_code}'")
         end
@@ -493,11 +495,11 @@ module NewRelic
         # from when they were added, or else other tracers that were added to the same method
         # may get removed as well.
         def remove_method_tracer(method_name, metric_name_code) # :nodoc:
-          return unless NewRelic::Control.instance.agent_enabled?
+          return unless Agent.config[:agent_enabled]
           if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
             alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
             undef_method "#{_traced_method_name(method_name, metric_name_code)}"
-            NewRelic::Control.instance.log.debug("removed method tracer #{method_name} #{metric_name_code}\n")
+            ::NewRelic::Agent.logger.debug("removed method tracer #{method_name} #{metric_name_code}\n")
           else
             raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
           end

data/lib/new_relic/agent/new_relic_service.rb

@@ -0,0 +1,379 @@
+require 'zlib'
+require 'new_relic/agent/audit_logger'
+
+module NewRelic
+  module Agent
+    class NewRelicService
+      # Specifies the version of the agent's communication protocol with
+      # the NewRelic hosted site.
+
+      PROTOCOL_VERSION = 10
+      # cf0d1ff1: v9 (tag 3.5.0)
+      # 14105: v8 (tag 2.10.3)
+      # (no v7)
+      # 10379: v6 (not tagged)
+      # 4078:  v5 (tag 2.5.4)
+      # 2292:  v4 (tag 2.3.6)
+      # 1754:  v3 (tag 2.3.0)
+      # 534:   v2 (shows up in 2.1.0, our first tag)
+
+      attr_accessor :request_timeout, :agent_id
+      attr_reader :collector, :marshaller
+
+      def initialize(license_key=nil, collector=control.server)
+        @license_key = license_key || Agent.config[:license_key]
+        @collector = collector
+        @request_timeout = Agent.config[:timeout]
+
+        @audit_logger = ::NewRelic::Agent::AuditLogger.new(Agent.config)
+        Agent.config.register_callback(:'audit_log.enabled') do |enabled|
+          @audit_logger.enabled = enabled
+        end
+        
+        Agent.config.register_callback(:marshaller) do |marshaller|
+          begin
+            if marshaller == 'json'
+              require 'json'
+              @marshaller = JsonMarshaller.new
+            else
+              @marshaller = PrubyMarshaller.new
+            end
+          rescue LoadError
+            @marshaller = PrubyMarshaller.new
+          end
+        end
+      end
+
+      def connect(settings={})
+        if host = get_redirect_host
+          @collector = NewRelic::Control.instance.server_from_host(host)
+        end
+        response = invoke_remote(:connect, settings)
+        @agent_id = response['agent_run_id']
+        response
+      end
+
+      def get_redirect_host
+        invoke_remote(:get_redirect_host)
+      end
+
+      def shutdown(time)
+        invoke_remote(:shutdown, @agent_id, time.to_i) if @agent_id
+      end
+
+      def metric_data(last_harvest_time, now, unsent_timeslice_data)
+        invoke_remote(:metric_data, @agent_id, last_harvest_time, now,
+                      unsent_timeslice_data)
+      end
+
+      def error_data(unsent_errors)
+        invoke_remote(:error_data, @agent_id, unsent_errors)
+      end
+
+      def transaction_sample_data(traces)
+        invoke_remote(:transaction_sample_data, @agent_id, traces)
+      end
+
+      def sql_trace_data(sql_traces)
+        invoke_remote(:sql_trace_data, sql_traces)
+      end
+
+      def profile_data(profile)
+        invoke_remote(:profile_data, @agent_id, profile) || ''
+      end
+
+      def get_agent_commands
+        invoke_remote(:get_agent_commands, @agent_id)
+      end
+
+      def agent_command_results(command_id, error=nil)
+        results = {}
+        results["error"] = error unless error.nil?
+
+        invoke_remote(:agent_command_results, @agent_id, { command_id.to_s => results })
+      end
+
+      # We do not compress if content is smaller than 64kb.  There are
+      # problems with bugs in Ruby in some versions that expose us
+      # to a risk of segfaults if we compress aggressively.
+      def compress_request_if_needed(data)
+        encoding = 'identity'
+        if data.size > 64 * 1024
+          data = Encoders::Compressed.encode(data)
+          encoding = 'deflate'
+        end
+        check_post_size(data)
+        [data, encoding]
+      end
+
+      private
+
+      # A shorthand for NewRelic::Control.instance
+      def control
+        NewRelic::Control.instance
+      end
+
+      # The path on the server that we should post our data to
+      def remote_method_uri(method, format='ruby')
+        params = {'run_id' => @agent_id, 'marshal_format' => format}
+        uri = "/agent_listener/#{PROTOCOL_VERSION}/#{@license_key}/#{method}"
+        uri << '?' + params.map do |k,v|
+          next unless v
+          "#{k}=#{v}"
+        end.compact.join('&')
+        uri
+      end
+
+      # send a message via post to the actual server. This attempts
+      # to automatically compress the data via zlib if it is large
+      # enough to be worth compressing, and handles any errors the
+      # server may return
+      def invoke_remote(method, *args)
+        now = Time.now
+
+        data = @marshaller.dump(args)
+        data, encoding = compress_request_if_needed(data)
+
+        uri = remote_method_uri(method, @marshaller.format)
+        full_uri = "#{@collector}#{uri}"
+
+        @audit_logger.log_request(full_uri, args, @marshaller)
+        response = send_request(:data      => data,
+                                :uri       => uri,
+                                :encoding  => encoding,
+                                :collector => @collector)
+        @marshaller.load(decompress_response(response))
+      rescue NewRelic::Agent::ForceRestartException => e
+        ::NewRelic::Agent.logger.debug e.message
+        raise
+      ensure
+        record_supportability_metrics(method, now)
+      end
+
+      def record_supportability_metrics(method, now)
+        NewRelic::Agent.instance.stats_engine. \
+          get_stats_no_scope('Supportability/invoke_remote'). \
+          record_data_point((Time.now - now).to_f)
+        NewRelic::Agent.instance.stats_engine. \
+          get_stats_no_scope('Supportability/invoke_remote/' + method.to_s). \
+          record_data_point((Time.now - now).to_f)
+      end
+
+      # Raises an UnrecoverableServerException if the post_string is longer
+      # than the limit configured in the control object
+      def check_post_size(post_string)
+        return if post_string.size < Agent.config[:post_size_limit]
+        ::NewRelic::Agent.logger.debug "Tried to send too much data: #{post_string.size} bytes"
+        raise UnrecoverableServerException.new('413 Request Entity Too Large')
+      end
+
+      # Posts to the specified server
+      #
+      # Options:
+      #  - :uri => the path to request on the server (a misnomer of
+      #              course)
+      #  - :encoding => the encoding to pass to the server
+      #  - :collector => a URI object that responds to the 'name' method
+      #                    and returns the name of the collector to
+      #                    contact
+      #  - :data => the data to send as the body of the request
+      def send_request(opts)
+        request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+        request['user-agent'] = user_agent
+        request.content_type = "application/octet-stream"
+        request.body = opts[:data]
+
+        ::NewRelic::Agent.logger.debug "Connect to #{opts[:collector]}#{opts[:uri]}"
+
+        response = nil
+        http = control.http_connection(@collector)
+        http.read_timeout = nil
+        begin
+          NewRelic::TimerLib.timeout(@request_timeout) do
+            response = http.request(request)
+          end
+        rescue Timeout::Error
+          ::NewRelic::Agent.logger.warn "Timed out trying to post data to New Relic (timeout = #{@request_timeout} seconds)" unless @request_timeout < 30
+          raise
+        end
+        if response.is_a? Net::HTTPUnauthorized
+          raise LicenseException, 'Invalid license key, please contact support@newrelic.com'
+        elsif response.is_a? Net::HTTPServiceUnavailable
+          raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
+        elsif response.is_a? Net::HTTPGatewayTimeOut
+          ::NewRelic::Agent.logger.warn("Timed out getting response: #{response.message}")
+          raise Timeout::Error, response.message
+        elsif response.is_a? Net::HTTPRequestEntityTooLarge
+          raise UnrecoverableServerException, '413 Request Entity Too Large'
+        elsif response.is_a? Net::HTTPUnsupportedMediaType
+          raise UnrecoverableServerException, '415 Unsupported Media Type'
+        elsif !(response.is_a? Net::HTTPSuccess)
+          raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
+        end
+        response
+      rescue SystemCallError, SocketError => e
+        # These include Errno connection errors
+        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
+      end
+
+      # Decompresses the response from the server, if it is gzip
+      # encoded, otherwise returns it verbatim
+      def decompress_response(response)
+        if response['content-encoding'] != 'gzip'
+          ::NewRelic::Agent.logger.debug "Uncompressed content returned"
+          return response.body
+        end
+        ::NewRelic::Agent.logger.debug "Decompressing return value"
+        i = Zlib::GzipReader.new(StringIO.new(response.body))
+        i.read
+      end
+
+      # Sets the user agent for connections to the server, to
+      # conform with the HTTP spec and allow for debugging. Includes
+      # the ruby version and also zlib version if available since
+      # that may cause corrupt compression if there is a problem.
+      def user_agent
+        ruby_description = ''
+        # note the trailing space!
+        ruby_description << "(ruby #{::RUBY_VERSION} #{::RUBY_PLATFORM}) " if defined?(::RUBY_VERSION) && defined?(::RUBY_PLATFORM)
+        zlib_version = ''
+        zlib_version << "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
+        "NewRelic-RubyAgent/#{NewRelic::VERSION::STRING} #{ruby_description}#{zlib_version}"
+      end
+
+      module Encoders
+        module Identity
+          def self.encode(data)
+            data
+          end
+        end
+
+        module Compressed
+          def self.encode(data)
+            Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
+          end
+        end
+
+        module Base64CompressedJSON
+          def self.encode(data)
+            Base64.encode64(Compressed.encode(JSON.dump(data)))
+          end
+        end
+      end
+
+      class Marshaller
+        def parsed_error(error)
+          error_class = error['error_type'].split('::') \
+            .inject(Module) {|mod,const| mod.const_get(const) }
+          error_class.new(error['message'])
+        rescue NameError
+          CollectorError.new("#{error['error_type']}: #{error['message']}")
+        end
+
+        def prepare(data, options={})
+          encoder = options[:encoder] || default_encoder
+          if data.respond_to?(:to_collector_array)
+            data.to_collector_array(encoder)
+          elsif data.kind_of?(Array)
+            data.map { |element| prepare(element, options) }
+          else
+            data
+          end
+        end
+
+        def default_encoder
+          Encoders::Identity
+        end
+
+        def self.human_readable?
+          false
+        end
+
+        protected
+
+        def return_value(data)
+          if data.respond_to?(:has_key?)
+            if data.has_key?('exception')
+              raise parsed_error(data['exception'])
+            elsif data.has_key?('return_value')
+              return data['return_value']
+            end
+          end
+          ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
+          nil
+        end
+      end
+
+      # Primitive Ruby Object Notation which complies JSON format data strutures
+      class PrubyMarshaller < Marshaller
+        def initialize
+          ::NewRelic::Agent.logger.debug 'Using Pruby marshaller'
+        end
+
+        def dump(ruby, opts={})
+          NewRelic::LanguageSupport.with_cautious_gc do
+            Marshal.dump(prepare(ruby, opts))
+          end
+        rescue => e
+          ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} when marshalling #{ruby.inspect}")
+          raise
+        end
+
+        def load(data)
+          return unless data && data != ''
+          NewRelic::LanguageSupport.with_cautious_gc do
+            return_value(Marshal.load(data))
+          end
+        rescue
+          ::NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
+          raise
+        end
+
+        def format
+          'pruby'
+        end
+
+        def self.is_supported?
+          true
+        end
+      end
+
+      # Marshal collector protocol with JSON when available
+      class JsonMarshaller < Marshaller
+        def initialize
+          ::NewRelic::Agent.logger.debug 'Using JSON marshaller'
+        end
+
+        def dump(ruby, opts={})
+          JSON.dump(prepare(ruby, opts))
+        end
+
+        def load(data)
+          return unless data && data != ''
+          return_value(JSON.load(data))
+        rescue
+          ::NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
+          raise
+        end
+
+        def default_encoder
+          Encoders::Base64CompressedJSON
+        end
+
+        def format
+          'json'
+        end
+
+        def self.is_supported?
+          RUBY_VERSION >= '1.9.2'
+        end
+
+        def self.human_readable?
+          true # for some definitions of 'human'
+        end
+      end
+
+      class CollectorError < StandardError; end
+    end
+  end
+end