newrelic_rpm 4.8.0.341 → 5.1.0.344

data/lib/new_relic/agent/distributed_trace_payload.rb

@@ -7,73 +7,66 @@ require 'base64'
 module NewRelic
   module Agent
     class DistributedTracePayload
-      VERSION =[0, 0].freeze
-      CALLER_TYPE = "App".freeze
+      VERSION =[0, 1].freeze
+      PARENT_TYPE = "App".freeze
       POUND = '#'.freeze
 
       # Key names for serialization
-      VERSION_KEY             = 'v'.freeze
-      DATA_KEY                = 'd'.freeze
-      CALLER_TYPE_KEY         = 'ty'.freeze
-      CALLER_ACCOUNT_KEY      = 'ac'.freeze
-      CALLER_APP_KEY          = 'ap'.freeze
-      ID_KEY                  = 'id'.freeze
-      TRIP_ID_KEY             = 'tr'.freeze
-      SAMPLED_KEY             = 'sa'.freeze
-      PARENT_IDS_KEY          = 'pa'.freeze
-      DEPTH_KEY               = 'de'.freeze
-      ORDER_KEY               = 'or'.freeze
-      TIMESTAMP_KEY           = 'ti'.freeze
-      HOST_KEY                = 'ho'.freeze
-      SYNTHETICS_KEY          = 'sy'.freeze
-      SYNTHETICS_RESOURCE_KEY = 'r'.freeze
-      SYNTHETICS_JOB_KEY      = 'j'.freeze
-      SYNTHETICS_MONITOR_KEY  = 'm'.freeze
+      VERSION_KEY                = 'v'.freeze
+      DATA_KEY                   = 'd'.freeze
+      PARENT_TYPE_KEY            = 'ty'.freeze
+      PARENT_ACCOUNT_ID_KEY      = 'ac'.freeze
+      PARENT_APP_KEY             = 'ap'.freeze
+      ID_KEY                     = 'id'.freeze
+      TRACE_ID_KEY               = 'tr'.freeze
+      SAMPLED_KEY                = 'sa'.freeze
+      PARENT_ID_KEY              = 'pa'.freeze
+      TIMESTAMP_KEY              = 'ti'.freeze
+      PRIORITY_KEY               = 'pr'.freeze
 
       # Intrinsic Keys
-      CALLER_TYPE_INTRINSIC_KEY                = "caller.type".freeze
-      CALLER_APP_INTRINSIC_KEY                 = "caller.app".freeze
-      CALLER_ACCOUNT_ID_INTRINSIC_KEY          = "caller.account".freeze
-      CALLER_TRANSPORT_TYPE_INTRINSIC_KEY      = "caller.transportType".freeze
-      CALLER_TRANSPORT_DURATION_INTRINSIC_KEY  = "caller.transportDuration".freeze
-      CALLER_HOST_INTRINSIC_KEY                = "caller.host".freeze
-      DEPTH_INTRINSIC_KEY                      = "nr.depth".freeze
-      ORDER_INTRINSIC_KEY                      = "nr.order".freeze
-      GUID_INTRINSIC_KEY                       = "nr.guid".freeze
-      REFERRING_TRANSACTION_GUID_INTRINSIC_KEY = "nr.referringTransactionGuid".freeze
+      PARENT_TYPE_INTRINSIC_KEY                = "parent.type".freeze
+      PARENT_APP_INTRINSIC_KEY                 = "parent.app".freeze
+      PARENT_ACCOUNT_ID_INTRINSIC_KEY          = "parent.account".freeze
+      PARENT_TRANSPORT_TYPE_INTRINSIC_KEY      = "parent.transportType".freeze
+      PARENT_TRANSPORT_DURATION_INTRINSIC_KEY  = "parent.transportDuration".freeze
+      GUID_INTRINSIC_KEY                       = "guid".freeze
+      TRACE_ID_INTRINSIC_KEY                   = "traceId".freeze
       TRIP_ID_INTRINSIC_KEY                    = "nr.tripId".freeze
