instana 1.192.1 → 1.193.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1671f39523faeeea826d7892820992a88ffbb3f923fb20b3c19c082dc281480a
-  data.tar.gz: a6f70177f02c753830fea6075556a70cd4c3ccd30e083d0e316f638396ea6c44
+  metadata.gz: 26ea11d0efe2f26610441700b71bc9c2abd4192566a86d00089d1e889d8457d3
+  data.tar.gz: 5dde944418b1f34391c08114692b4f34d27acc8328e0d7bd47c7b14834e21d61
 SHA512:
-  metadata.gz: be7333bc5dab3edff9342fd0f6a311b45df11a2fd58c9f61153e32fa3f638ac359a750365204655b6933dac90259e991fb1bddd9b9214f1d7f3fe62159c0d69b
-  data.tar.gz: bdc9a0ee62692ff327a849732508cf6656b76d24206528d8120830b764b2968bf040a1d93f9735f7004c1e2104c8e394f8c68834a91e1e3eaf3a2861247b295c
+  metadata.gz: 11c700d01ab267b978d527dd9fcc993b5ae19bb659074690ced25b12f34d1b58c850c241776b3c8932a274138170d885e7f9a0c28b430bc382a81c0df3b99451
+  data.tar.gz: 8e4dd40a1d9f87e00905eca337189870f3e8237ce33b3be80853d85e7b11667243fe1e5ca7c6e126b492e0c2ba5d404257bfa908e50984f40d184a65f1067239

data/lib/instana/frameworks/instrumentation/abstract_mysql_adapter.rb

@@ -6,10 +6,8 @@ module Instana
 
       # This module supports instrumenting ActiveRecord with the mysql2 adapter.
       #
-      def self.included(klass)
+      def self.prepended(klass)
         if ActiveRecord::VERSION::STRING >= '3.2'
-          Instana::Util.method_alias(klass, :execute)
-
           @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
         end
       end
@@ -40,17 +38,17 @@ module Instana
         IGNORED_PAYLOADS.include?(name) || sql !~ EXPLAINED_SQLS
       end
 
-      def execute_with_instana(sql, name = nil)
+      def execute(sql, name = nil)
         tracing = ::Instana.tracer.tracing?
         if !tracing || ignore_payload?(name, sql)
-          return execute_without_instana(sql, name)
+          return super(sql, name)
         elsif ::Instana.tracer.current_span[:n] == :activerecord
-          return execute_without_instana(sql, name)
+          return super(sql, name)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          execute_without_instana(sql, name)
+          super(sql, name)
         end
       end
     end

data/lib/instana/frameworks/instrumentation/action_view.rb

@@ -1,18 +1,13 @@
 module Instana
   module Instrumentation
     module ActionViewRenderer
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :render_partial)
-        ::Instana::Util.method_alias(klass, :render_collection)
-      end
-
-      def render_partial_with_instana(*args)
+      def render_partial(*args)
         kv_payload = { :render => {} }
         kv_payload[:render][:type] = :partial
         kv_payload[:render][:name] = @options[:partial].to_s if @options.is_a?(Hash)
 
         ::Instana.tracer.log_entry(:render, kv_payload)
-        render_partial_without_instana(*args)
+        super(*args)
       rescue Exception => e
         ::Instana.tracer.log_error(e)
         raise
@@ -20,13 +15,14 @@ module Instana
         ::Instana.tracer.log_exit(:render)
       end
 
-      def render_collection_with_instana(*args)
+      def render_collection(*args)
+        puts 'called'
         kv_payload = { :render => {} }
         kv_payload[:render][:type] = :collection
         kv_payload[:render][:name] = @path.to_s
 
         ::Instana.tracer.log_entry(:render, kv_payload)
-        render_collection_without_instana(*args)
+        super(*args)
       rescue Exception => e
         ::Instana.tracer.log_error(e)
         raise
@@ -39,5 +35,5 @@ end
 
 if defined?(::ActionView) && ::Instana.config[:action_view][:enabled] && ::ActionPack::VERSION::STRING >= '3.1'
   ::Instana.logger.debug "Instrumenting ActionView"
