newrelic_rpm 3.7.0.174.beta → 3.7.0.177

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

@@ -137,9 +137,9 @@ module NewRelic
         end
 
         def app_names
-          case self[:app_name]
-          when Array then self[:app_name]
-          when String then self[:app_name].split(';')
+          case NewRelic::Agent.config[:app_name]
+          when Array then NewRelic::Agent.config[:app_name]
+          when String then NewRelic::Agent.config[:app_name].split(';')
           else []
           end
         end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -22,36 +22,7 @@ module NewRelic
       }
       CONTENT_LENGTH_HEADER_KEYS = %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH}
 
-      # 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 = ""
-          encoded.force_encoding('binary') if encoded.respond_to?( :force_encoding )
-          index = 0
-          text.each_byte do |byte|
-            encoded.concat((byte ^ key[index % key.length].to_i))
-            index+=1
-          end
-          encoded
-        end
-
-      end
-      include EncodingFunctions
-
+      attr_reader :obfuscator
 
       def initialize(events = nil)
         # When we're starting up for real in the agent, we get passed the events
@@ -59,10 +30,14 @@ module NewRelic
         events ||= Agent.instance.events
 
         events.subscribe(:finished_configuring) do
-          register_event_listeners
+          on_finished_configuring
         end
       end
 
+      def on_finished_configuring
+        setup_obfuscator
+        register_event_listeners
+      end
 
       # Expected sequence of events:
       #   :before_call will save our cross application request id to the thread
@@ -93,6 +68,11 @@ module NewRelic
         end
       end
 
+      # This requires :encoding_key, so must wait until :finished_configuring
+      def setup_obfuscator
+        @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+      end
+
       def save_client_cross_app_id(request_headers)
         TransactionState.get.client_cross_app_id = decoded_id(request_headers)
       end
@@ -106,9 +86,8 @@ module NewRelic
       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_header = obfuscator.deobfuscate( txn_header )
         txn_info = NewRelic.json_load( txn_header )
         NewRelic::Agent.logger.debug "Referring txn_info: %p" % [ txn_info ]
 
@@ -143,9 +122,7 @@ module NewRelic
       end
 
       def cross_app_enabled?
-        NewRelic::Agent.config[:cross_process_id] &&
-          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] ||
-           NewRelic::Agent.config[:cross_application_tracing])
+        NewRelic::Agent::CrossAppTracing.cross_app_enabled?
       end
 
       # Expects an ID of format "12#345", and will only accept that!
@@ -170,8 +147,7 @@ module NewRelic
           content_length,
           transaction_guid()
         ]
-        key = NewRelic::Agent.config[:encoding_key]
-        payload = obfuscate_with_key( key, NewRelic.json_dump(payload) )
+        payload = obfuscator.obfuscate(NewRelic.json_dump(payload))
       end
 
       def set_transaction_custom_parameters
@@ -200,8 +176,7 @@ module NewRelic
         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 )
+        obfuscator.deobfuscate(encoded_id)
       end
 
       def content_length_from_request(request)

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -6,12 +6,10 @@
 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'
 
@@ -48,7 +46,6 @@ module NewRelic
         return response
       end
 
-
       # Set up the necessary state for cross-application tracing before the
       # given +request+ goes out.
       #
@@ -116,14 +113,24 @@ module NewRelic
         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])
+        valid_cross_process_id? &&
+          valid_encoding_key? &&
+          cross_application_tracer_enabled?
       end
 
+      def valid_cross_process_id?
+        NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
+      end
+
+      def valid_encoding_key?
+        NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
+      end
+
+      def cross_application_tracer_enabled?
+        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.
@@ -132,17 +139,19 @@ module NewRelic
           raise NewRelic::Agent::CrossAppTracing::Error, "No encoding_key set."
       end
 
+      def obfuscator
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(cross_app_encoding_key)
+      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::TransactionState.get.request_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 )
+        request[ NR_ID_HEADER ]  = obfuscator.obfuscate( cross_app_id )
+        request[ NR_TXN_HEADER ] = obfuscator.obfuscate( txn_data )
 
       rescue NewRelic::Agent::CrossAppTracing::Error => err
         NewRelic::Agent.logger.debug "Not injecting x-process header", err
@@ -254,8 +263,7 @@ module NewRelic
           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 = obfuscator.deobfuscate( appdata )
         decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
           decoded_appdata.respond_to?( :set_encoding )
 

data/lib/new_relic/agent/database.rb

@@ -21,8 +21,22 @@ module NewRelic
 
   module Agent
     module Database
