newrelic_rpm 3.11.2.286 → 3.12.0.288

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

@@ -16,14 +16,6 @@ module NewRelic
             :'resque.capture_params'  => false,
             :'sidekiq.capture_params' => false,
 
-            # These aren't strictly necessary as add_custom_parameters is
-            # directly responsible for ignoring incoming param, but we disallow
-            # attributes by these settings just to be safe
-            :'transaction_tracer.capture_attributes' => false,
-            :'error_collector.capture_attributes'    => false,
-            :'browser_monitoring.capture_attributes' => false,
-            :'analytics_events.capture_attributes'   => false,
-
             :'transaction_tracer.record_sql' => record_sql_setting(local_settings, :'transaction_tracer.record_sql'),
             :'slow_sql.record_sql'           => record_sql_setting(local_settings, :'slow_sql.record_sql'),
             :'mongo.obfuscate_queries'       => true,

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

@@ -211,7 +211,7 @@ module NewRelic
           DottedHash.new(apply_mask(flattened)).to_hash.delete_if do |k, v|
             default = DEFAULTS[k]
             if default
-              default[:local_only]
+              default[:exclude_from_reported_settings]
             else
               # In our tests, we add totally bogus configs, because testing.
               # In those cases, there will be no default. So we'll just let

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

@@ -6,22 +6,84 @@ module NewRelic
   module Agent
     module Configuration
       class ServerSource < DottedHash
-        def initialize(hash, existing_config={})
-          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')
+        # These keys appear *outside* of the agent_config hash in the connect
+        # response, but should still be merged in as config settings to the
+        # main agent configuration.
+        TOP_LEVEL_KEYS = [
+          "apdex_t",
+          "application_id",
+          "beacon",
+          "browser_key",
+          "browser_monitoring.debug",
+          "browser_monitoring.loader",
+          "browser_monitoring.loader_version",
+          "collect_utilization",
+          "cross_process_id",
+          "data_report_period",
+          "data_report_periods.analytic_event_data",
+          "encoding_key",
+          "error_beacon",
+          "js_agent_file",
+          "js_agent_loader",
+          "trusted_account_ids"
+        ]
+
+        def initialize(connect_reply, existing_config={})
+          merged_settings = {}
+
+          merge_top_level_keys(merged_settings, connect_reply)
+          merge_agent_config_hash(merged_settings, connect_reply)
+          fix_transaction_threshold(merged_settings)
+          filter_keys(merged_settings)
+
+          apply_feature_gates(merged_settings, connect_reply, existing_config)
+
+          # The value under this key is a hash mapping transaction name strings
+          # to apdex_t values. We don't want the nested hash to be flattened
+          # as part of the call to super below, so it skips going through
+          # merged_settings.
+          self[:web_transactions_apdex] = connect_reply['web_transactions_apdex']
+
+          # This causes keys in merged_settings to be symbolized and flattened
+          super(merged_settings)
+        end
+
+        def merge_top_level_keys(merged_settings, connect_reply)
+          TOP_LEVEL_KEYS.each do |key_name|
+            if connect_reply[key_name]
+              merged_settings[key_name] = connect_reply[key_name]
             end
+          end
+        end
 
-            hoist_agent_config(hash)
+        def merge_agent_config_hash(merged_settings, connect_reply)
+          if connect_reply['agent_config']
+            merged_settings.merge!(connect_reply['agent_config'])
           end
+        end
 
