newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

data.tar.gz.sig

@@ -1,2 +1,3 @@
-L��~׾
-=֚}������Ey�{'�,��9���`9�P�n��Aom�R3���<�y�@����Xt��	]��e'sT�����U<��|ŬB�Rl���QMF���z�)��.��u�Ѳ����|l_�6��l2tf"�)��#�.e�Jκ��4�^���䷪��%.�nQM�
+:�����]F�4��Di<F͙�Zb�R�xX~��PӁI吘�[s/t����Mw/�žUi�{��Ӆ
+�)��7j��\�����j�r}Q�X����U��&��U-�'I�e.��M�G��f��sw
+�}A�;ŏ�0_F��W鶐@����-�����l.��X��>�jE0d�/���ŚͨdCQ̴h�}y���mt�-�s����E�+������S⓫��_��g���۝��28�yx�0ٟH�

data/CHANGELOG

@@ -1,6 +1,37 @@
 
 # New Relic Ruby Agent Release Notes #
 
+## v3.5.8 ##
+
+  * Key Transactions
+
+    The Ruby agent now supports Key Transactions! Check out more details on the
+    feature at https://newrelic.com/docs/site/key-transactions
+
+  * Ruby 2.0
+
+    The Ruby agent is compatible with Ruby 2.0.0 which was just released.
+
+  * Improved Sinatra instrumentation
+
+    Several cases around the use of conditions and pass in Sinatra are now
+    better supported by the Ruby agent. Thanks Konstantin for the help!
+
+  * Outbound HTTP headers
+
+    Adds a 'X-NewRelic-ID' header to outbound Net::HTTP requests. This change
+    helps improve the correlation of performance between services in a service-
+    oriented architecture for a forthcoming feature. In the meantime, to disable
+    the header, set this in your newrelic.yml:
+
+      cross_application_tracer:
+        enabled: false
+
+  * Automatically detect Resque dispatcher
+
+    The agent does better auto-detection for the Resque worker process.
+    This should reduce the need to set NEW_RELIC_DISPATCHER=resque directly.
+
 ## v3.5.7 ##
 
   * Resolved some issues with tracking of frontend queue time, particularly
@@ -15,9 +46,9 @@
   * Use HTTPS by default
 
     The agent now defaults to using SSL when it communicates with New Relic's
-    servers.  By defaults already configured, New Relic does not transmit any
-    sensitive information (e.g. SQL parameters are masked), but SSL adds 
-    another layer of security.  Upgrading customers may need to remove the
+    servers.  By default is already configured New Relic does not transmit any
+    sensitive information (e.g. SQL parameters are masked), but SSL adds an
+    additional layer of security.  Upgrading customers may need to remove the
     "ssl: false" directive from their newrelic.yml to enable ssl.  Customers on
     Jruby may need to install the jruby-openssl gem to take advantage of this
     feature.

data/LICENSE

@@ -23,6 +23,29 @@ See https://github.com/jquery/jquery/blob/master/MIT-LICENSE.txt
     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+It also includes source derived from 'okjson' by Keith Rarick, distributed
+under the MIT license.
+See https://github.com/kr/okjson/blob/bdd1113/okjson.rb#L3-21
+
+    Copyright 2011, 2012 Keith Rarick
+    
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
 
 All other components of this product are
 Copyright (c) 2008-2012 New Relic, Inc.  All rights reserved.

data/lib/new_relic/agent.rb

@@ -63,7 +63,6 @@ module NewRelic
     
     require 'new_relic/version'
     require 'new_relic/local_environment'
-    require 'new_relic/stats'
     require 'new_relic/metrics'
     require 'new_relic/metric_spec'
     require 'new_relic/metric_data'
@@ -75,9 +74,10 @@ module NewRelic
     require 'new_relic/timer_lib'
 
     require 'new_relic/agent'
+    require 'new_relic/agent/stats'
     require 'new_relic/agent/chained_call'
     require 'new_relic/agent/browser_monitoring'
