newrelic_rpm 9.1.0 → 9.21.0

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

@@ -0,0 +1,91 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Kinesis
+    INSTRUMENTED_METHODS = %w[
+      add_tags_to_stream
+      create_stream
+      decrease_stream_retention_period
+      delete_stream
+      describe_limits
+      describe_stream
+      disable_enhanced_monitoring
+      enable_enhanced_monitoring
+      get_records
+      get_shard_iterator
+      increase_stream_retention_period
+      list_streams
+      list_tags_for_stream
+      merge_shards
+      put_record
+      put_records
+      remove_tags_from_stream
+      split_shard
+      update_shard_count
+    ].freeze
+
+    KINESIS = 'Kinesis'
+    AWS_KINESIS_DATA_STREAMS = 'aws_kinesis_data_streams'
+    MESSAGE_BROKER_SEGMENT_METHODS = %w[put_record put_records get_records].freeze
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(KINESIS)
+      params = args[0]
+      arn = get_arn(params) if params
+
+      if MESSAGE_BROKER_SEGMENT_METHODS.include?(method_name)
+        stream_name = get_stream_name(params, arn)
+        segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+          action: method_name == 'get_records' ? :consume : :produce,
+          library: KINESIS,
+          destination_type: :stream,
+          destination_name: stream_name
+        )
+      else
+        segment = NewRelic::Agent::Tracer.start_segment(name: get_segment_name(method_name, params))
+      end
+
+      segment&.add_agent_attribute('cloud.resource_id', arn) if arn
+
+      begin
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment&.add_agent_attribute('cloud.platform', AWS_KINESIS_DATA_STREAMS)
+        segment&.finish
+      end
+    end
+
+    def get_segment_name(method_name, params)
+      stream_name = params&.dig(:stream_name)
+      return "#{KINESIS}/#{method_name}/#{stream_name}" if stream_name
+
+      "#{KINESIS}/#{method_name}"
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to create segment name: #{e}")
+    end
+
+    def get_stream_name(params, arn)
+      params&.dig(:stream_name) || arn.split('/').last || NewRelic::UNKNOWN_LOWER
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to get stream name: #{e}")
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+
+    def get_arn(params)
+      stream_arn = params&.dig(:stream_arn)
+      return stream_arn if stream_arn
+
+      stream_name = params&.dig(:stream_name)
+      NewRelic::Agent::Aws.create_arn(KINESIS.downcase, "stream/#{stream_name}", config&.region, nr_account_id) if stream_name
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_kinesis/prepend.rb