-      PARENT_IDS_INTRINSIC_KEY                 = "nr.parentIds".freeze
+      PARENT_ID_INTRINSIC_KEY                  = "parentId".freeze
+      GRANDPARENT_ID_INTRINSIC_KEY             = "grandparentId".freeze
       COMMA                                    = ",".freeze
 
       INTRINSIC_KEYS = [
-        CALLER_TYPE_INTRINSIC_KEY,
-        CALLER_APP_INTRINSIC_KEY,
-        CALLER_ACCOUNT_ID_INTRINSIC_KEY,
-        CALLER_TRANSPORT_TYPE_INTRINSIC_KEY,
-        CALLER_TRANSPORT_DURATION_INTRINSIC_KEY,
-        CALLER_HOST_INTRINSIC_KEY,
-        DEPTH_INTRINSIC_KEY,
-        ORDER_INTRINSIC_KEY,
+        PARENT_TYPE_INTRINSIC_KEY,
+        PARENT_APP_INTRINSIC_KEY,
+        PARENT_ACCOUNT_ID_INTRINSIC_KEY,
+        PARENT_TRANSPORT_TYPE_INTRINSIC_KEY,
+        PARENT_TRANSPORT_DURATION_INTRINSIC_KEY,
         GUID_INTRINSIC_KEY,
-        REFERRING_TRANSACTION_GUID_INTRINSIC_KEY,
+        TRACE_ID_INTRINSIC_KEY,
         TRIP_ID_INTRINSIC_KEY,
-        PARENT_IDS_INTRINSIC_KEY
+        PARENT_ID_INTRINSIC_KEY,
+        GRANDPARENT_ID_INTRINSIC_KEY
       ].freeze
 
+      # Intrinsic Values
+      PARENT_TRANSPORT_TYPE_UNKNOWN = 'unknown'.freeze
+
       class << self
-        def for_transaction transaction, uri=nil
+        def for_transaction transaction
           payload = new
           return payload unless connected?
 
           payload.version = VERSION
-          payload.caller_type = CALLER_TYPE
+          payload.parent_type = PARENT_TYPE
 
           # We should not rely on the xp_id being formulated this way, but we have
           # seen nil account ids coming down in staging for some accounts
           account_id, fallback_app_id = Agent.config[:cross_process_id].split(POUND)
-          payload.caller_account_id = account_id
+          payload.parent_account_id = account_id
 
-          payload.caller_app_id =  if Agent.config[:application_id].empty?
+          payload.parent_app_id =  if Agent.config[:application_id].empty?
             fallback_app_id
           else
             Agent.config[:application_id]
@@ -81,18 +74,10 @@ module NewRelic
 
           payload.timestamp = (Time.now.to_f * 1000).round
           payload.id = transaction.guid
-          payload.trip_id = transaction.distributed_tracing_trip_id
+          payload.trace_id = transaction.trace_id
           payload.sampled = transaction.sampled?
-          payload.parent_ids = transaction.parent_ids
-          payload.depth = transaction.depth + 1
-          payload.order = transaction.order
-          payload.host = uri.host if uri
-
-          if transaction.synthetics_payload
-            payload.synthetics_resource = transaction.synthetics_payload[2]
-            payload.synthetics_job = transaction.synthetics_payload[3]
-            payload.synthetics_monitor = transaction.synthetics_payload[4]
-          end
+          payload.priority = transaction.priority
+          payload.parent_id = transaction.parent_id
 
           payload
         end
@@ -103,23 +88,15 @@ module NewRelic
 
           payload = new
           payload.version           = raw_payload[VERSION_KEY]
-          payload.caller_type       = payload_data[CALLER_TYPE_KEY]
-          payload.caller_account_id = payload_data[CALLER_ACCOUNT_KEY]
-          payload.caller_app_id     = payload_data[CALLER_APP_KEY]
+          payload.parent_type       = payload_data[PARENT_TYPE_KEY]
+          payload.parent_account_id = payload_data[PARENT_ACCOUNT_ID_KEY]
+          payload.parent_app_id     = payload_data[PARENT_APP_KEY]
           payload.timestamp         = payload_data[TIMESTAMP_KEY]
           payload.id                = payload_data[ID_KEY]
-          payload.trip_id           = payload_data[TRIP_ID_KEY]
+          payload.trace_id          = payload_data[TRACE_ID_KEY]
           payload.sampled           = payload_data[SAMPLED_KEY]