-  ::ActionView::PartialRenderer.send(:include, ::Instana::Instrumentation::ActionViewRenderer)
+  ::ActionView::PartialRenderer.send(:prepend, ::Instana::Instrumentation::ActionViewRenderer)
 end

data/lib/instana/frameworks/instrumentation/active_record.rb

@@ -9,19 +9,19 @@ if defined?(::ActiveRecord) && ::Instana.config[:active_record][:enabled]
   # Mysql
   if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
     ::Instana.logger.debug "Instrumenting ActiveRecord (mysql)"
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, ::Instana::Instrumentation::MysqlAdapter)
-    ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:include, ::Instana::Instrumentation::AbstractMysqlAdapter)
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:prepend, ::Instana::Instrumentation::MysqlAdapter)
+    ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:prepend, ::Instana::Instrumentation::AbstractMysqlAdapter)
   end
 
   # Mysql2
   if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
     ::Instana.logger.debug "Instrumenting ActiveRecord (mysql2)"
-    ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include, ::Instana::Instrumentation::Mysql2Adapter)
+    ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:prepend, ::Instana::Instrumentation::Mysql2Adapter)
   end
 
   # Postgres
   if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
     ::Instana.logger.debug "Instrumenting ActiveRecord (postgresql)"
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, ::Instana::Instrumentation::PostgreSQLAdapter)
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:prepend, ::Instana::Instrumentation::PostgreSQLAdapter)
   end
 end

data/lib/instana/frameworks/instrumentation/mysql2_adapter.rb

@@ -6,13 +6,9 @@ module Instana
 
       # This module supports instrumenting ActiveRecord with the mysql2 adapter.
       #
-      def self.included(klass)
+      def self.prepended(klass)
         # ActiveRecord 3.1 and up only (for now possibly)
         if ActiveRecord::VERSION::STRING > '3.0'
-          Instana::Util.method_alias(klass, :exec_delete)
-          Instana::Util.method_alias(klass, :exec_insert)
-          Instana::Util.method_alias(klass, :exec_query)
-
           @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
         end
       end
@@ -49,37 +45,37 @@ module Instana
         IGNORED_PAYLOADS.include?(name) || sql !~ EXPLAINED_SQLS
       end
 
-      def exec_delete_with_instana(sql, name = nil, binds = [])
+      def exec_delete(sql, name = nil, binds = [])
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
-          return exec_delete_without_instana(sql, name, binds)
+          return super(sql, name, binds)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_delete_without_instana(sql, name, binds)
+          super(sql, name, binds)
         end
       end
 
