instana 1.192.1 → 1.193.5

data/lib/instana/instrumentation/action_view.rb

@@ -0,0 +1,30 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
+    module ActionView
+      def render_partial(*args)
+        call_payload = {
+          render: {
+            type: :partial,
+            name: @options.is_a?(Hash) ? @options[:partial].to_s : 'Unknown'
+          }
+        }
+
+        ::Instana::Tracer.trace(:render, call_payload) { super(*args) }
+      end
+
+      def render_collection(*args)
+        call_payload = {
+          render: {
+            type: :collection,
+            name: @path.to_s
+          }
+        }
+
+        ::Instana::Tracer.trace(:render, call_payload) { super(*args) }
+      end
+    end
+  end
+end

data/lib/instana/instrumentation/active_record.rb

@@ -0,0 +1,50 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
+    module ActiveRecord
+      IGNORED_NAMES = %w[SCHEMA EXPLAIN CACHE].freeze
+      IGNORED_SQL = %w[BEGIN COMMIT SET].freeze
+      SANITIZE_REGEXP = /('[\s\S][^']*'|\d*\.\d+|\d+|NULL)/i.freeze
+
+      def log(sql, name = 'SQL', binds = [], *args)
+        call_payload = {
+          activerecord: {
+            adapter: @config[:adapter],
+            host: @config[:host],
+            username: @config[:username],
+            db: @config[:database],
+            sql: maybe_sanitize(sql)
+          }
+        }
+
+        if binds.all? { |b| b.respond_to?(:value_before_type_cast) }
+          mapped = binds.map(&:value_before_type_cast)
+          call_payload[:activerecord][:binds] = mapped
+        end
+
+        maybe_trace(call_payload, name) { super(sql, name, binds, *args) }
+      end
+
+      private
+
+      def maybe_sanitize(sql)
+        ::Instana.config[:sanitize_sql] ? sql.gsub(SANITIZE_REGEXP, '?') : sql
+      end
+
+      def maybe_trace(call_payload, name, &blk)
+        if ::Instana.tracer.tracing? && !ignored?(call_payload, name)
+          ::Instana.tracer.trace(:activerecord, call_payload, &blk)
+        else
+          yield
+        end
+      end
+
+      def ignored?(call_payload, name)
+        IGNORED_NAMES.include?(name) ||
+          IGNORED_SQL.any? { |s| call_payload[:activerecord][:sql].upcase.start_with?(s) }
+      end
+    end
+  end
+end

data/lib/instana/instrumentation/dalli.rb

@@ -1,15 +1,13 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2017
+
 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 +20,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 +34,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 +43,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,20 +61,14 @@ 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
 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)
-end

data/lib/instana/instrumentation/excon.rb

@@ -1,74 +1,71 @@
-if defined?(::Excon) && ::Instana.config[:excon][:enabled]
-  module Instana
-    module Instrumentation
-      class Excon < ::Excon::Middleware::Base
-        def request_call(datum)
-          return @stack.request_call(datum) unless ::Instana.tracer.tracing?
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2016
 
-          payload = { :http => {} }
-          path = datum[:path].split('?').first
-          payload[:http][:url] = ::Instana.secrets.remove_from_query("#{datum[:connection].instance_variable_get(:@socket_key)}#{path}")
-          payload[:http][:method] = datum[:method] if datum.key?(:method)
+module Instana
+  module Instrumentation
+    class Excon < ::Excon::Middleware::Base
+      def request_call(datum)
+        return @stack.request_call(datum) unless ::Instana.tracer.tracing?
 
-          if datum[:pipeline] == true
-            # Pass the context along in the datum so we get back on response
-            # and can close out the async span
-            datum[:instana_span] = ::Instana.tracer.log_async_entry(:excon, payload)
-            t_context = datum[:instana_span].context
-          else
-            ::Instana.tracer.log_entry(:excon, payload)
-            t_context = ::Instana.tracer.context
-          end
+        payload = { :http => {} }
+        path = datum[:path].split('?').first
+        payload[:http][:url] = ::Instana.secrets.remove_from_query("#{datum[:connection].instance_variable_get(:@socket_key)}#{path}")
+        payload[:http][:method] = datum[:method] if datum.key?(:method)
 
-          # Set request headers; encode IDs as hexadecimal strings
-          datum[:headers]['X-Instana-T'] = t_context.trace_id_header
-          datum[:headers]['X-Instana-S'] = t_context.span_id_header
-
-          @stack.request_call(datum)
+        if datum[:pipeline] == true
+          # Pass the context along in the datum so we get back on response
+          # and can close out the async span
+          datum[:instana_span] = ::Instana.tracer.log_async_entry(:excon, payload)
+          t_context = datum[:instana_span].context
+        else
+          ::Instana.tracer.log_entry(:excon, payload)
+          t_context = ::Instana.tracer.context
         end
 
