instana 1.10.1-java

data/test/instrumentation/net-http_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+class NetHTTPTest < Minitest::Test
+  def test_config_defaults
+    assert ::Instana.config[:nethttp].is_a?(Hash)
+    assert ::Instana.config[:nethttp].key?(:enabled)
+    assert_equal true, ::Instana.config[:nethttp][:enabled]
+  end
+
+  def test_block_request
+    clear_all!
+    WebMock.allow_net_connect!
+    url = "http://127.0.0.1:6511/"
+
+    uri = URI.parse(url)
+    req = Net::HTTP::Get.new(uri)
+
+    response = nil
+    Instana.tracer.start_or_continue_trace('net-http-test') do
+      Net::HTTP.start(req.uri.hostname, req.uri.port, :open_timeout => 1, :read_timeout => 1) do |http|
+        response = http.request(req)
+      end
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    rs_span = find_first_span_by_name(spans, :rack)
+    first_span = find_first_span_by_name(spans, :'net-http-test')
+    second_span = find_first_span_by_name(spans, :'net-http')
+
+    # Span name validation
+    assert_equal :sdk, first_span[:n]
+    assert_equal :'net-http', second_span[:n]
+
+    # first_span is the parent of second_span
+    assert_equal first_span[:s], 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]
+    assert !second_span.key?(:stack)
+
+    # Rack server trace should have the same trace ID
+    assert_equal rs_span[:t], first_span[:t]
+    assert_equal first_span[:t], second_span[:t]
+
+    # Rack server trace should have net-http has parent span
+    assert_equal second_span[:s], rs_span[:p]
+
+    WebMock.disable_net_connect!
+  end
+
+  def test_basic_post_without_uri
+    clear_all!
+    WebMock.allow_net_connect!
+
+    response = nil
+    Instana.tracer.start_or_continue_trace('net-http-test') do
+      http = Net::HTTP.new("127.0.0.1", 6511)
+      response = http.request(Net::HTTP::Post.new("/"))
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :'net-http-test')
+    http_span = find_first_span_by_name(spans, :'net-http')
+
+    # Span name validation
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :'net-http', http_span[:n]
+
+    # first_span is the parent of second_span
+    assert_equal sdk_span[:s], http_span[:p]
+
+    # data keys/values
+    refute_nil http_span.key?(:data)
+    refute_nil http_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", http_span[:data][:http][:url]
+    assert_equal "200", http_span[:data][:http][:status]
+    assert !http_span.key?(:stack)
+
+    # Rack server trace should have the same trace ID
+    assert_equal rack_span[:t], sdk_span[:t]
+    assert_equal sdk_span[:t], http_span[:t]
+
+    # Rack server trace should have net-http has parent span
+    assert_equal http_span[:s], rack_span[:p]
+
+    WebMock.disable_net_connect!
+  end
+
+  def test_request_with_dns_error
+    clear_all!
+    WebMock.allow_net_connect!
+
+    begin
+      Instana.tracer.start_or_continue_trace('net-http-error-test') do
+        http = Net::HTTP.new("asdfasdf.asdfsadf", 80)
+        http.request(Net::HTTP::Get.new("/blah"))
+      end
+    rescue Exception
+      nil
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.length
+
+    first_span = spans.first
+
+    assert_equal :sdk, first_span[:n]
+    assert_equal :'net-http-error-test', first_span[:data][:sdk][:name]
+    assert_equal true, first_span[:error]
+    assert_equal 1, first_span[:ec]
+    ts_key = first_span[:data][:sdk][:custom][:logs].keys.first
+    assert first_span[:data][:sdk][:custom][:logs].key?(ts_key)
+    assert first_span[:data][:sdk][:custom][:logs][ts_key].key?(:event)
+    assert first_span[:data][:sdk][:custom][:logs][ts_key].key?(:parameters)
+
+    WebMock.disable_net_connect!
+  end
+
+  def test_request_with_5xx_response
+    clear_all!
+    WebMock.allow_net_connect!
+
+    response = nil
+    Instana.tracer.start_or_continue_trace('net-http-error-test') do
+      http = Net::HTTP.new("127.0.0.1", 6511)
+      response = http.request(Net::HTTP::Get.new("/error"))
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :'net-http-error-test')
+    http_span = find_first_span_by_name(spans, :'net-http')
+
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :'net-http-error-test', sdk_span[:data][:sdk][:name]
+    assert_equal nil, sdk_span[:error]
+    assert_equal nil, sdk_span[:ec]
+
+    refute_nil http_span.key?(:data)
+    refute_nil http_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/error", http_span[:data][:http][:url]
+    assert_equal "500", http_span[:data][:http][:status]
+    assert_equal :'net-http', http_span[:n]
+    assert !http_span.key?(:stack)
+    assert_equal true, http_span[:error]
+    assert_equal 1, http_span[:ec]
+
+    WebMock.disable_net_connect!
+  end
+end