-          payload.parent_ids        = payload_data[PARENT_IDS_KEY]
-          payload.depth             = payload_data[DEPTH_KEY]
-          payload.order             = payload_data[ORDER_KEY]
-          payload.host              = payload_data[HOST_KEY]
-
-          if payload_synthetics = payload_data[SYNTHETICS_KEY]
-            payload.synthetics_resource = payload_synthetics[SYNTHETICS_RESOURCE_KEY]
-            payload.synthetics_job      = payload_synthetics[SYNTHETICS_JOB_KEY]
-            payload.synthetics_monitor  = payload_synthetics[SYNTHETICS_MONITOR_KEY]
-          end
+          payload.priority          = payload_data[PRIORITY_KEY]
+          payload.parent_id         = payload_data[PARENT_ID_KEY]
 
           payload
         end
@@ -129,11 +106,15 @@ module NewRelic
           from_json decoded_payload
         end
 
-        #assigns intrinsics for the first distributed trace in a trip
-        def assign_initial_intrinsics transaction, payload
-          payload[TRIP_ID_INTRINSIC_KEY] = transaction.distributed_tracing_trip_id
-          payload[DEPTH_INTRINSIC_KEY] = transaction.depth
-          payload[PARENT_IDS_INTRINSIC_KEY] = transaction.parent_ids
+        # Assigns intrinsics for the first distributed trace in a trip
+        def assign_intrinsics_for_first_trace transaction, transaction_payload
+          transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
+          transaction_payload[TRACE_ID_INTRINSIC_KEY] = transaction.trace_id
+          transaction_payload[TRIP_ID_INTRINSIC_KEY]  = transaction.trace_id
+        end
+
+        def major_version_matches?(payload)
+          payload.version[0] == VERSION[0]
         end
 
         private
@@ -146,26 +127,21 @@ module NewRelic
       end
 
       attr_accessor :version,
-                    :caller_type,
+                    :parent_type,
                     :caller_transport_type,
-                    :caller_account_id,
-                    :caller_app_id,
+                    :parent_account_id,
+                    :parent_app_id,
                     :id,
-                    :trip_id,
+                    :trace_id,
                     :sampled,
-                    :parent_ids,
-                    :synthetics_resource,
-                    :synthetics_job,
-                    :synthetics_monitor,
-                    :order,
-                    :depth,
-                    :timestamp,
-                    :host
+                    :priority,
+                    :parent_id,
+                    :timestamp
 
       alias_method :sampled?, :sampled
 
-      def synthetics?
-        !!(synthetics_resource || synthetics_job || synthetics_monitor)
+      def initialize
+        @caller_transport_type = PARENT_TRANSPORT_TYPE_UNKNOWN
       end
 
       def to_json
@@ -174,27 +150,19 @@ module NewRelic
         }
 
         result[DATA_KEY] = {
-          CALLER_TYPE_KEY    => caller_type,
-          CALLER_ACCOUNT_KEY => caller_account_id,
-          CALLER_APP_KEY     => caller_app_id,
-          ID_KEY             => id,
-          TRIP_ID_KEY        => trip_id,
-          SAMPLED_KEY        => sampled,
-          PARENT_IDS_KEY     => parent_ids,
-          DEPTH_KEY          => depth,
-          ORDER_KEY          => order,
-          HOST_KEY           => host,
+          PARENT_TYPE_KEY       => parent_type,
+          PARENT_ACCOUNT_ID_KEY => parent_account_id,
+          PARENT_APP_KEY        => parent_app_id,
+          ID_KEY                => id,
+          TRACE_ID_KEY          => trace_id,
+          SAMPLED_KEY           => sampled,
+          PRIORITY_KEY          => priority,
+          PARENT_ID_KEY         => parent_id,
+          # GRANDPARENT_ID_KEY does not go into the outbound JSON payload;
+          # the callee will take our parent ID as its grandparent ID
           TIMESTAMP_KEY      => timestamp,
         }
 
