instana 1.1.0 → 1.2.0

data/test/instana_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class InstanaTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Instana::VERSION
+  end
+
+  def test_that_it_has_a_logger
+    refute_nil ::Instana.logger
+  end
+
+  def test_that_it_has_an_agent
+    refute_nil ::Instana.agent
+  end
+
+  def test_that_it_has_a_collector
+    refute_nil ::Instana.collector
+  end
+
+  def test_that_it_has_a_tracer
+    refute_nil ::Instana.tracer
+  end
+
+  def test_that_it_has_a_config
+    refute_nil ::Instana.config
+  end
+end

data/test/instrumentation/dalli_test.rb

@@ -0,0 +1,274 @@
+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 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.start_or_continue_trace(:dalli_test) do
+      result = @dc.get(:instana)
+    end
+
+    assert_equal :boom, result
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_basic_set
+    clear_all!
+
+    result = nil
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      result = @dc.set(:instana, :rocks)
+    end
+
+    assert result.is_a?(Integer)
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_replace
+    clear_all!
+
+    @dc.set(:instana, :rocks)
+    result = nil
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      result = @dc.replace(:instana, :rocks)
+    end
+
+    assert result.is_a?(Integer)
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_delete
+    clear_all!
+
+    @dc.set(:instana, :rocks)
+    result = nil
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      result = @dc.delete(:instana)
+    end
+
+    assert_equal true, result
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_incr
+    clear_all!
+
+    result = nil
+    @dc.set(:counter, 0, nil, :raw => true)
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      result = @dc.incr(:counter, 1, nil, 0)
+    end
+
+    assert_equal 1, result
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_decr
+    clear_all!
+
+    result = nil
+    @dc.set(:counter, 0, nil, :raw => true)
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      result = @dc.decr(:counter, 1, nil, 0)
+    end
+
+    assert_equal 0, result
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+  end
+
+  def test_get_multi
+    clear_all!
+
+    @dc.set(:one, 1)
+    @dc.set(:three, 3)
+
+    ::Instana.tracer.start_or_continue_trace(:dalli_test) do
+      @dc.get_multi(:one, :two, :three, :four)
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    trace = traces.first
+
+    # Excon validation
+    assert_equal 2, trace.spans.count
+    spans = trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    assert_equal :dalli_test, first_span.name
+    assert_equal :memcache, second_span.name
+    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 ENV['MEMCACHED_HOST'], second_span[:data][:memcache][:server]
+    assert second_span[:data][:memcache].key?(:hits)
+    assert_equal 2, second_span[:data][:memcache][:hits]
+  end
+end

data/test/instrumentation/excon_test.rb

@@ -0,0 +1,171 @@
+require 'test_helper'
+
+class ExconTest < Minitest::Test
+  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.start_or_continue_trace('excon-test') do
+      connection.get(:path => '/?basic_get')
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 2, traces.count
+    rs_trace = traces[0]
+    http_trace = traces[1]
+
+    # Excon validation
+    assert_equal 2, http_trace.spans.count
+    spans = http_trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    # Span name validation
+    assert_equal :sdk, first_span[:n]
+    assert_equal :"excon-test", first_span[:data][:sdk][:name]
+    assert_equal :excon, second_span[:n]
+
+    # first_span is the parent of second_span
+    assert_equal first_span.id, second_span[:p]
+
+    # data keys/values
+    refute_nil second_span.key?(:data)
+    refute_nil second_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", second_span[:data][:http][:url]
+    assert_equal 200, second_span[:data][:http][:status]
+
+    # excon backtrace included check
+    assert second_span.key?(:stack)
+
+    # Rack server trace validation
+    assert_equal 1, rs_trace.spans.count
+    rs_span = rs_trace.spans.to_a[0]
+
+    # Rack server trace should have the same trace ID
+    assert_equal http_trace.id, rs_span[:t].to_i
+    assert_equal rs_span[:p].to_i, second_span[:s]
+  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:6500"
+
+    begin
+      connection = Excon.new(url)
+      Instana.tracer.start_or_continue_trace('excon-test') do
+        connection.get(:path => '/?basic_get')
+      end
+    rescue
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+    http_trace = traces.first
+
+    # Excon validation
+    assert_equal 2, http_trace.spans.count
+    spans = http_trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+
+    # Span name validation
+    assert_equal :sdk, first_span[:n]
+    assert_equal :"excon-test", first_span[:data][:sdk][:name]
+    assert_equal :excon, second_span[:n]
+
+    # first_span is the parent of second_span
+    assert_equal first_span.id, second_span[:p]
+
+    # data keys/values
+    refute_nil second_span.key?(:data)
+    refute_nil second_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6500/", second_span[:data][:http][:url]
+    assert_equal nil, second_span[:data][:http][:status]
+
+    # excon backtrace included check
+    assert second_span.key?(:stack)
+
+    # error validation
+    assert_equal true, second_span[:error]
+    #assert_equal 1, second_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.start_or_continue_trace('excon-test') do
+      connection.requests([request, request, request])
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 4, traces.count
+    http_trace = traces[3]
+
+    # Excon validation
+    assert_equal 4, http_trace.spans.count
+    spans = http_trace.spans.to_a
+    first_span = spans[0]
+    second_span = spans[1]
+    third_span = spans[2]
+    fourth_span = spans[3]
+
+    # Span name validation
+    assert_equal :sdk, first_span[:n]
+    assert_equal :"excon-test", first_span[:data][:sdk][:name]
+    assert_equal :excon, second_span[:n]
+    assert_equal :excon, third_span[:n]
+    assert_equal :excon, fourth_span[:n]
+
+    # first_span is the parent of second/third/fourth_span
+    assert_equal first_span.id, second_span[:p]
+    assert_equal first_span.id, third_span[:p]
+    assert_equal first_span.id, fourth_span[:p]
+
+    # data keys/values
+    refute_nil second_span.key?(:data)
+    refute_nil second_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", second_span[:data][:http][:url]
+    assert_equal 200, second_span[:data][:http][:status]
+    assert second_span.key?(:stack)
+
+    refute_nil third_span.key?(:data)
+    refute_nil third_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", third_span[:data][:http][:url]
+    assert_equal 200, third_span[:data][:http][:status]
+    assert third_span.key?(:stack)
+
+    refute_nil fourth_span.key?(:data)
+    refute_nil fourth_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", fourth_span[:data][:http][:url]
+    assert_equal 200, fourth_span[:data][:http][:status]
+    assert fourth_span.key?(:stack)
+  end
+end