sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,11 @@
+module NewRelic
+  module Agent
+    module Configuration
+      MASK_DEFAULTS = {
+        :'thread_profiler' =>         Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
+        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
+        :verify_certificate =>  Proc.new{ true }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class ServerSource < DottedHash
+        def initialize(hash)
+          if hash['agent_config']
+            if hash['agent_config']['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+              # when value is "apdex_f" remove the config and defer to default
+              hash['agent_config'].delete('transaction_tracer.transaction_threshold')
+            end
+            super(hash.delete('agent_config'))
+          end
+
+          string_map = [
+             ['collect_traces', 'transaction_tracer.enabled'],
+             ['collect_traces', 'slow_sql.enabled'],
+             ['collect_errors', 'error_collector.enabled']
+          ].each do |pair|
+            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
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'new_relic/agent/configuration'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class YamlSource < DottedHash
+        attr_accessor :file_path
+
+        def initialize(path, env)
+          ::NewRelic::Agent.logger.debug("Reading configuration from #{path}")
+
+          config = {}
+          begin
+            @file_path = File.expand_path(path)
+            if !File.exists?(@file_path)
+              ::NewRelic::Agent.logger.error("Unable to load configuration from #{path}")
+              return
+            end
+
+            file = File.read(@file_path)
+
+            # Next two are for populating the newrelic.yml via erb binding, necessary
+            # when using the default newrelic.yml file
+            generated_for_user = ''
+            license_key = ''
+
+            erb = ERB.new(file).result(binding)
+            confighash = YAML.load(erb)
+            ::NewRelic::Agent.logger.error("Config (#{path}) doesn't include a '#{env}' environment!") unless
+              confighash.key?(env)
+
+            config = merge!(confighash[env] || {})
+          rescue ScriptError, StandardError => e
+            ::NewRelic::Agent.logger.error("Unable to read configuration file #{path}: #{e}")
+          end
+
+          if config['transaction_tracer'] &&
+              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            config['transaction_tracer'].delete('transaction_threshold')
+          end
+
+          booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+
+          super(config)
+        end
+
+        protected
+
+        def booleanify_values(config, *keys)
+          # auto means defer ro default
+          keys.each do |option|
+            if config[option] == 'auto'
+              config.delete(option)
+            elsif !config[option].nil? && !is_boolean?(config[option])
+              config[option] = !!(config[option] =~ /yes|on|true/i)
+            end
+          end
+        end
+
+        def is_boolean?(value)
+          value == !!value
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -0,0 +1,239 @@
+require 'new_relic/rack/agent_hooks'
+require 'new_relic/agent/thread'
+
+module NewRelic
+  module Agent
+
+    class CrossAppMonitor
+
+      NEWRELIC_ID_HEADER = 'X-NewRelic-ID'
+      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'
+      NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'
+      NEWRELIC_TXN_HEADER_KEYS = %W{
+        #{NEWRELIC_TXN_HEADER} HTTP_X_NEWRELIC_TRANSACTION X_NEWRELIC_TRANSACTION
+      }
+      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.gsub(/\n/, '')
+        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 = from_headers( request_headers, NEWRELIC_TXN_HEADER_KEYS ) or return
+        txn_header = decode_with_key( key, txn_header )
+        txn_info = NewRelic.json_load( txn_header )
+        NewRelic::Agent.logger.debug "Referring txn_info: %p" % [ txn_info ]
+
+        NewRelic::Agent::AgentThread.current[THREAD_TXN_KEY] = txn_info
+      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.to_f,
+          timings.app_time_in_seconds.to_f,
+          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(:referring_transaction_guid => client_referring_transaction_guid()) if
+          client_referring_transaction_guid()
+
+        NewRelic::Agent.logger.debug "Referring transaction guid: %p" % [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
+

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -0,0 +1,281 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+module NewRelic
+  module Agent
+    module CrossAppTracing
+      extend NewRelic::Agent::CrossAppMonitor::EncodingFunctions
+
+      # Exception raised if there is a problem with cross app transactions.
+      class Error < RuntimeError; end
+
+
+      # The cross app response header for "outgoing" calls
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
+
+      # The cross app id header for "outgoing" calls
+      NR_ID_HEADER = 'X-NewRelic-ID'
+
+      # The cross app transaction header for "outgoing" calls
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
+
+      # The index of the transaction GUID in the appdata header of responses
+      APPDATA_TXN_GUID_INDEX = 5
+
+
+      ###############
+      module_function
+      ###############
+
+      # Send the given +request+, adding metrics appropriate to the
+      # response when it comes back.
+      def trace_http_request( http, request )
+        return yield unless NewRelic::Agent.is_execution_traced?
+
+        t0, segment = start_trace( http, request )
+        begin
+          response = yield
+        ensure
+          finish_trace( t0, segment, request, response, http ) if t0
+        end
+
+        return response
+      end
+
+
+      # Set up the necessary state for cross-application tracing before the
+      # given +request+ goes out on the specified +http+ connection.
+      def start_trace( http, request )
+        inject_request_headers( request ) if cross_app_enabled?
+
+        # Create a segment and time the call
+        t0 = Time.now
+        segment = stats_engine.push_scope( "External/#{http.address}/all", t0 )
+
+        return t0, segment
+      rescue => err
+        NewRelic::Agent.logger.error "Uncaught exception while tracing HTTP request", err
+        return nil
+      end
+
+
+      # Finish tracing the HTTP +request+ that started at +t0+ with the information in
+      # +response+ and the given +http+ connection.
+      def finish_trace( t0, segment, request, response, http )
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+
+        begin
+          if request && response && http
+            # Figure out which metrics we need to report based on the request and response
+            # The last (most-specific) one is scoped.
+            metrics = metrics_for( http, request, response )
+            scoped_metric = metrics.pop
+
+            # Report the metrics
+            metrics.each { |metric| get_metric(metric).trace_call(duration) }
+            get_scoped_metric( scoped_metric ).trace_call( duration )
+
+            # Add TT custom parameters
+            stats_engine.rename_scope_segment( scoped_metric )
+            extract_custom_parameters( response ) if response_is_crossapp?( response )
+          end
+        ensure
+          # We always need to pop the scope stack to avoid an inconsistent
+          # state, which will prevent tracing of the whole transaction.
+          stats_engine.pop_scope( segment, duration, t1 )
+        end
+      rescue NewRelic::Agent::CrossAppTracing::Error => err
+        NewRelic::Agent.logger.debug "while cross app tracing", err
+      rescue => err
+        NewRelic::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
+      end
+
+
+      # Return +true+ if cross app tracing is enabled in the config.
+      def cross_app_enabled?
+        NewRelic::Agent.config[:cross_process_id] &&
+          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] ||
+           NewRelic::Agent.config[:cross_application_tracing])
+      end
+
+
+      # Memoized fetcher for the cross app encoding key. Raises a
+      # NewRelic::Agent::CrossAppTracing::Error if the key isn't configured.
+      def cross_app_encoding_key
+        NewRelic::Agent.config[:encoding_key] or
+          raise NewRelic::Agent::CrossAppTracing::Error, "No encoding_key set."
+      end
+
+
+      # Inject the X-Process header into the outgoing +request+.
+      def inject_request_headers( request )
+        key = cross_app_encoding_key()
+        cross_app_id = NewRelic::Agent.config[:cross_process_id] or
+          raise NewRelic::Agent::CrossAppTracing::Error, "no cross app ID configured"
+        txn_guid = NewRelic::Agent::TransactionInfo.get.guid
+        txn_data = NewRelic.json_dump([ txn_guid, false ])
+
+        request[ NR_ID_HEADER ] = obfuscate_with_key( key, cross_app_id )
+        request[ NR_TXN_HEADER ] = obfuscate_with_key( key, txn_data )
+
+      rescue NewRelic::Agent::CrossAppTracing::Error => err
+        NewRelic::Agent.logger.debug "Not injecting x-process header", err
+      end
+
+
+      # Extract any custom parameters from +response+ if it's cross-application and
+      # add them to the current TT node.
+      def extract_custom_parameters( response )
+
+        appdata = extract_appdata( response )
+        sampler = NewRelic::Agent.instance.transaction_sampler
+        sampler.add_segment_parameters( :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
+
+      end
+
+
+      # Return the set of metrics (NewRelic::MethodTraceStats objects) that correspond to
+      # the given +request+ and +response+.
+      def metrics_for( http, request, response )
+        metrics = common_metrics( http )
+
+        if response_is_crossapp?( response )
+          begin
+            metrics.concat metrics_for_crossapp_response( http, response )
+          rescue => err
+            # Fall back to regular metrics if there's a problem with x-process metrics
+            NewRelic::Agent.logger.debug "%p while fetching x-process metrics: %s" %
+              [ err.class, err.message ]
+            metrics.concat metrics_for_regular_response( http, request, response )
+          end
+        else
+          NewRelic::Agent.logger.debug "Response doesn't have CAT headers."
+          metrics.concat metrics_for_regular_response( http, request, response )
+        end
+
+        return metrics
+      end
+
+
+      # Return an Array of metrics used for every response.
+      def common_metrics( http )
+        metrics = [ "External/all" ]
+        metrics << "External/#{http.address}/all"
+
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+
+        return metrics
+      end
+
+
+      # Returns +true+ if Cross Application Tracing is enabled, and the given +response+
+      # has the appropriate headers.
+      def response_is_crossapp?( response )
+        return false unless cross_app_enabled?
+        unless response[NR_APPDATA_HEADER]
+          NewRelic::Agent.logger.debug "Response doesn't have the %p header: %p" %
+            [ NR_APPDATA_HEADER, response.to_hash ]
+          return false
+        end
+
+        return true
+      end
+
+
+      # Return the set of metric objects appropriate for the given cross app
+      # +response+.
+      def metrics_for_crossapp_response( http, response )
+        xp_id, txn_name, q_time, r_time, req_len, _ = extract_appdata( response )
+
+        check_crossapp_id( xp_id )
+        check_transaction_name( txn_name )
+
+        NewRelic::Agent.logger.debug "CAT xp_id: %p, txn_name: %p." % [ xp_id, txn_name ]
+
+        metrics = []
+        metrics << "ExternalApp/#{http.address}/#{xp_id}/all"
+        metrics << "ExternalTransaction/#{http.address}/#{xp_id}/#{txn_name}"
+
+        return metrics
+      end
+
+
+      # Extract x-process application data from the specified +response+ and return
+      # it as an array of the form:
+      #
+      #  [
+      #    <cross app ID>,
+      #    <transaction name>,
+      #    <queue time in seconds>,
+      #    <response time in seconds>,
+      #    <request content length in bytes>,
+      #    <transaction GUID>
+      #  ]
+      def extract_appdata( response )
+        appdata = response[NR_APPDATA_HEADER] or
+          raise NewRelic::Agent::CrossAppTracing::Error,
+            "Can't derive metrics for response: no #{NR_APPDATA_HEADER} header!"
+
+        key = cross_app_encoding_key()
+        decoded_appdata = decode_with_key( key, appdata )
+        decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
+          decoded_appdata.respond_to?( :set_encoding )
+
+        return NewRelic.json_load( decoded_appdata )
+      end
+
+
+      # Return the set of metric objects appropriate for the given (non-cross app)
+      # +response+.
+      def metrics_for_regular_response( http, request, response )
+        metrics = []
+        metrics << "External/#{http.address}/Net::HTTP/#{request.method}"
+
+        return metrics
+      end
+
+
+      # Convenience function for fetching the metric associated with +metric_name+.
+      def get_metric( metric_name )
+        stats_engine.get_stats_no_scope( metric_name )
+      end
+
+
+      # Convenience function for fetching the scoped metric associated with +metric_name+.
+      def get_scoped_metric( metric_name )
+        # Default is to use the metric_name itself as the scope, which is what we want
+        stats_engine.get_stats( metric_name )
+      end
+
+
+      # Fetch a reference to the stats engine.
+      def stats_engine
+        NewRelic::Agent.instance.stats_engine
+      end
+
+
+      # Check the given +id+ to ensure it conforms to the format of a cross-application
+      # ID. Raises an NewRelic::Agent::CrossAppTracing::Error if it doesn't.
+      def check_crossapp_id( id )
+        id =~ /\A\d+#\d+\z/ or
+          raise NewRelic::Agent::CrossAppTracing::Error,
+            "malformed cross application ID %p" % [ id ]
+      end
+
+
+      # Check the given +name+ to ensure it conforms to the format of a valid transaction
+      # name.
+      def check_transaction_name( name )
+        # No-op -- apparently absolutely anything is a valid transaction name?
+        # This is here for when that inevitably comes back to haunt us.
+      end
+
+    end
+  end
+end
+