-      def exec_insert_with_instana(sql, name = 'SQL', binds = [], *args)
+      def exec_insert(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
-          return exec_insert_without_instana(sql, name, binds, *args)
+          return super(sql, name, binds, *args)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_insert_without_instana(sql, name, binds, *args)
+          super(sql, name, binds, *args)
         end
       end
 
-      def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
+      def exec_query(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql) ||
             ::Instana.tracer.current_span[:n] == :activerecord
-          return exec_query_without_instana(sql, name, binds, *args)
+          return super(sql, name, binds, *args)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_query_without_instana(sql, name, binds, *args)
+          super(sql, name, binds, *args)
         end
       end
     end

data/lib/instana/frameworks/instrumentation/mysql_adapter.rb

@@ -6,10 +6,8 @@ module Instana
 
       # This module supports instrumenting ActiveRecord with the mysql2 adapter.
       #
-      def self.included(klass)
+      def self.prepended(klass)
         if ActiveRecord::VERSION::STRING >= '3.2'
-          Instana::Util.method_alias(klass, :exec_query)
-
           @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
         end
       end
@@ -46,15 +44,15 @@ module Instana
         IGNORED_PAYLOADS.include?(name) || sql !~ EXPLAINED_SQLS
       end
 
-      def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
+      def exec_query(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql) ||
             ::Instana.tracer.current_span[:n] == :activerecord
-          return exec_query_without_instana(sql, name, binds, *args)
+          return super(sql, name, binds, *args)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_query_without_instana(sql, name, binds, *args)
+          super(sql, name, binds, *args)
         end
       end
     end

data/lib/instana/frameworks/instrumentation/postgresql_adapter.rb

@@ -8,15 +8,11 @@ module Instana
       # This module supports instrumenting ActiveRecord with the postgresql adapter.  Only
       # versions >= 3.1 are supported.
       #
-      def self.included(klass)
+      def self.prepended(klass)
         if (::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR > 0) ||
              ::ActiveRecord::VERSION::MAJOR >= 4
 
           # ActiveRecord 3.1 and up
-          Instana::Util.method_alias(klass, :exec_query)
-          Instana::Util.method_alias(klass, :exec_delete)
-          Instana::Util.method_alias(klass, :execute)
-
           @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
         end
       end
@@ -66,36 +62,36 @@ module Instana
         IGNORED_PAYLOADS.include?(name) || IGNORED_SQL.include?(sql)
       end
 
-      def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
+      def exec_query(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
-          return exec_query_without_instana(sql, name, binds, *args)
+          return super(sql, name, binds, *args)
         end
 
         kv_payload = collect(sql, binds)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_query_without_instana(sql, name, binds, *args)
+          super(sql, name, binds, *args)
         end
       end
 
-      def exec_delete_with_instana(sql, name = nil, binds = [])
+      def exec_delete(sql, name = nil, binds = [])
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
-          return exec_delete_without_instana(sql, name, binds)
+          return super(sql, name, binds)
         end
 
         kv_payload = collect(sql, binds)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          exec_delete_without_instana(sql, name, binds)
+          super(sql, name, binds)
         end
       end
 
-      def execute_with_instana(sql, name = nil)
+      def execute(sql, name = nil)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
-          return execute_without_instana(sql, name)
+          return super(sql, name)
         end
 
         kv_payload = collect(sql)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
-          execute_without_instana(sql, name)
+          super(sql, name)
         end
       end
     end

data/lib/instana/instrumentation/dalli.rb

@@ -1,15 +1,10 @@
 module Instana
   module Instrumentation
     module Dalli
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :perform)
-        ::Instana::Util.method_alias(klass, :get_multi)
-      end
-
-      def perform_with_instana(*args, &blk)
+      def perform(*args, &blk)
         if !::Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:memcache)
           do_skip = true
-          return perform_without_instana(*args, &blk)
+          return super(*args, &blk)
         end
 
         op, key, *_opts = args
@@ -22,7 +17,7 @@ module Instana
         ::Instana.tracer.log_entry(:memcache, entry_payload)
         exit_payload = { :memcache => {} }
 
-        result = perform_without_instana(*args, &blk)
+        result = super(*args, &blk)
 
         if op == :get
           exit_payload[:memcache][:hit] = result ? 1 : 0
@@ -36,7 +31,7 @@ module Instana
         ::Instana.tracer.log_exit(:memcache, exit_payload) unless do_skip
       end
 
-      def get_multi_with_instana(*keys)
+      def get_multi(*keys)
         entry_payload = { :memcache => {} }
         entry_payload[:memcache][:namespace] = @options[:namespace] if @options.key?(:namespace)
         entry_payload[:memcache][:command] = :get_multi
@@ -45,7 +40,7 @@ module Instana
         ::Instana.tracer.log_entry(:memcache, entry_payload)
         exit_payload = { :memcache => {} }
 
-        result = get_multi_without_instana(*keys)
+        result = super(*keys)
 
         exit_payload[:memcache][:hits] = result.length
         result
@@ -63,13 +58,13 @@ module Instana
         ::Instana::Util.method_alias(klass, :request)
       end
 
-      def request_with_instana(op, *args)
+      def request(op, *args)
         if ::Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:memcache)
           info_payload = { :memcache => {} }
           info_payload[:memcache][:server] = "#{@hostname}:#{@port}"
           ::Instana.tracer.log_info(info_payload)
         end
-        request_without_instana(op, *args)
+        super(op, *args)
       end
     end
   end
@@ -77,6 +72,6 @@ end
 
 if defined?(::Dalli) && ::Instana.config[:dalli][:enabled]
   ::Instana.logger.debug "Instrumenting Dalli"
-  ::Dalli::Client.send(:include, ::Instana::Instrumentation::Dalli)
-  ::Dalli::Server.send(:include, ::Instana::Instrumentation::DalliServer)
+  ::Dalli::Client.send(:prepend, ::Instana::Instrumentation::Dalli)
+  ::Dalli::Server.send(:prepend, ::Instana::Instrumentation::DalliServer)
 end

