instana 2.0.0 → 2.1.0

data/test/instrumentation/dalli_test.rb

@@ -1,325 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-
-class DalliTest < Minitest::Test
-  def setup
-    @memcached_host = ENV['MEMCACHED_HOST'] || '127.0.0.1:11211'
-    @dc = Dalli::Client.new(@memcached_host, :namespace => "instana_test")
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def test_config_defaults
-    assert ::Instana.config[:dalli].is_a?(Hash)
-    assert ::Instana.config[:dalli].key?(:enabled)
-    assert_equal true, ::Instana.config[:dalli][:enabled]
-  end
-
-  def test_basic_get
-    clear_all!
-
-    @dc.set(:instana, :boom)
-
-    result = nil
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.get(:instana)
-    end
-
-    assert_equal :boom, result
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :get, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :instana, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_basic_get_as_root_exit_span
-    clear_all!
-    @dc.set(:instana, :boom)
-
-    ::Instana.config[:allow_exit_as_root] = true
-    result = @dc.get(:instana)
-
-    assert_equal :boom, result
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-
-    first_span = spans[0]
-
-    assert_equal :memcache, first_span[:n]
-    assert_equal false, first_span.key?(:error)
-    assert_nil first_span[:p]
-    assert first_span[:t] == first_span[:s]
-    assert first_span[:data].key?(:memcache)
-    assert first_span[:data][:memcache].key?(:command)
-    assert_equal :get, first_span[:data][:memcache][:command]
-    assert first_span[:data][:memcache].key?(:key)
-    assert_equal :instana, first_span[:data][:memcache][:key]
-    assert first_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', first_span[:data][:memcache][:namespace]
-    assert first_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, first_span[:data][:memcache][:server]
-  end
-
-  def test_basic_set
-    clear_all!
-
-    result = nil
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.set(:instana, :rocks)
-    end
-
-    assert result.is_a?(Integer)
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :set, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :instana, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_replace
-    clear_all!
-
-    @dc.set(:instana, :rocks)
-    result = nil
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.replace(:instana, :rocks)
-    end
-
-    assert result.is_a?(Integer)
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :replace, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :instana, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_delete
-    clear_all!
-
-    @dc.set(:instana, :rocks)
-    result = nil
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.delete(:instana)
-    end
-
-    assert_equal true, result
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :delete, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :instana, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_incr
-    clear_all!
-
-    result = nil
-    @dc.set(:counter, 0, nil, :raw => true)
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.incr(:counter, 1, nil, 0)
-    end
-
-    assert_equal 1, result
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :incr, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :counter, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_decr
-    clear_all!
-
-    result = nil
-    @dc.set(:counter, 0, nil, :raw => true)
-    ::Instana.tracer.in_span(:dalli_test) do
-      result = @dc.decr(:counter, 1, nil, 0)
-    end
-
-    assert_equal 0, result
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :decr, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :counter, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-  end
-
-  def test_get_multi
-    clear_all!
-
-    @dc.set(:one, 1)
-    @dc.set(:three, 3)
-
-    ::Instana.tracer.in_span(:dalli_test) do
-      @dc.get_multi(:one, :two, :three, :four)
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal false, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :get_multi, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:keys)
-    assert_equal "one, two, three, four", second_span[:data][:memcache][:keys]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:server)
-    assert_equal @memcached_host, second_span[:data][:memcache][:server]
-    assert second_span[:data][:memcache].key?(:hits)
-    assert_equal 2, second_span[:data][:memcache][:hits]
-  end
-
-  def test_get_error_logging
-    clear_all!
-
-    # Invalid/broken client not connected to a server
-    broken_dc = Dalli::Client.new('128.0.0.100:11222', :namespace => "instana_test", :expires_in => 1)
-
-    result = nil
-    begin
-      ::Instana.tracer.in_span(:dalli_test) do
-        result = broken_dc.get(:instana)
-      end
-    rescue
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    validate_sdk_span(first_span, {:name => :dalli_test, :type => :entry})
-
-    assert_equal :memcache, second_span[:n]
-    assert_equal true, second_span.key?(:error)
-    assert second_span[:p] == first_span[:s]
-    assert first_span[:t] == first_span[:s]
-    assert second_span[:data].key?(:memcache)
-    assert second_span[:data][:memcache].key?(:command)
-    assert_equal :get, second_span[:data][:memcache][:command]
-    assert second_span[:data][:memcache].key?(:key)
-    assert_equal :instana, second_span[:data][:memcache][:key]
-    assert second_span[:data][:memcache].key?(:namespace)
-    assert_equal 'instana_test', second_span[:data][:memcache][:namespace]
-    assert second_span[:data][:memcache].key?(:error)
-  end
-end

data/test/instrumentation/excon_test.rb

