newrelic_rpm 6.3.0.355 → 6.4.0.356

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fad72be0a10cec48b242b8759e92676245a18b92be032e21dd7f652fcc78da2
-  data.tar.gz: 159a8569cf9b0c5caa5a8f5e89811325f9a5a47ac68dfd942e332ec945b43325
+  metadata.gz: 5b076c28227c61e989c31bb41023266f4319602621a913cc403e224d7e5c5822
+  data.tar.gz: '06062208e9ca3921d1d3353ea91dcc84423747496f6744b617053e98d8488a83'
 SHA512:
-  metadata.gz: a0a73fa55d266e1daa3ce89941f25ae9cb4b6b9f5a904bdfef4faf837450ff91e2b17ff83e1b870886eefc6bb9b5451ee6bb9f418c4bd2742f63c6e4bcef86ae
-  data.tar.gz: 7d15dd7ada137326cf86d53ddba404628fe606be1aab1284e39ae65ff4985bee6efc8c92c727a99a506ecac5b2b7f20dfffc7435cc59954732261b7d88681861
+  metadata.gz: f5ab26028a95f4bb69d6ae882733b0796f0e547cae5a0c276413b0c8daf701eed0697a67b4ad87e64c43e9d1359af37dc9a187f41d59cb2e24caa8b6bbd25afe
+  data.tar.gz: d67d418c31585f72e05173c10c858a649ca5f6615dfc80cdfaa25fee451055cf20430aac5602c4553468c7ff5018675b734902674a83a44be27f4e54c077df6c

data/.travis.yml

@@ -40,11 +40,6 @@ branches:
     - dev
     - release
 
-notifications:
-  webhooks: http://notifitron.herokuapp.com/
-  on_success: always
-  on_failure: always
-
 rvm:
   # Run slowest builds first to try and optimize overall cycle time.
   - jruby-9.2.6.0

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # New Relic Ruby Agent Release Notes #
 