data/lib/instana/instrumentation/grpc.rb

@@ -1,84 +1,94 @@
 call_types = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
 
 if defined?(GRPC::ActiveCall) && ::Instana.config[:grpc][:enabled]
-  call_types.each do |call_type|
-    GRPC::ClientStub.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def #{call_type}_with_instana(method, *others, **options)
-        kvs = { rpc: {} }
+  module Instana
+    module GRPCCientInstrumentation
+      CALL_TYPES = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
 
-        unless ::Instana.tracer.tracing?
-          return #{call_type}_without_instana(method, *others, **options)
-        end
+      CALL_TYPES.each do |call_type|
+        define_method(call_type) do |method, *others, **options|
+          begin
+            kvs = { rpc: {} }
 
-        kvs[:rpc][:flavor] = :grpc
-        kvs[:rpc][:host] = @host
-        kvs[:rpc][:call] = method
-        kvs[:rpc][:call_type] = :#{call_type}
+            unless ::Instana.tracer.tracing?
+              return super(method, *others, **options)
+            end
 
-        ::Instana.tracer.log_entry(:'rpc-client', kvs)
+            kvs[:rpc][:flavor] = :grpc
+            kvs[:rpc][:host] = @host
+            kvs[:rpc][:call] = method
+            kvs[:rpc][:call_type] = call_type
 
-        context = ::Instana.tracer.context
-        if context
-          options[:metadata] = (options[:metadata] || {}).merge(
-            'x-instana-t' => context.trace_id_header,
-            'x-instana-s' => context.span_id_header
-          )
-        end
+            ::Instana.tracer.log_entry(:'rpc-client', kvs)
 
-        #{call_type}_without_instana(method, *others, **options)
-      rescue => e
-        kvs[:rpc][:error] = true
-        ::Instana.tracer.log_info(kvs)
-        ::Instana.tracer.log_error(e)
-        raise
-      ensure
-        ::Instana.tracer.log_exit(:'rpc-client', {})
-      end
+            context = ::Instana.tracer.context
+            if context
+              options[:metadata] = (options[:metadata] || {}).merge(
+                'x-instana-t' => context.trace_id_header,
+                'x-instana-s' => context.span_id_header
+              )
+            end
 
-      alias #{call_type}_without_instana #{call_type}
-      alias #{call_type} #{call_type}_with_instana
-    RUBY
+            super(method, *others, **options)
+          rescue => e
+            kvs[:rpc][:error] = true
+            ::Instana.tracer.log_info(kvs)
+            ::Instana.tracer.log_error(e)
+            raise
+          ensure
+            ::Instana.tracer.log_exit(:'rpc-client', {})
+          end
+        end
+      end
+    end
   end
+
   ::Instana.logger.debug 'Instrumenting GRPC client'
+  ::GRPC::ClientStub.prepend(::Instana::GRPCCientInstrumentation)
 end
 
 if defined?(GRPC::RpcDesc) && ::Instana.config[:grpc][:enabled]
-  call_types.each do |call_type|
-    GRPC::RpcDesc.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def handle_#{call_type}_with_instana(active_call, mth, *others)
-        kvs = { rpc: {} }
-        metadata = active_call.metadata
+  module Instana
+    module GRPCServerInstrumentation
+      CALL_TYPES = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
 
-        incoming_context = {}
-        if metadata.key?('x-instana-t')
-          incoming_context[:trace_id]  = ::Instana::Util.header_to_id(metadata['x-instana-t'])
-          incoming_context[:span_id]   = ::Instana::Util.header_to_id(metadata['x-instana-s']) if metadata.key?('x-instana-s')
-          incoming_context[:level]     = metadata['x-instana-l'] if metadata.key?('x-instana-l')
-        end
+      CALL_TYPES.each do |call_type|
+        define_method(:"handle_#{call_type}") do |active_call, mth, *others|
+          begin
+            kvs = { rpc: {} }
+            metadata = active_call.metadata
 