@@ -0,0 +1,15 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Kinesis::Prepend
+    include NewRelic::Agent::Instrumentation::Kinesis
+
+    INSTRUMENTED_METHODS.each do |method_name|
+      define_method(method_name) do |*args|
+        instrument_method_with_new_relic(method_name, *args) { super(*args) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'aws_sdk_kinesis/instrumentation'
+require_relative 'aws_sdk_kinesis/chain'
+require_relative 'aws_sdk_kinesis/prepend'
+
+DependencyDetection.defer do
+  named :aws_sdk_kinesis
+
+  depends_on do
+    defined?(Aws::Kinesis::Client)
+  end
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::Kinesis::Client, NewRelic::Agent::Instrumentation::Kinesis::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Kinesis::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_lambda/chain.rb

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module AwsSdkLambda::Chain
+    def self.instrument!
+      ::Aws::Lambda::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::AwsSdkLambda
+
+        alias_method(:invoke_without_new_relic, :invoke)
+
+        def invoke(*args)
+          invoke_with_new_relic(*args) { invoke_without_new_relic(*args) }
+        end
+
+        alias_method(:invoke_async_without_new_relic, :invoke_async)
+
+        def invoke_async(*args)
+          invoke_async_with_new_relic(*args) { invoke_async_without_new_relic(*args) }
+        end
+
+        alias_method(:invoke_with_response_stream_without_new_relic, :invoke_with_response_stream)
+
+        def invoke_with_response_stream(*args)
+          invoke_with_response_stream_with_new_relic(*args) { invoke_with_response_stream_without_new_relic(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'json'
+
+module NewRelic::Agent::Instrumentation
+  module AwsSdkLambda
+    INSTRUMENTATION_NAME = 'aws_sdk_lambda'
+    AWS_SERVICE = 'lambda'
+    CLOUD_PLATFORM = 'aws_lambda'
+    WRAPPED_RESPONSE = Struct.new(:status_code, :has_status_code?)
+
+    def invoke_with_new_relic(*args)
+      with_tracing(:invoke, *args) { yield }
+    end
+
+    def invoke_async_with_new_relic(*args)
+      with_tracing(:invoke_async, *args) { yield }
+    end
+
+    def invoke_with_response_stream_with_new_relic(*args)
+      with_tracing(:invoke_with_response_stream, *args) { yield }
+    end
+
+    private
+
+    def with_tracing(action, *args)
+      segment = generate_segment(action, *args)
+
+      # prevent additional instrumentation for things like Net::HTTP from
+      # creating any segments that may appear as redundant / confusing
+      NewRelic::Agent.disable_all_tracing do
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        process_response(response, segment)
+        response
+      end
+    ensure
+      segment&.finish
+    end
+
+    def process_response(response, segment)
+      process_function_error(response) if response.respond_to?(:function_error)
+    rescue => e
+      NewRelic::Agent.logger.error("Error processing aws-sdk-lambda invocation response: #{e}")
+    end
+
+    # notice error that was raised / unhandled by the function
+    def process_function_error(response)
+      function_error = response.function_error
+      return unless function_error
+
+      msg = "[#{function_error}]"
+      payload = response.payload&.string if response.respond_to?(:payload)
+      payload_hash = JSON.parse(payload) if payload
+      msg = "#{msg} #{payload_hash['errorType']} - #{payload_hash['errorMessage']}" if payload_hash
+      e = StandardError.new(msg)
+      e.set_backtrace(payload_hash['stackTrace']) if payload_hash
+
+      NewRelic::Agent.notice_error(e)
+    end
+
+    def generate_segment(action, options = {})
+      function = function_name(options)
+      region = aws_region
+      arn = aws_arn(function, region)
+      segment = NewRelic::Agent::Tracer.start_segment(name: "Lambda/#{action}/#{function}")
+      segment.add_agent_attribute('cloud.account.id', nr_account_id)
+      segment.add_agent_attribute('cloud.platform', CLOUD_PLATFORM)
+      segment.add_agent_attribute('cloud.region', region)
+      segment.add_agent_attribute('cloud.resource_id', arn) if arn
+      segment
+    end
+
+    def function_name(options = {})
+      (options.fetch(:function_name, nil) if options.respond_to?(:fetch)) || NewRelic::UNKNOWN
+    end
+
+    def aws_region
+      config&.region if self.respond_to?(:config)
+    end
+
+    def aws_arn(function, region)
+      NewRelic::Agent::Aws.create_arn(AWS_SERVICE, "function:#{function}", region, nr_account_id)
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_lambda/prepend.rb

@@ -0,0 +1,23 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module AwsSdkLambda::Prepend
+    include NewRelic::Agent::Instrumentation::AwsSdkLambda
+
+    def invoke(*args)
+      invoke_with_new_relic(*args) { super }
+    end
+
+    def invoke_async(*args)
+      invoke_async_with_new_relic(*args) { super }
+    end
+
+    def invoke_with_response_stream(*args)
+      invoke_with_response_stream_with_new_relic(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+DependencyDetection.defer do
+  named :aws_sdk_lambda
+
+  depends_on do
+    defined?(Aws::Lambda::Client)
+  end
+
+  executes do
+    require_relative 'aws_sdk_lambda/instrumentation'
+
+    if use_prepend?
+      require_relative 'aws_sdk_lambda/prepend'
+      prepend_instrument Aws::Lambda::Client, NewRelic::Agent::Instrumentation::AwsSdkLambda::Prepend
+    else
+      require_relative 'aws_sdk_lambda/chain'
+      chain_instrument NewRelic::Agent::Instrumentation::AwsSdkLambda::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sqs/chain.rb

@@ -0,0 +1,37 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module AwsSqs::Chain
+    def self.instrument!
+      ::Aws::SQS::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::AwsSqs
+
+        alias_method(:send_message_without_new_relic, :send_message)
+
+        def send_message(*args)
+          send_message_with_new_relic(*args) do
+            send_message_without_new_relic(*args)
+          end
+        end
+
+        alias_method(:send_message_batch_without_new_relic, :send_message_batch)
+
+        def send_message_batch(*args)
+          send_message_batch_with_new_relic(*args) do
+            send_message_batch_without_new_relic(*args)
+          end
+        end
+
+        alias_method(:receive_message_without_new_relic, :receive_message)
+
+        def receive_message(*args)
+          receive_message_with_new_relic(*args) do
+            receive_message_without_new_relic(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module AwsSqs
+    MESSAGING_LIBRARY = 'SQS'
+
+    def send_message_with_new_relic(*args)
+      with_tracing(:produce, args) do
+        yield
+      end
+    end
+
+    def send_message_batch_with_new_relic(*args)
+      with_tracing(:produce, args) do
+        yield
+      end
+    end
+
+    def receive_message_with_new_relic(*args)
+      with_tracing(:consume, args) do
+        yield
+      end
+    end
+
+    def with_tracing(action, params)
+      segment = nil
+      begin
+        info = get_url_info(params[0])
+        segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+          action: action,
+          library: MESSAGING_LIBRARY,
+          destination_type: :queue,
+          destination_name: info[:queue_name]
+        )
+        add_aws_attributes(segment, info)
+      rescue => e
+        NewRelic::Agent.logger.error('Error starting message broker segment in Aws::SQS::Client', e)
+      end
+      NewRelic::Agent::Tracer.capture_segment_error(segment) do
+        yield
+      end
+    ensure
+      segment&.finish
+    end
+
+    private
+
+    def add_aws_attributes(segment, info)
+      return unless segment
+
+      segment.add_agent_attribute('messaging.system', 'aws_sqs')
+      segment.add_agent_attribute('cloud.region', config&.region)
+      segment.add_agent_attribute('cloud.account.id', info[:account_id])
+      segment.add_agent_attribute('messaging.destination.name', info[:queue_name])
+    end
+
+    def get_url_info(params)
+      split = params[:queue_url].split('/')
+      {
+        queue_name: split.last,
+        account_id: split[-2]
+      }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sqs/prepend.rb

@@ -0,0 +1,21 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module AwsSqs::Prepend
+    include NewRelic::Agent::Instrumentation::AwsSqs
+
+    def send_message(*args)
+      send_message_with_new_relic(*args) { super }
+    end
+
+    def send_message_batch(*args)
+      send_message_batch_with_new_relic(*args) { super }
+    end
+
+    def receive_message(*args)
+      receive_message_with_new_relic(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'aws_sqs/instrumentation'
+require_relative 'aws_sqs/chain'
+require_relative 'aws_sqs/prepend'
+
+DependencyDetection.defer do
+  named :aws_sqs
+
+  depends_on do
+    defined?(Aws::SQS::Client)
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::SQS::Client, NewRelic::Agent::Instrumentation::AwsSqs::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::AwsSqs::Chain
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
-  module Bunny
+  module Bunny::Chain
     def self.instrument!
       ::Bunny::Exchange.class_eval do
         include NewRelic::Agent::Instrumentation::Bunny::Exchange

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

@@ -12,6 +12,7 @@ module NewRelic
         DEFAULT_NAME = 'Default'
         DEFAULT_TYPE = :direct
         SLASH = '/'
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def exchange_name(name)
           name.empty? ? DEFAULT_NAME : name
@@ -28,6 +29,8 @@ module NewRelic
           include Bunny
 
           def publish_with_tracing(payload, opts = {})
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               destination = exchange_name(name)
 
@@ -45,6 +48,12 @@ module NewRelic
                 correlation_id: opts[:correlation_id],
                 exchange_type: type
               )
+              if segment
+                segment.add_agent_attribute('server.address', channel&.connection&.hostname)
+                segment.add_agent_attribute('server.port', channel&.connection&.port)
+                segment.add_agent_attribute('messaging.destination.name', destination) # for produce, this is exchange name
+                segment.add_agent_attribute('messaging.rabbitmq.destination.routing_key', opts[:routing_key])
+              end
             rescue => e
               NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Exchange#publish', e)
               yield
@@ -62,6 +71,8 @@ module NewRelic
           include Bunny
 
           def pop_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
             begin
               t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
@@ -89,6 +100,14 @@ module NewRelic
                 queue_name: name,
                 start_time: t0
               )
+              if segment
+                segment.add_agent_attribute('server.address', channel&.connection&.hostname)
+                segment.add_agent_attribute('server.port', channel&.connection&.port)
+                segment.add_agent_attribute('messaging.destination.name', name) # for consume, this is queue name
+                segment.add_agent_attribute('messaging.destination_publish.name', exch_name)
+                segment.add_agent_attribute('message.queueName', name)
+                segment.add_agent_attribute('messaging.rabbitmq.destination.routing_key', delivery_info&.routing_key)
+              end
             rescue => e
               NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Queue#pop', e)
             else
@@ -104,6 +123,8 @@ module NewRelic
           end
 
           def purge_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               type = server_named? ? :temporary_queue : :queue
               segment = NewRelic::Agent::Tracer.start_message_broker_segment(
@@ -129,6 +150,8 @@ module NewRelic
           include Bunny
 
           def call_with_tracing(*args)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             delivery_info, message_properties, _ = args
             queue_name = queue.respond_to?(:name) ? queue.name : queue
 

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

@@ -14,7 +14,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Bunny instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/messaging'
     require 'new_relic/agent/transaction/message_broker_segment'
@@ -22,11 +21,11 @@ DependencyDetection.defer do
 
   executes do
     if use_prepend?
-      prepend_instrument Bunny::Exchange, NewRelic::Agent::Instrumentation::Bunny::Prepend::Exchange
-      prepend_instrument Bunny::Queue, NewRelic::Agent::Instrumentation::Bunny::Prepend::Queue
-      prepend_instrument Bunny::Consumer, NewRelic::Agent::Instrumentation::Bunny::Prepend::Consumer
+      prepend_instrument Bunny::Exchange, NewRelic::Agent::Instrumentation::Bunny::Prepend::Exchange, 'Bunny::Exchange'
+      prepend_instrument Bunny::Queue, NewRelic::Agent::Instrumentation::Bunny::Prepend::Queue, 'Bunny::Queue'
+      prepend_instrument Bunny::Consumer, NewRelic::Agent::Instrumentation::Bunny::Prepend::Consumer, 'Bunny::Consumer'
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Bunny
+      chain_instrument NewRelic::Agent::Instrumentation::Bunny::Chain
     end
   end
 end

data/lib/new_relic/agent/instrumentation/concurrent_ruby/chain.rb

@@ -13,7 +13,7 @@ module NewRelic::Agent::Instrumentation
         def post(*args, &task)
           return post_without_new_relic(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
 
-          traced_task = add_task_tracing(*args, &task)
+          traced_task = add_task_tracing(&task)
           post_without_new_relic(*args, &traced_task)
         end
       end

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

@@ -5,13 +5,12 @@
 module NewRelic::Agent::Instrumentation
   module ConcurrentRuby
     SEGMENT_NAME = 'Concurrent/Task'
-    SUPPORTABILITY_METRIC = 'Supportability/ConcurrentRuby/Invoked'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
-    def add_task_tracing(*args, &task)
-      NewRelic::Agent.record_metric_once(SUPPORTABILITY_METRIC)
+    def add_task_tracing(&task)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
 
       NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        *args,
         segment_name: SEGMENT_NAME,
         parent: NewRelic::Agent::Tracer.current_segment,
         &task

data/lib/new_relic/agent/instrumentation/concurrent_ruby/prepend.rb

@@ -10,7 +10,7 @@ module NewRelic::Agent::Instrumentation
       def post(*args, &task)
         return super(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
 
-        traced_task = add_task_tracing(*args, &task)
+        traced_task = add_task_tracing(&task)
         super(*args, &traced_task)
       end
     end

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

@@ -11,12 +11,11 @@ DependencyDetection.defer do
 
   depends_on do
     defined?(Concurrent) &&
-      Gem::Version.new(Concurrent::VERSION) >= Gem::Version.new('1.1.5')
+      defined?(Concurrent::VERSION) &&
+      NewRelic::Helper.version_satisfied?(Concurrent::VERSION, '>=', '1.1.5')
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing concurrent-ruby instrumentation')
-
     if use_prepend?
       prepend_instrument(Concurrent::ThreadPoolExecutor, NewRelic::Agent::Instrumentation::ConcurrentRuby::Prepend)
 

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

@@ -41,8 +41,6 @@ module NewRelic
             clazz.extend(ClassMethodsShim)
           end
 
-          def new_relic_trace_controller_action(*args); yield; end
-
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
@@ -56,6 +54,7 @@ module NewRelic
           # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
           # using :except and :only.  If no actions are specified, all actions are ignored.
           #
+          # @!scope class
           # @api public
           #
           def newrelic_ignore(specifiers = {})
@@ -67,6 +66,7 @@ module NewRelic
           # actions that are not user facing or that skew your overall apdex measurement.
           # Accepts :except and :only options, as with #newrelic_ignore.
           #
+          # @!scope class
           # @api public
           #
           def newrelic_ignore_apdex(specifiers = {})
@@ -74,6 +74,7 @@ module NewRelic
             newrelic_ignore_aspect(NR_IGNORE_APDEX_KEY, specifiers)
           end
 
+          # @!scope class
           # @api public
           def newrelic_ignore_enduser(specifiers = {})
             NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_enduser)
@@ -161,6 +162,7 @@ module NewRelic
           # See NewRelic::Agent::Instrumentation::ControllerInstrumentation#perform_action_with_newrelic_trace
           # for the full list of available options.
           #
+          # @!scope class
           # @api public
           #
           def add_transaction_tracer(method, options = {})
@@ -245,6 +247,7 @@ module NewRelic
             when :background then ::NewRelic::Agent::Transaction::TASK_PREFIX
             when :rack then ::NewRelic::Agent::Transaction::RACK_PREFIX
             when :uri then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :roda then ::NewRelic::Agent::Transaction::RODA_PREFIX
             when :sinatra then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
             when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
             when :grape then ::NewRelic::Agent::Transaction::GRAPE_PREFIX