newrelic_rpm 6.2.0.354 → 6.3.0.355

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

@@ -0,0 +1,39 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Configuration
+      module EventData
+
+        extend self
+
+        EVENT_DATA_CONFIG_KEY_MAPPING = {
+          :analytic_event_data => :'analytics_events.max_samples_stored',
+          :custom_event_data => :'custom_insights_events.max_samples_stored',
+          :error_event_data => :'error_collector.max_event_samples_stored'
+        }
+
+        def from_config(config)
+          {:harvest_limits => EVENT_DATA_CONFIG_KEY_MAPPING.inject({}) do
+            |event_data, (event_data_key, config_key)|
+              event_data[event_data_key] = config[config_key]
+              event_data
+            end
+          }
+        end
+
+        def to_config_hash(connect_reply)
+          config_hash = EVENT_DATA_CONFIG_KEY_MAPPING.inject({}) do 
+            |event_data, (event_data_key, config_key)|
+              event_data[config_key] = connect_reply['event_data']['harvest_limits'][event_data_key.to_s]
+              event_data
+            end
+          config_hash[:event_report_period] = connect_reply['event_data']['report_period_ms'] / 1000
+          config_hash
+        end
+      end
+    end
+  end
+end

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

@@ -20,7 +20,6 @@ module NewRelic
           "browser_monitoring.loader_version",
           "cross_process_id",
           "data_report_period",
-          "data_report_periods.analytic_event_data",
           "encoding_key",
           "error_beacon",
           "js_agent_file",
@@ -39,6 +38,7 @@ module NewRelic
           merge_top_level_keys(merged_settings, connect_reply)
           merge_agent_config_hash(merged_settings, connect_reply)
           fix_transaction_threshold(merged_settings)
+          add_event_data(merged_settings, connect_reply)
           filter_keys(merged_settings)
 
           apply_feature_gates(merged_settings, connect_reply, existing_config)
@@ -74,6 +74,16 @@ module NewRelic
           end
         end
 
+        def add_event_data(merged_settings, connect_reply)
+            if connect_reply['event_data']
+              merged_settings.merge! EventData.to_config_hash(connect_reply)
+            else
+              NewRelic::Agent.logger.warn "No event data configuration found " \
+                  "in connect response; using default event report period."
+              NewRelic::Agent.record_metric('Supportability/Agent/Collector/MissingEventData', 1)
+            end
+        end
+
         def filter_keys(merged_settings)
           merged_settings.delete_if do |key, _|
             setting_spec = DEFAULTS[key.to_sym]

data/lib/new_relic/agent/connect/request_builder.rb

@@ -0,0 +1,63 @@
+# 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 'new_relic/environment_report'
+require 'new_relic/agent/configuration/event_data'
+
+module NewRelic
+  module Agent
+    module Connect
+
+      class RequestBuilder
+
+        def initialize(new_relic_service, config)
+          @service = new_relic_service
+          @config = config
+        end
+
+
+        # Initializes the hash of settings that we send to the
+        # server. Returns a literal hash containing the options
+        def connect_payload
+          {
+            :pid           => $$,
+            :host          => local_host,
+            :display_host  => Agent.config[:'process_host.display_name'],
+            :app_name      => Agent.config.app_names,
+            :language      => 'ruby',
+            :labels        => Agent.config.parsed_labels,
+            :agent_version => NewRelic::VERSION::STRING,
+            :environment   => sanitize_environment_report(environment_report),
+            :settings      => Agent.config.to_collector_hash,
+            :high_security => Agent.config[:high_security],
+            :utilization   => UtilizationData.new.to_collector_hash,
+            :identifier    => "ruby:#{local_host}:#{Agent.config.app_names.sort.join(',')}",
+            :event_data    => Configuration::EventData.from_config(Agent.config)
+          }
+        end
+
+        # We've seen objects in the environment report (Rails.env in
+        # particular) that can't seralize to JSON. Cope with that here and
+        # clear out so downstream code doesn't have to check again.
+        def sanitize_environment_report(environment_report)
+          return [] unless @service.valid_to_marshal?(environment_report)
+          environment_report
+        end
+
+        # Checks whether we should send environment info, and if so,
+        # returns the snapshot from the local environment.
+        # Generating the EnvironmentReport has the potential to trigger
+        # require calls in Rails environments, so this method should only
+        # be called synchronously from on the main thread.
+        def environment_report
+          Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
+        end
+
+        def local_host
+          NewRelic::Agent::Hostname.get
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/connect/response_handler.rb

