instana 1.11.8 → 1.193.2

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

data/test/frameworks/roda_test.rb

@@ -40,5 +40,19 @@ if defined?(::Roda)
       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/sinatra_test.rb

@@ -48,5 +48,19 @@ if defined?(::Sinatra)
       assert rack_span[:data][:http].key?(:host)
       assert_equal "example.org", rack_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/instrumentation/excon_test.rb

@@ -116,8 +116,6 @@ class ExconTest < Minitest::Test
     assert_equal 3, rack_spans.length
     assert_equal 3, excon_spans.length
 
-    # ::Instana::Util.pry!
-
     for rack_span in rack_spans
       # data keys/values
       refute_nil rack_span.key?(:data)

data/test/instrumentation/graphql_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+class GraphqlTest < Minitest::Test
+  class TaskType < GraphQL::Schema::Object
+    field :id, ID, null: false
+    field :action, String, null: false
+  end
+  
+  class NewTaskType < GraphQL::Schema::Mutation
+    argument :action, String, required: true
+    field :task, TaskType, null: true
+    
+    def resolve(action:)
+      {
+        task: OpenStruct.new(id: '0', action: action)
+      }
+    end
+  end
+  
+  class QueryType < GraphQL::Schema::Object
+    field :tasks, TaskType.connection_type, null: false
+    
+    def tasks()
+      [
+        OpenStruct.new(id: '0', action: 'Sample')
+      ]
+    end
+  end
+  
+  class MutationType < GraphQL::Schema::Object
+    field :create_task, mutation: NewTaskType
+  end
+  
+  class Schema < GraphQL::Schema
+    query QueryType
+    mutation MutationType
+  end
+  
+  def test_it_works
+    assert defined?(GraphQL)
+  end
+  
+  def test_config_defaults    
+    assert ::Instana.config[:graphql].is_a?(Hash)
+    assert ::Instana.config[:graphql].key?(:enabled)
+    assert_equal true, ::Instana.config[:graphql][:enabled]
+  end
+  
+  def test_query
+    clear_all!
+    
+    query = "query Sample {
+      tasks(after: \"\", first: 10) {
+        nodes {
+          action
+        }
+      }
+    }"
+    
+    expected_data = {
+      :operationName => "Sample",
+      :operationType => "query",
+      :arguments => { "tasks" => ["after", "first"] },
+      :fields => { "tasks" => ["nodes"], "nodes" => ["action"] }
+    }
+    expected_results = {
+      "data" => {
+        "tasks" => { 
+          "nodes" => [{ "action" => "Sample" }]
+        }
+      }
+    }
+    
+    results = Instana.tracer.start_or_continue_trace('graphql-test') { Schema.execute(query) }
+    query_span, root_span = *Instana.processor.queued_spans
+    
+    assert_equal expected_results, results.to_h
+    assert_equal :sdk, root_span[:n]
+    assert_equal :'graphql.server', query_span[:n]
+    assert_equal expected_data, query_span[:data][:graphql]
+  end
+  
+  def test_mutation
+    clear_all!
+    
+    query = "mutation Sample {
+      createTask(action: \"Sample\") {
+        task {
+          action
+        }
+      }
+    }"
+    
+    expected_data = {
+      :operationName => "Sample",
+      :operationType => "mutation",
+      :arguments => { "createTask" => ["action"] },
+      :fields => { "createTask" => ["task"], "task" => ["action"] }
+    }
+    expected_results = {
+      "data" => {
+        "createTask" => { 
+          "task" => { "action" => "Sample" }
+        }
+      }
+    }
+    
+    results = Instana.tracer.start_or_continue_trace('graphql-test') { Schema.execute(query) }
+    query_span, root_span = *Instana.processor.queued_spans
+        
+    assert_equal expected_results, results.to_h
+    assert_equal :sdk, root_span[:n]
+    assert_equal :'graphql.server', query_span[:n]
+    assert_equal expected_data, query_span[:data][:graphql]
+  end
+end