-        kvs[:rpc][:flavor] = :grpc
-        kvs[:rpc][:host] = Socket.gethostname
-        kvs[:rpc][:call] = "/\#{mth.owner.service_name}/\#{name}"
-        kvs[:rpc][:call_type] = :#{call_type}
-        kvs[:rpc][:peer] = { address: active_call.peer }
+            incoming_context = {}
+            if metadata.key?('x-instana-t')
+              incoming_context[:trace_id]  = ::Instana::Util.header_to_id(metadata['x-instana-t'])
+              incoming_context[:span_id]   = ::Instana::Util.header_to_id(metadata['x-instana-s']) if metadata.key?('x-instana-s')
+              incoming_context[:level]     = metadata['x-instana-l'] if metadata.key?('x-instana-l')
+            end
 
-        ::Instana.tracer.log_start_or_continue(
-          :'rpc-server', kvs, incoming_context
-        )
+            kvs[:rpc][:flavor] = :grpc
+            kvs[:rpc][:host] = Socket.gethostname
+            kvs[:rpc][:call] = "/#{mth.owner.service_name}/#{name}"
+            kvs[:rpc][:call_type] = call_type
+            kvs[:rpc][:peer] = { address: active_call.peer }
 
-        handle_#{call_type}_without_instana(active_call, mth, *others)
-      rescue => e
-        kvs[:rpc][:error] = true
-        ::Instana.tracer.log_info(kvs)
-        ::Instana.tracer.log_error(e)
-        raise
-      ensure
-        ::Instana.tracer.log_end(:'rpc-server', {}) if ::Instana.tracer.tracing?
-      end
+            ::Instana.tracer.log_start_or_continue(
+              :'rpc-server', kvs, incoming_context
+            )
 
-      alias handle_#{call_type}_without_instana handle_#{call_type}
-      alias handle_#{call_type} handle_#{call_type}_with_instana
-    RUBY
+            super(active_call, mth, *others)
+          rescue => e
+            kvs[:rpc][:error] = true
+            ::Instana.tracer.log_info(kvs)
+            ::Instana.tracer.log_error(e)
+            raise
+          ensure
+            ::Instana.tracer.log_end(:'rpc-server', {}) if ::Instana.tracer.tracing?
+          end
+        end
+      end
+    end
   end
+
   ::Instana.logger.debug 'Instrumenting GRPC server'
+  ::GRPC::RpcDesc.prepend(::Instana::GRPCServerInstrumentation)
 end

data/lib/instana/instrumentation/net-http.rb

@@ -1,61 +1,60 @@
 require 'net/http'
 
 if defined?(::Net::HTTP) && ::Instana.config[:nethttp][:enabled]
-  Net::HTTP.class_eval {
-
-    def request_with_instana(*args, &block)
-      if !Instana.tracer.tracing? || !started?
-        do_skip = true
-        return request_without_instana(*args, &block)
-      end
+  module Instana
+    module NetHTTPInstrumentation
+      def request(*args, &block)
+        if !Instana.tracer.tracing? || !started?
+          do_skip = true
+          return super(*args, &block)
+        end
 
-      ::Instana.tracer.log_entry(:'net-http')
+        ::Instana.tracer.log_entry(:'net-http')
 
-      # Send out the tracing context with the request
-      request = args[0]
+        # Send out the tracing context with the request
+        request = args[0]
 
-      # Set request headers; encode IDs as hexadecimal strings
-      t_context = ::Instana.tracer.context
-      request['X-Instana-T'] = t_context.trace_id_header
-      request['X-Instana-S'] = t_context.span_id_header
+        # Set request headers; encode IDs as hexadecimal strings
+        t_context = ::Instana.tracer.context
+        request['X-Instana-T'] = t_context.trace_id_header
+        request['X-Instana-S'] = t_context.span_id_header
 
-      # Collect up KV info now in case any exception is raised
-      kv_payload = { :http => {} }
-      kv_payload[:http][:method] = request.method
+        # Collect up KV info now in case any exception is raised
+        kv_payload = { :http => {} }
+        kv_payload[:http][:method] = request.method
 
-      if request.uri
-        kv_payload[:http][:url] = request.uri.to_s
-      else
-        if use_ssl?
-          kv_payload[:http][:url] = "https://#{@address}:#{@port}#{request.path}"
+        if request.uri
+          kv_payload[:http][:url] = request.uri.to_s
         else
-          kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
+          if use_ssl?
+            kv_payload[:http][:url] = "https://#{@address}:#{@port}#{request.path}"
+          else
+            kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
+          end
         end
-      end
-      
-      kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
 
-      # The core call
-      response = request_without_instana(*args, &block)
+        kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
 
-      kv_payload[:http][:status] = response.code
-      if response.code.to_i.between?(500, 511)
-        # Because of the 5xx response, we flag this span as errored but
-        # without a backtrace (no exception)
-        ::Instana.tracer.log_error(nil)
-      end
+        # The core call
+        response = super(*args, &block)
 
-      response
-    rescue => e
-      ::Instana.tracer.log_error(e)
-      raise
-    ensure
-      ::Instana.tracer.log_exit(:'net-http', kv_payload) unless do_skip
-    end
+        kv_payload[:http][:status] = response.code
+        if response.code.to_i.between?(500, 511)
+          # Because of the 5xx response, we flag this span as errored but
+          # without a backtrace (no exception)
+          ::Instana.tracer.log_error(nil)
+        end
 
-    ::Instana.logger.debug "Instrumenting Net::HTTP"
+        response
+      rescue => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:'net-http', kv_payload) unless do_skip
+      end
+    end
+  end
 
