elastic-apm 3.15.1 → 4.2.0

data/lib/elastic_apm/spies/dynamo_db.rb

@@ -22,6 +22,7 @@ module ElasticAPM
   module Spies
     # @api private
     class DynamoDBSpy
+      NAME = 'dynamodb'
       TYPE = 'db'
       SUBTYPE = 'dynamodb'
 
@@ -49,15 +50,12 @@ module ElasticAPM
         end
       end
 
-      def install
-        ::Aws::DynamoDB::Client.class_eval do
+      # @api private
+      module Ext
+        def self.prepended(mod)
           # Alias all available operations
-          api.operation_names.each do |operation_name|
-            alias :"#{operation_name}_without_apm" :"#{operation_name}"
-
+          mod.api.operation_names.each do |operation_name|
             define_method(operation_name) do |params = {}, options = {}|
-              cloud = ElasticAPM::Span::Context::Destination::Cloud.new(region: config.region)
-
               context = ElasticAPM::Span::Context.new(
                 db: {
                   instance: config.region,
@@ -65,9 +63,8 @@ module ElasticAPM
                   statement: params[:key_condition_expression]
                 },
                 destination: {
-                  cloud: cloud,
-                  resource: SUBTYPE,
-                  type: TYPE
+                  service: { resource: "#{SUBTYPE}/#{config.region}" },
+                  cloud: { region: config.region }
                 }
               )
 
@@ -79,14 +76,17 @@ module ElasticAPM
                 context: context
               ) do
                 ElasticAPM::Spies::DynamoDBSpy.without_net_http do
-                  original_method = method("#{operation_name}_without_apm")
-                  original_method.call(params, options)
+                  super(params, options)
                 end
               end
             end
           end
         end
       end