@@ -0,0 +1,61 @@
+# 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.
+
+
+module NewRelic
+  module Agent
+    module Connect
+
+      class ResponseHandler
+
+        def initialize(agent, config)
+          @agent = agent
+          @config = config
+        end
+
+        # Takes a hash of configuration data returned from the
+        # server and uses it to set local variables and to
+        # initialize various parts of the agent that are configured
+        # separately.
+        #
+        # Can accommodate most arbitrary data - anything extra is
+        # ignored unless we say to do something with it here.
+        def configure_agent(config_data)
+          return if config_data == nil
+
+          @agent.agent_id = config_data['agent_run_id']
+
+          security_policies = config_data.delete('security_policies')
+
+          add_server_side_config(config_data)
+          add_security_policy_config(security_policies) if security_policies
+
+          @agent.transaction_rules = RulesEngine.create_transaction_rules(config_data)
+          @agent.stats_engine.metric_rules = RulesEngine.create_metric_rules(config_data)
+
+          # If you're adding something else here to respond to the server-side config,
+          # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
+        end
+
+        def add_server_side_config(config_data)
+          if config_data['agent_config']
+            ::NewRelic::Agent.logger.debug "Using config from server"
+          end
+
+          ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
+          server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data, @config)
+          @config.replace_or_add_config(server_config)
+        end
+
+        def add_security_policy_config(security_policies)
+          ::NewRelic::Agent.logger.info 'Installing security policies'
+          security_policy_source = NewRelic::Agent::Configuration::SecurityPolicySource.new(security_policies)
+          @config.replace_or_add_config(security_policy_source)
+          # drop data collected before applying security policies
+          @agent.drop_buffered_data
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/hostname.rb

@@ -13,7 +13,7 @@ module NewRelic
           dyno_name = "#{matching_prefix}.*" if matching_prefix
           dyno_name
         else
-          Socket.gethostname
+          Socket.gethostname.force_encoding(Encoding::UTF_8)
         end
       end
 

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