-        if synthetics?
-          result[DATA_KEY][SYNTHETICS_KEY] = {
-            SYNTHETICS_RESOURCE_KEY => synthetics_resource,
-            SYNTHETICS_JOB_KEY      => synthetics_job,
-            SYNTHETICS_MONITOR_KEY  => synthetics_monitor
-          }
-        end
-
         JSON.dump(result)
       end
 
@@ -204,19 +172,17 @@ module NewRelic
         Base64.strict_encode64 to_json
       end
 
-      def assign_intrinsics transaction, payload
-        payload[CALLER_TYPE_INTRINSIC_KEY] = caller_type
-        payload[CALLER_APP_INTRINSIC_KEY] = caller_app_id
-        payload[CALLER_ACCOUNT_ID_INTRINSIC_KEY] = caller_account_id
-        payload[CALLER_TRANSPORT_TYPE_INTRINSIC_KEY] = caller_transport_type
-        payload[CALLER_TRANSPORT_DURATION_INTRINSIC_KEY] = transaction.transport_duration
-        payload[CALLER_HOST_INTRINSIC_KEY] = host
-        payload[DEPTH_INTRINSIC_KEY] = depth
-        payload[ORDER_INTRINSIC_KEY] = order
-        payload[GUID_INTRINSIC_KEY] = transaction.guid
-        payload[REFERRING_TRANSACTION_GUID_INTRINSIC_KEY] = id
-        payload[TRIP_ID_INTRINSIC_KEY] = trip_id
-        payload[PARENT_IDS_INTRINSIC_KEY] = parent_ids.join COMMA if parent_ids
+      def assign_intrinsics transaction, transaction_payload
+        transaction_payload[PARENT_TYPE_INTRINSIC_KEY] = parent_type
+        transaction_payload[PARENT_APP_INTRINSIC_KEY] = parent_app_id
+        transaction_payload[PARENT_ACCOUNT_ID_INTRINSIC_KEY] = parent_account_id
+        transaction_payload[PARENT_TRANSPORT_TYPE_INTRINSIC_KEY] = caller_transport_type
+        transaction_payload[PARENT_TRANSPORT_DURATION_INTRINSIC_KEY] = transaction.transport_duration
+        transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
+        transaction_payload[TRACE_ID_INTRINSIC_KEY] = trace_id
+        transaction_payload[TRIP_ID_INTRINSIC_KEY] = trace_id
+        transaction_payload[PARENT_ID_INTRINSIC_KEY] = transaction.parent_id if transaction.parent_id
+        transaction_payload[GRANDPARENT_ID_INTRINSIC_KEY] = transaction.grandparent_id if transaction.grandparent_id
       end
     end
   end

data/lib/new_relic/agent/error_collector.rb

@@ -13,6 +13,9 @@ module NewRelic
       # made configurable in the future. This is a tradeoff between
       # memory and data retention
       MAX_ERROR_QUEUE_LENGTH = 20
+      # Maximum number of frames in backtraces. May be made configurable
+      # in the future.
+      MAX_BACKTRACE_FRAMES = 50
       EXCEPTION_TAG_IVAR = :'@__nr_seen_exception'
 
       attr_reader :error_trace_aggregator, :error_event_aggregator
@@ -213,6 +216,19 @@ module NewRelic
         nil
       end
 
+      def truncate_trace(trace, keep_frames=MAX_BACKTRACE_FRAMES)
+        return trace if trace.length < keep_frames || trace.length == 0
+
+        # If keep_frames is odd, we will split things up favoring the top of the trace
+        keep_top = (keep_frames / 2.0).ceil
+        keep_bottom = (keep_frames / 2.0).floor
+
+        truncate_frames = trace.length - keep_frames
+
+        truncated_trace = trace[0...keep_top].concat(["<truncated #{truncate_frames.to_s} additional frames>"]).concat(trace[-keep_bottom..-1])
+        truncated_trace
+      end
+
       EMPTY_STRING = ''.freeze
 
       def create_noticed_error(exception, options)
@@ -225,7 +241,7 @@ module NewRelic
 
         noticed_error.file_name   = sense_method(exception, :file_name)
         noticed_error.line_number = sense_method(exception, :line_number)
-        noticed_error.stack_trace = extract_stack_trace(exception)
+        noticed_error.stack_trace = truncate_trace(extract_stack_trace(exception))
 
         noticed_error.expected = !! options.delete(:expected)
 

