newrelic_rpm 9.2.2 → 9.5.0

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/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
 
@@ -245,6 +243,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

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

@@ -68,6 +68,8 @@ module NewRelic
         module Multi
           include NewRelic::Agent::MethodTracer
 
+          INSTRUMENTATION_NAME = 'Curb'
+
           # Add CAT with callbacks if the request is serial
           def add_with_tracing(curl)
             if curl.respond_to?(:_nr_serial) && curl._nr_serial
@@ -81,6 +83,8 @@ module NewRelic
           def perform_with_tracing
             return yield if first_request_is_serial?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             trace_execution_scoped('External/Multiple/Curb::Multi/perform') do
               yield
             end

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

@@ -31,8 +31,11 @@ module NewRelic
         include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
         NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+        INSTRUMENTATION_NAME = 'DelayedJob'
 
         def invoke_job_with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           options = {
             :category => NR_TRANSACTION_CATEGORY,
             :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)

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

@@ -8,15 +8,18 @@ module NewRelic::Agent::Instrumentation
   module Elasticsearch
     PRODUCT_NAME = 'Elasticsearch'
     OPERATION = 'perform_request'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
     def perform_request_with_tracing(method, path, params = {}, body = nil, headers = nil)
       return yield unless NewRelic::Agent::Tracer.tracing_enabled?
 
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: PRODUCT_NAME,
         operation: nr_operation || OPERATION,
         host: nr_hosts[:host],
-        port_path_or_id: path,
+        port_path_or_id: nr_hosts[:port],
         database_name: nr_cluster_name
       )
       begin

data/lib/new_relic/agent/instrumentation/excon/middleware.rb

@@ -6,6 +6,7 @@ module ::Excon
   module Middleware
     class NewRelicCrossAppTracing
       TRACE_DATA_IVAR = :@newrelic_trace_data
+      INSTRUMENTATION_NAME = 'Excon'
 
       def initialize(stack)
         @stack = stack
@@ -18,6 +19,8 @@ module ::Excon
           # :idempotent in the options, but there will be only a single
           # accompanying response_call/error_call.
           if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
             segment = NewRelic::Agent::Tracer.start_external_request_segment(
               library: wrapped_request.type,

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

@@ -10,9 +10,16 @@ module NewRelic::Agent::Instrumentation
 
         alias_method(:initialize_without_new_relic, :initialize)
 
-        def initialize(*args, &block)
-          traced_block = add_thread_tracing(*args, &block)
-          initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+        if RUBY_VERSION < '2.7.0'
+          def initialize(*_args, &block)
+            traced_block = add_thread_tracing(&block)
+            initialize_with_newrelic_tracing { initialize_without_new_relic(&traced_block) }
+          end
+        else
+          def initialize(**kwargs, &block)
+            traced_block = add_thread_tracing(&block)
+            initialize_with_newrelic_tracing { initialize_without_new_relic(**kwargs, &traced_block) }
+          end
         end
       end
     end

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

@@ -11,11 +11,10 @@ module NewRelic::Agent::Instrumentation
       yield
     end
 
-    def add_thread_tracing(*args, &block)
+    def add_thread_tracing(&block)
       return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
       NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        *args,
         segment_name: 'Ruby/Fiber',
         &block
       )

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

@@ -9,9 +9,16 @@ module NewRelic::Agent::Instrumentation
     module Prepend
       include NewRelic::Agent::Instrumentation::MonitoredFiber
 
-      def initialize(*args, &block)
-        traced_block = add_thread_tracing(*args, &block)
-        initialize_with_newrelic_tracing { super(*args, &traced_block) }
+      if RUBY_VERSION < '2.7.0'
+        def initialize(*_args, &block)
+          traced_block = add_thread_tracing(&block)
+          initialize_with_newrelic_tracing { super(&traced_block) }
+        end
+      else
+        def initialize(**kawrgs, &block)
+          traced_block = add_thread_tracing(&block)
+          initialize_with_newrelic_tracing { super(**kawrgs, &traced_block) }
+        end
       end
     end
   end

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

@@ -9,6 +9,8 @@ module NewRelic::Agent::Instrumentation
     module Instrumentation
       extend self
 
+      INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
       # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
       # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
       def instrumented_class
@@ -46,6 +48,8 @@ module NewRelic::Agent::Instrumentation
       def handle_transaction(endpoint, class_name, version)
         return unless endpoint && route = endpoint.route
 
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         name_transaction(route, class_name, version)
         capture_params(endpoint)
       end

data/lib/new_relic/agent/instrumentation/grpc/client/instrumentation.rb

@@ -12,10 +12,14 @@ module NewRelic
         module Client
           include NewRelic::Agent::Instrumentation::GRPC::Helper
 
