instana 1.195.3 → 1.198.0.pre1

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/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
 
@@ -147,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

data/test/instrumentation/rack_instrumented_request_test.rb

@@ -29,6 +29,7 @@ class RackInstrumentedRequestTest < Minitest::Test
     expected = {
       trace_id: id,
       span_id: id,
+      from_w3: false,
       level: '1'
     }
 
@@ -47,6 +48,7 @@ class RackInstrumentedRequestTest < Minitest::Test
       external_state: nil,
       trace_id: 'a3ce929d0e0e4736',
       span_id: '00f067aa0ba902b7',
+      from_w3: true,
       level: '1'
     }
 
@@ -81,7 +83,8 @@ class RackInstrumentedRequestTest < Minitest::Test
   end
 
   def test_request_tags
-    ::Instana.agent.extra_headers = %w[X-Capture-This]
+    ::Instana.agent.define_singleton_method(:extra_headers) { %w[X-Capture-This] }
+
     req = Instana::InstrumentedRequest.new(
       'HTTP_HOST' => 'example.com',
       'REQUEST_METHOD' => 'GET',
@@ -101,7 +104,7 @@ class RackInstrumentedRequestTest < Minitest::Test
     }
 
     assert_equal expected, req.request_tags
-    ::Instana.agent.extra_headers = nil
+    ::Instana.agent.singleton_class.send(:remove_method, :extra_headers)
   end
 
   def test_correlation_data_valid

data/test/instrumentation/rack_test.rb

@@ -80,9 +80,6 @@ class RackTest < Minitest::Test
     assert_equal 200, rack_span[:data][:http][:status]
     assert_equal 'example.org', rack_span[:data][:http][:host]
     assert rack_span.key?(:f)
-    assert rack_span[:f].key?(:e)
-    assert rack_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
     assert !rack_span.key?(:stack)
 
     # Restore to default
@@ -134,9 +131,6 @@ class RackTest < Minitest::Test
     assert_equal "/mrlobster", rack_span[:data][:http][:url]
     assert_equal 200, rack_span[:data][:http][:status]
     assert rack_span.key?(:f)
-    assert rack_span[:f].key?(:e)
-    assert rack_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_basic_put
@@ -166,9 +160,6 @@ class RackTest < Minitest::Test
     assert_equal "/mrlobster", rack_span[:data][:http][:url]
     assert_equal 200, rack_span[:data][:http][:status]
     assert rack_span.key?(:f)
-    assert rack_span[:f].key?(:e)
-    assert rack_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_context_continuation
@@ -202,9 +193,6 @@ class RackTest < Minitest::Test
     assert_equal "/mrlobster", rack_span[:data][:http][:url]
     assert_equal 200, rack_span[:data][:http][:status]
     assert rack_span.key?(:f)
-    assert rack_span[:f].key?(:e)
-    assert rack_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
 
     # Context validation
     # The first span should have the passed in trace ID
@@ -260,7 +248,7 @@ class RackTest < Minitest::Test
   def test_custom_headers_capture
     clear_all!
     ::Instana.config[:collect_backtraces] = true
-    ::Instana.agent.extra_headers = %w(X-Capture-This X-Capture-That)
+    ::Instana.agent.define_singleton_method(:extra_headers) { %w(X-Capture-This X-Capture-That) }
 
     get '/mrlobster', {}, { "HTTP_X_CAPTURE_THIS" => "ThereYouGo" }
     assert last_response.ok?
@@ -280,7 +268,7 @@ class RackTest < Minitest::Test
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
-    ::Instana.agent.extra_headers = nil
+    ::Instana.agent.singleton_class.send(:remove_method, :extra_headers)
   end
 
   def test_capture_http_path_template

data/test/secrets_test.rb

@@ -5,72 +5,91 @@ require 'test_helper'
 
 class SecretsTest < Minitest::Test
   def setup
-    @subject = Instana::Secrets.new
+    @subject = Instana::Secrets.new(logger: Logger.new('/dev/null'))
   end
-  
+
   def test_equals_ignore_case
     sample_config = {
-      "matcher"=>"equals-ignore-case", 
+      "matcher"=>"equals-ignore-case",
       "list"=>["key"]
     }
-    
+
     url = url_for(%w(key Str kEy KEY))
     assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy KEY)
   end
-  
+
   def test_equals
     sample_config = {
-      "matcher"=>"equals", 
+      "matcher"=>"equals",
       "list"=>["key", "kEy"]
     }
-    
+
     url = url_for(%w(key Str kEy KEY))
     assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy)
   end