-    require 'new_relic/agent/cross_process_monitoring'
+    require 'new_relic/agent/cross_app_monitor'
     require 'new_relic/agent/agent'
     require 'new_relic/agent/shim_agent'
     require 'new_relic/agent/method_tracer'
@@ -93,6 +93,7 @@ module NewRelic
     require 'new_relic/agent/pipe_channel_manager'
     require 'new_relic/agent/transaction_info'
     require 'new_relic/agent/configuration'
+    require 'new_relic/agent/rules_engine'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -154,14 +155,60 @@ module NewRelic
       @logger = log
     end
 
+    # Record a value for the given metric name.
+    #
+    # This method should be used to record event-based metrics such as method
+    # calls that are associated with a specific duration or magnitude.
+    #
+    # +metric_name+ should follow a slash separated path convention. Application
+    # specific metrics should begin with "Custom/".
+    #
+    # +value+ should be either a single Numeric value representing the duration/
+    # magnitude of the event being recorded, or a Hash containing :count,
+    # :total, :min, :max, and :sum_of_squares keys. The latter form is useful
+    # for recording pre-aggregated metrics collected externally.
+    #
+    # This method is safe to use from any thread.
+    #
+    # @api public
+    def record_metric(metric_name, value)
+      if value.is_a?(Hash)
+        stats = NewRelic::Agent::Stats.new
+        stats.call_count = value[:count]
+        stats.total_call_time = value[:total]
+        stats.total_exclusive_time = value[:total]
+        stats.min_call_time = value[:min]
+        stats.max_call_time = value[:max]
+        stats.sum_of_squares = value[:sum_of_squares]
+        value = stats
+      end
+      agent.stats_engine.record_metric(metric_name, value)
+    end
+
+    # Increment a simple counter metric.
+    #
+    # +metric_name+ should follow a slash separated path convention. Application
+    # specific metrics should begin with "Custom/".
+    #
+    # This method is safe to use from any thread.
+    #
+    # @api public
+    def increment_metric(metric_name, amount=1)
+      agent.stats_engine.record_metric(metric_name) do |stats|
+        stats.increment_count(amount)
+      end
+    end
+
     # 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
+    # Return a NewRelic::Agent::Stats that accepts data
     # via calls to add_data_point(value).
+    #
+    # @deprecated
     def get_stats(metric_name, use_scope=false)
       agent.stats_engine.get_stats(metric_name, use_scope)
     end

data/lib/new_relic/agent/agent.rb

@@ -9,6 +9,8 @@ require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/database'
 require 'new_relic/agent/thread_profiler'
+require 'new_relic/agent/event_listener'
+require 'new_relic/agent/cross_app_monitor'
 
 module NewRelic
   module Agent
@@ -23,14 +25,15 @@ module NewRelic
       def initialize
         @launch_time = Time.now
 
-        @metric_ids = {}
-        @events = NewRelic::Agent::EventListener.new
-        @stats_engine = NewRelic::Agent::StatsEngine.new
-        @transaction_sampler = NewRelic::Agent::TransactionSampler.new
-        @sql_sampler = NewRelic::Agent::SqlSampler.new
-        @thread_profiler = NewRelic::Agent::ThreadProfiler.new
-        @cross_process_monitor = NewRelic::Agent::CrossProcessMonitor.new(@events)
-        @error_collector = NewRelic::Agent::ErrorCollector.new
+        @events                = NewRelic::Agent::EventListener.new
+        @stats_engine          = NewRelic::Agent::StatsEngine.new
+        @transaction_sampler   = NewRelic::Agent::TransactionSampler.new
+        @sql_sampler           = NewRelic::Agent::SqlSampler.new
+        @thread_profiler       = NewRelic::Agent::ThreadProfiler.new
+        @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
+        @error_collector       = NewRelic::Agent::ErrorCollector.new
+        @transaction_rules     = NewRelic::Agent::RulesEngine.new
+        @metric_rules          = NewRelic::Agent::RulesEngine.new
 
         @connect_state = :pending
         @connect_attempts = 0