+## v6.4.0
+
+* **Custom Metadata Collection**
+
+  The agent now collects environment variables prefixed by `NEW_RELIC_METADATA_`.  These
+  may be added to transaction events to provide context between your Kubernetes cluster
+  and your services.  For details on the behavior, see
+  [this blog post](https://blog.newrelic.com/engineering/monitoring-application-performance-in-kubernetes/).
+
+* **Bugfix for faster ActiveRecord connection resolution**
+
+  Version 6.3.0 of the agent backported the faster ActiveRecord connection resolution
+  from Rails 6.0 to previous versions, but the implementation caused certain other gems
+  which measured ActiveRecord performance to stop working. This version of the agent
+  changes the implementation of this performance improvement so no such conflicts occur.
+
+* **Bugfix for Grape instrumentation error**
+
+  Previous versions of the agent would fail to install Grape instrumentation in Grape
+  versions 1.2.0 and up if the API being instrumented subclassed `Grape::API::Instance`
+  rather than `Grape::API`.  A warning would also print to the newrelic_agent log:
+  ```
+  WARN : Error in Grape instrumentation
+  WARN : NoMethodError: undefined method `name' for nil:NilClass
+  ```
+
+  This version of the agent successfully installs instrumentation for subclasses
+  of `Grape::API::Instance`, and these log messages should no longer appear.
+
+* **Bugfix for streaming responses**
+
+  Previous versions of the agent would attempt to insert JavaScript instrumentation into
+  any streaming response that did not make use of `ActionController::Live`.  This resulted
+  in an empty, non-streamed response being sent to the client.
+
+  This version of the agent will not attempt to insert JavaScript instrumentation into
+  a response which includes the header `Transfer-Encoding=chunked`, which indicates a
+  streaming response.
+
+  This should exclude JavaScript instrumentation for all streamed responses.  To include
+  this instrumentation manually, see
+  [Manually instrument via agent API](https://docs.newrelic.com/docs/agents/ruby-agent/features/new-relic-browser-ruby-agent#manual_instrumentation)
+  in our documentation.
+
 ## v6.3.0
 
   * **Official Rails 6.0 support**

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -9,7 +9,6 @@
 # like the ThreadProfiler, so it's simpler to just keep it together here.
 
 require 'new_relic/agent/commands/agent_command'
-require 'new_relic/agent/commands/xray_session_collection'
 require 'new_relic/agent/threading/backtrace_service'
 
 module NewRelic
@@ -18,8 +17,7 @@ module NewRelic
       class AgentCommandRouter
         attr_reader :handlers
 
-        attr_accessor :thread_profiler_session, :backtrace_service,
-                      :xray_session_collection
+        attr_accessor :thread_profiler_session, :backtrace_service
 
         def initialize(event_listener=nil)
           @handlers    = Hash.new { |*| Proc.new { |cmd| self.unrecognized_agent_command(cmd) } }
@@ -27,11 +25,9 @@ module NewRelic
           @backtrace_service = Threading::BacktraceService.new(event_listener)
 
           @thread_profiler_session = ThreadProfilerSession.new(@backtrace_service)
-          @xray_session_collection = XraySessionCollection.new(@backtrace_service, event_listener)
 
           @handlers['start_profiler'] = Proc.new { |cmd| thread_profiler_session.handle_start_command(cmd) }
           @handlers['stop_profiler']  = Proc.new { |cmd| thread_profiler_session.handle_stop_command(cmd) }
-          @handlers['active_xray_sessions'] = Proc.new { |cmd| xray_session_collection.handle_active_xray_sessions(cmd) }
 
           if event_listener
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
@@ -45,20 +41,10 @@ module NewRelic
         def check_for_and_handle_agent_commands
           commands = get_agent_commands
 
-          stop_xray_sessions unless active_xray_command?(commands)
-
           results = invoke_commands(commands)
           new_relic_service.agent_command_results(results) unless results.empty?
         end
 
-        def stop_xray_sessions
-          self.xray_session_collection.stop_all_sessions
-        end
-
-        def active_xray_command?(commands)
-          commands.any? {|command| command.name == 'active_xray_sessions'}
-        end
-
         def on_before_shutdown(*args)
           if self.thread_profiler_session.running?
             self.thread_profiler_session.stop(true)
@@ -67,7 +53,6 @@ module NewRelic
 
         def harvest!
           profiles = []
-          profiles += harvest_from_xray_session_collection
           profiles += harvest_from_thread_profiler_session
           log_profiles(profiles)
           profiles
@@ -76,14 +61,10 @@ module NewRelic
         # We don't currently support merging thread profiles that failed to send
         # back into the AgentCommandRouter, so we just no-op this method.
         # Same with reset! - we don't support asynchronous cancellation of a
-        # running thread profile or X-Ray session currently.
+        # running thread profile currently.
         def merge!(*args); end
         def reset!; end
 
-        def harvest_from_xray_session_collection
-          self.xray_session_collection.harvest_thread_profiles
-        end
-
         def harvest_from_thread_profiler_session
           if self.thread_profiler_session.ready_to_harvest?
             self.thread_profiler_session.stop(true)

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

@@ -1171,35 +1171,7 @@ module NewRelic
           :allowed_from_server => true,
           :description => 'If <code>true</code>, enables use of the <a href="https://docs.newrelic.com/docs/apm/applications-menu/events/thread-profiler-tool">thread profiler</a>.'
         },
-        :'xray_session.enabled' => {
-          :default => true,
-          :public => true,
-          :type => Boolean,
-          :allowed_from_server => true,
-          :description => 'If <code>true</code>, enables <a href="https://docs.newrelic.com/docs/apm/transactions-menu/x-ray-sessions/x-ray-sessions">X-Ray sessions</a>.'
-        },
-        :'xray_session.allow_traces' => {
-          :default => true,
-          :public => false,
-          :type => Boolean,
-          :allowed_from_server => true,
-          :description => 'Enable or disable X-Ray sessions recording transaction traces.'
-        },
-        :'xray_session.allow_profiles' => {
-          :default => true,
-          :public => false,
-          :type => Boolean,
-          :allowed_from_server => true,
-          :description => 'Enable or disable X-Ray sessions taking thread profiles.'
-        },
-        :'xray_session.max_samples' => {
-          :default => 10,
-          :public => false,
-          :type => Integer,
-          :allowed_from_server => true,
-          :description => 'Maximum number of transaction traces to buffer for active X-Ray sessions'
-        },
-        :'xray_session.max_profile_overhead' => {
+        :'thread_profiler.max_profile_overhead' => {
           :default => 0.05,
           :public => false,
           :type => Float,

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

@@ -9,7 +9,8 @@ module NewRelic
         SUPPORTED_PREFIXES = /^new_relic_|^newrelic_/i
         SPECIAL_CASE_KEYS  = [
           'NEW_RELIC_ENV', # read by NewRelic::Control::Frameworks::Ruby
-          'NEW_RELIC_LOG'  # read by set_log_file
+          'NEW_RELIC_LOG',  # read by set_log_file
+          /^NEW_RELIC_METADATA_/ # read by NewRelic::Agent::Connect::RequestBuilder
         ]
 
         attr_accessor :alias_map, :type_map
@@ -66,7 +67,8 @@ module NewRelic
           nr_env_var_keys = collect_new_relic_environment_variable_keys
 
           nr_env_var_keys.each do |key|
-            next if SPECIAL_CASE_KEYS.include?(key.upcase)
+            next if SPECIAL_CASE_KEYS.any? { |pattern| pattern === key.upcase }
+
             set_value_from_environment_variable(key)
           end
         end

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

@@ -13,6 +13,7 @@ module NewRelic
             :capture_params           => false,
             :'resque.capture_params'  => false,
             :'sidekiq.capture_params' => false,
+            :'attributes.include'     => [],
 
             :'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'),

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

@@ -29,6 +29,7 @@ module NewRelic
             :labels        => Agent.config.parsed_labels,
             :agent_version => NewRelic::VERSION::STRING,
             :environment   => sanitize_environment_report(environment_report),
+            :metadata      => environment_metadata,
             :settings      => Agent.config.to_collector_hash,
             :high_security => Agent.config[:high_security],
             :utilization   => UtilizationData.new.to_collector_hash,
@@ -54,6 +55,10 @@ module NewRelic
           Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
         end
 
+        def environment_metadata
+          ENV.select {|k, v| k =~ /^NEW_RELIC_METADATA_/}
+        end
+
         def local_host
           NewRelic::Agent::Hostname.get
         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,77 +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,
+        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(
-                  event.payload[:params],
-                  Rails.application.config.filter_parameters),
-              apdex_start_time: event.queue_start,
-              ignore_apdex:     event.apdex_ignored?,
-              ignore_enduser:   event.enduser_ignored?
+                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
-      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}"
+        def format_metric_name(metric_action, controller_name)
+          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+          "Controller/#{controller_class.controller_path}/#{metric_action}"
         end
 
-        def metric_path
-          @controller_class.controller_path
+        def controller_class(payload)
+          ::NewRelic::LanguageSupport.constantize(payload[:controller])
         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)
-        end
-
-        def enduser_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
-        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