+
+      def install
+        ::Aws::DynamoDB::Client.prepend(Ext)
+      end
     end
 
     register(

data/lib/elastic_apm/spies/elasticsearch.rb

@@ -37,47 +37,50 @@ module ElasticAPM
           end
       end
 
-      def install
-        ::Elasticsearch::Transport::Client.class_eval do
-          alias perform_request_without_apm perform_request
-
-          def perform_request(method, path, *args, &block)
-            unless ElasticAPM.current_transaction
-              return perform_request_without_apm(method, path, *args, &block)
-            end
+      # @api private
+      module Ext
+        def perform_request(method, path, *args, &block)
+          unless ElasticAPM.current_transaction
+            return super(method, path, *args, &block)
+          end
 
-            name = format(NAME_FORMAT, method, path)
-            statement = []
+          name = format(NAME_FORMAT, method, path)
+          statement = []
 
-            statement << { params: args&.[](0) }
+          statement << { params: args&.[](0) }
 
-            if ElasticAPM.agent.config.capture_elasticsearch_queries
-              unless args[1].nil? || args[1].empty?
-                statement << {
-                  body: ElasticAPM::Spies::ElasticsearchSpy
-                             .sanitizer.strip_from(args[1])
-                }
-              end
+          if ElasticAPM.agent.config.capture_elasticsearch_queries
+            unless args[1].nil? || args[1].empty?
+              body =
+                ElasticAPM::Spies::ElasticsearchSpy
+                .sanitizer.strip_from(args[1])
+              statement << { body: body }
             end
+          end
 
-            context = Span::Context.new(
-              db: { statement: statement.reduce({}, :merge).to_json },
-              destination: {
+          context = Span::Context.new(
+            db: { statement: statement.reduce({}, :merge).to_json },
+            destination: {
+              service: {
                 name: SUBTYPE,
                 resource: SUBTYPE,
                 type: TYPE
               }
-            )
+            }
+          )
 
-            ElasticAPM.with_span(
-              name,
-              TYPE,
-              subtype: SUBTYPE,
-              context: context
-            ) { perform_request_without_apm(method, path, *args, &block) }
-          end
+          ElasticAPM.with_span(
+            name,
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) { super(method, path, *args, &block) }
         end
       end
+
+      def install
+        ::Elasticsearch::Transport::Client.prepend(Ext)
+      end
     end
 
     register(

data/lib/elastic_apm/spies/faraday.rb

@@ -22,88 +22,108 @@ module ElasticAPM
   module Spies
     # @api private
     class FaradaySpy
-      TYPE = 'ext'
-      SUBTYPE = 'faraday'
+      DISABLE_KEY = :__elastic_apm_faraday_disabled
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
-      def self.without_net_http
-        return yield unless defined?(NetHTTPSpy)
+      class << self
+        def disabled=(disabled)
+          Thread.current[DISABLE_KEY] = disabled
+        end
+
+        def disabled?
+          Thread.current[DISABLE_KEY] ||= false
+        end
 
-        # rubocop:disable Style/ExplicitBlockArgument
-        ElasticAPM::Spies::NetHTTPSpy.disable_in do
-          yield
+        def disable_in
+          self.disabled = true
+
+          begin
+            yield
+          ensure
+            self.disabled = false
+          end
         end
-        # rubocop:enable Style/ExplicitBlockArgument
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def install
-        ::Faraday::Connection.class_eval do
-          alias run_request_without_apm run_request
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def run_request(method, url, body, headers, &block)
+          unless (transaction = ElasticAPM.current_transaction)
+            return super(method, url, body, headers, &block)
+          end
 
-          def run_request(method, url, body, headers, &block)
-            unless (transaction = ElasticAPM.current_transaction)
-              return run_request_without_apm(method, url, body, headers, &block)
-            end
+          if ElasticAPM::Spies::FaradaySpy.disabled?
+            return super(method, url, body, headers, &block)
+          end
 
-            uri = URI(build_url(url))
+          uri = URI(build_url(url))
 
-            # If url is set inside block it isn't available until yield,
-            # so we temporarily build the request to yield. This could be a
-            # problem if the block has side effects as it will be yielded twice
-            # ~mikker
-            unless uri.host
-              tmp_request = build_request(method) do |req|
-                yield(req) if block_given?
-              end
-              uri = tmp_request.path && URI(tmp_request.path)
+          # If url is set inside block it isn't available until yield,
+          # so we temporarily build the request to yield. This could be a
+          # problem if the block has side effects as it will be yielded twice
+          # ~mikker
+          unless uri.host
+            tmp_request = build_request(method) do |req|
+              yield(req) if block_given?
             end
+            uri = tmp_request.path && URI(tmp_request.path)
+          end
 
-            host = uri&.host || 'localhost'
+          host = uri&.host || 'localhost'
 
-            upcased_method = method.to_s.upcase
+          upcased_method = method.to_s.upcase
 
-            if uri
-              destination = ElasticAPM::Span::Context::Destination.from_uri(uri)
+          if uri
+            destination = ElasticAPM::Span::Context::Destination.from_uri(uri, type: SUBTYPE)
 
-              context =
-                ElasticAPM::Span::Context.new(
-                  http: { url: uri, method: upcased_method },
-                  destination: destination
-                )
-            else
-              context =
-                ElasticAPM::Span::Context.new(http: { url: uri, method: upcased_method })
-            end
+            context =
+              ElasticAPM::Span::Context.new(
+                http: { url: uri, method: upcased_method },
+                destination: destination
+              )
+          else
+            context =
+              ElasticAPM::Span::Context.new(http: { url: uri, method: upcased_method })
+          end
+
+          context =
+            ElasticAPM::Span::Context.new(
+              http: { url: uri, method: upcased_method },
+              destination: destination
+            )
+
+          ElasticAPM.with_span(
+            "#{upcased_method} #{host}",
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            ElasticAPM::Spies.without_net_http do
+              trace_context = span&.trace_context || transaction.trace_context
+
+              result = super(method, url, body, headers) do |req|
+                trace_context.apply_headers { |k, v| req[k] = v }
+
+                yield req if block
+              end
 
-            ElasticAPM.with_span(
-              "#{upcased_method} #{host}",
-              TYPE,
-              subtype: SUBTYPE,
-              action: upcased_method,
-              context: context
-            ) do |span|
-              ElasticAPM::Spies::FaradaySpy.without_net_http do
-                trace_context = span&.trace_context || transaction.trace_context
-
-                result =
-                  run_request_without_apm(method, url, body, headers) do |req|
-                    trace_context.apply_headers { |k, v| req[k] = v }
-
-                    yield req if block_given?
-                  end
-
-                if (http = span&.context&.http)
-                  http.status_code = result.status.to_s
-                end
-
-                span&.outcome = Span::Outcome.from_http_status(result.status)
-                result
+              if (http = span&.context&.http)
+                http.status_code = result.status.to_s
               end
+
+              span&.outcome = Span::Outcome.from_http_status(result.status)
+              result
             end
           end
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      def install
+        ::Faraday::Connection.prepend(Ext)
+      end
     end
 
     register 'Faraday', 'faraday', FaradaySpy.new

data/lib/elastic_apm/spies/http.rb

@@ -22,51 +22,50 @@ module ElasticAPM
   module Spies
     # @api private
     class HTTPSpy
-      TYPE = 'ext'
-      SUBTYPE = 'http_rb'
-      def install
-        ::HTTP::Client.class_eval do
-          alias perform_without_apm perform
-
-          def perform(req, options)
-            unless (transaction = ElasticAPM.current_transaction)
-              return perform_without_apm(req, options)
-            end
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
-            method = req.verb.to_s.upcase
-            host = req.uri.host
+      # @api private
+      module Ext
+        def perform(req, options)
+          unless (transaction = ElasticAPM.current_transaction)
+            return super(req, options)
+          end
 
-            destination =
-              ElasticAPM::Span::Context::Destination.from_uri(req.uri)
-            context = ElasticAPM::Span::Context.new(
-              http: { url: req.uri, method: method },
-              destination: destination
-            )
+          method = req.verb.to_s.upcase
+          host = req.uri.host
 
-            name = "#{method} #{host}"
+          context = ElasticAPM::Span::Context.new(
+            http: { url: req.uri, method: method },
+            destination: ElasticAPM::Span::Context::Destination.from_uri(req.uri, type: SUBTYPE)
+          )
 
-            ElasticAPM.with_span(
-              name,
-              TYPE,
-              subtype: SUBTYPE,
-              action: method,
-              context: context
-            ) do |span|
-              trace_context = span&.trace_context || transaction.trace_context
-              trace_context.apply_headers { |key, value| req[key] = value }
+          name = "#{method} #{host}"
 
-              result = perform_without_apm(req, options)
+          ElasticAPM.with_span(
+            name,
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers { |key, value| req[key] = value }
 
-              if (http = span&.context&.http)
-                http.status_code = result.status.to_s
-              end
+            result = super(req, options)
 
-              span&.outcome = Span::Outcome.from_http_status(result.status)
-              result
+            if (http = span&.context&.http)
+              http.status_code = result.status.to_s
             end
+
+            span&.outcome = Span::Outcome.from_http_status(result.status)
+            result
           end
         end
       end
+
+      def install
+        ::HTTP::Client.prepend(Ext)
+      end
     end
 
     register 'HTTP', 'http', HTTPSpy.new

data/lib/elastic_apm/spies/mongo.rb

@@ -108,9 +108,11 @@ module ElasticAPM
               user: nil
             },
             destination: {
-              name: SUBTYPE,
-              resource: SUBTYPE,
-              type: TYPE
+              service: {
+                name: SUBTYPE,
+                resource: SUBTYPE,
+                type: TYPE
+              }
             }
           )
         end

data/lib/elastic_apm/spies/net_http.rb

@@ -22,17 +22,17 @@ module ElasticAPM
   module Spies
     # @api private
     class NetHTTPSpy
-      KEY = :__elastic_apm_net_http_disabled
-      TYPE = 'ext'
-      SUBTYPE = 'net_http'
+      DISABLE_KEY = :__elastic_apm_net_http_disabled
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
       class << self
         def disabled=(disabled)
-          Thread.current[KEY] = disabled
+          Thread.current[DISABLE_KEY] = disabled
         end
 
         def disabled?
-          Thread.current[KEY] ||= false
+          Thread.current[DISABLE_KEY] ||= false
         end
 
         def disable_in
@@ -46,65 +46,68 @@ module ElasticAPM
         end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      def install
-        Net::HTTP.class_eval do
-          alias request_without_apm request
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def request(req, body = nil, &block)
+          unless (transaction = ElasticAPM.current_transaction)
+            return super(req, body, &block)
+          end
 
-          def request(req, body = nil, &block)
-            unless (transaction = ElasticAPM.current_transaction)
-              return request_without_apm(req, body, &block)
-            end
+          if ElasticAPM::Spies::NetHTTPSpy.disabled?
+            return super(req, body, &block)
+          end
 
-            if ElasticAPM::Spies::NetHTTPSpy.disabled?
-              return request_without_apm(req, body, &block)
+          host = req['host']&.split(':')&.first || address || 'localhost'
+          method = req.method.to_s.upcase
+
+          uri_or_path = URI(req.path)
+
+          # Support the case where a whole url is passed as a path to a nil host
+          uri =
+            if uri_or_path.host
+              uri_or_path
+            else
+              path, query = req.path.split('?')
+              url = use_ssl? ? +'https://' : +'http://'
+              url << host
+              url << ":#{port}" if port
+              url << path
+              url << "?#{query}" if query
+              URI(url)
             end
 
-            host = req['host']&.split(':')&.first || address || 'localhost'
-            method = req.method.to_s.upcase
-            path, query = req.path.split('?')
-
-            url = use_ssl? ? +'https://' : +'http://'
-            url << host
-            url << ":#{port}" if port
-            url << path
-            url << "?#{query}" if query
-            uri = URI(url)
-
-            destination =
-              ElasticAPM::Span::Context::Destination.from_uri(uri)
-
-            context =
-              ElasticAPM::Span::Context.new(
-                http: { url: uri, method: method },
-                destination: destination
-              )
-
-            ElasticAPM.with_span(
-              "#{method} #{host}",
-              TYPE,
-              subtype: SUBTYPE,
-              action: method,
-              context: context
-            ) do |span|
-              trace_context = span&.trace_context || transaction.trace_context
-              trace_context.apply_headers { |key, value| req[key] = value }
-
-              result = request_without_apm(req, body, &block)
-
-              if (http = span&.context&.http)
-                http.status_code = result.code
-              end
-
-              span&.outcome = Span::Outcome.from_http_status(result.code)
-              result
+          context =
+            ElasticAPM::Span::Context.new(
+              http: { url: uri, method: method },
+              destination: ElasticAPM::Span::Context::Destination.from_uri(uri, type: SUBTYPE)
+            )
+
+          ElasticAPM.with_span(
+            "#{method} #{host}",
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers { |key, value| req[key] = value }
+
+            result = super(req, body, &block)
+
+            if (http = span&.context&.http)
+              http.status_code = result.code
             end
+
+            span&.outcome = Span::Outcome.from_http_status(result.code)
+            result
           end
         end
+        # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      end
+
+      def install
+        Net::HTTP.prepend(Ext)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
 
     register 'Net::HTTP', 'net/http', NetHTTPSpy.new