-        def error_call(datum)
-          return @stack.error_call(datum) unless ::Instana.tracer.tracing?
+        # Set request headers; encode IDs as hexadecimal strings
+        datum[:headers]['X-Instana-T'] = t_context.trace_id_header
+        datum[:headers]['X-Instana-S'] = t_context.span_id_header
+
+        @stack.request_call(datum)
+      end
 
-          if datum[:pipeline] == true
-            ::Instana.tracer.log_async_error(datum[:error], datum[:instana_span])
-          else
-            ::Instana.tracer.log_error(datum[:error])
-          end
-          @stack.error_call(datum)
+      def error_call(datum)
+        return @stack.error_call(datum) unless ::Instana.tracer.tracing?
+
+        if datum[:pipeline] == true
+          ::Instana.tracer.log_async_error(datum[:error], datum[:instana_span])
+        else
+          ::Instana.tracer.log_error(datum[:error])
         end
+        @stack.error_call(datum)
+      end
 
-        def response_call(datum)
-          # FIXME: Will connect exceptions call a response?
-          #
-          return @stack.response_call(datum) unless ::Instana.tracer.tracing?
+      def response_call(datum)
+        # FIXME: Will connect exceptions call a response?
+        #
+        return @stack.response_call(datum) unless ::Instana.tracer.tracing?
 
-          result =  @stack.response_call(datum)
+        result =  @stack.response_call(datum)
 
-          status = datum[:status]
-          if !status && datum.key?(:response) && datum[:response].is_a?(Hash)
-            status = datum[:response][:status]
-          end
+        status = datum[:status]
+        if !status && datum.key?(:response) && datum[:response].is_a?(Hash)
+          status = datum[:response][:status]
+        end
 
-          if status.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
+        if status.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
 
-          if datum[:pipeline] == true
-            # Pickup context of this async span from datum[:instana_span]
-            ::Instana.tracer.log_async_exit(:excon, { :http => {:status => status } }, datum[:instana_span])
-          else
-            ::Instana.tracer.log_exit(:excon, { :http => {:status => status } })
-          end
-          result
+        if datum[:pipeline] == true
+          # Pickup context of this async span from datum[:instana_span]
+          ::Instana.tracer.log_async_exit(:excon, { :http => {:status => status } }, datum[:instana_span])
+        else
+          ::Instana.tracer.log_exit(:excon, { :http => {:status => status } })
         end
+        result
       end
     end
   end
-
-  ::Instana.logger.debug "Instrumenting Excon"
-  ::Excon.defaults[:middlewares].unshift(::Instana::Instrumentation::Excon)
 end
-

data/lib/instana/instrumentation/graphql.rb

@@ -1,5 +1,8 @@
-if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && ::Instana.config[:graphql][:enabled]
-  module Instana
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
     class GraphqlTracing < GraphQL::Tracing::PlatformTracing
       self.platform_keys = {
         'lex' => 'lex.graphql',
@@ -11,26 +14,26 @@ if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && :
         'execute_query' => 'execute.graphql',
         'execute_query_lazy' => 'execute.graphql',
       }
-      
-      def platform_trace(platform_key, key, data) 
-        return yield unless key == 'execute_query'    
+
+      def platform_trace(platform_key, key, data)
+        return yield unless key == 'execute_query'
         operation = data[:query].selected_operation
-            
+
         arguments = []
         fields = []
-        
+
         operation.selections.each do |field|
           arguments.concat(walk_fields(field, :arguments))
-          fields.concat(walk_fields(field, :selections))    
+          fields.concat(walk_fields(field, :selections))
         end
-            
+
         payload = {
           operationName: data[:query].operation_name || 'anonymous',
           operationType: operation.operation_type,
           arguments: grouped_fields(arguments),
           fields: grouped_fields(fields),
         }
-                
+
         begin
           ::Instana.tracer.log_entry(:'graphql.server')
           yield
@@ -41,11 +44,11 @@ if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && :
           ::Instana.tracer.log_exit(:'graphql.server', {graphql: payload})
         end
       end
-    
+
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}"
       end
-      
+
       def platform_authorized_key(type)
         "#{type.graphql_name}.authorized.graphql"
       end
@@ -53,17 +56,17 @@ if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && :
       def platform_resolve_type_key(type)
         "#{type.graphql_name}.resolve_type.graphql"
       end
-      
+
       private
-      
+
       def walk_fields(parent, method)
         return [] unless parent.respond_to?(method)
-        
+
         parent.send(method).map do |field|
           [{object: parent.name, field: field.name}] + walk_fields(field, method)
         end.flatten
       end
-      
+
       def grouped_fields(fields)
         fields
           .group_by { |p| p[:object] }
@@ -72,6 +75,4 @@ if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && :
       end
     end
   end
-  
-  ::GraphQL::Schema.use(::Instana::GraphqlTracing)
 end

data/lib/instana/instrumentation/grpc.rb

@@ -1,84 +1,91 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2017
+
 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 Instrumentation
+    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'
 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 Instrumentation
+    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'
 end