elastic-apm 3.15.1 → 4.2.0

data/lib/elastic_apm/spies/rake.rb

@@ -22,41 +22,43 @@ module ElasticAPM
   module Spies
     # @api private
     class RakeSpy
-      def install
-        ::Rake::Task.class_eval do
-          alias execute_without_apm execute
-
-          def execute(*args)
-            agent = ElasticAPM.start
-
-            unless agent && agent.config.instrumented_rake_tasks.include?(name)
-              return execute_without_apm(*args)
-            end
+      # @api private
+      module Ext
+        def execute(*args)
+          agent = ElasticAPM.start
 
-            transaction =
-              ElasticAPM.start_transaction("Rake::Task[#{name}]", 'Rake')
+          unless agent && agent.config.instrumented_rake_tasks.include?(name)
+            return super(*args)
+          end
 
-            begin
-              result = execute_without_apm(*args)
+          transaction =
+            ElasticAPM.start_transaction("Rake::Task[#{name}]", 'Rake')
 
-              transaction&.result = 'success'
-              transaction&.outcome = Transaction::Outcome::SUCCESS
-            rescue StandardError => e
-              transaction&.result = 'error'
-              transaction&.outcome = Transaction::Outcome::FAILURE
-              ElasticAPM.report(e)
+          begin
+            result = super(*args)
 
-              raise
-            ensure
-              ElasticAPM.end_transaction
-              ElasticAPM.stop
-            end
+            transaction&.result = 'success'
+            transaction&.outcome = Transaction::Outcome::SUCCESS
+          rescue StandardError => e
+            transaction&.result = 'error'
+            transaction&.outcome = Transaction::Outcome::FAILURE
+            ElasticAPM.report(e)
 
-            result
+            raise
+          ensure
+            ElasticAPM.end_transaction
+            ElasticAPM.stop
           end
+
+          result
         end
       end
+
+      def install
+        ::Rake::Task.prepend(Ext)
+      end
     end
+
     register 'Rake::Task', 'rake', RakeSpy.new
   end
 end

data/lib/elastic_apm/spies/redis.rb

@@ -22,21 +22,22 @@ module ElasticAPM
   module Spies
     # @api private
     class RedisSpy
-      def install
-        ::Redis::Client.class_eval do
-          alias call_without_apm call
-
-          def call(command, &block)
-            name = command[0].upcase
+      # @api private
+      module Ext
+        def call(command, &block)
+          name = command[0].upcase
 
-            return call_without_apm(command, &block) if command[0] == :auth
+          return super(command, &block) if command[0] == :auth
 
-            ElasticAPM.with_span(name.to_s, 'db.redis') do
-              call_without_apm(command, &block)
-            end
+          ElasticAPM.with_span(name.to_s, 'db.redis') do
+            super(command, &block)
           end
         end
       end
+
+      def install
+        ::Redis::Client.prepend(Ext)
+      end
     end
 
     register 'Redis', 'redis', RedisSpy.new

data/lib/elastic_apm/spies/resque.rb

@@ -24,29 +24,26 @@ module ElasticAPM
     class ResqueSpy
       TYPE = 'Resque'
 
-      def install
-        install_perform_spy
+      # @api private
+      module Ext
+        def perform
+          name = @payload && @payload['class']&.to_s
+          transaction = ElasticAPM.start_transaction(name, TYPE)
+          super
+          transaction&.done 'success'
+          transaction&.outcome = Transaction::Outcome::SUCCESS
+        rescue ::Exception => e
+          ElasticAPM.report(e, handled: false)
+          transaction&.done 'error'
+          transaction&.outcome = Transaction::Outcome::FAILURE
+          raise
+        ensure
+          ElasticAPM.end_transaction
+        end
       end
 
-      def install_perform_spy
-        ::Resque::Job.class_eval do
-          alias :perform_without_elastic_apm :perform
-
-          def perform
-            name = @payload && @payload['class']&.to_s
-            transaction = ElasticAPM.start_transaction(name, TYPE)
-            perform_without_elastic_apm
-            transaction&.done 'success'
-            transaction&.outcome = Transaction::Outcome::SUCCESS
-          rescue ::Exception => e
-            ElasticAPM.report(e, handled: false)
-            transaction&.done 'error'
-            transaction&.outcome = Transaction::Outcome::FAILURE
-            raise
-          ensure
-            ElasticAPM.end_transaction
-          end
-        end
+      def install
+        ::Resque::Job.prepend(Ext)
       end
     end
 

data/lib/elastic_apm/spies/s3.rb

@@ -14,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-
+#
 # frozen_string_literal: true
 
 module ElasticAPM
@@ -76,24 +76,20 @@ module ElasticAPM
       end
 
 
-      def install
-        ::Aws::S3::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 = {}, &block|
               bucket_name = ElasticAPM::Spies::S3Spy.bucket_name(params)
-              cloud = ElasticAPM::Span::Context::Destination::Cloud.new(
-                region: ElasticAPM::Spies::S3Spy.accesspoint_region(params) || config.region
-              )
+              region = ElasticAPM::Spies::S3Spy.accesspoint_region(params) || config.region
 