data/lib/new_relic/agent/external.rb

@@ -53,6 +53,15 @@ module NewRelic
       #
       def process_request_metadata request_metadata
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
+
+        if NewRelic::Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.log_once(
+            :warn,
+            :process_request_metadata_noop,
+            'Skipping process_request_metadata because distributed tracing is enabled')
+          return
+        end
+
         return unless CrossAppTracing.cross_app_enabled?
 
         state = NewRelic::Agent::TransactionState.tl_get
@@ -100,6 +109,11 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
+        if NewRelic::Agent.config[:'distributed_tracing.enabled']
+          ::NewRelic::Agent.logger.warn('Skipping get_response_metadata because distributed tracing is enabled')
+          return
+        end
+
         state = NewRelic::Agent::TransactionState.tl_get
         if transaction = state.current_transaction and state.client_cross_app_id
 

data/lib/new_relic/agent/heap.rb

@@ -0,0 +1,140 @@
+# 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
+    # This class implements a min Heap. The first element is always the one with the
+    # lowest priority. It is a tree structure that is represented as an array. The
+    # relationship between between nodes in the tree and indices in the array are as
+    # follows:
+    #
+    # parent_index      = (child_index -  1) / 2
+    # left_child_index  = parent_index * 2 + 1
+    # right_child_index = parent_index * 2 + 2
+    #
+    # the root node is at index 0
+    # a node is a leaf node when its index >= length / 2
+    #
+
+    class Heap
+
+      # @param [Array] items an optional array of items to intialize the heap
+      #
+      # @param [Callable] priority_fn an optional priority function used to
+      #   to compute the priority for an item. If it's not supplied priority
+      #   will be computed using Comparable.
+      def initialize(items = nil, &priority_fn)
+        @items = []
+        @priority_fn = priority_fn || ->(x) { x }
+        items.each{ |item| push(item) } if items
+      end
+
+      def [](index)
+        @items[index]
+      end
+
+      def []=(index, value)
+        @items[index] = value
+      end
+
+      def fix(index)
+        parent_index = parent_index_for(index)
+
+        if in_range?(parent_index) && priority(parent_index) > priority(index)
+          heapify_up(index)
+        else
+          child_index = left_child_index_for(index)
+
+          return unless in_range?(child_index)
+
+          if right_sibling_smaller?(child_index)
+            child_index += 1
+          end
+
+          if priority(child_index) < priority(index)
+            heapify_down(index)
+          end
+        end
+      end
+
+      def push(item)
+        @items << item
+        heapify_up(size - 1)
+      end
+
+      alias_method :<<, :push
+
+      def pop
+        swap(0, size - 1)
+        item = @items.pop
+        heapify_down(0)
+        item
+      end
+
+      def size
+        @items.size
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def to_a
+        @items
+      end
+
+      private
+
+      def priority(index)
+        @priority_fn.call(@items[index])
+      end
+
+      def parent_index_for child_index
+        (child_index - 1) / 2
+      end
+
+      def left_child_index_for parent_index
+        2 * parent_index + 1
+      end
+
+      def right_sibling_smaller?(lchild_index)
+        in_range?(lchild_index + 1) && priority(lchild_index) > priority(lchild_index + 1)
+      end
+
+      def in_range?(index)
+        index >= 0 && index < size
+      end
+
+      def heapify_up(child_index)
+        return if child_index == 0
+
+        parent_index = parent_index_for(child_index)
+
+        if priority(child_index) < priority(parent_index)
+          swap(child_index, parent_index)
+          heapify_up(parent_index)
+        end
+      end
+
+      def heapify_down(parent_index)
+        child_index = left_child_index_for(parent_index)
+        return unless in_range?(child_index)
+
+        if right_sibling_smaller?(child_index)
+          child_index += 1
+        end
+
+        if priority(child_index) < priority(parent_index)
+          swap(parent_index, child_index)
+          heapify_down(child_index)
+        end
+      end
+
+      def swap(i, j)
+        @items[i], @items[j] = @items[j], @items[i]
+      end
+    end
+
+  end
+end

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

