instana 1.10.1-java

data/test/instrumentation/excon_test.rb

@@ -0,0 +1,147 @@
+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
+
+    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 => :intermediate})
+
+    # 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]
+
+    # 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_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.start_or_continue_trace('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 => :intermediate})
+
+    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.start_or_continue_trace('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 => :intermediate})
+
+    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)
+      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
+end

data/test/instrumentation/grpc_test.rb

@@ -0,0 +1,377 @@
+require 'test_helper'
+
+class GrpcTest < Minitest::Test
+  def client_stub
+    PingPongService::Stub.new('127.0.0.1:50051', :this_channel_is_insecure)
+  end
+
+  def assert_client_span(client_span, call: '', call_type: '', error: nil)
+    data = client_span[:data]
+    assert_equal '127.0.0.1:50051', data[:rpc][:host]
+    assert_equal :grpc, data[:rpc][:flavor]
+    assert_equal call, data[:rpc][:call]
+    assert_equal call_type, data[:rpc][:call_type]
+
+    if error
+      assert_equal true, data[:rpc][:error]
+      assert_equal "2:RuntimeError: #{error}", data[:log][:message]
+    end
+  end
+
+  def assert_server_span(server_span, call: '', call_type: '', error: nil)
+    # Span name validation
+    assert_equal :'rpc-server', server_span[:n]
+
+    data = server_span[:data]
+    assert_equal :grpc, data[:rpc][:flavor]
+    assert_equal call, data[:rpc][:call]
+    assert_equal call_type, data[:rpc][:call_type]
+
+    if error
+      assert_equal true, data[:rpc][:error]
+      assert_equal error, data[:log][:message]
+    end
+  end
+
+  def test_request_response
+    clear_all!
+    response = nil
+
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      response = client_stub.ping(
+        PingPongService::PingRequest.new(message: 'Hello World')
+      )
+    end
+    sleep 1
+
+    assert 'Hello World', response.message
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/Ping',
+        call_type: :request_response
+    )
+
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/Ping',
+        call_type: :request_response
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_client_streamer
+    clear_all!
+    response = nil
+
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      response = client_stub.ping_with_client_stream(
+        (0..5).map do |index|
+          PingPongService::PingRequest.new(message: index.to_s)
+        end
+      )
+    end
+    sleep 1
+
+    assert '01234', response.message
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithClientStream',
+        call_type: :client_streamer
+    )
+
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithClientStream',
+        call_type: :client_streamer
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_server_streamer
+    clear_all!
+    responses = []
+
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      responses = client_stub.ping_with_server_stream(
+        PingPongService::PingRequest.new(message: 'Hello World')
+      )
+    end
+    assert %w(0 1 2 3 4), responses.map(&:message)
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithServerStream',
+        call_type: :server_streamer
+    )
+
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithServerStream',
+        call_type: :server_streamer
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_bidi_streamer
+    clear_all!
+    responses = []
+
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      responses = client_stub.ping_with_bidi_stream(
+        (0..5).map do |index|
+          PingPongService::PingRequest.new(message: (index * 2).to_s)
+        end
+      )
+    end
+    sleep 1
+
+    assert %w(0 2 4 6 8), responses.to_a.map(&:message)
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/PingWithBidiStream',
+        call_type: :bidi_streamer
+    )
+
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/PingWithBidiStream',
+        call_type: :bidi_streamer
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_request_response_failure
+    clear_all!
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      begin
+        client_stub.fail_to_ping( PingPongService::PingRequest.new(message: 'Hello World'))
+      rescue
+      end
+    end
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+    
+    assert_client_span(
+        client_span,
+        call: '/PingPongService/FailToPing',
+        call_type: :request_response,
+        error: 'Unexpected failed'
+    )
+    assert_server_span(
+        server_span,
+        call: '/PingPongService/FailToPing',
+        call_type: :request_response,
+        error: 'Unexpected failed'
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_client_streamer_failure
+    clear_all!
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      begin
+        client_stub.fail_to_ping_with_client_stream(
+          (0..5).map do |index|
+            PingPongService::PingRequest.new(message: index.to_s)
+          end
+        )
+      rescue
+      end
+    end
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+      client_span,
+      call: '/PingPongService/FailToPingWithClientStream',
+      call_type: :client_streamer,
+      error: 'Unexpected failed'
+    )
+
+    assert_server_span(
+      server_span,
+      call: '/PingPongService/FailToPingWithClientStream',
+      call_type: :client_streamer,
+      error: 'Unexpected failed'
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_server_streamer_failure
+    clear_all!
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      begin
+        client_stub.fail_to_ping_with_server_stream(
+          PingPongService::PingRequest.new(message: 'Hello World')
+        )
+      rescue
+      end
+    end
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+      client_span,
+      call: '/PingPongService/FailToPingWithServerStream',
+      call_type: :server_streamer
+    )
+
+    assert_server_span(
+      server_span,
+      call: '/PingPongService/FailToPingWithServerStream',
+      call_type: :server_streamer,
+      error: 'Unexpected failed'
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+
+  def test_bidi_streamer_failure
+    clear_all!
+    Instana.tracer.start_or_continue_trace(:rpctests) do
+      client_stub.fail_to_ping_with_bidi_stream(
+        (0..5).map do |index|
+          PingPongService::PingRequest.new(message: (index * 2).to_s)
+        end
+      )
+    end
+
+    # Pause for a split second to allow traces to be queued
+    sleep 0.2
+
+    spans = ::Instana.processor.queued_spans
+    sdk_span = find_spans_by_name(spans, :rpctests).first
+    client_span = find_spans_by_name(spans, :'rpc-client').first
+    server_span = find_spans_by_name(spans, :'rpc-server').first
+
+    validate_sdk_span(sdk_span)
+
+    assert_client_span(
+      client_span,
+      call: '/PingPongService/FailToPingWithBidiStream',
+      call_type: :bidi_streamer
+    )
+
+    assert_server_span(
+      server_span,
+      call: '/PingPongService/FailToPingWithBidiStream',
+      call_type: :bidi_streamer,
+      error: 'Unexpected failed'
+    )
+
+    trace_id = sdk_span[:t]
+    assert_equal trace_id, client_span[:t]
+    assert_equal trace_id, server_span[:t]
+
+    assert_equal server_span[:p], client_span[:s]
+    assert_equal client_span[:p], sdk_span[:s]
+  end
+end