-          if hash['web_transactions_apdex']
-            self[:web_transactions_apdex] = hash.delete('web_transactions_apdex')
+        def fix_transaction_threshold(merged_settings)
+          # when value is "apdex_f" remove the config and defer to default
+          if merged_settings['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+            merged_settings.delete('transaction_tracer.transaction_threshold')
           end
-          apply_feature_gates(hash, existing_config)
+        end
 
-          super(hash)
+        def filter_keys(merged_settings)
+          merged_settings.delete_if do |key, _|
+            setting_spec = DEFAULTS[key.to_sym]
+            if setting_spec
+              if setting_spec[:allowed_from_server]
+                false # it's allowed, so don't delete it
+              else
+                NewRelic::Agent.logger.warn("Ignoring server-sent config for '#{key}' - this setting cannot be set from the server")
+                true # delete it
+              end
+            else
+              NewRelic::Agent.logger.debug("Ignoring unrecognized config key from server: '#{key}'")
+              true
+            end
+          end
         end
 
         # These feature gates are not intended to be bullet-proof, but only to
@@ -29,33 +91,26 @@ module NewRelic
         # the user's subscription level precludes its use. The server is the
         # ultimate authority regarding subscription levels, so we expect it to
         # do the real enforcement there.
-        def apply_feature_gates(server_config, existing_config)
+        def apply_feature_gates(merged_settings, connect_reply, existing_config)
           gated_features = {
-            :'transaction_tracer.enabled'     => 'collect_traces',
-            :'slow_sql.enabled'               => 'collect_traces',
-            :'error_collector.enabled'        => 'collect_errors',
-            :'analytics_events.enabled'       => 'collect_analytics_events',
-            :'custom_insights_events.enabled' => 'collect_custom_events'
+            'transaction_tracer.enabled'     => 'collect_traces',
+            'slow_sql.enabled'               => 'collect_traces',
+            'error_collector.enabled'        => 'collect_errors',
+            'analytics_events.enabled'       => 'collect_analytics_events',
+            'custom_insights_events.enabled' => 'collect_custom_events'
           }
-          gated_features.each do |feature, gate_key|
-            if server_config.has_key?(gate_key)
-              allowed_by_server = server_config[gate_key]
-              requested_value = ungated_value(feature, server_config, existing_config)
-              effective_value = (allowed_by_server && requested_value)
-              server_config[feature] = effective_value
+          gated_features.each do |config_key, gate_key|
+            if connect_reply.has_key?(gate_key)
+              allowed_by_server = connect_reply[gate_key]
+              requested_value   = ungated_value(config_key, merged_settings, existing_config)
+              effective_value   = (allowed_by_server && requested_value)
+              merged_settings[config_key] = effective_value
             end
           end
         end
 
-        def ungated_value(key, server_config, existing_config)
-          server_config.has_key?(key) ? server_config[key] : existing_config[key]
-        end
-
-        # Move agent_config subkey to top level of hash, symbolizing it too
-        def hoist_agent_config(hash)
-          agent_config = hash.delete('agent_config')
-          DottedHash.symbolize(agent_config)
-          hash.merge!(agent_config)
+        def ungated_value(key, merged_settings, existing_config)
+          merged_settings.has_key?(key) ? merged_settings[key] : existing_config[key.to_sym]
         end
       end
     end

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

@@ -26,7 +26,7 @@ module NewRelic
           end
 
           substitute_transaction_threshold(config)
-          booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+          booleanify_values(config, 'agent_enabled', 'enabled')
 
           super(config, true)
         end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -37,7 +37,7 @@ module NewRelic
 
             save_client_cross_app_id(state, env)
             save_referring_transaction_info(state, env)
-            set_transaction_custom_parameters(state)
+            set_transaction_attributes(state)
           end
         end
 
@@ -47,11 +47,6 @@ module NewRelic
           insert_response_header(state, env, headers)
         end
 
-        events.subscribe(:notice_error) do |_, options| #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-
-          set_error_custom_parameters(state, options)
-        end
       end
 
       def save_client_cross_app_id(state, request_headers)
@@ -137,21 +132,21 @@ module NewRelic
         payload = obfuscator.obfuscate(NewRelic::JSONWrapper.dump(payload))
       end
 
-      def set_transaction_custom_parameters(state)
+      def set_transaction_attributes(state)
         # 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 => state.client_cross_app_id) if state.client_cross_app_id
+        return unless txn = state.current_transaction
+
+        if state.client_cross_app_id
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, state.client_cross_app_id)
+        end
 
         referring_guid = client_referring_transaction_guid(state)
         if referring_guid