-    alias request_without_instana request
-    alias request request_with_instana
-  }
+  ::Instana.logger.debug "Instrumenting Net::HTTP"
+  Net::HTTP.prepend(::Instana::NetHTTPInstrumentation)
 end

data/lib/instana/instrumentation/redis.rb

@@ -1,11 +1,11 @@
-if defined?(::Redis) && ::Instana.config[:redis][:enabled]
-  ::Redis::Client.class_eval do
-    def call_with_instana(*args, &block)
+module Instana
+  module RedisInstrumentation
+    def call(*args, &block)
       kv_payload = { redis: {} }
       dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
-        return call_without_instana(*args, &block)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name) || !Instana.config[:redis][:enabled]
+        return super(*args, &block)
       end
 
       begin
@@ -19,7 +19,7 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
           nil
         end
 
-        call_without_instana(*args, &block)
+        super(*args, &block)
       rescue => e
         ::Instana.tracer.log_info({ redis: {error: true} })
         ::Instana.tracer.log_error(e)
@@ -29,17 +29,12 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
       end
     end
 
-    ::Instana.logger.debug "Instrumenting Redis"
-
-    alias call_without_instana call
-    alias call call_with_instana
-
-    def call_pipeline_with_instana(*args, &block)
+    def call_pipeline(*args, &block)
       kv_payload = { redis: {} }
       dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
-        return call_pipeline_without_instana(*args, &block)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name) || !Instana.config[:redis][:enabled]
+        return super(*args, &block)
       end
 
       begin
@@ -54,7 +49,7 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
           nil
         end
 
-        call_pipeline_without_instana(*args, &block)
+        super(*args, &block)
       rescue => e
         ::Instana.tracer.log_info({ redis: {error: true} })
         ::Instana.tracer.log_error(e)
@@ -63,8 +58,10 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
         ::Instana.tracer.log_exit(:redis, kv_payload)
       end
     end
-
-    alias call_pipeline_without_instana call_pipeline
-    alias call_pipeline call_pipeline_with_instana
   end
 end
+
+if defined?(::Redis) && ::Instana.config[:redis][:enabled]
+  ::Instana.logger.debug "Instrumenting Redis"
+  Redis::Client.prepend(::Instana::RedisInstrumentation)
+end

data/lib/instana/instrumentation/resque.rb

@@ -3,11 +3,8 @@ require 'socket'
 module Instana
   module Instrumentation
     module ResqueClient
-      def self.included(klass)
+      def self.prepended(klass)
         klass.send :extend, ::Resque
-        ::Instana::Util.method_alias(klass, :enqueue)
-        ::Instana::Util.method_alias(klass, :enqueue_to)
-        ::Instana::Util.method_alias(klass, :dequeue)
       end
 
       def collect_kvs(op, klass, args)
@@ -23,50 +20,46 @@ module Instana
         { :'resque-client' => kvs }
       end
 