@@ -82,27 +85,24 @@ module NewRelic
         attr_reader :error_collector
         # whether we should record raw, obfuscated, or no sql
         attr_reader :record_sql
-        # a cached set of metric_ids to save the collector some time -
-        # it returns a metric id for every metric name we send it, and
-        # in the future we transmit using the metric id only
-        attr_reader :metric_ids
-        # in theory a set of rules applied by the agent to the output
-        # of its metrics. Currently unimplemented
-        attr_reader :url_rules
         # a configuration for the Real User Monitoring system -
         # handles things like static setup of the header for inclusion
         # into pages
         attr_reader :beacon_configuration
-        # cross process id's and encoding
+        # cross application tracing ids and encoding
         attr_reader :cross_process_id
-        attr_reader :cross_process_encoding_bytes
+        attr_reader :cross_app_encoding_bytes
         # service for communicating with collector
         attr_accessor :service
         # Global events dispatcher. This will provides our primary mechanism
         # for agent-wide events, such as finishing configuration, error notification
         # and request before/after from Rack.
         attr_reader :events
-
+        # Transaction and metric renaming rules as provided by the
+        # collector on connect.  The former are applied during txns,
+        # the latter during harvest.
+        attr_reader :transaction_rules
+        attr_reader :metric_rules
 
         # Returns the length of the unsent errors array, if it exists,
         # otherwise nil
@@ -187,7 +187,6 @@ module NewRelic
             @service = NewRelic::Agent::PipeService.new(channel_id)
             if connected?
               @connected_pid = $$
-              @metric_ids = {}
             else
               ::NewRelic::Agent.logger.debug("Child process #{$$} not reporting to non-connected parent.")
               @service.shutdown(Time.now)
@@ -533,7 +532,7 @@ module NewRelic
           def handle_force_restart(error)
             ::NewRelic::Agent.logger.debug error.message
             reset_stats
-            @metric_ids = {}
+            @service.reset_metric_id_cache if @service
             @connect_state = :pending
             sleep 30
           end
@@ -747,12 +746,24 @@ module NewRelic
             Agent.config.apply_config(server_config, 1)
             log_connection!(config_data) if @service
 
+            add_rules_to_engine(config_data['transaction_name_rules'],
+                                NewRelic::Agent.instance.transaction_rules)
+            add_rules_to_engine(config_data['metric_name_rules'],
+                                NewRelic::Agent.instance.metric_rules)
+
             # If you're adding something else here to respond to the server-side config,
             # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
 
             @beacon_configuration = BeaconConfiguration.new
           end
 
+          def add_rules_to_engine(rule_specifications, rules_engine)
+            return unless rule_specifications && rule_specifications.any?
+            rule_specifications.each do |rule_spec|
+              rules_engine << NewRelic::Agent::RulesEngine::Rule.new(rule_spec)
+            end
+          end
+
           # Logs when we connect to the server, for debugging purposes
           # - makes sure we know if an agent has not connected
           def log_connection!(config_data)
@@ -772,30 +783,13 @@ module NewRelic
         end
         include Connect
 
-
-        # Serialize all the important data that the agent might want
-        # to send to the server. We could be sending this to file (
-        # common in short-running background transactions ) or
-        # alternately we could serialize via a pipe or socket to a
-        # local aggregation device
-        def serialize
-          accumulator = []
-          accumulator[1] = harvest_transaction_traces if @transaction_sampler
-          accumulator[2] = harvest_errors if @error_collector
-          accumulator[0] = harvest_timeslice_data
-          reset_stats
-          @metric_ids = {}
-          accumulator
-        end
-        public :serialize
-
-        # Accepts data as provided by the serialize method and merges
+        # Accepts an array of (metrics, transaction_traces, errors) and merges
         # it into our current collection of data to send. Can be
         # dangerous if we re-merge the same data more than once - it
         # will be sent multiple times.
         def merge_data_from(data)
           metrics, transaction_traces, errors = data