@@ -1,204 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-require 'test_helper'
-require 'support/apps/http_endpoint/boot'
-
-class ExconTest < Minitest::Test
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def test_config_defaults
-    assert ::Instana.config[:excon].is_a?(Hash)
-    assert ::Instana.config[:excon].key?(:enabled)
-    assert_equal true, ::Instana.config[:excon][:enabled]
-  end
-
-  def test_basic_get
-    clear_all!
-
-    # A slight hack but webmock chokes with pipelined requests.
-    # Delete their excon middleware
-    Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
-    Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
-
-    url = "http://127.0.0.1:6511"
-
-    connection = Excon.new(url)
-    Instana.tracer.in_span(:'excon-test') do
-      connection.get(:path => '/?basic_get')
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    sdk_span = find_first_span_by_name(spans, :'excon-test')
-    excon_span = find_first_span_by_name(spans, :excon)
-    rack_span = find_first_span_by_name(spans, :rack)
-
-    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :entry})
-
-    # data keys/values
-    refute_nil excon_span.key?(:data)
-    refute_nil excon_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", excon_span[:data][:http][:url]
-    assert_equal 200, excon_span[:data][:http][:status]
-    assert_equal 'basic_get', excon_span[:data][:http][:params]
-
-    # excon backtrace not included by default check
-    assert !excon_span.key?(:stack)
-
-    assert_equal sdk_span[:t], excon_span[:t]
-    assert_equal rack_span[:t], excon_span[:t]
-
-    assert_equal rack_span[:p], excon_span[:s]
-    assert_equal excon_span[:p], sdk_span[:s]
-  end
-
-  def test_basic_get_as_root_exit_span
-    clear_all!
-
-    # A slight hack but webmock chokes with pipelined requests.
-    # Delete their excon middleware
-    Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
-    Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
-
-    url = "http://127.0.0.1:6511"
-
-    ::Instana.config[:allow_exit_as_root] = true
-    connection = Excon.new(url)
-    connection.get(:path => '/?basic_get')
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    excon_span = find_first_span_by_name(spans, :excon)
-    rack_span = find_first_span_by_name(spans, :rack)
-
-    # data keys/values
-    refute_nil excon_span.key?(:data)
-    refute_nil excon_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", excon_span[:data][:http][:url]
-    assert_equal 200, excon_span[:data][:http][:status]
-    assert_equal 'basic_get', excon_span[:data][:http][:params]
-
-    # excon backtrace not included by default check
-    assert !excon_span.key?(:stack)
-
-    assert_equal rack_span[:t], excon_span[:t]
-
-    assert_equal rack_span[:p], excon_span[:s]
-    assert_nil excon_span[:p]
-  end
-
-  def test_basic_get_with_error
-    clear_all!
-
-    # A slight hack but webmock chokes with pipelined requests.
-    # Delete their excon middleware
-    Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
-    Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
-
-    url = "http://127.0.0.1:6511"
-
-    begin
-      connection = Excon.new(url)
-      Instana.tracer.in_span('excon-test') do
-        connection.get(:path => '/error')
-      end
-    rescue
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    rack_span = find_first_span_by_name(spans, :rack)
-    excon_span = find_first_span_by_name(spans, :excon)
-    sdk_span = find_first_span_by_name(spans, :'excon-test')
-
-    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :entry})
-
-    assert_equal sdk_span[:s], excon_span[:p]
-    assert_equal excon_span[:s], rack_span[:p]
-
-    assert_equal :excon, excon_span[:n]
-    refute_nil excon_span.key?(:data)
-    refute_nil excon_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/error", excon_span[:data][:http][:url]
-    assert_equal 500, excon_span[:data][:http][:status]
-
-    # error validation
-    assert_equal true, excon_span[:error]
-    assert_equal 1, excon_span[:ec]
-  end
-
-  def test_pipelined_requests
-    clear_all!
-
-    # A slight hack but webmock chokes with pipelined requests.
-    # Delete their excon middleware
-    Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
-    Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
-
-    url = "http://127.0.0.1:6511"
-
-    connection = Excon.new(url)
-    request = { :method => :get, :path => '/?pipelined_request' }
-    Instana.tracer.in_span('excon-test') do
-      connection.requests([request, request, request])
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 7, spans.length
-
-    rack_spans = find_spans_by_name(spans, :rack)
-    excon_spans = find_spans_by_name(spans, :excon)
-    sdk_span = find_first_span_by_name(spans, :'excon-test')
-
-    validate_sdk_span(sdk_span, {:name => :'excon-test', :type => :entry})
-
-    assert_equal 3, rack_spans.length
-    assert_equal 3, excon_spans.length
-
-    for rack_span in rack_spans
-      # data keys/values
-      refute_nil rack_span.key?(:data)
-      refute_nil rack_span[:data].key?(:http)
-      assert_equal "/", rack_span[:data][:http][:url]
-      assert_equal 200, rack_span[:data][:http][:status]
-      assert !rack_span.key?(:stack)
-
-      # Make sure a parent is specified and that we have it
-      refute_nil rack_span[:p]
-      excon_span = find_span_by_id(spans, rack_span[:p])
-      assert_equal :excon, excon_span[:n]
-
-      refute_nil excon_span.key?(:data)
-      refute_nil excon_span[:data].key?(:http)
-      assert_equal "http://127.0.0.1:6511/", excon_span[:data][:http][:url]
-      assert_equal 200, excon_span[:data][:http][:status]
-      assert !excon_span.key?(:stack)
-
-      # walk up the line
-      refute_nil excon_span[:p]
-      grandparent_span = find_span_by_id(spans, excon_span[:p])
-      assert_nil grandparent_span[:p]
-      assert_equal :sdk, grandparent_span[:n]
-    end
-  end
-
-  def test_basic_get_no_tracing
-    clear_all!
-
-    # A slight hack but webmock chokes with pipelined requests.
-    # Delete their excon middleware
-    Excon.defaults[:middlewares].delete ::WebMock::HttpLibAdapters::ExconAdapter
-    Excon.defaults[:middlewares].delete ::Excon::Middleware::Mock
-
-    url = "http://127.0.0.1:6511"
-
-    connection = Excon.new(url)
-    connection.get(:path => '/?basic_get')
-  end
-end