data/test/instrumentation/redis_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+class RedisTest < Minitest::Test
+  def test_normal_call
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      redis_client.set('hello', 'world')
+    end
+    redis_client.disconnect!
+
+    assert_redis_trace('SET')
+  end
+
+  def test_normal_call_with_error
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      begin
+        redis_client.zadd('hello', 'invalid', 'value')
+      rescue; end
+    end
+    redis_client.disconnect!
+
+    assert_redis_trace('ZADD', with_error: 'ERR value is not a valid float')
+  end
+
+  def test_pipeline_call
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      redis_client.pipelined do
+        redis_client.set('hello', 'world')
+        redis_client.set('other', 'world')
+      end
+    end
+
+    assert_redis_trace('PIPELINE')
+  end
+
+  def test_pipeline_call_with_error
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      begin
+        redis_client.pipelined do
+          redis_client.set('other', 'world')
+          redis_client.call('invalid')
+        end
+      rescue; end
+    end
+
+    assert_redis_trace('PIPELINE', with_error: "ERR unknown command 'invalid'")
+  end
+
+  def test_multi_call
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      redis_client.multi do
+        redis_client.set('hello', 'world')
+        redis_client.set('other', 'world')
+      end
+    end
+
+    assert_redis_trace('MULTI')
+  end
+
+  def test_multi_call_with_error
+    clear_all!
+    redis_client = create_redis_client
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      begin
+        redis_client.multi do
+          redis_client.set('other', 'world')
+          redis_client.call('invalid')
+        end
+      rescue; end
+    end
+
+    assert_redis_trace('MULTI', with_error: "ERR unknown command 'invalid'")
+  end
+
+  private
+
+  def create_redis_client
+    Redis.new(url: ENV['I_REDIS_URL'])
+  end
+
+  def assert_redis_trace(command, with_error: nil)
+    spans = ::Instana.processor.queued_spans
+    assert_equal 2, spans.length
+    first_span, second_span = spans.to_a.reverse
+
+    # first_span is the parent of second_span
+    assert_equal first_span[:s], second_span[:p]
+    assert_equal :sdk, first_span[:n]
+    assert_equal :redis, second_span[:n]
+
+    data = second_span[:data]
+
+    uri = URI.parse(ENV['I_REDIS_URL'])
+    assert_equal "#{uri.host}:#{uri.port}", data[:redis][:connection]
+
+    assert_equal 0, data[:redis][:db]
+    assert_equal command, data[:redis][:command]
+
+    if with_error
+      assert_equal true, data[:redis][:error]
+      assert data[:log].key?(:message)
+    end
+  end
+end