-          @stats_engine.merge_data(metrics) if metrics
+          @stats_engine.merge!(metrics) if metrics
           if transaction_traces && transaction_traces.respond_to?(:any?) &&
               transaction_traces.any?
             if @traces
@@ -831,8 +825,8 @@ module NewRelic
         #   agent run and New Relic sees it as a separate instance (default is false).
         def connect(options={})
           defaults = {
-            :keep_retrying => true,
-            :force_reconnect => false
+            :keep_retrying => Agent.config[:keep_retrying],
+            :force_reconnect => Agent.config[:force_reconnect]
           }
           opts = defaults.merge(options)
 
@@ -876,21 +870,11 @@ module NewRelic
           NewRelic::Agent::BusyCalculator.harvest_busy
 
           @unsent_timeslice_data ||= {}
-          @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data, @metric_ids)
+          @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data,
+                                                                        @metric_rules)
           @unsent_timeslice_data
         end
 
-        # takes an array of arrays of spec and id, adds it into the
-        # metric cache so we can save the collector some work by
-        # sending integers instead of strings
-        def fill_metric_id_cache(pairs_of_specs_and_ids)
-          Array(pairs_of_specs_and_ids).each do |metric_spec_hash, metric_id|
-            metric_spec = MetricSpec.new(metric_spec_hash['name'],
-                                         metric_spec_hash['scope'])
-            @metric_ids[metric_spec] = metric_id
-          end
-        end
-
         # note - exceptions are logged in invoke_remote.  If an exception is encountered here,
         # then the metric data is downsampled for another
         # transmission later
@@ -899,17 +883,13 @@ module NewRelic
           NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point(0.0)
           NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/metric_data').record_data_point(0.0)
           harvest_timeslice_data(now)
-          # In this version of the protocol
-          # we get back an assoc array of spec to id.
-          metric_specs_and_ids = []
           begin
-            metric_specs_and_ids = @service.metric_data(@last_harvest_time.to_f,
-                                                now.to_f,
-                                                @unsent_timeslice_data.values)
+            @service.metric_data(@last_harvest_time.to_f,
+                                  now.to_f,
+                                  @unsent_timeslice_data)
           rescue UnrecoverableServerException => e
             ::NewRelic::Agent.logger.debug e.message
           end
-          fill_metric_id_cache(metric_specs_and_ids)
 
           ::NewRelic::Agent.logger.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@service.agent_id}) in #{Time.now - now} seconds"
 

data/lib/new_relic/agent/configuration/defaults.rb

@@ -1,7 +1,12 @@
 module NewRelic
   module Agent
     module Configuration
