instana 1.195.1 → 1.197.0.pre2

data/test/backend/host_agent_test.rb

@@ -0,0 +1,47 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class HostAgentTest < Minitest::Test
+  def test_spawn_background_thread
+    ENV['INSTANA_TEST'] = nil
+    ::Instana.config[:agent_host] = '10.10.10.10'
+
+    if File.exist?('/sbin/ip')
+      addr = `/sbin/ip route | awk '/default/ { print $3 }'`.strip
+      stub_request(:get, "http://#{addr}:42699/")
+        .to_timeout
+    end
+
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_timeout.times(3).then
+      .to_return(status: 200, body: "", headers: {})
+
+    discovery = Minitest::Mock.new
+    discovery.expect(:delete_observers, discovery, [])
+    discovery.expect(:with_observer, discovery, [Instana::Backend::HostAgentActivationObserver])
+    discovery.expect(:with_observer, discovery, [Instana::Backend::HostAgentReportingObserver])
+    discovery.expect(:swap, discovery, [])
+
+    subject = Instana::Backend::HostAgent.new(discovery: discovery)
+
+    FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/ecs', '/proc')
+      subject.spawn_background_thread
+    end
+
+    subject.future.value!
+
+    discovery.verify
+  ensure
+    ::Instana.config[:agent_host] = '127.0.0.1'
+    ENV['INSTANA_TEST'] = 'true'
+  end
+
+  def test_discovery_value
+    discovery = Concurrent::Atom.new({'pid' => 1})
+    subject = Instana::Backend::HostAgent.new(discovery: discovery)
+    assert_equal 1, subject.source[:e]
+  end
+end

data/test/backend/process_info_test.rb

@@ -0,0 +1,63 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class ProcessInfoTest < Minitest::Test
+  def test_osx_argument_stripping
+    host_os = RbConfig::CONFIG['host_os']
+    RbConfig::CONFIG['host_os'] = 'darwin'
+
+    subject = Instana::Backend::ProcessInfo.new(OpenStruct.new(cmdline: 'test INSTANA_TEST=1 KV=2'))
+    assert_equal ['KV=2'], subject.arguments
+  ensure
+    RbConfig::CONFIG['host_os'] = host_os
+  end
+
+  def test_linux_argument_stripping
+    host_os = RbConfig::CONFIG['host_os']
+    RbConfig::CONFIG['host_os'] = 'linux'
+
+    subject = Instana::Backend::ProcessInfo.new(OpenStruct.new(cmdline: 'test INSTANA_TEST=1 KV=2'))
+    assert_equal ['INSTANA_TEST=1', 'KV=2'], subject.arguments
+  ensure
+    RbConfig::CONFIG['host_os'] = host_os
+  end
+
+  def test_no_proc
+    subject = Instana::Backend::ProcessInfo.new(OpenStruct.new(pid: 0))
+
+    FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/ecs', '/proc')
+
+      assert_equal 0, subject.parent_pid
+      assert_nil subject.cpuset
+      assert_nil subject.sched_pid
+      refute subject.in_container?
+    end
+  end
+
+  def test_cpuset_proc
+    subject = Instana::Backend::ProcessInfo.new(OpenStruct.new(pid: 0))
+
+    FakeFS do
+      FakeFS::FileSystem.clone('test/support/proc', '/proc')
+      assert_equal '/', subject.cpuset
+      refute subject.in_container?
+    end
+  end
+
+  def test_sched_pid
+    subject = Instana::Backend::ProcessInfo.new(OpenStruct.new(pid: 1))
+
+    FakeFS do
+      FakeFS::FileSystem.clone('test/support/proc', '/proc')
+      refute_equal '/', subject.cpuset
+
+      assert subject.in_container?
+      assert_equal 35, subject.sched_pid
+      assert subject.from_parent_namespace
+      assert_equal subject.sched_pid, subject.parent_pid
+    end
+  end
+end

data/test/backend/request_client_test.rb

@@ -0,0 +1,39 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class RequestClientTest < Minitest::Test
+  def test_send_request_simple
+    stub_request(:get, 'http://example.com:9292/')
+      .to_return(body: 'ok', status: '200')
+
+    subject = Instana::Backend::RequestClient.new('example.com', 9292)
+    response = subject.send_request('GET', '/')
+
+    assert response.ok?
+    assert 'ok', response.body
+  end
+
+  def test_send_request_json
+    stub_request(:post, 'http://example.com:9292/')
+      .with(body: '{"key":"value"}')
+      .to_return(body: '{"ok": true}', status: '200')
+
+    subject = Instana::Backend::RequestClient.new('example.com', 9292)
+    response = subject.send_request('POST', '/', {key: 'value'})
+
+    assert response.ok?
+    assert_equal({"ok" => true}, response.json)
+  end
+
+  def test_send_request_failure
+    stub_request(:get, 'http://example.com:9292/')
+      .to_return(status: '500')
+
+    subject = Instana::Backend::RequestClient.new('example.com', 9292)
+    response = subject.send_request('GET', '/')
+
+    refute response.ok?
+  end
+end