data/test/instrumentation/instrumented_request_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+class InstrumentedRequestTest < Minitest::Test
+  def test_skip_trace_with_header
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_X_INSTANA_L' => '0;sample-data'
+    )
+
+    assert req.skip_trace?
+  end
+
+  def test_skip_trace_without_header
+    req = Instana::InstrumentedRequest.new({})
+
+    refute req.skip_trace?
+  end
+
+  def test_incomming_context
+    id = Instana::Util.generate_id
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_X_INSTANA_L' => '1',
+      'HTTP_X_INSTANA_T' => id,
+      'HTTP_X_INSTANA_S' => id
+    )
+
+    expected = {
+      trace_id: id,
+      span_id: id,
+      level: '1'
+    }
+
+    assert_equal expected, req.incoming_context
+  end
+
+  def test_request_tags
+    ::Instana.agent.extra_headers = %w[X-Capture-This]
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_HOST' => 'example.com',
+      'REQUEST_METHOD' => 'GET',
+      'HTTP_X_CAPTURE_THIS' => 'that',
+      'PATH_INFO' => '/'
+    )
+
+    expected = {
+      method: 'GET',
+      url: '/',
+      host: 'example.com',
+      header: {
+        "X-Capture-This": 'that'
+      }
+    }
+
+    assert_equal expected, req.request_tags
+    ::Instana.agent.extra_headers = nil
+  end
+
+  def test_correlation_data_valid
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_X_INSTANA_L' => '1,correlationType=web ;correlationId=1234567890abcdef'
+    )
+    expected = {
+      type: 'web',
+      id: '1234567890abcdef'
+    }
+
+    assert_equal expected, req.correlation_data
+  end
+
+  def test_correlation_data_invalid
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_X_INSTANA_L' => '0;sample-data'
+    )
+
+    assert_equal({}, req.correlation_data)
+  end
+
+  def test_correlation_data_legacy
+    req = Instana::InstrumentedRequest.new(
+      'HTTP_X_INSTANA_L' => '1'
+    )
+
+    assert_equal({}, req.correlation_data)
+  end
+end

data/test/instrumentation/redis_test.rb

@@ -20,6 +20,16 @@ class RedisTest < Minitest::Test
     assert_redis_trace('SET')
   end
 
+  def test_georadius
+    clear_all!
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      @redis_client.georadius('Sicily', '15', '37', '200', 'km', 'WITHCOORD', 'WITHDIST')
+    end
+
+    assert_redis_trace('GEORADIUS')
+  end
+
   def test_normal_call_with_error
     clear_all!
 

data/test/secrets_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class SecretsTest < Minitest::Test
+  def setup
+    @subject = Instana::Secrets.new
+  end
+  
+  def test_equals_ignore_case
+    sample_config = {
+      "matcher"=>"equals-ignore-case", 
+      "list"=>["key"]
+    }
+    
+    url = url_for(%w(key Str kEy KEY))
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy KEY)
+  end
+  
+  def test_equals
+    sample_config = {
+      "matcher"=>"equals", 
+      "list"=>["key", "kEy"]
+    }
+    
+    url = url_for(%w(key Str kEy KEY))
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy)
+  end
+  
+  def test_contains_ignore_case
+    sample_config = {
+      "matcher"=>"contains-ignore-case", 
+      "list"=>["stan"]
+    }
+    
+    url = url_for(%w(instantiate conTESTant sample))
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate conTESTant)
+  end
+  
+  def test_contains
+    sample_config = {
+      "matcher"=>"contains", 
+      "list"=>["stan"]
+    }
+    
+    url = url_for(%w(instantiate conTESTant sample))
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
+  
+  end
+  
+  def test_regexp
+    sample_config = {
+      "matcher"=>"regex", 
+      "list"=>["l{2}"]
+    }
+    
+    url = url_for(%w(ball foot move))
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(ball) 
+  end
+  
+  private
+  
+  def url_for(keys)
+    url = URI('http://example.com')
+    url.query = URI.encode_www_form(keys.map { |k| [k, rand(1..100)]})
+    url.to_s
+  end
+  
+  def assert_redacted(str, keys)
+    url = URI(str)
+    params = CGI.parse(url.query)
+    
+    assert_equal keys, params.select { |_, v| v == %w(<redacted>) }.keys, 'to be redacted'
+  end
+end