instana 1.11.7 → 1.193.1

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

@@ -76,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

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/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.7"
+  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

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
@@ -51,11 +57,7 @@ class RackTest < Minitest::Test
     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 rack_span.key?(:stack)
-    assert_equal 2, rack_span[:stack].count
-    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert !rack_span.key?(:stack)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
@@ -227,14 +229,24 @@ class RackTest < Minitest::Test
     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 rack_span.key?(:stack)
-    assert_equal 2, rack_span[:stack].count
-    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert !rack_span.key?(:stack)
 
     # 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

data/test/frameworks/rails/actioncontroller_test.rb

@@ -153,4 +153,16 @@ class ActionControllerTest < Minitest::Test
     assert ac_span.key?(:stack)
     assert 1, ac_span[:ec]
   end
+  
+  def test_path_template
+    clear_all!
+
+    Net::HTTP.get(URI.parse('http://localhost:3205/test/world'))
+    
+    spans = ::Instana.processor.queued_spans
+    rack_span = find_first_span_by_name(spans, :rack)
+
+    assert_equal false, rack_span.key?(:error)
+    assert_equal '/test/world(.:format)', rack_span[:data][:http][:path_tpl]
+  end
 end

data/test/frameworks/rails/activerecord_test.rb

@@ -2,7 +2,14 @@ require 'test_helper'
 require 'active_record'
 
 class ActiveRecordTest < Minitest::Test
+
+  def teardown
+    # Make sure defaults are back in place
+    ::Instana.config[:sanitize_sql] = true
+  end
+
   def test_config_defaults
+    assert ::Instana.config[:sanitize_sql] == true
     assert ::Instana.config[:active_record].is_a?(Hash)
     assert ::Instana.config[:active_record].key?(:enabled)
     assert_equal true, ::Instana.config[:active_record][:enabled]
@@ -28,19 +35,14 @@ class ActiveRecordTest < Minitest::Test
       assert span[:data][:activerecord].key?(:username)
     end
 
-
-    found = false
     if ::Rails::VERSION::MAJOR < 4
       sql = "INSERT INTO \"blocks\" (\"color\", \"created_at\", \"name\", \"updated_at\") VALUES ($?, $?, $?, $?) RETURNING \"id\""
     else
       sql = "INSERT INTO \"blocks\" (\"name\", \"color\", \"created_at\", \"updated_at\") VALUES ($?, $?, $?, $?) RETURNING \"id\""
     end
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] ==
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
     end
-    assert found
 
     found = false
     if ::Rails::VERSION::MAJOR >= 5
@@ -50,12 +52,9 @@ class ActiveRecordTest < Minitest::Test
     else
       sql = "SELECT  \"blocks\".* FROM \"blocks\"  WHERE \"blocks\".\"name\" = ? LIMIT ?"
     end
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == sql
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
     end
-    assert found
 
     found = false
     if ::Rails::VERSION::MAJOR == 3
@@ -63,12 +62,73 @@ class ActiveRecordTest < Minitest::Test
     else
       sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = $?"
     end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+  end
+
+  def test_postgresql_without_sanitize
+    skip unless ::Instana::Test.postgresql?
+
+    # Shut SQL sanitization off
+    ::Instana.config[:sanitize_sql] = false
+    # Pause so the thread can syncronize values
+    sleep 1
+
+    clear_all!
+
+    Net::HTTP.get(URI.parse('http://localhost:3205/test/db'))
+
+    spans = Instana.processor.queued_spans
+    assert_equal 6, spans.length
+    rack_span = find_first_span_by_name(spans, :rack)
+
+    ar_spans = find_spans_by_name(spans, :activerecord)
+    assert_equal 3, ar_spans.length
+
     ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == sql
-        found = true
-      end
+      assert_equal "postgresql", span[:data][:activerecord][:adapter]
+      assert span[:data][:activerecord].key?(:host)
+      assert span[:data][:activerecord].key?(:username)
+    end
+
+    if ::Rails::VERSION::MAJOR < 4
+      sql = "INSERT INTO \"blocks\" (\"color\", \"created_at\", \"name\", \"updated_at\") VALUES ($1, $2, $3, $4) RETURNING \"id\""
+    else
+      sql = "INSERT INTO \"blocks\" (\"name\", \"color\", \"created_at\", \"updated_at\") VALUES ($1, $2, $3, $4) RETURNING \"id\""
     end
-    assert found
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 4, ar_span[:data][:activerecord][:binds].length
+
+    if ::Rails::VERSION::MAJOR >= 5
+      sql = "SELECT  \"blocks\".* FROM \"blocks\" WHERE \"blocks\".\"name\" = $1 ORDER BY \"blocks\".\"id\" ASC LIMIT $2"
+    elsif ::Rails::VERSION::MAJOR == 4
+      sql = "SELECT  \"blocks\".* FROM \"blocks\" WHERE \"blocks\".\"name\" = $?  ORDER BY \"blocks\".\"id\" ASC LIMIT ?"
+    else
+      sql = "SELECT  \"blocks\".* FROM \"blocks\"  WHERE \"blocks\".\"name\" = ? LIMIT ?"
+    end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 2, ar_span[:data][:activerecord][:binds].length
+
+    if ::Rails::VERSION::MAJOR == 3
+      sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = 1"
+    else
+      sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = $1"
+    end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 1, ar_span[:data][:activerecord][:binds].length
   end
 
   def test_postgresql_lock_table
@@ -93,21 +153,13 @@ class ActiveRecordTest < Minitest::Test
       assert_equal "postgres", ar_span[:data][:activerecord][:username]
     end
 
-    found = false
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == "LOCK blocks IN ACCESS EXCLUSIVE MODE"
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == "LOCK blocks IN ACCESS EXCLUSIVE MODE"
     end
-    assert found
 
-    found = false
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == "SELECT ?"
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == "SELECT ?"
     end
-    assert found
   end
 
   def test_postgresql_raw_execute