instana 1.11.6 → 1.193.1

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/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/net-http.rb

@@ -32,6 +32,8 @@ if defined?(::Net::HTTP) && ::Instana.config[:nethttp][:enabled]
           kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
         end
       end
+      
+      kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
 
       # The core call
       response = request_without_instana(*args, &block)

data/lib/instana/instrumentation/rack.rb

@@ -8,8 +8,9 @@ module Instana
       @app = app
     end
 
-    def call(env)
-      kvs = { :http => {} }
+    def collect_kvs(env)
+      kvs = {}
+      kvs[:http] = {}
       kvs[:http][:method] = env['REQUEST_METHOD']
       kvs[:http][:url] = ::CGI.unescape(env['PATH_INFO'])
 
@@ -37,15 +38,27 @@ module Instana
           end
         }
       end
+      return kvs
+    end
 
+    def call(env)
       # Check incoming context
       incoming_context = {}
       if env.key?('HTTP_X_INSTANA_T')
         incoming_context[:trace_id]  = ::Instana::Util.header_to_id(env['HTTP_X_INSTANA_T'])
         incoming_context[:span_id]   = ::Instana::Util.header_to_id(env['HTTP_X_INSTANA_S']) if env.key?('HTTP_X_INSTANA_S')
         incoming_context[:level]     = env['HTTP_X_INSTANA_L'] if env.key?('HTTP_X_INSTANA_L')
+
+        # Honor X-Instana-L
+        if incoming_context[:level] and incoming_context[:level].length > 0
+          if incoming_context[:level][0] == "0"
+            return @app.call(env)
+          end
+        end
       end
 
+      kvs = collect_kvs(env)
+
       ::Instana.tracer.log_start_or_continue(:rack, {}, incoming_context)
 
       status, headers, response = @app.call(env)
@@ -63,6 +76,11 @@ module Instana
           ::Instana.tracer.log_error(nil)
         end
 
+        # If the framework instrumentation provides a path template,
+        # pass it into the span here.
+        # See: https://www.instana.com/docs/tracing/custom-best-practices/#path-templates-visual-grouping-of-http-endpoints
+        kvs[:http][:path_tpl] = env['INSTANA_HTTP_PATH_TEMPLATE'] if env['INSTANA_HTTP_PATH_TEMPLATE']
+
         # Save the IDs before the trace ends so we can place
         # them in the response headers in the ensure block
         trace_id = ::Instana.tracer.current_span.trace_id
@@ -78,8 +96,10 @@ module Instana
         # Set reponse headers; encode as hex string
         headers['X-Instana-T'] = ::Instana::Util.id_to_header(trace_id)
         headers['X-Instana-S'] = ::Instana::Util.id_to_header(span_id)
+        headers['X-Instana-L'] = '1'
+        headers['Server-Timing'] = "intid;desc=#{::Instana::Util.id_to_header(trace_id)}"
+        ::Instana.tracer.log_end(:rack, kvs)
       end
-      ::Instana.tracer.log_end(:rack, kvs)
     end
   end
 end

data/lib/instana/secrets.rb

@@ -0,0 +1,42 @@
+require 'uri'
+require 'cgi'
+
+module Instana
+  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)
+      
+      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'
+        ->(expected, actual) { expected.casecmp(actual) == 0 }
+      when 'equals'
+        ->(expected, actual) { (expected <=> actual) == 0 }
+      when 'contains-ignore-case'
+        ->(expected, actual) { actual.downcase.include?(expected) }
+      when 'contains'
+        ->(expected, actual) { actual.include?(expected) }
+      when 'regex'
+        ->(expected, actual) { !Regexp.new(expected).match(actual).nil? }
+      else
+        ::Instana.logger.warn("Matcher #{name} is not supported.")
+        lambda { false }
+      end
+    end
+  end
+end

data/lib/instana/setup.rb

@@ -4,6 +4,7 @@ require "instana/base"
 require "instana/config"
 require "instana/agent"
 require "instana/collector"
+require "instana/secrets"
 require "instana/tracer"
 require "instana/tracing/processor"
 require "instana/instrumentation"

data/lib/instana/test.rb

@@ -7,14 +7,15 @@ module Instana
       def setup_environment
         # Set defaults if not set
         ENV['MEMCACHED_HOST']     ||= '127.0.0.1:11211'
-        ENV['TRAVIS_PSQL_HOST']   ||= "127.0.0.1"
-        ENV['TRAVIS_PSQL_USER']   ||= "postgres"
+        ENV['POSTGRES_HOST']      ||= "127.0.0.1"
+        ENV['POSTGRES_USER']      ||= "stan"
+        ENV['POSTGRES_PASSWORD']  ||= "stanlikesdata"
         ENV['TRAVIS_MYSQL_HOST']  ||= "127.0.0.1"
         ENV['TRAVIS_MYSQL_USER']  ||= "root"
 
         if !ENV.key?('DATABASE_URL')
           if ENV['DB_FLAVOR'] == 'postgresql'