-      def enqueue_with_instana(klass, *args)
+      def enqueue(klass, *args)
         if Instana.tracer.tracing?
           kvs = collect_kvs(:enqueue, klass, args)
 
           Instana.tracer.trace(:'resque-client', kvs) do
-            enqueue_without_instana(klass, *args)
+            super(klass, *args)
           end
         else
-          enqueue_without_instana(klass, *args)
+          super(klass, *args)
         end
       end
 
-      def enqueue_to_with_instana(queue, klass, *args)
+      def enqueue_to(queue, klass, *args)
         if Instana.tracer.tracing? && !Instana.tracer.tracing_span?(:'resque-client')
           kvs = collect_kvs(:enqueue_to, klass, args)
           kvs[:Queue] = queue.to_s if queue
 
           Instana.tracer.trace(:'resque-client', kvs) do
-            enqueue_to_without_instana(queue, klass, *args)
+            super(queue, klass, *args)
           end
         else
-          enqueue_to_without_instana(queue, klass, *args)
+          super(queue, klass, *args)
         end
       end
 
-      def dequeue_with_instana(klass, *args)
+      def dequeue(klass, *args)
         if Instana.tracer.tracing?
           kvs = collect_kvs(:dequeue, klass, args)
 
           Instana.tracer.trace(:'resque-client', kvs) do
-            dequeue_without_instana(klass, *args)
+            super(klass, *args)
           end
         else
-          dequeue_without_instana(klass, *args)
+          super(klass, *args)
         end
       end
     end
 
     module ResqueWorker
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :perform)
-      end
-
-      def perform_with_instana(job)
+      def perform(job)
         kvs = {}
         kvs[:'resque-worker'] = {}
 
@@ -81,17 +74,13 @@ module Instana
         end
 
         Instana.tracer.start_or_continue_trace(:'resque-worker', kvs) do
-          perform_without_instana(job)
+          super(job)
         end
       end
     end
 
     module ResqueJob
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :fail)
-      end
-
-      def fail_with_instana(exception)
+      def fail(exception)
         if Instana.tracer.tracing?
           ::Instana.tracer.log_info(:'resque-worker' => { :error => "#{exception.class}: #{exception}"})
           ::Instana.tracer.log_error(exception)
@@ -99,7 +88,7 @@ module Instana
       rescue Exception => e
         ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" } if Instana::Config[:verbose]
       ensure
-        fail_without_instana(exception)
+        super(exception)
       end
     end
   end
@@ -109,14 +98,14 @@ if defined?(::Resque) && RUBY_VERSION >= '1.9.3'
 
   if ::Instana.config[:'resque-client'][:enabled]
     ::Instana.logger.debug 'Instrumenting Resque Client'
-    ::Instana::Util.send_include(::Resque,         ::Instana::Instrumentation::ResqueClient)
+    ::Resque.prepend(::Instana::Instrumentation::ResqueClient)
   end
 
   if ::Instana.config[:'resque-worker'][:enabled]
     ::Instana.logger.debug 'Instrumenting Resque Worker'
 
-    ::Instana::Util.send_include(::Resque::Worker, ::Instana::Instrumentation::ResqueWorker)
-    ::Instana::Util.send_include(::Resque::Job,    ::Instana::Instrumentation::ResqueJob)
+    ::Resque::Worker.prepend(::Instana::Instrumentation::ResqueWorker)
+    ::Resque::Job.prepend(::Instana::Instrumentation::ResqueJob)
 
     ::Resque.before_fork do |job|
       ::Instana.agent.before_resque_fork

data/lib/instana/instrumentation/rest-client.rb

@@ -1,34 +1,24 @@
 module Instana
   module Instrumentation
     module RestClientRequest
-      def self.included(klass)
-        if klass.method_defined?(:execute)
-          klass.class_eval do
-            alias execute_without_instana execute
-            alias execute execute_with_instana
-          end
-        end
-      end
-
-      def execute_with_instana & block
+      def execute(&block)
         # Since RestClient uses net/http under the covers, we just
         # provide span visibility here.  HTTP related KVs are reported
         # in the Net::HTTP instrumentation
         ::Instana.tracer.log_entry(:'rest-client')
 
