newrelic_rpm 9.9.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,7 +138,7 @@ 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
@@ -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,7 +235,7 @@ module NewRelic
           }.freeze
 
           DEFAULT = 'default'.freeze
-          UNKNOWN = 'unknown'.freeze
+          UNKNOWN = NewRelic::UNKNOWN_LOWER
           LOCALHOST = 'localhost'.freeze
 
           def adapter_from_config(config)

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,7 +86,7 @@ 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
@@ -113,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,
@@ -131,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
 
@@ -146,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.rb

@@ -12,8 +12,6 @@ DependencyDetection.defer do
   depends_on { defined?(ActiveSupport::BroadcastLogger) }
 
   executes do
-    NewRelic::Agent.logger.info('Installing ActiveSupport::BroadcastLogger instrumentation')
-
     if use_prepend?
       prepend_instrument ActiveSupport::BroadcastLogger, NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Prepend
     else

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

@@ -14,8 +14,6 @@ DependencyDetection.defer do
   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.rb

@@ -11,14 +11,13 @@ DependencyDetection.defer do
 
   depends_on do
     defined?(Async::HTTP) &&
-      Gem::Version.new(Async::HTTP::VERSION) >= Gem::Version.new('0.59.0') &&
+      NewRelic::Helper.version_satisfied?(Async::HTTP::VERSION, '>=', '0.59.0') &&
       !defined?(Traces::Backend::NewRelic) # defined in the traces-backend-newrelic gem
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing async_http instrumentation')
-
     require 'async/http/internet'
+
     if use_prepend?
       prepend_instrument Async::HTTP::Internet, NewRelic::Agent::Instrumentation::AsyncHttp::Prepend
     else

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

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