@@ -48,7 +48,9 @@ module NewRelic
             category:         :controller,
             options: {
               request:          event.request,
-              filtered_params:  filter(event.payload[:params]),
+              filtered_params:  NewRelic::Agent::ParameterFiltering.filter_using_rails(
+                  event.payload[:params],
+                  Rails.application.config.filter_parameters),
               apdex_start_time: event.queue_start,
               ignore_apdex:     event.apdex_ignored?,
               ignore_enduser:   event.enduser_ignored?
@@ -59,12 +61,6 @@ module NewRelic
         def stop_transaction(event)
           (finishable = event.payload[:finishable]) && finishable.finish
         end
-
-        def filter(params)
-          munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(params)
-          filters = Rails.application.config.filter_parameters
-          ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
-        end
       end
 
       class ControllerEvent < Event

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

@@ -0,0 +1,161 @@
+# 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 'new_relic/agent/instrumentation/active_record_subscriber'
+require 'new_relic/agent/instrumentation/active_record_prepend'
+
+
+# Provides a way to send :connection through ActiveSupport notifications to avoid
+# looping through connection handlers to locate a connection by connection_id
+# This is not needed in Rails 6+: https://github.com/rails/rails/pull/34602
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordNotifications
+        module BaseExtensions41
+          # https://github.com/rails/rails/blob/4-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L371
+          def log(sql, name = "SQL", binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              "sql.active_record",
+              :sql            => sql,
+              :name           => name,
+              :connection_id  => object_id,
+              :connection     => self,
+              :statement_name => statement_name,
+              :binds          => binds) { yield }
+          rescue => e
+            raise translate_exception(e, sql)
+          end
+        end
+
+        module BaseExtensions50
+          # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L582
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              "sql.active_record",
+              sql:               sql,
+              name:              name,
+              binds:             binds,
+              type_casted_binds: type_casted_binds,
+              statement_name:    statement_name,
+              connection_id:     object_id,
+              connection:        self) { yield }
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+
+        module BaseExtensions51
+          # https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L603
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+            @instrumenter.instrument(
+              "sql.active_record",
+              sql:               sql,
+              name:              name,
+              binds:             binds,
+              type_casted_binds: type_casted_binds,
+              statement_name:    statement_name,
+              connection_id:     object_id,
+              connection:        self) do
+                @lock.synchronize do
+                  yield
+                end
+              end
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :active_record_notifications
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+      defined?(::ActiveRecord::VERSION) &&
+      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
+  end
+
+
+  depends_on do
+    # If the deprecated :disable_active_record_4 setting is true, and 
+    # the active record version is four, disable!
+    NewRelic::Agent.config[:disable_active_record_4] == false \
+        || ::ActiveRecord::VERSION::MAJOR.to_i != 4
+  end
+
+  depends_on do
+    # If the deprecated :disable_active_record_5 setting is true, and 
+    # the active record version is five, disable!
+    NewRelic::Agent.config[:disable_active_record_5] == false \
+        || ::ActiveRecord::VERSION::MAJOR.to_i  != 5 
+  end
+
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing notifications based Active Record instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
+  end
+
+  executes do
+    ActiveSupport.on_load(:active_record) do
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
+          ::ActiveRecord::Base,
+          ::ActiveRecord::Relation)
+
+      # Default to .prepending, unless the ActiveRecord version is <=4 
+      # **AND** the :prepend_active_record_instrumentation config is false
+      if ::ActiveRecord::VERSION::MAJOR > 4 \
+          || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+
+        ::ActiveRecord::Base.send(:prepend,
+            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ::ActiveRecord::Relation.send(:prepend,
+            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+      else
+        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+      end
+    end
+  end
+
+  executes do
+    if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
+
+      activerecord_extension = if ::ActiveRecord::VERSION::MAJOR.to_i == 4
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions41
+      elsif ::ActiveRecord::VERSION::MAJOR.to_i == 5
+        if ::ActiveRecord::VERSION::MINOR.to_i == 0
+          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+        elsif ::ActiveRecord::VERSION::MINOR.to_i >= 1
+          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+        end
+      end
+
+      unless activerecord_extension.nil?
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+      end
+    end
+  end
+
+  executes do
+    if ::ActiveRecord::VERSION::MAJOR == 5 \
+        && ::ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ::ActiveRecord::VERSION::TINY.to_i >= 6
+
+      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
+    end
+  end
+end

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

@@ -78,6 +78,13 @@ module NewRelic
         def active_record_config(payload)
           return unless payload[:connection_id]
 
+          # handle if the notification payload provides the AR connection
+          # available in Rails 6+ & our ActiveRecordNotifications#log extension
+          if payload[:connection]
+            connection_config = payload[:connection].instance_variable_get(:@config)
+            return connection_config if connection_config
+          end
+
           connection = nil
           connection_id = payload[:connection_id]
 

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

@@ -11,10 +11,33 @@ module NewRelic
         end
 
         def self.subscribed?
+          find_all_subscribers.find{|s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def self.find_all_subscribers
           # TODO: need to talk to Rails core about an API for this,
           # rather than digging through Listener ivars
-          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
-            .find{|s| s.instance_variable_get(:@delegate).class == self }
+          instance_variable_names = [:@subscribers, :@string_subscribers, :@other_subscribers]
+          all_subscribers = []
+
+          notifier = ActiveSupport::Notifications.notifier
+
+          instance_variable_names.each do |name| 
+            if notifier.instance_variable_defined?(name)
+              subscribers = notifier.instance_variable_get(name)
+              if subscribers.is_a? Array
+                # Rails 5 @subscribers, and Rails 6 @other_subscribers is a
+                # plain array of subscriber objects
+                all_subscribers += subscribers
+              elsif subscribers.is_a? Hash
+                # Rails 6 @string_subscribers is a Hash mapping the pattern
+                # string of a subscriber to an array of subscriber objects
+                subscribers.values.each { |array| all_subscribers += array }
+              end
+            end
+          end
+
+          all_subscribers
         end
 
         def self.subscribe(pattern)
@@ -51,7 +74,15 @@ module NewRelic
 
         def pop_event(transaction_id)
           event = event_stack[transaction_id].pop
-          event.end = Time.now
+
+          if event.respond_to?(:finish!)
+            # ActiveSupport version 6 and greater use a finish! method rather
+            # that allowing us to set the end directly
+            event.finish!
+          else
+            event.end = Time.now
+          end
+
           return event
         end