-          NewRelic::Agent.add_custom_parameters(:referring_transaction_guid => referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end
 
-      def set_error_custom_parameters(state, options)
-        options[:client_cross_process_id] = state.client_cross_app_id if state.client_cross_app_id
-      end
-
       def set_metrics(id, timings)
         metric_name = "ClientApplication/#{id}/all"
         NewRelic::Agent.record_metric(metric_name, timings.app_time_in_seconds)

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -44,10 +44,10 @@ module NewRelic
         # a race condition if we raise after begin but before t0's set.
         t0 = Time.now
         begin
-          segment = start_trace(state, t0, request)
+          node = start_trace(state, t0, request)
           response = yield
         ensure
-          finish_trace(state, t0, segment, request, response)
+          finish_trace(state, t0, node, request, response)
         end
 
         return response
@@ -67,13 +67,13 @@ module NewRelic
       # * []=(key, val) - Set an HTTP request header by name
       # * uri  - Full URI of the request
       #
-      # This method returns the transaction segment if it was sucessfully pushed.
+      # This method returns the transaction node if it was sucessfully pushed.
       def start_trace(state, t0, request)
         inject_request_headers(state, request) if cross_app_enabled?
         stack = state.traced_method_stack
-        segment = stack.push_frame(state, :http_request, t0)
+        node = stack.push_frame(state, :http_request, t0)
 
-        return segment
+        return node
       rescue => err
         NewRelic::Agent.logger.error "Uncaught exception while tracing HTTP request", err
         return nil
@@ -95,7 +95,7 @@ module NewRelic
       # * [](key) - Reads response headers.
       # * to_hash - Converts response headers to a Hash
       #
-      def finish_trace(state, t0, segment, request, response)
+      def finish_trace(state, t0, node, request, response)
         unless t0
           NewRelic::Agent.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
           return
@@ -114,19 +114,19 @@ module NewRelic
             stats_engine.record_scoped_and_unscoped_metrics(
               state, scoped_metric, metrics, duration)
 
-            # If we don't have segment, something failed during start_trace so
-            # the current segment isn't the HTTP call it should have been.
-            if segment
-              segment.name = scoped_metric
+            # If we don't have node, something failed during start_trace so
+            # the current node isn't the HTTP call it should have been.
+            if node
+              node.name = scoped_metric
               add_transaction_trace_parameters(request, response)
             end
           end
         ensure
-          # If we have a segment, always pop the traced method stack to avoid
+          # If we have a node, always pop the traced method stack to avoid
           # an inconsistent state, which prevents tracing of whole transaction.
-          if segment
+          if node
             stack = state.traced_method_stack
-            stack.pop_frame(state, segment, scoped_metric, t1)
+            stack.pop_frame(state, node, scoped_metric, t1)
           end
         end
       rescue NewRelic::Agent::CrossAppTracing::Error => err
@@ -192,7 +192,7 @@ module NewRelic
 
       def add_transaction_trace_parameters(request, response)
         filtered_uri = ::NewRelic::Agent::HTTPClients::URIUtil.filter_uri(request.uri)
-        transaction_sampler.add_segment_parameters(:uri => filtered_uri)
+        transaction_sampler.add_node_parameters(:uri => filtered_uri)
         if response && response_is_crossapp?(response)
           add_cat_transaction_trace_parameters(response)
         end
@@ -203,7 +203,7 @@ module NewRelic
       # add them to the current TT node.
       def add_cat_transaction_trace_parameters( response )
         appdata = extract_appdata( response )
-        transaction_sampler.add_segment_parameters( \
+        transaction_sampler.add_node_parameters( \
           :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
       end
 

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/agent/sized_buffer'
+require 'new_relic/agent/attribute_processing'
 
 module NewRelic
   module Agent
@@ -11,7 +12,6 @@ module NewRelic
 
       TYPE             = 'type'.freeze
       TIMESTAMP        = 'timestamp'.freeze
-      EVENT_PARAMS_CTX = 'recording custom event'.freeze
       EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
 
       DEFAULT_CAPACITY_KEY = :'custom_insights_events.max_samples_stored'
@@ -33,6 +33,10 @@ module NewRelic
       end
 
       def record(type, attributes)
+        unless attributes.is_a? Hash
+          raise ArgumentError, "Expected Hash but got #{attributes.class}"
+        end
+
         type = @type_strings[type]
         unless type =~ EVENT_TYPE_REGEX
           note_dropped_event(type)
@@ -41,7 +45,7 @@ module NewRelic
 
         event = [
           { TYPE => type, TIMESTAMP => Time.now.to_i },
-          event_params(attributes, EVENT_PARAMS_CTX)
+          AttributeProcessing.flatten_and_coerce(attributes)
         ]
 
         stored = @lock.synchronize do

data/lib/new_relic/agent/database.rb

@@ -49,7 +49,9 @@ module NewRelic
       end
 
       def record_sql_method(config_section=:transaction_tracer)
-        case Agent.config["#{config_section}.record_sql".to_sym].to_s
+        key = record_sql_method_key(config_section)
+
+        case Agent.config[key].to_s
         when 'off'
           :off
         when 'none'
@@ -63,6 +65,17 @@ module NewRelic
         end
       end
 
+      def record_sql_method_key(config_section)
+        case config_section
+        when :transaction_tracer
+          :'transaction_tracer.record_sql'
+        when :slow_sql
+          :'slow_sql.record_sql'
+        else
+          "#{config_section}.record_sql".to_sym
+        end
+      end
+
       RECORD_FOR = [:raw, :obfuscated].freeze
 
       def should_record_sql?(config_section=:transaction_tracer)
@@ -96,7 +109,7 @@ module NewRelic
 
       # Perform this in the runtime environment of a managed
       # application, to explain the sql statement executed within a
-      # segment of a transaction sample. Returns an array of
+      # node of a transaction sample. Returns an array of
       # explanations (which is an array rows consisting of an array of
       # strings for each column returned by the the explain query)
       # Note this happens only for statements whose execution time

data/lib/new_relic/agent/datastores.rb

@@ -6,8 +6,16 @@ require 'new_relic/agent/datastores/metric_helper'
 
 module NewRelic
   module Agent
+    #
+    # This module contains helper methods to facilitate instrumentation of
+    # datastores not directly supported by the Ruby agent. It is intended to be
+    # primarily used by authors of 3rd-party datastore instrumentation.
+    #
+    # @api public
     module Datastores
 
+      # @!group Tracing query methods
+
       # Add Datastore tracing to a method. This properly generates the metrics
       # for New Relic's Datastore features. It does not capture the actual
       # query content into Transaction Traces. Use wrap if you want to provide
@@ -16,12 +24,12 @@ module NewRelic
       # @param [Class] clazz the class to instrument
       #
       # @param [String, Symbol] method_name the name of instance method to
-      # instrument
+      #   instrument
       #
       # @param [String] product name of your datastore for use in metric naming, e.g. "Redis"
       #
       # @param [optional,String] operation the name of operation if different
-      # than the instrumented method name
+      #   than the instrumented method name
       #
       # @api public
       #
@@ -62,33 +70,33 @@ module NewRelic
       #   end
       #
       # @param [String] product the datastore name for use in metric naming,
-      # e.g. "FauxDB"
+      #   e.g. "FauxDB"
       #
       # @param [String,Symbol] operation the name of operation (e.g. "select"),
-      # often named after the method that's being instrumented.
+      #   often named after the method that's being instrumented.
       #
       # @param [optional, String] collection the collection name for use in
-      # statement-level metrics (i.e. table or model name)
+      #   statement-level metrics (i.e. table or model name)
       #
       # @param [Proc,#call] callback proc or other callable to invoke after
-      # running the datastore block. Receives three arguments: result of the
-      # yield, the most specific (scoped) metric name, and elapsed time of the
-      # call. An example use is attaching SQL to Transaction Traces at the end
-      # of a wrapped datastore call.
+      #   running the datastore block. Receives three arguments: result of the
+      #   yield, the most specific (scoped) metric name, and elapsed time of the
+      #   call. An example use is attaching SQL to Transaction Traces at the end
+      #   of a wrapped datastore call.
       #
-      #   callback = Proc.new do |result, metrics, elapsed|
-      #     NewRelic::Agent::Datastores.notice_sql(query, metrics, elapsed)
-      #   end
+      #     callback = Proc.new do |result, metrics, elapsed|
+      #       NewRelic::Agent::Datastores.notice_sql(query, metrics, elapsed)
+      #     end
       #
-      #   NewRelic::Agent::Datastores.wrap("FauxDB", "find", "items", callback) do
-      #     FauxDB.find(query)
-      #   end
+      #     NewRelic::Agent::Datastores.wrap("FauxDB", "find", "items", callback) do
+      #       FauxDB.find(query)
+      #     end
       #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING SQL!**
-      # New Relic's Transaction Tracing and Slow SQL features will
-      # attempt to apply obfuscation to the passed queries, but it is possible
-      # for a query format to be unsupported and result in exposing user
-      # information embedded within captured queries.
+      # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING QUERY TEXT!
+      #   New Relic's Transaction Tracing and Slow SQL features will
+      #   attempt to apply obfuscation to the passed queries, but it is possible
+      #   for a query format to be unsupported and result in exposing user
+      #   information embedded within captured queries.
       #
       # @api public
       #
@@ -110,29 +118,33 @@ module NewRelic
         end
       end
 
+      # @!group Capturing query / statement text
+
       # Wrapper for simplifying attaching SQL queries during a transaction.
       #
-      # If you are recording non-SQL data, please use the notice_statement
-      # method instead.
+      # If you are recording non-SQL data, please use {notice_statement}
+      # instead.
       #
       #   NewRelic::Agent::Datastores.notice_sql(query, metrics, elapsed)
       #
       # @param [String] query the SQL text to be captured. Note that depending
-      # on user settings, this string will be run through obfuscation, but
-      # some dialects of SQL (or non-SQL queries) are not guaranteed to be
-      # properly obfuscated by these routines!
+      #   on user settings, this string will be run through obfuscation, but
+      #   some dialects of SQL (or non-SQL queries) are not guaranteed to be
+      #   properly obfuscated by these routines!
       #
       # @param [String] scoped_metric The most specific metric relating to this
-      # query. Typically the result of
-      # NewRelic::Agent::Datastores::MetricHelper#metrics_for
+      #   query. Typically the result of
+      #   NewRelic::Agent::Datastores::MetricHelper#metrics_for
       #
       # @param [Float] elapsed the elapsed time during query execution
       #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING SQL!**
-      # New Relic's Transaction Tracing and Slow SQL features will
-      # attempt to apply obfuscation to the passed queries, but it is possible
-      # for a query format to be unsupported and result in exposing user
-      # information embedded within captured queries.
+      # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING QUERY TEXT!
+      #   New Relic's Transaction Tracing and Slow SQL features will
+      #   attempt to apply obfuscation to the passed queries, but it is possible
+      #   for a query format to be unsupported and result in exposing user
+      #   information embedded within captured queries.
+      #
+      # @api public
       #
       def self.notice_sql(query, scoped_metric, elapsed)
         agent = NewRelic::Agent.instance
@@ -155,12 +167,14 @@ module NewRelic
       #
       # @param [Float] elapsed the elapsed time during query execution
       #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING STATEMENTS!**
-      # This method will properly ignore statements when the user has turned
-      # off capturing queries, but it is not able to obfuscate arbitrary data!
-      # To prevent exposing user information embedded in captured queries,
-      # please ensure all data passed to this method is safe to transmit to
-      # New Relic.
+      # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING STATEMENTS!
+      #   This method will properly ignore statements when the user has turned
+      #   off capturing queries, but it is not able to obfuscate arbitrary data!
+      #   To prevent exposing user information embedded in captured queries,
+      #   please ensure all data passed to this method is safe to transmit to
+      #   New Relic.
+      #
+      # @api public
       #
       def self.notice_statement(statement, elapsed)
         # Settings may change eventually, but for now we follow the same