+          INSTRUMENTATION_NAME = 'gRPC_Client'
+
           def issue_request_with_tracing(grpc_type, method, requests, marshal, unmarshal,
             deadline:, return_op:, parent:, credentials:, metadata:)
             return yield unless trace_with_newrelic?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             segment = request_segment(method)
             request_wrapper = NewRelic::Agent::Instrumentation::GRPC::Client::RequestWrapper.new(@host)
             # do not insert CAT headers for gRPC requests https://github.com/newrelic/newrelic-ruby-agent/issues/1730

data/lib/new_relic/agent/instrumentation/grpc/server/instrumentation.rb

@@ -11,6 +11,8 @@ module NewRelic
         module Server
           include NewRelic::Agent::Instrumentation::GRPC::Helper
 
+          INSTRUMENTATION_NAME = 'gRPC_Server'
+
           DT_KEYS = [NewRelic::NEWRELIC_KEY, NewRelic::TRACEPARENT_KEY, NewRelic::TRACESTATE_KEY].freeze
           INSTANCE_VAR_HOST = :@host_nr
           INSTANCE_VAR_PORT = :@port_nr
@@ -23,6 +25,8 @@ module NewRelic
           def handle_with_tracing(streamer_type, active_call, mth, _inter_ctx)
             return yield unless trace_with_newrelic?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             metadata = metadata_for_call(active_call)
             txn = NewRelic::Agent::Transaction.start_new_transaction(NewRelic::Agent::Tracer.state,
               CATEGORY,

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

@@ -13,7 +13,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = 'gRPC_Client'
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::ClientStub, NewRelic::Agent::Instrumentation::GRPC::Client::Prepend, supportability_name
     else

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = 'gRPC_Server'
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::RpcServer, NewRelic::Agent::Instrumentation::GRPC::Server::RpcServerPrepend, supportability_name
       prepend_instrument GRPC::RpcDesc, NewRelic::Agent::Instrumentation::GRPC::Server::RpcDescPrepend, supportability_name

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

@@ -5,7 +5,11 @@
 module NewRelic::Agent::Instrumentation
   module HTTPClient
     module Instrumentation
+      INSTRUMENTATION_NAME = 'HTTPClient'
+
       def with_tracing(request, connection)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(request)
         segment = NewRelic::Agent::Tracer.start_external_request_segment(
           library: wrapped_request.type,

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

@@ -4,7 +4,11 @@
 
 module NewRelic::Agent::Instrumentation
   module HTTPrb
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing(request)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
 
       begin

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module Logger
+        INSTRUMENTATION_NAME = 'Logger'
+
         def skip_instrumenting?
           defined?(@skip_instrumenting) && @skip_instrumenting
         end
@@ -51,6 +53,7 @@ module NewRelic
             mark_skip_instrumenting
 
             unless ::NewRelic::Agent.agent.nil?
+              ::NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
               ::NewRelic::Agent.agent.log_event_aggregator.record(formatted_message, severity)
               formatted_message = LocalLogDecorator.decorate(formatted_message)
             end

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

@@ -10,9 +10,12 @@ module NewRelic::Agent::Instrumentation
       LOCALHOST = 'localhost'
       MULTIGET_METRIC_NAME = 'get_multi_request'
       MEMCACHED = 'Memcached'
+      INSTRUMENTATION_NAME = 'Dalli'
 
       def with_newrelic_tracing(operation, *args)
-        segment = NewRelic::Agent::Tracer.start_datastore_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = NewRelic::Agent::Tracer.start_datastore_segment(
           product: MEMCACHED,
           operation: operation
         )
@@ -28,6 +31,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def server_for_key_with_newrelic_tracing
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         yield.tap do |server|
           begin
             if txn = ::NewRelic::Agent::Tracer.current_transaction
@@ -43,7 +48,9 @@ module NewRelic::Agent::Instrumentation
       end
 
       def get_multi_with_newrelic_tracing(method_name)
-        segment = NewRelic::Agent::Tracer.start_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = NewRelic::Agent::Tracer.start_segment(
           name: "Ruby/Memcached/Dalli/#{method_name}"
         )
 
@@ -55,7 +62,9 @@ module NewRelic::Agent::Instrumentation
       end
 
       def send_multiget_with_newrelic_tracing(keys)
-        segment = ::NewRelic::Agent::Tracer.start_datastore_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = ::NewRelic::Agent::Tracer.start_datastore_segment(
           product: MEMCACHED,
           operation: MULTIGET_METRIC_NAME
         )

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

@@ -5,8 +5,8 @@
 # NOTE: there are multiple implementations of the Memcached client in Ruby,
 # each with slightly different APIs and semantics.
 # See:
-#     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
-#     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
+#     https://rubygems.org/gems/Ruby-MemCache (Gem: Ruby-MemCache)
+#     https://github.com/mperham/memcache-client (Gem: memcache-client)
 #     https://github.com/mperham/dalli (Gem: dalli)
 
 require_relative 'memcache/helper'

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

@@ -6,7 +6,11 @@ module NewRelic
   module Agent
     module Instrumentation
       module NetHTTP
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def request_with_tracing(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
           segment = NewRelic::Agent::Tracer.start_external_request_segment(

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

@@ -47,6 +47,10 @@ module NewRelic
           end
         end
 
+        # The agent doesn't use the traditional ActiveSupport::Notifications.subscribe
+        # pattern due to threading issues discovered on initial instrumentation.
+        # Instead we define a #start and #finish method, which Rails responds to.
+        # See: https://github.com/rails/rails/issues/12069
         def start(name, id, payload)
           return unless state.is_execution_traced?
 

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

@@ -4,7 +4,11 @@
 
 module NewRelic::Agent::Instrumentation
   module Padrino
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def invoke_route_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         env['newrelic.last_route'] = args[0].original_path
       rescue => e

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

@@ -5,7 +5,7 @@
 module NewRelic
   module Agent
     module Instrumentation
-      # https://newrelic.com/docs/features/tracking-front-end-time
+      # https://docs.newrelic.com/docs/features/tracking-front-end-time
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module RackBuilder
+        INSTRUMENTATION_NAME = 'Rack'
+
         def self.track_deferred_detection(builder_class)
           class << builder_class
             attr_accessor :_nr_deferred_detection_ran
@@ -51,6 +53,8 @@ module NewRelic
         def run_with_tracing(app)
           return yield(app) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
         end
 
@@ -58,6 +62,8 @@ module NewRelic
           return if middleware_class.nil?
           return yield(middleware_class) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
         end
       end

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -9,6 +9,8 @@ module NewRelic
     module Instrumentation
       module Rails3
         module ActionController
+          INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
           # determine the path that is used in the metric name for
           # the called controller action
           def newrelic_metric_path(action_name_override = nil)
@@ -21,6 +23,8 @@ module NewRelic
           end
 
           def process_action(*args) # THREAD_LOCAL_ACCESS
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
             perform_action_with_newrelic_trace(:category => :controller,
               :name => self.action_name,

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

@@ -25,7 +25,7 @@ DependencyDetection.defer do
 
   executes do
     # enumerate the specific events we want so that we do not get unexpected additions in the future
-    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit|broadcast)\.action_cable\z/,
+    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit.*|broadcast)\.action_cable\z/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do

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

@@ -7,11 +7,15 @@ module NewRelic
     module Instrumentation
       module Rake
         module Tracer
+          INSTRUMENTATION_NAME = 'Rake'
+
           def invoke_with_newrelic_tracing(*args)
             unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               timeout = NewRelic::Agent.config[:'rake.connect_timeout']
               NewRelic::Agent.instance.wait_on_connect(timeout)

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

@@ -6,6 +6,8 @@ require_relative 'constants'
 
 module NewRelic::Agent::Instrumentation
   module Redis
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def connect_with_tracing
       with_tracing(Constants::CONNECT, database: db) { yield }
     end
@@ -43,6 +45,8 @@ module NewRelic::Agent::Instrumentation
     private
 
     def with_tracing(operation, statement: nil, database: nil)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: Constants::PRODUCT_NAME,
         operation: operation,

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

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',

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

@@ -0,0 +1,43 @@
+# 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 Roda
+    module Chain
+      def self.instrument!
+        ::Roda.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+          alias_method(:_roda_handle_main_route_without_tracing, :_roda_handle_main_route)
+
+          def _roda_handle_main_route(*args)
+            _roda_handle_main_route_with_tracing(*args) do
+              _roda_handle_main_route_without_tracing(*args)
+            end
+          end
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Roda.class_eval do
+            include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+            class << self
+              alias_method(:build_rack_app_without_tracing, :build_rack_app)
+
+              def build_rack_app
+                build_rack_app_with_tracing do
+                  build_rack_app_without_tracing
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# 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 Roda
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      INSTRUMENTATION_NAME = 'Roda'
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_rack_app_with_tracing
+        unless NewRelic::Agent.config[:disable_roda_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            self.use middleware_class
+          end
+        end
+        yield
+      end
+
+      # Roda makes use of Rack, so we can get params from the request object
+      def rack_request_params
+        begin
+          @_request.params
+        rescue => e
+          NewRelic::Agent.logger.debug('Failed to get params from Rack request.', e)
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def _roda_handle_main_route_with_tracing(*args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        perform_action_with_newrelic_trace(
+          category: :roda,
+          name: ::NewRelic::Agent::Instrumentation::Roda::TransactionNamer.transaction_name(request),
+          params: ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, rack_request_params)
+        ) do
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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 Roda
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+      def _roda_handle_main_route(*args)
+        _roda_handle_main_route_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+        def build_rack_app
+          build_rack_app_with_tracing { super }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -0,0 +1,30 @@
+# 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
+  module Agent
+    module Instrumentation
+      module Roda
+        module TransactionNamer
+          extend self
+
+          ROOT = '/'.freeze
+          REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
+
+          def transaction_name(request)
+            path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
+            name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
+            name = ROOT if name.empty?
+            name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
+
+            name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Roda transaction name")
+            ::NewRelic::Agent::UNKNOWN_METRIC
+          end
+        end
+      end
+    end
+  end
+end