+      MAX_QUERY_LENGTH = 16384
+
       extend self
 
+      def capture_query(query)
+        Helper.correctly_encoded(truncate_query(query))
+      end
+
+      def truncate_query(query)
+        if query.length > (MAX_QUERY_LENGTH - 4)
+          query[0..MAX_QUERY_LENGTH - 4] + '...'
+        else
+          query
+        end
+      end
+
       def obfuscate_sql(sql)
         Obfuscator.instance.obfuscator.call(sql)
       end
@@ -46,6 +60,16 @@ module NewRelic
         end
       end
 
+      RECORD_FOR = [:raw, :obfuscated].freeze
+
+      def should_record_sql?
+        RECORD_FOR.include?(record_sql_method)
+      end
+
+      def should_collect_explain_plans?
+        should_record_sql? && Agent.config[:'transaction_tracer.explain_enabled']
+      end
+
       def get_connection(config, &connector)
         ConnectionManager.instance.get_connection(config, &connector)
       end

data/lib/new_relic/agent/error_collector.rb

@@ -163,7 +163,11 @@ module NewRelic
         # If anything else is left over, we treat it like a custom param
         def custom_params_from_opts(options)
           # If anything else is left over, treat it like a custom param:
-          fetch_from_options(options, :custom_params, {}).merge(options)
+          if Agent.config[:'capture_attributes.traces']
+            fetch_from_options(options, :custom_params, {}).merge(options)
+          else
+            {}
+          end
         end
 
         # takes the request parameters out of the options hash, and
@@ -306,7 +310,7 @@ module NewRelic
 
       # Get the errors currently queued up.  Unsent errors are left
       # over from a previous unsuccessful attempt to send them to the server.
-      def harvest_errors
+      def harvest!
         @lock.synchronize do
           errors = @errors
           @errors = []

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -32,12 +32,14 @@ DependencyDetection.defer do
         self.send attr_name
       end
 
-      protected
       # determine the path that is used in the metric name for
       # the called controller action
       def newrelic_metric_path
         "#{controller_name}/#{action_name}"
       end
+
+      protected
+
       alias_method :perform_action_without_newrelic_trace, :_dispatch
       alias_method :_dispatch, :perform_action_with_newrelic_trace
     end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'base64'