-  
+
   def test_contains_ignore_case
     sample_config = {
-      "matcher"=>"contains-ignore-case", 
+      "matcher"=>"contains-ignore-case",
       "list"=>["stan"]
     }
-    
+
     url = url_for(%w(instantiate conTESTant sample))
     assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate conTESTant)
   end
-  
+
   def test_contains
     sample_config = {
-      "matcher"=>"contains", 
+      "matcher"=>"contains",
       "list"=>["stan"]
     }
-    
+
     url = url_for(%w(instantiate conTESTant sample))
     assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
-  
   end
-  
+
   def test_regexp
     sample_config = {
-      "matcher"=>"regex", 
+      "matcher"=>"regex",
       "list"=>["l{2}"]
     }
-    
+
     url = url_for(%w(ball foot move))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(ball) 
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(ball)
+  end
+
+  def test_invalid
+    sample_config = {
+      "matcher"=>"test_invalid",
+      "list"=>["key"]
+    }
+
+    url = url_for(%w(key Str kEy KEY))
+    assert_redacted @subject.remove_from_query(url, sample_config), []
+  end
+
+  def test_without_scheme
+    sample_config = {
+      "matcher"=>"contains",
+      "list"=>["stan"]
+    }
+
+    url = 'example.com?instantiate=true'
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
   end
-  
+
   private
-  
+
   def url_for(keys)
     url = URI('http://example.com')
     url.query = URI.encode_www_form(keys.map { |k| [k, rand(1..100)]})
     url.to_s
   end
-  
+
   def assert_redacted(str, keys)
     url = URI(str)
     params = CGI.parse(url.query)
-    
+
     assert_equal keys, params.select { |_, v| v == %w(<redacted>) }.keys, 'to be redacted'
   end
 end

data/test/serverless_test.rb

