newrelic_rpm 9.1.0 → 9.21.0

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

@@ -9,18 +9,12 @@ module NewRelic
     module Instrumentation
       module ActiveRecord
         EXPLAINER = lambda do |statement|
-          connection = NewRelic::Agent::Database.get_connection(statement.config) do
-            ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
-              statement.config)
-          end
-          # the following line needs else branch coverage
-          if connection && connection.respond_to?(:execute) # rubocop:disable Style/SafeNavigation
-            return connection.execute("EXPLAIN #{statement.sql}")
-          end
+          NewRelic::Agent::Database.explain_this(statement, true)
         end
 
         def self.insert_instrumentation
-          if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
+          if defined?(::ActiveRecord::VERSION::MAJOR) &&
+              NewRelic::Helper.version_satisfied?(::ActiveRecord::VERSION::MAJOR, '>=', 3)
             if ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
               ::ActiveRecord::Base.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
               ::ActiveRecord::Relation.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
@@ -44,7 +38,7 @@ module NewRelic
           end
         end
 
-        if RUBY_VERSION < '2.7.0'
+        if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
           def log_with_newrelic_instrumentation(*args, &block)
             state = NewRelic::Agent::Tracer.state
 
@@ -144,11 +138,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
       (!defined?(ActiveRecord::VERSION) ||
-        ActiveRecord::VERSION::MAJOR.to_i <= 3)
+        NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::MAJOR, '<=', 3))
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation]
+    !NewRelic::Agent.config[:disable_active_record_instrumentation]
   end
 
   executes do
@@ -158,7 +152,8 @@ DependencyDetection.defer do
   executes do
     require 'new_relic/agent/instrumentation/active_record_helper'
 
-    if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i == 3
+    if defined?(Rails::VERSION::MAJOR) &&
+        NewRelic::Helper.version_satisfied?(Rails::VERSION::MAJOR, '==', 3)
       ActiveSupport.on_load(:active_record) do
         NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
       end

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

@@ -49,7 +49,7 @@ module NewRelic
 
             alias_method(:delete_all_without_newrelic, :delete_all)
 
-            if RUBY_VERSION < '2.7.0'
+            if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
               def delete_all(*args, &blk)
                 ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
                   delete_all_without_newrelic(*args, &blk)
@@ -170,6 +170,9 @@ module NewRelic
 
           'sqlite3' => 'SQLite',
 
+          # https://rubygems.org/gems/trilogy
+          'trilogy' => 'MySQL',
+
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
           'jdbcmysql' => 'MySQL',
 
@@ -222,7 +225,8 @@ module NewRelic
 
             'postgresql' => :postgres,
             'jdbcpostgresql' => :postgres,
-            'postgis' => :postgres
+            'postgis' => :postgres,
+            'redshift' => :postgres
           }.freeze
 
           DATASTORE_DEFAULT_PORTS = {
@@ -231,8 +235,7 @@ module NewRelic
           }.freeze
 
           DEFAULT = 'default'.freeze
-          UNKNOWN = 'unknown'.freeze
-          SLASH = '/'.freeze
+          UNKNOWN = NewRelic::UNKNOWN_LOWER
           LOCALHOST = 'localhost'.freeze
 
           def adapter_from_config(config)
@@ -288,7 +291,7 @@ module NewRelic
           private
 
           def postgres_unix_domain_socket_case?(host, adapter)
-            adapter == :postgres && host && host.start_with?(SLASH)
+            adapter == :postgres && host && host.start_with?(NewRelic::SLASH)
           end
 
           def mysql_default_case?(config, adapter)

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

@@ -28,7 +28,7 @@ module NewRelic
             ) { yield }
           rescue => e
             # The translate_exception_class method got introduced in 4.1
-            if ::ActiveRecord::VERSION::MINOR == 0
+            if NewRelic::Helper.version_satisfied?(::ActiveRecord::VERSION::MINOR, '==', 0)
               raise translate_exception(e, sql)
             else
               raise translate_exception_class(e, sql)