-        execute_without_instana(&block)
+        super(&block)
       rescue => e
         ::Instana.tracer.log_error(e)
         raise
       ensure
         ::Instana.tracer.log_exit(:'rest-client')
       end
-
     end
   end
 end
 
 if defined?(::RestClient::Request) && ::Instana.config[:'rest-client'][:enabled]
   ::Instana.logger.debug "Instrumenting RestClient"
-  ::RestClient::Request.send(:include, ::Instana::Instrumentation::RestClientRequest)
+  ::RestClient::Request.send(:prepend, ::Instana::Instrumentation::RestClientRequest)
 end

data/lib/instana/secrets.rb

@@ -2,25 +2,25 @@ require 'uri'
 require 'cgi'
 
 module Instana
-  class Secrets    
+  class Secrets
     def remove_from_query(str, secret_values = Instana.agent.secret_values)
       return str unless secret_values
-      
+
       url = URI(str)
-      params = CGI.parse(url.query)
-      
+      params = CGI.parse(url.query || '')
+
       redacted = params.map do |k, v|
         needs_redaction = secret_values['list']
           .any? { |t| matcher(secret_values['matcher']).(t,k) }
         [k, needs_redaction ? '<redacted>' : v]
       end
-      
+
       url.query = URI.encode_www_form(redacted)
       CGI.unescape(url.to_s)
     end
-    
+
     private
-    
+
     def matcher(name)
       case name
       when 'equals-ignore-case'

data/lib/instana/util.rb

@@ -2,46 +2,6 @@ module Instana
   module Util
     class << self
       ID_RANGE = -2**63..2**63-1
-
-      # An agnostic approach to method aliasing.
-      #
-      # @param klass [Object] The class or module that holds the method to be alias'd.
-      # @param method [Symbol] The name of the method to be aliased.
-      #
-      def method_alias(klass, method)
-        if klass.method_defined?(method.to_sym) ||
-            klass.private_method_defined?(method.to_sym)
-
-          with = "#{method}_with_instana"
-          without = "#{method}_without_instana"
-
-          klass.class_eval do
-            alias_method without, method.to_s
-            alias_method method.to_s, with
-          end
-        else
-          ::Instana.logger.debug "No such method (#{method}) to alias on #{klass}"
-        end
-      end
-
-      # Calls on target_class to 'extend' cls
-      #
-      # @param target_cls [Object] the class/module to do the 'extending'
-      # @param cls [Object] the class/module to be 'extended'
-      #
-      def send_extend(target_cls, cls)
-        target_cls.send(:extend, cls) if defined?(target_cls)
-      end
-
-      # Calls on <target_cls> to include <cls> into itself.
-      #
-      # @param target_cls [Object] the class/module to do the 'including'
-      # @param cls [Object] the class/module to be 'included'
-      #
-      def send_include(target_cls, cls)
-        target_cls.send(:include, cls) if defined?(target_cls)
-      end
-
       # Debugging helper method
       #
       def pry!
@@ -246,7 +206,7 @@ module Instana
       #
       def id_to_header(id)
         return '' unless id.is_a?(String)
-        # Only send 64bit IDs downstream for now 
+        # Only send 64bit IDs downstream for now
         id.length == 32 ? id[16..-1] : id
       end
 

data/lib/instana/version.rb

@@ -1,4 +1,4 @@
 module Instana
-  VERSION = "1.192.1"
+  VERSION = "1.193.2"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/test_helper.rb

@@ -68,17 +68,11 @@ def clear_all!
 end
 
 def disable_redis_instrumentation
-  ::Redis::Client.class_eval do
-    alias call call_without_instana
-    alias call_pipeline call_pipeline_without_instana
-  end
+  ::Instana.config[:redis][:enabled] = false
 end
 
 def enable_redis_instrumentation
-  ::Redis::Client.class_eval do
-    alias call call_with_instana
-    alias call_pipeline call_pipeline_with_instana
-  end
+  ::Instana.config[:redis][:enabled] = true
 end
 
 def validate_sdk_span(json_span, sdk_hash = {}, errored = false, ec = 1)
@@ -156,4 +150,4 @@ def find_first_span_by_qualifier(spans, &block)
     end
   end
   raise Exception.new("Span with qualifier not found")
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 1.192.1
+  version: 1.193.2
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler