newrelic_rpm 6.1.0.352 → 6.6.0.358

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(:initial_configuration_complete) 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/error_collector.rb

@@ -18,9 +18,9 @@ module NewRelic
       attr_reader :error_trace_aggregator, :error_event_aggregator
 
       # Returns a new error collector
-      def initialize
+      def initialize events
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
-        @error_event_aggregator = ErrorEventAggregator.new
+        @error_event_aggregator = ErrorEventAggregator.new events
 
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}

data/lib/new_relic/agent/error_event_aggregator.rb

@@ -13,7 +13,8 @@ module NewRelic
 
       named :ErrorEventAggregator
       capacity_key :'error_collector.max_event_samples_stored'
-      enabled_key :'error_collector.capture_events'
+      enabled_keys :'error_collector.enabled',
+                   :'error_collector.capture_events'
       buffer_class PrioritySampledBuffer
 
       def record noticed_error, transaction_payload = nil

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -91,6 +91,7 @@ module NewRelic
 
       def register_config_callbacks
         Agent.config.register_callback(:'error_collector.enabled') do |enabled|
+          reset! if enabled == false
           ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
         end
       end

data/lib/new_relic/agent/event_aggregator.rb

@@ -8,20 +8,6 @@ module NewRelic
   module Agent
     class EventAggregator
       class << self
-        # This architecture requires that every aggregator
-        # implementation provide its own `named`, `capacity_key`, and
-        # `enabled_...` settings.  In particular, we do not allow
-        # subclasses to share these values from an intermediate
-        # superclass.
-
-        def inherited(subclass)
-          # Prevent uninitialized variable warnings; we have to do
-          # this as soon as the subclass is defined, before its
-          # implementor calls enabled_key() or enabled_fn().
-          subclass.instance_variable_set(:@enabled_key, nil)
-          subclass.instance_variable_set(:@enabled_fn,  nil)
-        end
-
         def named named = nil
           named ? @named = named.to_s.freeze : @named
         end
@@ -30,10 +16,25 @@ module NewRelic
           key ? @capacity_key = key : @capacity_key
         end
 
-        def enabled_key key = nil
-          key ? @enabled_key = key : @enabled_key
+        # An aggregator can specify one or more keys to check to see if it is
+        # enabled. Multiple keys will be &&'d and the enabled status of the
+        # aggregator will be reset when agent configuration changes.
+
+        def enabled_keys *keys
+          if keys.empty?
+            @enabled_keys ||= []
+          else
+            @enabled_keys = Array(keys)
+            @enabled_fn = ->(){ @enabled_keys.all? { |k| Agent.config[k] } }
+          end
         end
 
+        alias_method :enabled_key, :enabled_keys
+
+        # This can be used instead of `enabled_key(s)` for more fine grained
+        # control over whether an aggregator should be enabled. The enabled fn
+        # will be reevaluated after configuration changes
+
         def enabled_fn fn = nil
           fn ? @enabled_fn = fn : @enabled_fn
         end
@@ -47,13 +48,13 @@ module NewRelic
         end
       end
 
-      def initialize
+      def initialize events
         @lock = Mutex.new
         @buffer = self.class.buffer_class.new NewRelic::Agent.config[self.class.capacity_key]
-        @enabled = false
+        @enabled = self.class.enabled_fn ? self.class.enabled_fn.call : false
         @notified_full = false
         register_capacity_callback
-        register_enabled_callback
+        register_enabled_callback events
         after_initialize
       end
 
@@ -66,7 +67,6 @@ module NewRelic
       end
 
       def enabled?
-        return self.class.enabled_fn.call if self.class.enabled_fn
         @enabled
       end
 
@@ -126,18 +126,12 @@ module NewRelic
         end
       end
 
-      def register_enabled_callback
-        unless self.class.enabled_key || self.class.enabled_fn
-          ::NewRelic::Agent.logger.warn "#{self.class.named} needs an enabled_key or an enabled_fn."
-        end
-
-        return if self.class.enabled_fn
-
-        NewRelic::Agent.config.register_callback(self.class.enabled_key) do |enabled|
-          # intentionally unsynchronized for liveness
-          @enabled = enabled
-          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{enabled ? '' : 'not '}be sent to the New Relic service."
-        end
+      def register_enabled_callback events
+        events.subscribe(:server_source_configuration_added) {
+          @enabled = self.class.enabled_fn.call
+          reset! if @enabled == false
+          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{@enabled ? '' : 'not '}be sent to the New Relic service."
+        }
       end
 
       def notify_if_full

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/inbound_request_monitor.rb

@@ -20,8 +20,8 @@ module NewRelic
       attr_reader :obfuscator
 
       def initialize(events)
-        events.subscribe(:finished_configuring) do
-          # This requires :encoding_key, so must wait until :finished_configuring
+        events.subscribe(:initial_configuration_complete) do
+          # This requires :encoding_key, so must wait until :initial_configuration_complete
           setup_obfuscator
           on_finished_configuring(events)
         end

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

@@ -1,77 +1,59 @@
 # 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/evented_subscriber'
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActionCableSubscriber < EventedSubscriber
+      class ActionCableSubscriber < NotificationsSubscriber
 
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
-        def start name, id, payload #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
-          event = super
-          if event.name == PERFORM_ACTION
-            start_transaction event
+
+          finishable = if name == PERFORM_ACTION
+            Tracer.start_transaction_or_segment(
+              name: transaction_name_from_payload(payload),
+              category: :action_cable
+            )
           else
-            start_recording_metrics event
+            Tracer.start_segment(name: metric_name_from_payload(name, payload))
           end
+          push_segment(id, finishable)
         rescue => e
           log_notification_error e, name, 'start'
         end
 
-        def finish name, id, payload #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
-          event = super
+
           notice_error payload if payload.key? :exception
-          if event.name == PERFORM_ACTION
-            finish_transaction event
-          else
-            stop_recording_metrics event
-          end
+          finishable = pop_segment(id)
+          finishable.finish if finishable
         rescue => e
           log_notification_error e, name, 'finish'
         end
 
         private
 
-        def start_transaction event
-          event.payload[:finishable] = Tracer.start_transaction_or_segment(
-            name:     transaction_name_from_event(event),
-            category: :action_cable
-          )
-        end
-
-        def finish_transaction event
-          (finishable = event.payload[:finishable]) && finishable.finish
-        end
-
-        def start_recording_metrics event
-          event.payload[:segment] = Tracer.start_segment name: metric_name_from_event(event)
-        end
-
-        def stop_recording_metrics event
-          event.payload[:segment].finish if event.payload[:segment]
-        end
-
-        def transaction_name_from_event event
-          "Controller/ActionCable/#{event.payload[:channel_class]}/#{event.payload[:action]}"
+        def transaction_name_from_payload(payload)
+          "Controller/ActionCable/#{payload[:channel_class]}/#{payload[:action]}"
         end
 
-        def metric_name_from_event event
-          "Ruby/ActionCable/#{event.payload[:channel_class]}/#{action_name_from_event(event)}"
+        def metric_name_from_payload(name, payload)
+          "Ruby/ActionCable/#{payload[:channel_class]}/#{action_name(name)}"
         end
 
-        DOT_ACTION_CABLE = ".action_cable".freeze
-        EMPTY_STRING = "".freeze
+        DOT_ACTION_CABLE = '.action_cable'.freeze
+        EMPTY_STRING = ''.freeze
 
-        def action_name_from_event event
-          event.name.gsub DOT_ACTION_CABLE, EMPTY_STRING
+        def action_name(name)
+          name.gsub DOT_ACTION_CABLE, EMPTY_STRING
         end
 
-        def notice_error payload
+        def notice_error(payload)
           NewRelic::Agent.notice_error payload[:exception_object]
         end
       end

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

@@ -1,24 +1,24 @@
 # 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/evented_subscriber'
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 require 'new_relic/agent/instrumentation/ignore_actions'
 require 'new_relic/agent/parameter_filtering'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActionControllerSubscriber < EventedSubscriber
+      class ActionControllerSubscriber < NotificationsSubscriber
 
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
           # @req is a historically stable but not guaranteed Rails header property
           request = payload[:headers].instance_variable_get(:@req)
 
-          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
-          push_event(event)
+          controller_class = controller_class(payload)
 
-          if state.is_execution_traced? && !event.ignored?
-            start_transaction(event)
+          if state.is_execution_traced? && !should_ignore(payload, controller_class)
+            finishable = start_transaction_or_segment(payload, request, controller_class)
+            push_segment(id, finishable)
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
@@ -30,11 +30,12 @@ module NewRelic
         end
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
-          event.payload.merge!(payload)
+          finishable = pop_segment(id)
 
-          if state.is_execution_traced? && !event.ignored?
-            stop_transaction(event)
+          if state.is_execution_traced? \
+              && !should_ignore(payload, controller_class(payload))
+
+            finishable.finish
           else
             Agent.instance.pop_trace_execution_flag
           end
@@ -42,81 +43,52 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(event)
-          event.payload[:finishable] = Tracer.start_transaction_or_segment(
-            name:             event.metric_name,
-            category:         :controller,
-            options: {
-              request:          event.request,
-              filtered_params:  filter(event.payload[:params]),
-              apdex_start_time: event.queue_start,
-              ignore_apdex:     event.apdex_ignored?,
-              ignore_enduser:   event.enduser_ignored?
+        def start_transaction_or_segment(payload, request, controller_class)
+          Tracer.start_transaction_or_segment(
+            name:      format_metric_name(payload[:action], controller_class),
+            category:  :controller,
+            options:   {
+              request:          request,
+              filtered_params:  NewRelic::Agent::ParameterFiltering.filter_using_rails(
+                payload[:params],
+                Rails.application.config.filter_parameters
+              ),
+              apdex_start_time: queue_start(request),
+              ignore_apdex:     NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+                ControllerInstrumentation::NR_IGNORE_APDEX_KEY,
+                controller_class,
+                payload[:action]
+              ),
+              ignore_enduser:   NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+                ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
+                controller_class,
+                payload[:action]
+              )
             }
           )
         end
 
-        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
-        attr_accessor :parent
-        attr_reader :queue_start, :request
-
-        def initialize(name, start, ending, transaction_id, payload, request)
-          # We have a different initialize parameter list, so be explicit
-          super(name, start, ending, transaction_id, payload)
-
-          @request = request
-          @controller_class = payload[:controller].split('::') \
-            .inject(Object){|m,o| m.const_get(o)}
-
-          if request && request.respond_to?(:env)
-            @queue_start = QueueTime.parse_frontend_timestamp(request.env, self.time)
-          end
-        end
-
-        def metric_name
-          @metric_name || "Controller/#{metric_path}/#{metric_action}"
-        end
-
-        def metric_path
-          @controller_class.controller_path
-        end
-
-        def metric_action
-          payload[:action]
-        end
-
-        def ignored?
-          _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
-        end
-
-        def apdex_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_APDEX_KEY)
+        def format_metric_name(metric_action, controller_name)
+          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+          "Controller/#{controller_class.controller_path}/#{metric_action}"
         end
 
-        def enduser_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
+        def controller_class(payload)
+          ::NewRelic::LanguageSupport.constantize(payload[:controller])
         end
 
-        def _is_filtered?(key)
+        def should_ignore(payload, controller_class)
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-            key,
-            @controller_class,
-            metric_action)
+            ControllerInstrumentation::NR_DO_NOT_TRACE_KEY,
+            controller_class,
+            payload[:action]
+          )
         end
 
-        def to_s
-          "#<NewRelic::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        def queue_start(request)
+          if request && request.respond_to?(:env)
+            QueueTime.parse_frontend_timestamp(request.env, Time.now)
+          end
         end
       end
     end