@@ -86,11 +86,12 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
       defined?(ActiveRecord::VERSION) &&
-      ActiveRecord::VERSION::MAJOR.to_i >= 4
+      NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::MAJOR, '>=', 4)
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+    !NewRelic::Agent.config[:disable_active_record_instrumentation] &&
+      !NewRelic::Agent.config[:disable_active_record_notifications] &&
       !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
   end
 
@@ -112,7 +113,7 @@ DependencyDetection.defer do
 
       # Default to .prepending, unless the ActiveRecord version is <=4
       # **AND** the :prepend_active_record_instrumentation config is false
-      if ActiveRecord::VERSION::MAJOR > 4 \
+      if NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::MAJOR, '>', 4) \
           || NewRelic::Agent.config[:prepend_active_record_instrumentation]
 
         ActiveRecord::Base.send(:prepend,
@@ -130,11 +131,13 @@ DependencyDetection.defer do
       major_version = ActiveRecord::VERSION::MAJOR.to_i
       minor_version = ActiveRecord::VERSION::MINOR.to_i
 
-      activerecord_extension = if major_version == 4
+      activerecord_extension = if NewRelic::Helper.version_satisfied?(major_version, '==', 4)
         NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
-      elsif major_version == 5 && minor_version == 0
+      elsif NewRelic::Helper.version_satisfied?(major_version, '==', 5) &&
+          NewRelic::Helper.version_satisfied?(minor_version, '==', 0)
         NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
-      elsif major_version == 5 && minor_version == 1
+      elsif NewRelic::Helper.version_satisfied?(major_version, '==', 5) &&
+          NewRelic::Helper.version_satisfied?(minor_version, '==', 1)
         NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
       end
 
@@ -145,9 +148,9 @@ DependencyDetection.defer do
   end
 
   executes do
-    if ActiveRecord::VERSION::MAJOR == 5 \
-        && ActiveRecord::VERSION::MINOR.to_i == 1 \
-        && ActiveRecord::VERSION::TINY.to_i >= 6
+    if NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::MAJOR, '==', 5) \
+        && NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::MINOR, '==', 1) \
+        && NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::TINY, '>=', 6)
 
       ActiveRecord::Base.prepend(NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
     end

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

@@ -11,7 +11,7 @@ module NewRelic
         ACTIVE_RECORD = 'ActiveRecord'.freeze
 
         module BaseExtensions
-          if RUBY_VERSION < '2.7.0'
+          if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
             def save(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
@@ -46,7 +46,7 @@ module NewRelic
           # Starting in v5.1.6, this call no longer happens. We'll
           # have to set the database metrics explicitly now.
           #
-          if RUBY_VERSION < '2.7.0'
+          if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
             def touch(*args, **kwargs, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super

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

@@ -70,18 +70,7 @@ module NewRelic
         end
 
         def get_explain_plan(statement)
-          connection = NewRelic::Agent::Database.get_connection(statement.config) do
-            ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
-              statement.config)
-          end
-          # the following line needs else branch coverage
-          if connection && connection.respond_to?(:exec_query) # rubocop:disable Style/SafeNavigation
-            return connection.exec_query("EXPLAIN #{statement.sql}",
-              "Explain #{statement.name}",
-              statement.binds)
-          end
-        rescue => e
-          NewRelic::Agent.logger.debug("Couldn't fetch the explain plan for #{statement} due to #{e}")
+          NewRelic::Agent::Database.explain_this(statement)
         end
 
         def active_record_config(payload)
@@ -127,10 +116,14 @@ module NewRelic
           port_path_or_id = nil
           database = nil
 
-          if ActiveRecordHelper::InstanceIdentification.supported_adapter?(config)
-            host = ActiveRecordHelper::InstanceIdentification.host(config)
-            port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
-            database = config && config[:database]
+          begin
+            if ActiveRecordHelper::InstanceIdentification.supported_adapter?(config)
+              host = ActiveRecordHelper::InstanceIdentification.host(config)
+              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
+              database = config && config[:database]
+            end
+          rescue
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord host, port, and database details for adapter: #{config && config[:adapter]}")
           end
 
           segment = Tracer.start_datastore_segment(product: product,

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

@@ -0,0 +1,69 @@
+# 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 ActiveSupportBroadcastLogger::Chain
+    def self.instrument!
+      ::ActiveSupportBroadcastLogger.class_eval do
+        include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+        alias_method(:add_without_new_relic, :add)
+
+        def add(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            add_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:debug_without_new_relic, :debug)
+
+        def debug(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            debug_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:info_without_new_relic, :info)
+
+        def info(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            info_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:warn_without_new_relic, :warn)
+
+        def warn(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            warn_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:error_without_new_relic, :error)
+
+        def error(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            error_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:fatal_without_new_relic, :fatal)
+
+        def fatal(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            fatal_without_new_relic(*args, &traced_task)
+          end
+        end
+      end
+
+      alias_method(:unknown_without_new_relic, :unknown)
+
+      def unknown(*args, &task)
+        record_one_broadcast_with_new_relic(*args) do
+          unknown_without_new_relic(*args, &traced_task)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# 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 ActiveSupportBroadcastLogger
+    def record_one_broadcast_with_new_relic(*args)
+      if broadcasts && broadcasts[1..-1]
+        broadcasts[1..-1].each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, true) }
+        yield
+        broadcasts.each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, false) }
+      else
+        NewRelic::Agent.logger.error('Error recording broadcasted logger')
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_broadcast_logger/prepend.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 ActiveSupportBroadcastLogger::Prepend
+    include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+    def add(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def debug(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def info(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def warn(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def error(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def fatal(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def unknown(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_broadcast_logger.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
+
+require_relative 'active_support_broadcast_logger/instrumentation'
+require_relative 'active_support_broadcast_logger/chain'
+require_relative 'active_support_broadcast_logger/prepend'
+
+DependencyDetection.defer do
+  named :'active_support_broadcast_logger'
+
+  depends_on { defined?(ActiveSupport::BroadcastLogger) }
+
+  executes do
+    if use_prepend?
+      prepend_instrument ActiveSupport::BroadcastLogger, NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Chain
+    end
+  end
+end

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

@@ -6,8 +6,12 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveSupportLogger
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         # Mark @skip_instrumenting on any broadcasted loggers to instrument Rails.logger only
         def broadcast_with_tracing(logger)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(logger)
           yield
         rescue => error

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

@@ -9,11 +9,11 @@ require_relative 'active_support_logger/prepend'
 DependencyDetection.defer do
   named :active_support_logger
 
-  depends_on { defined?(ActiveSupport::Logger) }
+  depends_on do
+    defined?(ActiveSupport::Logger) && defined?(ActiveSupport::Logger.broadcast)
+  end
 
   executes do
-    NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')
-
     if use_prepend?
       # the only method currently instrumented is a class method
       prepend_instrument ActiveSupport::Logger.singleton_class, NewRelic::Agent::Instrumentation::ActiveSupportLogger::Prepend

data/lib/new_relic/agent/instrumentation/async_http/chain.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 AsyncHttp::Chain
+    def self.instrument!
+      ::Async::HTTP::Internet.class_eval do
+        include NewRelic::Agent::Instrumentation::AsyncHttp
+
+        alias_method(:call_without_new_relic, :call)
+
+        def call(method, url, headers = nil, body = nil)
+          call_with_new_relic(method, url, headers, body) do |hdr|
+            call_without_new_relic(method, url, hdr, body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/async_http/instrumentation.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
+
+require 'new_relic/agent/http_clients/async_http_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module AsyncHttp
+    def call_with_new_relic(method, url, headers = nil, body = nil)
+      headers ||= {} # if it is nil, we need to make it a hash so we can insert headers
+      wrapped_request = NewRelic::Agent::HTTPClients::AsyncHTTPRequest.new(self, method, url, headers)
+
+      segment = NewRelic::Agent::Tracer.start_external_request_segment(
+        library: wrapped_request.type,
+        uri: wrapped_request.uri,
+        procedure: wrapped_request.method
+      )
+
+      begin
+        response = nil
+        segment.add_request_headers(wrapped_request)
+
+        NewRelic::Agent.disable_all_tracing do
+          response = NewRelic::Agent::Tracer.capture_segment_error(segment) do
+            yield(headers)
+          end
+        end
+
+        wrapped_response = NewRelic::Agent::HTTPClients::AsyncHTTPResponse.new(response)
+        segment.process_response_headers(wrapped_response)
+        response
+      ensure
+        segment&.finish
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/async_http/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
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module AsyncHttp::Prepend
+    include NewRelic::Agent::Instrumentation::AsyncHttp
+
+    def call(method, url, headers = nil, body = nil)
+      call_with_new_relic(method, url, headers, body) { |hdr| super(method, url, hdr, body) }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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 'async_http/instrumentation'
+require_relative 'async_http/chain'
+require_relative 'async_http/prepend'
+
+DependencyDetection.defer do
+  named :async_http
+
+  depends_on do
+    defined?(Async::HTTP) &&
+      NewRelic::Helper.version_satisfied?(Async::HTTP::VERSION, '>=', '0.59.0') &&
+      !defined?(Traces::Backend::NewRelic) # defined in the traces-backend-newrelic gem
+  end
+
+  executes do
+    require 'async/http/internet'
+
+    if use_prepend?
+      prepend_instrument Async::HTTP::Internet, NewRelic::Agent::Instrumentation::AsyncHttp::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::AsyncHttp::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_firehose/chain.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 Firehose::Chain
+    def self.instrument!
+      ::Aws::Firehose::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::Firehose
+
+        NewRelic::Agent::Instrumentation::Firehose::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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 Firehose
+    INSTRUMENTED_METHODS = %w[
+      create_delivery_stream
+      delete_delivery_stream
+      describe_delivery_stream
+      list_delivery_streams
+      list_tags_for_delivery_stream
+      put_record
+      put_record_batch
+      start_delivery_stream_encryption
+      stop_delivery_stream_encryption
+      tag_delivery_stream
+      untag_delivery_stream
+      update_destination
+    ].freeze
+
+    FIREHOSE = 'Firehose'
+    AWS_KINESIS_DELIVERY_STREAMS = 'aws_kinesis_delivery_streams'
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(FIREHOSE)
+
+      params = args[0]
+      segment = NewRelic::Agent::Tracer.start_segment(name: get_segment_name(method_name, params))
+      arn = get_arn(params) if params
+      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_DELIVERY_STREAMS)
+        segment&.finish
+      end
+    end
+
+    def get_segment_name(method_name, params)
+      stream_name = params&.dig(:delivery_stream_name)
+      return "#{FIREHOSE}/#{method_name}/#{stream_name}" if stream_name
+
+      "#{FIREHOSE}/#{method_name}"
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to create segment 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(:delivery_stream_arn)
+      return stream_arn if stream_arn
+
+      stream_name = params&.dig(:delivery_stream_name)
+      NewRelic::Agent::Aws.create_arn(FIREHOSE.downcase, "deliverystream/#{stream_name}", config&.region, nr_account_id) if stream_name
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_firehose/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 Firehose::Prepend
+    include NewRelic::Agent::Instrumentation::Firehose
+
+    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_firehose.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_firehose/instrumentation'
+require_relative 'aws_sdk_firehose/chain'
+require_relative 'aws_sdk_firehose/prepend'
+
+DependencyDetection.defer do
+  named :aws_sdk_firehose
+
+  depends_on do
+    defined?(Aws::Firehose::Client)
+  end
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::Firehose::Client, NewRelic::Agent::Instrumentation::Firehose::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Firehose::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_kinesis/chain.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 Kinesis::Chain
+    def self.instrument!
+      ::Aws::Kinesis::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::Kinesis
+
+        NewRelic::Agent::Instrumentation::Kinesis::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+      end
+    end
+  end
+end