instana 1.11.5 → 1.13.0

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/instrumentation/redis.rb

@@ -2,28 +2,31 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
   ::Redis::Client.class_eval do
     def call_with_instana(*args, &block)
       kv_payload = { redis: {} }
+      dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:redis)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
         return call_without_instana(*args, &block)
       end
 
-      ::Instana.tracer.log_entry(:redis)
-
       begin
-        kv_payload[:redis][:connection] = "#{self.host}:#{self.port}"
-        kv_payload[:redis][:db] = db.to_s
-        kv_payload[:redis][:command] = args[0][0].to_s.upcase
-      rescue
-        nil
-      end
+        ::Instana.tracer.log_entry(:redis)
 
-      call_without_instana(*args, &block)
-    rescue => e
-      ::Instana.tracer.log_info({ redis: {error: true} })
-      ::Instana.tracer.log_error(e)
-      raise
-    ensure
-      ::Instana.tracer.log_exit(:redis, kv_payload)
+        begin
+          kv_payload[:redis][:connection] = "#{self.host}:#{self.port}"
+          kv_payload[:redis][:db] = db.to_s
+          kv_payload[:redis][:command] = args[0][0].to_s.upcase
+        rescue
+          nil
+        end
+
+        call_without_instana(*args, &block)
+      rescue => e
+        ::Instana.tracer.log_info({ redis: {error: true} })
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:redis, kv_payload)
+      end
     end
 
     ::Instana.logger.debug "Instrumenting Redis"
@@ -33,29 +36,32 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
 
     def call_pipeline_with_instana(*args, &block)
       kv_payload = { redis: {} }
+      dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:redis)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
         return call_pipeline_without_instana(*args, &block)
       end
 
-      ::Instana.tracer.log_entry(:redis)
-
-      pipeline = args.first
       begin
-        kv_payload[:redis][:connection] = "#{self.host}:#{self.port}"
-        kv_payload[:redis][:db] = db.to_s
-        kv_payload[:redis][:command] = pipeline.is_a?(::Redis::Pipeline::Multi) ? 'MULTI' : 'PIPELINE'
-      rescue
-        nil
-      end
+        ::Instana.tracer.log_entry(:redis)
 
-      call_pipeline_without_instana(*args, &block)
-    rescue => e
-      ::Instana.tracer.log_info({ redis: {error: true} })
-      ::Instana.tracer.log_error(e)
-      raise
-    ensure
-      ::Instana.tracer.log_exit(:redis, kv_payload)
+        pipeline = args.first
+        begin
+          kv_payload[:redis][:connection] = "#{self.host}:#{self.port}"
+          kv_payload[:redis][:db] = db.to_s
+          kv_payload[:redis][:command] = pipeline.is_a?(::Redis::Pipeline::Multi) ? 'MULTI' : 'PIPELINE'
+        rescue
+          nil
+        end
+
+        call_pipeline_without_instana(*args, &block)
+      rescue => e
+        ::Instana.tracer.log_info({ redis: {error: true} })
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:redis, kv_payload)
+      end
     end
 
     alias call_pipeline_without_instana call_pipeline

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

@@ -303,6 +303,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.5"
+  VERSION = "1.13.0"
   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

data/test/frameworks/cuba_test.rb

@@ -1,4 +1,3 @@
-
 if defined?(::Cuba)
   require 'test_helper'
   require File.expand_path(File.dirname(__FILE__) + '/../apps/cuba')
@@ -40,5 +39,19 @@ if defined?(::Cuba)
       assert first_span[:data][:http].key?(:host)
       assert_equal "example.org", first_span[:data][:http][:host]
     end
+
+    def test_path_template
+      clear_all!
+
+      r = get '/greet/instana'
+      assert last_response.ok?
+
+      spans = ::Instana.processor.queued_spans
+      assert_equal 1, spans.count
+
+      first_span = spans.first
+      assert_equal :rack, first_span[:n]
+      assert_equal '/greet/{name}', first_span[:data][:http][:path_tpl]
+    end
   end
 end

data/test/frameworks/rack_test.rb

@@ -5,16 +5,22 @@ require "instana/rack"
 
 class RackTest < Minitest::Test
   include Rack::Test::Methods
+  
+  class PathTemplateApp
+    def call(env)
+      env['INSTANA_HTTP_PATH_TEMPLATE'] = 'sample_template'
+      [200, {}, ['Ok']]
+    end
+  end
 
   def app
-    @app = Rack::Builder.new {
+    @app = Rack::Builder.new do
       use Rack::CommonLogger
       use Rack::ShowExceptions
       use Instana::Rack
-      map "/mrlobster" do
-        run Rack::Lobster.new
-      end
-    }
+      map("/mrlobster") { run Rack::Lobster.new }
+      map("/path_tpl") { run PathTemplateApp.new }
+    end
   end
 
   def test_basic_get
@@ -29,23 +35,33 @@ class RackTest < Minitest::Test
     # Span validation
     assert_equal 1, spans.count
 
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "GET", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert_equal 'example.org', first_span[:data][:http][:host]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "GET", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert_equal 'example.org', rack_span[:data][:http][:host]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
 
     # Backtrace fingerprint validation
-    assert first_span.key?(:stack)
-    assert_equal 2, first_span[:stack].count
-    refute_nil first_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert rack_span.key?(:stack)
+    assert_equal 2, rack_span[:stack].count
+    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
@@ -63,8 +79,8 @@ class RackTest < Minitest::Test
     # Span validation
     assert_equal 1, spans.count
 
-    first_span = spans.first
-    assert_equal 'WalterBishop', first_span[:data][:service]
+    rack_span = spans.first
+    assert_equal 'WalterBishop', rack_span[:data][:service]
 
     ENV.delete('INSTANA_SERVICE_NAME')
   end
@@ -78,17 +94,27 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "POST", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "POST", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_basic_put
@@ -100,17 +126,27 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "PUT", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "PUT", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_context_continuation
@@ -125,23 +161,33 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "GET", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "GET", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
 
     # Context validation
     # The first span should have the passed in trace ID
     # and specify the passed in span ID as it's parent.
-    assert_equal 1234, first_span[:t]
-    assert_equal 4321, first_span[:p]
+    assert_equal 1234, rack_span[:t]
+    assert_equal 4321, rack_span[:p]
   end
 
   def test_instana_response_headers
@@ -181,20 +227,34 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
+    rack_span = spans.first
 
-    assert first_span[:data][:http].key?(:header)
-    assert first_span[:data][:http][:header].key?(:"X-Capture-This")
-    assert !first_span[:data][:http][:header].key?(:"X-Capture-That")
-    assert_equal "ThereYouGo", first_span[:data][:http][:header][:"X-Capture-This"]
+    assert rack_span[:data][:http].key?(:header)
+    assert rack_span[:data][:http][:header].key?(:"X-Capture-This")
+    assert !rack_span[:data][:http][:header].key?(:"X-Capture-That")
+    assert_equal "ThereYouGo", rack_span[:data][:http][:header][:"X-Capture-This"]
 
     # Backtrace fingerprint validation
-    assert first_span.key?(:stack)
-    assert_equal 2, first_span[:stack].count
-    refute_nil first_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert rack_span.key?(:stack)
+    assert_equal 2, rack_span[:stack].count
+    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
     ::Instana.agent.extra_headers = nil
   end
+  
+  def test_capture_http_path_template
+    clear_all!
+    
+    get '/path_tpl'
+    assert last_response.ok?
+    
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+    
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+    assert_equal 'sample_template', rack_span[:data][:http][:path_tpl]
+  end
 end