+              resource = "#{SUBTYPE}/#{bucket_name || 'unknown-bucket'}"
               context = ElasticAPM::Span::Context.new(
                 destination: {
-                  cloud: cloud,
-                  resource: bucket_name,
-                  type: TYPE,
-                  name: SUBTYPE
+                  service: { resource: resource },
+                  cloud: { region: region }
                 }
               )
 
@@ -105,14 +101,17 @@ module ElasticAPM
                 context: context
               ) do
                 ElasticAPM::Spies::S3Spy.without_net_http do
-                  original_method = method("#{operation_name}_without_apm")
-                  original_method.call(params, options, &block)
+                  super(params, options, &block)
                 end
               end
             end
           end
         end
       end
+
+      def install
+        ::Aws::S3::Client.prepend(Ext)
+      end
     end
 
     register(

data/lib/elastic_apm/spies/sequel.rb

@@ -17,7 +17,7 @@
 
 # frozen_string_literal: true
 
-require 'elastic_apm/sql'
+require 'elastic_apm/sql/signature'
 
 module ElasticAPM
   # @api private
@@ -28,64 +28,58 @@ module ElasticAPM
       ACTION = 'query'
 
       def self.summarizer
-        @summarizer ||= Sql.summarizer
+        @summarizer ||= Sql::Signature::Summarizer.new
       end
 
-      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      def install
-        require 'sequel/database/logging'
-
-        ::Sequel::Database.class_eval do
-          alias log_connection_yield_without_apm log_connection_yield
-
-          def log_connection_yield(sql, connection, args = nil, &block)
-            unless ElasticAPM.current_transaction
-              return log_connection_yield_without_apm(
-                sql, connection, args, &block
-              )
-            end
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def log_connection_yield(sql, connection, args = nil, &block)
+          unless ElasticAPM.current_transaction
+            return super(sql, connection, args, &block)
+          end
 
-            subtype = database_type.to_s
+          subtype = database_type.to_s
 
-            name =
-              ElasticAPM::Spies::SequelSpy.summarizer.summarize sql
+          name =
+            ElasticAPM::Spies::SequelSpy.summarizer.summarize sql
 
-            context = ElasticAPM::Span::Context.new(
-              db: { statement: sql, type: 'sql', user: opts[:user] },
-              destination: { name: subtype, resource: subtype, type: TYPE }
-            )
+          context = ElasticAPM::Span::Context.new(
+            db: { statement: sql, type: 'sql', user: opts[:user] },
+            destination: { service: { resource: subtype } }
+          )
 
-            span = ElasticAPM.start_span(
-              name,
-              TYPE,
-              subtype: subtype,
-              action: ACTION,
-              context: context
-            )
-            log_connection_yield_without_apm(
-              sql,
-              connection,
-              args,
-              &block
-            ).tap do |result|
-              if name =~ /^(UPDATE|DELETE)/
-                if connection.respond_to?(:changes)
-                  span.context.db.rows_affected = connection.changes
-                elsif result.is_a?(Integer)
-                  span.context.db.rows_affected = result
-                end
+          span = ElasticAPM.start_span(
+            name,
+            TYPE,
+            subtype: subtype,
+            action: ACTION,
+            context: context
+          )
+          super(sql, connection, args, &block).tap do |result|
+            if /^(UPDATE|DELETE)/.match?(name)
+              if connection.respond_to?(:changes)
+                span.context.db.rows_affected = connection.changes
+              elsif result.is_a?(Integer)
+                span.context.db.rows_affected = result
               end
             end
-          rescue
-            span&.outcome = Span::Outcome::FAILURE
-            raise
-          ensure
-            span&.outcome ||= Span::Outcome::SUCCESS
-            ElasticAPM.end_span
           end
+        rescue
+          span&.outcome = Span::Outcome::FAILURE
+          raise
+        ensure
+          span&.outcome ||= Span::Outcome::SUCCESS
+          ElasticAPM.end_span
         end
+        # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      end
+
+      def install
+        require 'sequel/database/logging'
+
+        ::Sequel::Database.prepend(Ext)
       end
-      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
     end
 
     register 'Sequel', 'sequel', SequelSpy.new

data/lib/elastic_apm/spies/sidekiq.rb

@@ -65,34 +65,32 @@ module ElasticAPM
         end
       end
 
-      def install_processor
-        require 'sidekiq/processor'
-
-        Sidekiq::Processor.class_eval do
-          alias start_without_apm start
-          alias terminate_without_apm terminate
-
-          def start
-            result = start_without_apm
-
+      # @api private
+      module Ext
+        def start
+          super.tap do
             # Already running from Railtie if Rails
             if ElasticAPM.running?
               ElasticAPM.agent.config.logger = Sidekiq.logger
             else
               ElasticAPM.start
             end
-
-            result
           end
+        end
 
-          def terminate
-            terminate_without_apm
-
+        def terminate
+          super.tap do
             ElasticAPM.stop
           end
         end
       end
 
+      def install_processor
+        require 'sidekiq/processor'
+
+        Sidekiq::Processor.prepend(Ext)
+      end
+
       def install
         install_processor
         install_middleware

data/lib/elastic_apm/spies/sinatra.rb

@@ -22,35 +22,34 @@ module ElasticAPM
   module Spies
     # @api private
     class SinatraSpy
-      def install
-        ::Sinatra::Base.class_eval do
-          alias dispatch_without_apm! dispatch!
-          alias compile_template_without_apm compile_template
-
-          def dispatch!(*args, &block)
-            dispatch_without_apm!(*args, &block).tap do
-              next unless (transaction = ElasticAPM.current_transaction)
-              next unless (route = env['sinatra.route'])
-
-              transaction.name = route
-            end
+      # @api private
+      module Ext
+        def dispatch!(*args, &block)
+          super(*args, &block).tap do
+            next unless (transaction = ElasticAPM.current_transaction)
+            next unless (route = env['sinatra.route'])
+
+            transaction.name = route
           end
+        end
 
-          def compile_template(engine, data, opts, *args, &block)
-            opts[:__elastic_apm_template_name] =
-              case data
-              when Symbol then data.to_s
-              else format('Inline %s', engine)
-              end
+        def compile_template(engine, data, opts, *args, &block)
+          opts[:__elastic_apm_template_name] =
+            case data
+            when Symbol then data.to_s
+            else format('Inline %s', engine)
+            end
 
-            compile_template_without_apm(engine, data, opts, *args, &block)
-          end
+          super(engine, data, opts, *args, &block)
         end
       end
+
+      def install
+        ::Sinatra::Base.prepend(Ext)
+      end
     end
 
     register 'Sinatra::Base', 'sinatra/base', SinatraSpy.new
-
     require 'elastic_apm/spies/tilt'
   end
 end

data/lib/elastic_apm/spies/sns.rb

@@ -39,7 +39,7 @@ module ElasticAPM
 
       def self.get_topic(params)
         return '<PHONE_NUMBER>' if params[:phone_number]
-        
+
         last_after_slash_or_colon(
           params[:topic_arn] || params[:target_arn]
         )
@@ -64,62 +64,57 @@ module ElasticAPM
       end
 
       def self.span_context(topic, region)
-        cloud = ElasticAPM::Span::Context::Destination::Cloud.new(region: region)
-
         ElasticAPM::Span::Context.new(
-          message: {
-            queue_name: topic
-          },
+          message: { queue_name: topic },
           destination: {
-            resource: [SUBTYPE, topic].compact.join('/'),
-            type: TYPE,
-            name: SUBTYPE,
-            cloud: cloud
+            service: { resource: "#{SUBTYPE}/#{topic}" },
+            cloud: { region: region }
           }
         )
       end
 
-      def install
-        ::Aws::SNS::Client.class_eval do
-          alias :publish_without_apm :publish
+      # @api private
+      module Ext
+        def publish(params = {}, options = {})
+          unless (transaction = ElasticAPM.current_transaction)
+            return super(params, options)
+          end
 
-          def publish(params = {}, options = {})
-            unless (transaction = ElasticAPM.current_transaction)
-              return publish_without_apm(params, options)
+          topic = ElasticAPM::Spies::SNSSpy.get_topic(params)
+          span_name = topic ? "SNS PUBLISH to #{topic}" : 'SNS PUBLISH'
+          region = ElasticAPM::Spies::SNSSpy.arn_region(
+            params[:topic_arn] || params[:target_arn]
+          )
+          context = ElasticAPM::Spies::SNSSpy.span_context(
+            topic,
+            region || config.region
+          )
+
+          ElasticAPM.with_span(
+            span_name,
+            TYPE,
+            subtype: SUBTYPE,
+            action: 'publish',
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers do |key, value|
+              params[:message_attributes] ||= {}
+              params[:message_attributes][key] ||= {}
+              params[:message_attributes][key][:string_value] = value
+              params[:message_attributes][key][:data_type] = 'String'
             end
 
-            topic = ElasticAPM::Spies::SNSSpy.get_topic(params)
-            span_name = topic ? "SNS PUBLISH to #{topic}" : 'SNS PUBLISH'
-            region = ElasticAPM::Spies::SNSSpy.arn_region(
-              params[:topic_arn] || params[:target_arn]
-            )
-            context = ElasticAPM::Spies::SNSSpy.span_context(
-              topic,
-              region || config.region
-            )
-
-            ElasticAPM.with_span(
-              span_name,
-              TYPE,
-              subtype: SUBTYPE,
-              action: 'publish',
-              context: context
-            ) do |span|
-              trace_context = span&.trace_context || transaction.trace_context
-              trace_context.apply_headers do |key, value|
-                params[:message_attributes] ||= {}
-                params[:message_attributes][key] ||= {}
-                params[:message_attributes][key][:string_value] = value
-                params[:message_attributes][key][:data_type] = 'String'
-              end
-
-              ElasticAPM::Spies::SNSSpy.without_net_http do
-                publish_without_apm(params, options)
-              end
+            ElasticAPM::Spies::SNSSpy.without_net_http do
+              super(params, options)
             end
           end
         end
       end
+
+      def install
+        ::Aws::SNS::Client.prepend(Ext)
+      end
     end
 
     register(