@@ -31,6 +31,11 @@ DependencyDetection.defer do
       ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveRecord::Base, ::ActiveRecord::Relation)
       ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions
       ::ActiveRecord::Relation.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions
+
+      if ::ActiveRecord::VERSION::MINOR.to_i == 1 &&
+         ::ActiveRecord::VERSION::TINY.to_i >= 6
+        ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
+      end
     end
   end
 end

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

@@ -24,6 +24,19 @@ module NewRelic
           end
         end
 
+        module BaseExtensions516
+          # In ActiveRecord v5.0.0 through v5.1.5, touch() will call
+          # update_all() and cause us to record a transaction.
+          # Starting in v5.1.6, this call no longer happens. We'll
+          # have to set the database metrics explicitly now.
+          #
+          def touch(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+        end
+
         module RelationExtensions
           def update_all(*args, &blk)
             ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -58,4 +71,4 @@ module NewRelic
       end
     end
   end
-end
+end

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

@@ -24,7 +24,11 @@ DependencyDetection.defer do
         def publish payload, opts = {}
           begin
             destination = NewRelic::Agent::Instrumentation::Bunny.exchange_name(name)
-            opts[:headers] ||= {} if NewRelic::Agent::CrossAppTracing.cross_app_enabled?
+
+            tracing_enabled =
+              NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
+              NewRelic::Agent.config[:'distributed_tracing.enabled']
+            opts[:headers] ||= {} if tracing_enabled
 
             segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
               library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,

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

@@ -30,35 +30,33 @@ module NewRelic
           Transaction.set_default_transaction_name(txn_name, :grape, node_name)
         end
 
-        if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
-          def name_for_transaction(route, class_name, version)
-            action_name = route.path.sub(FORMAT_REGEX, EMPTY_STRING)
-            method_name = route.request_method
-            version ||= route.version
-
-            # defaulting does not set rack.env['api.version'] and route.version may return Array
-            #
-            version = version.join(PIPE_STRING) if Array === version
-
-            if version
-              action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
-              "#{class_name}-#{version}#{action_name} (#{method_name})"
-            else
-              "#{class_name}#{action_name} (#{method_name})"
-            end
+        def name_for_transaction(route, class_name, version)
+          action_name = route.path.sub(FORMAT_REGEX, EMPTY_STRING)
+          method_name = route.request_method
+          version ||= route.version
+
+          # defaulting does not set rack.env['api.version'] and route.version may return Array
+          #
+          version = version.join(PIPE_STRING) if Array === version
+
+          if version
+            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            "#{class_name}-#{version}#{action_name} (#{method_name})"
+          else
+            "#{class_name}#{action_name} (#{method_name})"
           end
-        else
-          def name_for_transaction(route, class_name, version)
-            action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
-            method_name = route.route_method
-            version ||= route.route_version
-
-            if version
-              action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
-              "#{class_name}-#{version}#{action_name} (#{method_name})"
-            else
-              "#{class_name}#{action_name} (#{method_name})"
-            end
+        end
+
+        def name_for_transaction_deprecated(route, class_name, version)
+          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+          method_name = route.route_method
+          version ||= route.route_version
+
+          if version
+            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            "#{class_name}-#{version}#{action_name} (#{method_name})"
+          else
+            "#{class_name}#{action_name} (#{method_name})"
           end
         end
 
@@ -109,6 +107,13 @@ DependencyDetection.defer do
   end
 
   def instrument_call
+    if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
+      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction_deprecated
+    else
+      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction
+      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :alias_method, :name_for_transaction, :name_for_transaction_deprecated
+    end
+
     ::Grape::API.class_eval do
       def call_with_new_relic(env)
         begin
@@ -130,5 +135,4 @@ DependencyDetection.defer do
       alias_method :call, :call_with_new_relic
     end
   end
-
 end

data/lib/new_relic/agent/instrumentation/rails5/action_cable.rb

@@ -27,6 +27,10 @@ DependencyDetection.defer do
     ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
-    ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::Engine, ::ActionCable::RemoteConnections)
+    ActiveSupport.on_load(:action_cable) do
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ::ActionCable::Engine,
+        ::ActionCable::RemoteConnections)
+    end
   end
 end