@@ -0,0 +1,323 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class ServerlessTest < Minitest::Test
+  def setup
+    @mock_agent = Minitest::Mock.new
+    @mock_agent.expect(:send_bundle, true, [])
+    @subject = Instana::Serverless.new(agent: @mock_agent)
+  end
+
+  def teardown
+    @mock_agent.verify
+  end
+
+  def test_lambda_send_error
+    mock_logger = Minitest::Mock.new
+    mock_logger.expect(:error, true, [String])
+
+    @mock_agent.expect(:send_bundle, true) { |_args| raise StandardError, 'error' }
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+
+    subject = Instana::Serverless.new(agent: @mock_agent, logger: mock_logger)
+    subject.wrap_aws(nil, mock_context) { 0 }
+    subject.wrap_aws(nil, mock_context) { 0 }
+
+    mock_logger.verify
+  end
+
+  def test_lambda_data
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+
+    @subject.wrap_aws(nil, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda]
+
+    assert_equal 'aws:api.gateway.noproxy', lambda_span[:data][:lambda][:trigger]
+
+    assert_equal mock_context.invoked_function_arn, data[:arn]
+    assert_equal mock_context.function_name, data[:functionName]
+    assert_equal mock_context.function_version, data[:functionVersion]
+    assert_equal 'ruby', data[:runtime]
+  end
+
+  def test_lambda_http
+    clear_all!
+
+    mock_id = Instana::Util.generate_id
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_http = {
+      "headers" => {
+        "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "Accept-Encoding" => "gzip, deflate",
+        "Accept-Language" => "en-US,en;q=0.5",
+        "Connection" => "keep-alive",
+        "Host" => "127.0.0.1:3000",
+        "Upgrade-Insecure-Requests" => "1",
+        "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:87.0) Gecko/20100101 Firefox/87.0",
+        "X-Forwarded-Port" => "3000",
+        "X-Forwarded-Proto" => "http",
+        'X-Instana-S' => mock_id,
+        'X-Instana-T' => mock_id,
+        'X-Instana-L' => '1'
+      },
+      "httpMethod" => "GET",
+      "path" => "/hello",
+      "queryStringParameters" => {"test" => "abcde"}
+    }
+
+    @subject.wrap_aws(mock_http, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:http]
+
+    assert_equal 'aws:api.gateway', lambda_span[:data][:lambda][:trigger]
+    assert_equal mock_id, lambda_span[:t]
+    assert_equal mock_id, lambda_span[:p]
+
+    assert_equal 'GET', data[:method]
+    assert_equal '/hello', data[:url]
+    assert_equal '127.0.0.1:3000', data[:host]
+    assert_equal 'test=abcde', data[:params]
+  end
+
+  def test_lambda_alb
+    clear_all!
+
+    mock_id = Instana::Util.generate_id
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_http = {
+      "headers" => {
+        "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "Accept-Encoding" => "gzip, deflate",
+        "Accept-Language" => "en-US,en;q=0.5",
+        "Connection" => "keep-alive",
+        "Host" => "127.0.0.1:3000",
+        "Upgrade-Insecure-Requests" => "1",
+        "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:87.0) Gecko/20100101 Firefox/87.0",
+        "X-Forwarded-Port" => "3000",
+        "X-Forwarded-Proto" => "http",
+        'X-Instana-S' => mock_id,
+        'X-Instana-T' => mock_id,
+        'X-Instana-L' => '1'
+      },
+      "httpMethod" => "GET",
+      "path" => "/hello",
+      "requestContext" => { "elb" => {} }
+    }
+
+    @subject.wrap_aws(mock_http, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:http]
+
+    assert_equal 'aws:application.load.balancer', lambda_span[:data][:lambda][:trigger]
+    assert_equal mock_id, lambda_span[:t]
+    assert_equal mock_id, lambda_span[:p]
+
+    assert_equal 'GET', data[:method]
+    assert_equal '/hello', data[:url]
+    assert_equal '127.0.0.1:3000', data[:host]
+    assert_equal '', data[:params]
+  end
+
+  def test_lambda_cw_event
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "detail-type" => "Scheduled Event",
+      "source" => "aws.events",
+      "id" => "test",
+      "resources" => ["test"]
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:cw][:events]
+
+    assert_equal 'aws:cloudwatch.events', lambda_span[:data][:lambda][:trigger]
+    assert_equal 'test', data[:id]
+    assert_equal ["test"], data[:resources]
+  end
+
+  def test_lambda_cw_logs
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "awslogs" => {"data" => File.read('test/support/serverless/cloudwatch_log.bin')}
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:cw][:logs]
+
+    assert_equal 'aws:cloudwatch.logs', lambda_span[:data][:lambda][:trigger]
+    assert_equal '/aws/lambda/echo-nodejs', data[:group]
+    assert_equal '2019/03/13/[$LATEST]94fa867e5374431291a7fc14e2f56ae7', data[:stream]
+  end
+
+  def test_lambda_cw_error
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "awslogs" => {"data" => "error"}
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:cw][:logs]
+
+    assert_equal 'aws:cloudwatch.logs', lambda_span[:data][:lambda][:trigger]
+    assert_equal 'incorrect header check', data[:decodingError]
+  end
+
+  def test_lambda_s3
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "Records" => [
+        {
+          "source" => "aws:s3",
+          "eventName" => "test",
+          "s3" => {
+            "bucket" => {"name" => "test_bucket"},
+            "object" => {"key" => "test_key"}
+          }
+        }
+      ]
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:s3]
+
+    assert_equal 'aws:s3', lambda_span[:data][:lambda][:trigger]
+    assert_equal 1, data[:events].length
+
+    assert_equal 'test', data[:events].first[:name]
+    assert_equal 'test_bucket', data[:events].first[:bucket]
+    assert_equal 'test_key', data[:events].first[:object]
+  end
+
+  def test_lambda_s3_no_object
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "Records" => [
+        {
+          "source" => "aws:s3",
+          "eventName" => "test"
+        }
+      ]
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:s3]
+
+    assert_equal 'aws:s3', lambda_span[:data][:lambda][:trigger]
+    assert_equal 1, data[:events].length
+
+    assert_equal 'test', data[:events].first[:name]
+    assert_nil data[:events].first[:bucket]
+    assert_nil data[:events].first[:object]
+  end
+
+  def test_lambda_sqs
+    clear_all!
+
+    mock_context = OpenStruct.new(
+      invoked_function_arn: 'test_arn',
+      function_name: 'test_function',
+      function_version: '$TEST'
+    )
+    mock_event = {
+      "Records" => [
+        {
+          "source" => "aws:sqs",
+          "eventSourceARN" => "test_arn"
+        }
+      ]
+    }
+
+    @subject.wrap_aws(mock_event, mock_context) { 0 }
+
+    lambda_span, *rest = Instana.processor.queued_spans
+    assert rest.empty?
+
+    data = lambda_span[:data][:lambda][:sqs]
+
+    assert_equal 'aws:sqs', lambda_span[:data][:lambda][:trigger]
+    assert_equal 1, data[:messages].length
+
+    assert_equal 'test_arn', data[:messages].first[:queue]
+  end
+end