+require 'new_relic/agent/obfuscator'
+require 'new_relic/agent/transaction_timings'
+
+module NewRelic
+  module Agent
+    class JavascriptInstrumentor
+      include NewRelic::Coerce
+
+      RUM_KEY_LENGTH = 13
+
+      def initialize(event_listener)
+        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+      end
+
+      def log_configuration
+        NewRelic::Agent.logger.debug("JS agent loader requested: #{NewRelic::Agent.config[:'browser_monitoring.loader']}",
+                                     "JS agent loader debug: #{NewRelic::Agent.config[:'browser_monitoring.debug']}",
+                                     "JS agent loader version: #{NewRelic::Agent.config[:'browser_monitoring.loader_version']}")
+
+        if !NewRelic::Agent.config[:'rum.enabled']
+          NewRelic::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
+        end
+      end
+
+      def enabled?
+        Agent.config[:'rum.enabled'] && !!Agent.config[:beacon]
+      end
+
+      def obfuscator
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:license_key], RUM_KEY_LENGTH)
+      end
+
+      def current_transaction
+        NewRelic::Agent::TransactionState.get.transaction
+      end
+
+      def insert_js?
+        if !enabled?
+          ::NewRelic::Agent.logger.log_once(:debug, :js_agent_disabled,
+                                            "JS agent instrumentation is disabled.")
+          false
+        elsif missing_config?(:js_agent_loader)
+          ::NewRelic::Agent.logger.log_once(:debug, :missing_js_agent_loader,
+                                            "Missing :js_agent_loader. Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:beacon)
+          ::NewRelic::Agent.logger.log_once(:debug, :missing_beacon,
+                                            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:browser_key)
+          ::NewRelic::Agent.logger.log_once(:debug, :missing_browser_key,
+                                            "Browser key is not set. Skipping browser instrumentation.")
+          false
+        elsif !current_transaction
+          ::NewRelic::Agent.logger.debug "Not in transaction. Skipping browser instrumentation."
+          false
+        elsif !::NewRelic::Agent.is_transaction_traced?
+          ::NewRelic::Agent.logger.debug "Transaction is not traced. Skipping browser instrumentation."
+          false
+        elsif !::NewRelic::Agent.is_execution_traced?
+          ::NewRelic::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
+          false
+        elsif ::NewRelic::Agent::TransactionState.get.request_ignore_enduser
+          ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
+          false
+        else
+          true
+        end
+      end
+
+      def missing_config?(key)
+        value = NewRelic::Agent.config[key]
+        value.nil? || value.empty?
+      end
+
+      def browser_timing_header
+        return "" unless insert_js?
+        browser_timing_config + browser_timing_loader
+      end
+
+      # NOTE: Internal prototyping often overrides this, so leave name stable!
+      def browser_timing_loader
+        html_safe_if_needed("\n<script type=\"text/javascript\">#{Agent.config[:js_agent_loader]}</script>")
+      end
+
+      # NOTE: Internal prototyping often overrides this, so leave name stable!
+      def browser_timing_config
+        NewRelic::Agent::Transaction.freeze_name
+        data = data_for_js_agent
+        json = NewRelic.json_dump(data)
+        html_safe_if_needed("\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+      end
+
+      BEACON_KEY           = "beacon".freeze
+      ERROR_BEACON_KEY     = "errorBeacon".freeze
+      LICENSE_KEY_KEY      = "licenseKey".freeze
+      APPLICATIONID_KEY    = "applicationID".freeze
+      TRANSACTION_NAME_KEY = "transactionName".freeze
+      QUEUE_TIME_KEY       = "queueTime".freeze
+      APPLICATION_TIME_KEY = "applicationTime".freeze
+      TT_GUID_KEY          = "ttGuid".freeze
+      AGENT_TOKEN_KEY      = "agentToken".freeze
+      AGENT_KEY            = "agent".freeze
+      EXTRA_KEY            = "extra".freeze
+      SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
+
+      # NOTE: Internal prototyping may override this, so leave name stable!
+      def data_for_js_agent
+        state = NewRelic::Agent::TransactionState.get
+        timings = state.timings
+
+        data = {
+          BEACON_KEY           => NewRelic::Agent.config[:beacon],
+          ERROR_BEACON_KEY     => NewRelic::Agent.config[:error_beacon],
+          LICENSE_KEY_KEY      => NewRelic::Agent.config[:browser_key],
+          APPLICATIONID_KEY    => NewRelic::Agent.config[:application_id],
+          TRANSACTION_NAME_KEY => obfuscator.obfuscate(timings.transaction_name_or_unknown),
+          QUEUE_TIME_KEY       => timings.queue_time_in_millis,
+          APPLICATION_TIME_KEY => timings.app_time_in_millis,
+          TT_GUID_KEY          => state.request_guid_to_include,
+          AGENT_TOKEN_KEY      => state.request_token,
+          AGENT_KEY            => NewRelic::Agent.config[:js_agent_file],
+          EXTRA_KEY            => obfuscator.obfuscate(formatted_extra_parameter_for_js_agent)
+        }
+        add_ssl_for_http(data)
+
+        data
+      end
+
+      def add_ssl_for_http(data)
+        ssl_for_http = NewRelic::Agent.config[:'browser_monitoring.ssl_for_http']
+        unless ssl_for_http.nil?
+          data[SSL_FOR_HTTP_KEY] = ssl_for_http
+        end
+      end
+
+      # NOTE: Internal prototyping may override this, so leave name stable!
+      def data_for_js_agent_extra_parameter
+        return {} unless include_custom_parameters_in_extra?
+        current_transaction.custom_parameters.dup
+      end
+
+      def include_custom_parameters_in_extra?
+        current_transaction &&
+          NewRelic::Agent.config[:'analytics_events.enabled'] &&
+          NewRelic::Agent.config[:'capture_attributes.page_view_events']
+      end
+
+      def formatted_extra_parameter_for_js_agent
+        format_extra_data(data_for_js_agent_extra_parameter)
+      end
+
+      # Format the props using semicolon separated pairs separated by '=':
+      #   product=pro;user=bill@microsoft.com
+      def format_extra_data(extra_props)
+        event_params(extra_props).
+          map {|k,v| format_pair(k, v)}.
+          join(';')
+      end
+
+      def format_pair(key, value)
+        key = escape_special_characters(key)
+        value = format_value(value)
+        "#{key}=#{value}"
+      end
+
+      def escape_special_characters(string)
+        string.to_s.tr("\";=", "':-" )
+      end
+
+      def format_value(v)
+        v = "##{v}" if v.is_a?(Numeric)
+        escape_special_characters(v)
+      end
+
+      def html_safe_if_needed(string)
+        string = string.html_safe if string.respond_to?(:html_safe)
+        string
+      end
+    end
+  end
+end