-      DEFAULTS = {
+      # This is so we can easily differentiate between the actual
+      # default source and a Hash that was simply pushed onto the
+      # config stack.
+      class DefaultSource < Hash; end
+
+      DEFAULTS = DefaultSource[
         :config_path => Proc.new {
           # Check a sequence of file locations for newrelic.yml
           files = []
@@ -115,12 +120,13 @@ module NewRelic
         :'rum.load_episodes_file' => true,
         :'browser_monitoring.auto_instrument' => Proc.new { self[:'rum.enabled'] },
 
-        :'cross_process.enabled'  => true,
+        :trusted_account_ids                => [],
+        :"cross_application_tracer.enabled" => true,
 
         :'thread_profiler.enabled' => Proc.new { NewRelic::Agent::ThreadProfiler.is_supported? },
 
         :marshaller => Proc.new { NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? 'json' : 'pruby' }
-      }.freeze
+      ].freeze
     end
   end
 end

data/lib/new_relic/agent/configuration/server_source.rb

@@ -19,6 +19,10 @@ module NewRelic
             hash[pair[1]] = hash[pair[0]] if hash[pair[0]] != nil
           end
 
+          if hash['web_transactions_apdex']
+            self[:web_transactions_apdex] = hash.delete('web_transactions_apdex')
+          end
+
           super
         end
       end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -0,0 +1,230 @@
+require 'new_relic/rack/agent_hooks'
+require 'new_relic/agent/thread'
+
+module NewRelic
+  module Agent
+
+    class CrossAppMonitor
+
+      NEWRELIC_ID_HEADER = 'X-NewRelic-ID'
+      NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'
+      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'
+      NEWRELIC_ID_HEADER_KEYS = %W{#{NEWRELIC_ID_HEADER} HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}
+      CONTENT_LENGTH_HEADER_KEYS = %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH}
+
+      # Because we aren't in the right spot when our transaction actually
+      # starts, hold client_cross_app_id we get thread local until then.
+      THREAD_ID_KEY = :newrelic_client_cross_app_id
+
+      # Same for the referring transaction guid
+      THREAD_TXN_KEY = :newrelic_cross_app_referring_txn_info
+
+      
+      # Functions for obfuscating and unobfuscating header values
+      module EncodingFunctions
+
+        module_function
+
+        def obfuscate_with_key(key, text)
+          [ encode_with_key(key, text) ].pack('m').chomp
+        end
+
+        def decode_with_key(key, text)
+          encode_with_key( key, text.unpack('m').first )
+        end
+
+        def encode_with_key(key, text)
+          return text unless key
+          key = key.bytes.to_a if key.respond_to?( :bytes )
+
+          encoded = ""
+          index = 0
+          text.each_byte do |byte|
+            encoded.concat((byte ^ key[index % key.length].to_i))
+            index+=1
+          end
+          encoded
+        end
+
+      end
+      include EncodingFunctions
+
+
+      def initialize(events = nil)
+        # When we're starting up for real in the agent, we get passed the events
+        # Other spots can pull from the agent, during startup the agent doesn't exist yet!
+        events ||= Agent.instance.events
+
+        events.subscribe(:finished_configuring) do
+          register_event_listeners
+        end
+      end
+
+
+      # Expected sequence of events:
+      #   :before_call will save our cross application request id to the thread
+      #   :start_transaction will get called when a transaction starts up
+      #   :after_call will write our response headers/metrics and clean up the thread
+      def register_event_listeners
+        NewRelic::Agent.logger.
+          debug("Wiring up Cross Application Tracing to events after finished configuring")
+
+        events = Agent.instance.events
+        events.subscribe(:before_call) do |env|
+          if should_process_request(env)
+            save_client_cross_app_id(env)
+            save_referring_transaction_info(env)
+          end
+        end
+
+        events.subscribe(:start_transaction) do |name|
+          set_transaction_custom_parameters
+        end
+
+        events.subscribe(:after_call) do |env, (status_code, headers, body)|
+          insert_response_header(env, headers)
+        end
+
+        events.subscribe(:notice_error) do |_, options|
+          set_error_custom_parameters(options)
+        end
+      end
+
+      def save_client_cross_app_id(request_headers)
+        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = decoded_id(request_headers)
+      end
+
+      def clear_client_cross_app_id
+        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = nil
+      end
+
+      def client_cross_app_id
+        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY]
+      end
+
+      def save_referring_transaction_info(request_headers)
+        key = NewRelic::Agent.config[:encoding_key]
+        txn_header = request_headers[NEWRELIC_TXN_HEADER] or return
+        txn_header = decode_with_key( key, txn_header )
+        NewRelic::Agent::AgentThread.current[THREAD_TXN_KEY] = NewRelic.json_load( txn_header )
+      end
+
+      def clear_referring_transaction_info
+        NewRelic::Agent::AgentThread.current[THREAD_TXN_KEY] = nil
+      end
+
+      def client_referring_transaction_guid
+        info = NewRelic::Agent::AgentThread.current[THREAD_TXN_KEY] or return nil
+        return info[0]
+      end
+
+      def client_referring_transaction_record_flag
+        info = NewRelic::Agent::AgentThread.current[THREAD_TXN_KEY] or return nil
+        return info[1]
+      end
+
+      def insert_response_header(request_headers, response_headers)
+        unless client_cross_app_id.nil?
+          timings = NewRelic::Agent::BrowserMonitoring.timings
+          content_length = content_length_from_request(request_headers)
+
+          set_response_headers(response_headers, timings, content_length)
+          set_metrics(client_cross_app_id, timings)
+
+          clear_client_cross_app_id
+        end
+      end
+
+      def should_process_request(request_headers)
+        return cross_app_enabled? && trusts?(request_headers)
+      end
+
+      def cross_app_enabled?
+        NewRelic::Agent.config[:cross_process_id] &&
+          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] || 
+           NewRelic::Agent.config[:cross_application_tracing])
+      end
+
+      # Expects an ID of format "12#345", and will only accept that!
+      def trusts?(request)
+        id = decoded_id(request)
+        split_id = id.match(/(\d+)#\d+/)
+        return false if split_id.nil?
+
+        NewRelic::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
+      end
+
+      def set_response_headers(response_headers, timings, content_length)
+        response_headers[NEWRELIC_APPDATA_HEADER] = build_payload(timings, content_length)
+      end
+
+      def build_payload(timings, content_length)
+
+        # FIXME The transaction name might not be properly encoded.  use a json generator
+        # For now we just handle quote characters by dropping them
+        transaction_name = timings.transaction_name.gsub(/["']/, "")
+
+        payload = [
+          NewRelic::Agent.config[:cross_process_id],
+          transaction_name,
+          timings.queue_time_in_seconds,
+          timings.app_time_in_seconds,
+          content_length,
+          transaction_guid()
+        ]
+        key = NewRelic::Agent.config[:encoding_key]
+        payload = obfuscate_with_key( key, NewRelic.json_dump(payload) )
+      end
+
+      def set_transaction_custom_parameters
+        # We expect to get the before call to set the id (if we have it) before
+        # this, and then write our custom parameter when the transaction starts
+        NewRelic::Agent.add_custom_parameters(:client_cross_process_id => client_cross_app_id) if client_cross_app_id()
+        NewRelic::Agent.add_custom_parameters(:transaction_guid => transaction_guid()) if transaction_guid()
+        NewRelic::Agent.add_custom_parameters(:transaction_referring_guid => client_referring_transaction_guid()) if
+          client_referring_transaction_guid()
+      end
+
+      def set_error_custom_parameters(options)
+        options[:client_cross_process_id] = client_cross_app_id() if client_cross_app_id()
+        # [MG] TODO: Should the CAT metrics be set here too?
+      end
+
+      def set_metrics(id, timings)
+        metric = NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ClientApplication/#{id}/all")
+        metric.record_data_point(timings.app_time_in_seconds)
+      end
+
+      def decoded_id(request)
+        encoded_id = from_headers(request, NEWRELIC_ID_HEADER_KEYS)
+        return "" if encoded_id.nil?
+
+        key = NewRelic::Agent.config[:encoding_key]
+        decode_with_key( key, encoded_id )
+      end
+
+      def content_length_from_request(request)
+        from_headers(request, CONTENT_LENGTH_HEADER_KEYS) || -1
+      end
+
+      def transaction_guid
+        NewRelic::Agent::TransactionInfo.get.guid
+      end
+
+      private
+
+      def from_headers(request, try_keys)
+        # For lookups, upcase all our keys on both sides just to be safe
+        upcased_keys = try_keys.map{|k| k.upcase}
+        upcased_keys.each do |header|
+          found_key = request.keys.find { |k| k.upcase == header }
+          return request[found_key] unless found_key.nil?
+        end
+        nil
+      end
+
+    end
+
+  end
+end
+