data/test/instrumentation/resque_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+require_relative "../jobs/resque_fast_job"
+require_relative "../jobs/resque_error_job"
+require 'resque'
+
+if ENV.key?('REDIS_URL')
+  ::Resque.redis = ENV['REDIS_URL']
+elsif ENV.key?('I_REDIS_URL')
+  ::Resque.redis = ENV['I_REDIS_URL']
+else
+  ::Resque.redis = 'localhost:6379'
+end
+
+class ResqueClientTest < Minitest::Test
+  def setup
+    clear_all!
+    ENV['FORK_PER_JOB'] = 'false'
+    Resque.redis.redis.flushall
+    @worker = Resque::Worker.new(:critical)
+  end
+
+  def teardown
+  end
+
+  def test_enqueue
+    ::Instana.tracer.start_or_continue_trace('resque-client_test') do
+      ::Resque.enqueue(FastJob)
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
+
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
+
+    assert_equal :"resque-client", resque_span[:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
+
+    assert_equal :redis, redis_span[:n]
+  end
+
+  def test_enqueue_to
+    ::Instana.tracer.start_or_continue_trace('resque-client_test') do
+      ::Resque.enqueue_to(:critical, FastJob)
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
+
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
+    assert_equal :"resque-client", resque_span[:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
+    assert_equal :redis, redis_span[:n]
+  end
+
+  def test_dequeue
+    ::Instana.tracer.start_or_continue_trace('resque-client_test', '', {}) do
+      ::Resque.dequeue(FastJob, { :generate => :farfalla })
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
+    resque_span = find_first_span_by_name(spans, :'resque-client')
+    redis_span = find_first_span_by_name(spans, :redis)
+
+    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
+    assert_equal :"resque-client", spans[1][:n]
+    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
+    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
+    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
+    assert_equal :redis, redis_span[:n]
+  end
+
+  def test_worker_job
+    Resque::Job.create(:critical, FastJob)
+    @worker.work(0)
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 3, spans.length
+
+    resque_span = spans[2]
+    redis1_span = spans[1]
+    redis2_span = spans[0]
+
+    assert_equal :'resque-worker', resque_span[:n]
+    assert_equal false, resque_span.key?(:error)
+    assert_equal false, resque_span.key?(:ec)
+    assert_equal "FastJob", resque_span[:data][:'resque-worker'][:job]
+    assert_equal "critical", resque_span[:data][:'resque-worker'][:queue]
+    assert_equal false, resque_span[:data][:'resque-worker'].key?(:error)
+
+    assert_equal :redis, redis1_span[:n]
+    assert_equal "SET", redis1_span[:data][:redis][:command]
+    assert_equal :redis, redis2_span[:n]
+    assert_equal "SET", redis2_span[:data][:redis][:command]
+  end
+
+  def test_worker_error_job
+    Resque::Job.create(:critical, ErrorJob)
+    @worker.work(0)
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 5, spans.length
+
+    resque_span = find_first_span_by_name(spans, :'resque-worker')
+
+    assert_equal :'resque-worker', resque_span[:n]
+    assert_equal true, resque_span.key?(:error)
+    assert_equal 1, resque_span[:ec]
+    assert_equal "ErrorJob", resque_span[:data][:'resque-worker'][:job]
+    assert_equal "critical", resque_span[:data][:'resque-worker'][:queue]
+    assert_equal "Exception: Silly Rabbit, Trix are for kids.", resque_span[:data][:'resque-worker'][:error]
+    assert_equal Array, resque_span[:stack].class
+  end
+end

data/test/instrumentation/rest-client_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class RestClientTest < Minitest::Test
+  def test_config_defaults
+    assert ::Instana.config[:'rest-client'].is_a?(Hash)
+    assert ::Instana.config[:'rest-client'].key?(:enabled)
+    assert_equal true, ::Instana.config[:'rest-client'][:enabled]
+  end
+
+  def test_basic_get
+    clear_all!
+    WebMock.allow_net_connect!
+
+    url = "http://127.0.0.1:6511/"
+
+    Instana.tracer.start_or_continue_trace('restclient-test') do
+      RestClient.get url
+    end
+
+    spans = ::Instana.processor.queued_spans
+    assert_equal 4, spans.length
+
+    rack_span = find_first_span_by_name(spans, :rack)
+    sdk_span = find_first_span_by_name(spans, :'restclient-test')
+    rest_span = find_first_span_by_name(spans, :'rest-client')
+    net_span = find_first_span_by_name(spans, :'net-http')
+
+    validate_sdk_span(sdk_span, {:name => :'restclient-test', :type => :intermediate})
+    validate_sdk_span(rest_span, {:name => :'rest-client', :type => :intermediate})
+
+    # Span name validation
+    assert_equal :rack, rack_span[:n]
+    assert_equal :sdk, sdk_span[:n]
+    assert_equal :sdk, rest_span[:n]
+    assert_equal :"net-http", net_span[:n]
+
+    # Trace IDs and relationships
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, rest_span[:t]
+    assert_equal trace_id, net_span[:t]
+    assert_equal trace_id, rack_span[:t]
+
+    assert_equal sdk_span[:s], rest_span[:p]
+    assert_equal rest_span[:s], net_span[:p]
+    assert_equal net_span[:s], rack_span[:p]
+
+    # data keys/values
+    refute_nil net_span.key?(:data)
+    refute_nil net_span[:data].key?(:http)
+    assert_equal "http://127.0.0.1:6511/", net_span[:data][:http][:url]
+    assert_equal "200", net_span[:data][:http][:status]
+
+    WebMock.disable_net_connect!
+  end
+end