data/test/backend/serverless_agent_test.rb

@@ -0,0 +1,73 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class ServerlesAgentTest < Minitest::Test
+  def test_report
+    stub_request(:post, "http://10.10.10.10:9292//bundle")
+      .to_return(status: 500)
+      .to_return(status: 200)
+
+    host_name = Class.new do
+      def host_name
+        'hello'
+      end
+    end.new
+
+    snapshots = [Instana::Snapshot::RubyProcess.new, host_name]
+    subject = Instana::Backend::ServerlessAgent.new(snapshots, timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/', logger: Logger.new('/dev/null'))
+
+    subject.timer.block.call
+    subject.timer.block.call
+  end
+
+  def test_ready
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/')
+    assert subject.ready?
+  end
+
+  def test_extra_headers
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/')
+    assert_equal [], subject.extra_headers
+  end
+
+  def test_secret_values
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/')
+    assert_equal({"matcher" => "contains-ignore-case", "list" => %w[key password secret]}, subject.secret_values)
+  end
+
+  def test_spawn_background_thread
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/')
+    subject.spawn_background_thread
+
+    assert subject.timer.running
+  end
+
+  def test_source
+    snapshot = Class.new do
+      def source
+        {test: 1}
+      end
+    end.new
+    subject = Instana::Backend::ServerlessAgent.new([snapshot], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/')
+
+    assert_equal({test: 1}, subject.source)
+    assert_equal({test: 1}, subject.source)
+  end
+
+  def test_missing_source
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/', logger: Logger.new('/dev/null'))
+
+    assert_equal({}, subject.source)
+  end
+
+  def test_report_error
+    stub_request(:post, "http://10.10.10.10:9292//bundle")
+      .to_return(status: 500)
+
+    subject = Instana::Backend::ServerlessAgent.new([], timer_class: MockTimer, backend_uri: 'http://10.10.10.10:9292/', logger: Logger.new('/dev/null'))
+
+    subject.timer.block.call
+  end
+end

data/test/config_test.rb

@@ -21,4 +21,14 @@ class ConfigTest < Minitest::Test
       assert_equal true, ::Instana.config[:metrics][k].key?(:enabled)
     end
   end
+
+  def test_custom_agent_host
+    subject = Instana::Config.new(logger: Logger.new('/dev/null'), agent_host: 'abc')
+    assert_equal 'abc', subject[:agent_host]
+  end
+
+  def test_custom_agent_port
+    subject = Instana::Config.new(logger: Logger.new('/dev/null'), agent_port: 'abc')
+    assert_equal 'abc', subject[:agent_port]
+  end
 end

data/test/instana_test.rb

@@ -16,10 +16,6 @@ class InstanaTest < Minitest::Test
     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
@@ -27,4 +23,15 @@ class InstanaTest < Minitest::Test
   def test_that_it_has_a_config
     refute_nil ::Instana.config
   end
+
+  def test_assign_logger
+    mock = Minitest::Mock.new
+    mock.expect(:info, true, [String])
+
+    ::Instana.logger = mock
+    ::Instana.logger.info('test')
+    ::Instana.logger = Logger.new('/dev/null')
+
+    mock.verify
+  end
 end

data/test/instrumentation/aws_test.rb

@@ -4,6 +4,10 @@
 require 'test_helper'
 
 class AwsTest < Minitest::Test
+  def setup
+    clear_all!
+  end
+
   def test_dynamo_db
     dynamo = Aws::DynamoDB::Client.new(
       region: "local",
@@ -27,7 +31,131 @@ class AwsTest < Minitest::Test
     assert rest.empty?
     assert_equal entry_span[:s], dynamo_span[:p]
     assert_equal :dynamodb, dynamo_span[:n]
-    assert_equal :get_item, dynamo_span[:data][:op]
-    assert_equal 'sample_table', dynamo_span[:data][:table]
+    assert_equal 'get', dynamo_span[:data][:dynamodb][:op]
+    assert_equal 'sample_table', dynamo_span[:data][:dynamodb][:table]
+  end
+
+  def test_s3
+    dynamo = Aws::S3::Client.new(
+      region: "local",
+      access_key_id: "minioadmin",
+      secret_access_key: "minioadmin",
+      endpoint: "http://localhost:9000"
+    )
+
+    assert_raises Aws::S3::Errors::NoSuchBucket do
+      Instana::Tracer.start_or_continue_trace(:s3_test, {}) do
+        dynamo.get_object(
+          bucket: 'sample_bucket',
+          key: 'sample_key'
+        )
+      end
+    end
+
+    spans = ::Instana.processor.queued_spans
+    s3_span, entry_span, *rest = spans
+
+    assert rest.empty?
+    assert_equal entry_span[:s], s3_span[:p]
+    assert_equal :s3, s3_span[:n]
+    assert_equal 'get', s3_span[:data][:s3][:op]
+    assert_equal 'sample_bucket', s3_span[:data][:s3][:bucket]
+    assert_equal 'sample_key', s3_span[:data][:s3][:key]
+  end
+
+  def test_sns_publish
+    sns = Aws::SNS::Client.new(
+      region: "local",
+      access_key_id: "test",
+      secret_access_key: "test",
+      endpoint: "http://localhost:9911"
+    )
+
+    assert_raises Aws::SNS::Errors::NotFound do
+      Instana::Tracer.start_or_continue_trace(:sns_test, {}) do
+        sns.publish(
+          topic_arn: 'topic:arn',
+          target_arn: 'target:arn',
+          phone_number: '555-0100',
+          subject: 'Test Subject',
+          message: 'Test Message'
+        )
+      end
+    end
+
+    spans = ::Instana.processor.queued_spans
+    aws_span, entry_span, *rest = spans
+
+    assert rest.empty?
+    assert_equal entry_span[:s], aws_span[:p]
+    assert_equal :sns, aws_span[:n]
+    assert_equal 'topic:arn', aws_span[:data][:sns][:topic]
+    assert_equal 'target:arn', aws_span[:data][:sns][:target]
+    assert_equal '555-0100', aws_span[:data][:sns][:phone]
+    assert_equal 'Test Subject', aws_span[:data][:sns][:subject]
+  end
+
+  def test_sns_other
+    sns = Aws::SNS::Client.new(
+      region: "local",
+      access_key_id: "test",
+      secret_access_key: "test",
+      endpoint: "http://localhost:9911"
+    )
+
+    Instana::Tracer.start_or_continue_trace(:sns_test, {}) do
+      sns.list_subscriptions
+    end
+
+    spans = ::Instana.processor.queued_spans
+    aws_span, entry_span, *rest = spans
+
+    assert rest.empty?
+    assert_equal entry_span[:s], aws_span[:p]
+    assert_equal :"net-http", aws_span[:n]
+  end
+
+  def test_sqs
+    sqs = Aws::SQS::Client.new(
+      region: "local",
+      access_key_id: "test",
+      secret_access_key: "test",
+      endpoint: "http://localhost:9324"
+    )
+
+    create_response = nil
+    get_url_response = nil
+
+    Instana::Tracer.start_or_continue_trace(:sqs_test, {}) do
+      create_response = sqs.create_queue(queue_name: 'test')
+      get_url_response = sqs.get_queue_url(queue_name: 'test')
+      sqs.send_message(queue_url: create_response.queue_url, message_body: 'Sample')
+    end
+
+    received = sqs.receive_message(
+      queue_url: create_response.queue_url,
+      message_attribute_names: ['All']
+    )
+    sqs.delete_queue(queue_url: create_response.queue_url)
+    message = received.messages.first
+    create_span, get_span, send_span, _root = ::Instana.processor.queued_spans
+
+    assert_equal :sqs, create_span[:n]
+    assert_equal create_response.queue_url, create_span[:data][:sqs][:queue]
+    assert_equal 'exit', create_span[:data][:sqs][:sort]
+    assert_equal 'create.queue', create_span[:data][:sqs][:type]
+
+    assert_equal :sqs, get_span[:n]
+    assert_equal get_url_response.queue_url, get_span[:data][:sqs][:queue]
+    assert_equal 'exit', get_span[:data][:sqs][:sort]
+    assert_equal 'get.queue', get_span[:data][:sqs][:type]
+
+    assert_equal :sqs, send_span[:n]
+    assert_equal get_url_response.queue_url, send_span[:data][:sqs][:queue]
+    assert_equal 'exit', send_span[:data][:sqs][:sort]
+    assert_equal 'single.sync', send_span[:data][:sqs][:type]
+    assert_equal send_span[:t], message.message_attributes['X_INSTANA_T'].string_value
+    assert_equal send_span[:s], message.message_attributes['X_INSTANA_S'].string_value
+    assert_equal 'Sample', message.body
   end
 end

data/test/instrumentation/excon_test.rb

@@ -22,7 +22,7 @@ class ExconTest < Minitest::Test
     url = "http://127.0.0.1:6511"
 
     connection = Excon.new(url)
-    Instana.tracer.start_or_continue_trace('excon-test') do
+    Instana.tracer.start_or_continue_trace(:'excon-test') do
       connection.get(:path => '/?basic_get')
     end
 
@@ -40,6 +40,7 @@ class ExconTest < Minitest::Test
     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)
@@ -146,4 +147,18 @@ class ExconTest < Minitest::Test
       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