-            ENV['DATABASE_URL'] = "postgresql://#{ENV['TRAVIS_PSQL_USER']}:#{ENV['TRAVIS_PSQL_PASS']}@#{ENV['TRAVIS_PSQL_HOST']}:5432/travis_ci_test"
+            ENV['DATABASE_URL'] = "postgresql://#{ENV['POSTGRES_USER']}:#{ENV['POSTGRES_PASSWORD']}@#{ENV['POSTGRES_HOST']}:5432/#{ENV['POSTGRES_USER']}"
           elsif ENV['DB_FLAVOR'] == 'mysql'
             ENV['DATABASE_URL'] = "mysql://#{ENV['TRAVIS_MYSQL_USER']}:#{ENV['TRAVIS_MYSQL_PASS']}@#{ENV['TRAVIS_MYSQL_HOST']}:3306/travis_ci_test"
           else

data/lib/instana/tracing/span.rb

@@ -3,8 +3,8 @@ module Instana
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
                          :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
-                         :redis, :'resque-client', :'resque-worker' ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker' ].freeze
+                         :redis, :'resque-client', :'resque-worker', :'graphql.server'  ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server' ].freeze
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
                    :'rpc-client', :'sidekiq-client', :redis ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
@@ -57,9 +57,6 @@ module Instana
       end
 
       if ::Instana.config[:collect_backtraces]
-        # For entry spans, add a backtrace fingerprint
-        add_stack(limit: 2) if ENTRY_SPANS.include?(name)
-
         # Attach a backtrace to all exit spans
         add_stack if EXIT_SPANS.include?(name)
       end
@@ -76,9 +73,11 @@ module Instana
     #
     # @param limit [Integer] Limit the backtrace to the top <limit> frames
     #
-    def add_stack(limit: nil, stack: Kernel.caller)
+    def add_stack(limit: 30, stack: Kernel.caller)
       frame_count = 0
+      sanitized_stack = []
       @data[:stack] = []
+      limit = 40 if limit > 40
 
       stack.each do |i|
         # If the stack has the full instana gem version in it's path
@@ -86,18 +85,23 @@ module Instana
         if !i.match(/instana\/instrumentation\/rack.rb/).nil? ||
           (i.match(::Instana::VERSION_FULL).nil? && i.match('lib/instana/').nil?)
 
-          break if limit && frame_count >= limit
-
           x = i.split(':')
 
-          @data[:stack] << {
+          sanitized_stack << {
             :c => x[0],
             :n => x[1],
             :m => x[2]
           }
-         frame_count = frame_count + 1 if limit
         end
       end
+
+      if sanitized_stack.length > limit
+        # (limit * -1) gives us negative form of <limit> used for
+        # slicing from the end of the list. e.g. stack[-30, 30]
+        @data[:stack] = sanitized_stack[limit*-1, limit]
+      else
+        @data[:stack] = sanitized_stack
+      end
     end
 
     # Log an error into the span
@@ -303,6 +307,15 @@ module Instana
     # a String, Numeric, or Boolean it will be encoded with to_s
     #
     def set_tag(key, value)
+      if ![Symbol, String].include?(key.class)
+        key = key.to_s
+      end
+
+      # If <value> is not a Symbol, String, Array, Hash or Numeric - convert to string
+      if ![Symbol, String, Array, TrueClass, FalseClass, Hash].include?(value.class) && !value.is_a?(Numeric)
+        value = value.to_s
+      end
+
       if custom?
         @data[:data][:sdk][:custom] ||= {}
         @data[:data][:sdk][:custom][:tags] ||= {}

data/lib/instana/version.rb

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

data/test/apps/cuba.rb

@@ -7,6 +7,10 @@ Cuba.define do
     on "hello" do
       res.write "Hello Instana!"
     end
+    
+    on "greet/:name" do |name|
+      res.write "Hello, #{name}"
+    end
 
     on root do
       res.redirect '/hello'

data/test/apps/roda.rb

@@ -6,5 +6,8 @@ class InstanaRodaApp < Roda
     r.get "hello" do
       "Hello Roda + Instana"
     end
+    r.get "greet", String do |name|
+      "Hello, #{name}!"
+    end
   end
 end

data/test/apps/sinatra.rb

@@ -2,4 +2,8 @@ class InstanaSinatraApp < ::Sinatra::Base
   get '/' do
     "Hello Sinatra!"
   end
+  
+  get '/greet/:name' do
+    "Hello, #{params[:name]}!"
+  end
 end

data/test/config_test.rb

@@ -10,28 +10,12 @@ class ConfigTest < Minitest::Test
     assert_equal '127.0.0.1', ::Instana.config[:agent_host]
     assert_equal 42699, ::Instana.config[:agent_port]
 
-    assert ::Instana.config[:enabled]
     assert ::Instana.config[:tracing][:enabled]
     assert ::Instana.config[:metrics][:enabled]
 
     ::Instana.config[:metrics].each do |k, v|
+      next unless v.is_a? Hash
       assert_equal true, ::Instana.config[:metrics][k].key?(:enabled)
     end
   end
-
-  def test_that_global_affects_children
-    # Disabling the gem should explicitly disable
-    # metrics and tracing flags
-    ::Instana.config[:enabled] = false
-
-    assert_equal false, ::Instana.config[:tracing][:enabled]
-    assert_equal false, ::Instana.config[:metrics][:enabled]
-
-    # Enabling the gem should explicitly enable
-    # metrics and tracing flags
-    ::Instana.config[:enabled] = true
-
-    assert_equal ::Instana.config[:tracing][:enabled]
-    assert_equal ::Instana.config[:metrics][:enabled]
-  end
 end