instana 1.11.8 → 1.193.2

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

@@ -8,16 +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
@@ -27,14 +22,33 @@ module Instana
       # @param sql [String]
       # @return [Hash] Hash of collected KVs
       #
-      def collect(sql)
+      def collect(sql, binds = nil)
         payload = { :activerecord => {} }
-        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+
         payload[:activerecord][:adapter] = @config[:adapter]
         payload[:activerecord][:host] = @config[:host]
         payload[:activerecord][:db] = @config[:database]
         payload[:activerecord][:username] = @config[:username]
+
+        if ::Instana.config[:sanitize_sql]
+          payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        else
+          # No sanitization so raw SQL and collect up binds
+          payload[:activerecord][:sql] = sql
+
+          # FIXME: Only works on Rails 5 as the bind format varied in previous versions of Rails
+          if binds.is_a?(Array)
+            raw_binds = []
+            binds.each { |x| raw_binds << x.value_before_type_cast }
+            payload[:activerecord][:binds] = raw_binds
+          end
+        end
+
         payload
+      rescue Exception => e
+        ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      ensure
+        return payload
       end
 
       # In the spirit of ::ActiveRecord::ExplainSubscriber.ignore_payload?  There are
@@ -48,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)
+        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)
+        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/frameworks/roda.rb

@@ -1,6 +1,47 @@
 require "instana/rack"
 
+module Instana
+  module RodaPathTemplateExtractor
+    module RequestMethods
+      TERM = defined?(::Roda) ? ::Roda::RodaPlugins::Base::RequestMethods::TERM : Object
+      
+      def if_match(args, &blk)
+        path = @remaining_path
+        captures = @captures.clear
+  
+        if match_all(args)
+          (env['INSTANA_PATH_TEMPLATE_FRAGMENTS'] ||= []).concat(named_args(args, blk))
+          block_result(blk.(*captures))
+          env['INSTANA_HTTP_PATH_TEMPLATE'] = env['INSTANA_PATH_TEMPLATE_FRAGMENTS']
+            .join('/')
+            .prepend('/')
+          throw :halt, response.finish
+        else
+          @remaining_path = path
+          false
+        end
+      end
+      
+      def named_args(args, blk)  
+        parameters = blk.parameters      
+        args.map do |a| 
+          case a
+          when String
+            a
+          when TERM
+            nil
+          else
+            _, name = parameters.pop
+            "{#{name}}"
+          end
+        end.compact
+      end  
+    end
+  end
+end
+
 if defined?(::Roda)
   ::Instana.logger.debug "Instrumenting Roda"
   Roda.use ::Instana::Rack
+  Roda.plugin ::Instana::RodaPathTemplateExtractor
 end

data/lib/instana/frameworks/sinatra.rb

@@ -3,7 +3,24 @@ require "instana/rack"
 # This instrumentation will insert Rack into Sinatra _and_ Padrino since
 # the latter is based on Sinatra
 
+module Instana
+  module SinatraPathTemplateExtractor
+    def self.extended(base)
+      ::Instana.logger.debug "#{base} extended #{self}"
+      base.store_path_template
+    end
+    
+    def store_path_template
+      after do
+        @env["INSTANA_HTTP_PATH_TEMPLATE"] = @env["sinatra.route"]
+          .sub("#{@request.request_method} ", '')
+      end
+    end
+  end
+end
+
 if defined?(::Sinatra)
   ::Instana.logger.debug "Instrumenting Sinatra"
   ::Sinatra::Base.use ::Instana::Rack
+  ::Sinatra::Base.register ::Instana::SinatraPathTemplateExtractor
 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/excon.rb

@@ -7,7 +7,7 @@ if defined?(::Excon) && ::Instana.config[:excon][:enabled]
 
           payload = { :http => {} }
           path = datum[:path].split('?').first
-          payload[:http][:url] = "#{datum[:connection].instance_variable_get(:@socket_key)}#{path}"
+          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)
 
           if datum[:pipeline] == true

data/lib/instana/instrumentation/graphql.rb

@@ -0,0 +1,77 @@
+if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && ::Instana.config[:graphql][:enabled]
+  module Instana
+    class GraphqlTracing < GraphQL::Tracing::PlatformTracing
+      self.platform_keys = {
+        'lex' => 'lex.graphql',
+        'parse' => 'parse.graphql',
+        'validate' => 'validate.graphql',
+        'analyze_query' => 'analyze.graphql',
+        'analyze_multiplex' => 'analyze.graphql',
+        'execute_multiplex' => 'execute.graphql',
+        'execute_query' => 'execute.graphql',
+        'execute_query_lazy' => 'execute.graphql',
+      }
+      
+      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))    
+        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
+        rescue Exception => e
+          ::Instana.tracer.log_error(e)
+          raise e
+        ensure
+          ::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
+
+      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] }
+          .map { |name, p| [name, p.map { |f| f[:field] }] }
+          .to_h
+      end
+    end
+  end
+  
+  ::GraphQL::Schema.use(::Instana::GraphqlTracing)
+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