instana 1.197.0.pre1 → 1.199.0

data/lib/instana/util.rb

@@ -156,8 +156,10 @@ module Instana
       #
       # @return [String]
       #
-      def header_to_id(header_id)
-        header_id.is_a?(String) && header_id.match(/\A[a-z\d]{16,32}\z/i) ? header_id : ''
+      def header_to_id(given)
+        return '' unless given.is_a?(String)
+        return '' unless given.match(/\A[a-z\d]{16,32}\z/i)
+        given
       end
     end
   end

data/lib/instana/version.rb

@@ -2,6 +2,6 @@
 # (c) Copyright Instana Inc. 2016
 
 module Instana
-  VERSION = "1.197.0.pre1"
+  VERSION = "1.199.0"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/backend/agent_test.rb

@@ -43,6 +43,32 @@ class AgentTest < Minitest::Test
     ENV['ECS_CONTAINER_METADATA_URI'] = nil
   end
 
+  def test_lambda
+    ENV['_HANDLER'] = 'TEST_FUNCTION'
+    ENV['INSTANA_ENDPOINT_URL'] = 'http://example.com'
+
+    subject = Instana::Backend::Agent.new
+    assert_nil subject.delegate
+    subject.setup
+    assert subject.delegate.is_a?(Instana::Backend::ServerlessAgent)
+  ensure
+    ENV['_HANDLER'] = nil
+    ENV['INSTANA_ENDPOINT_URL'] = nil
+  end
+
+  def test_google_cloud
+    ENV['K_REVISION'] = 'TEST'
+    ENV['INSTANA_ENDPOINT_URL'] = 'http://example.com'
+
+    subject = Instana::Backend::Agent.new
+    assert_nil subject.delegate
+    subject.setup
+    assert subject.delegate.is_a?(Instana::Backend::ServerlessAgent)
+  ensure
+    ENV['K_REVISION'] = nil
+    ENV['INSTANA_ENDPOINT_URL'] = nil
+  end
+
   def test_delegate_super
     subject = Instana::Backend::Agent.new
     assert_raises NoMethodError do

data/test/backend/host_agent_activation_observer_test.rb

@@ -4,6 +4,10 @@
 require 'test_helper'
 
 class HostAgentActivationObserverTest < Minitest::Test
+  def setup
+    @socket_proc = ->(_c) { OpenStruct.new(fileno: 0) }
+  end
+
   def test_standard_discovery
     stub_request(:put, "http://10.10.10.10:9292/com.instana.plugin.ruby.discovery")
       .and_timeout
@@ -17,7 +21,7 @@ class HostAgentActivationObserverTest < Minitest::Test
     client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
     discovery = Concurrent::Atom.new(nil)
 
-    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1)
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1, socket_proc: @socket_proc)
 
     subject.update(nil, nil, nil)
     assert_equal({'pid' => 1234}, discovery.value)
@@ -31,15 +35,18 @@ class HostAgentActivationObserverTest < Minitest::Test
       .and_return(status: 200, body: '{"ok": true}')
 
     client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
-    # This is the cleanest way to fake it so it works across all test environments
-    client.define_singleton_method(:fileno) { '0' }
-    client.define_singleton_method(:inode) { '0' }
-
     discovery = Concurrent::Atom.new(nil)
 
-    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1)
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1, socket_proc: @socket_proc)
 
-    subject.update(nil, nil, nil)
+    FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/proc', '/proc')
+      FakeFS::FileSystem.clone('test/support/proc/0', "/proc/#{Process.pid}")
+      Dir.mkdir('/proc/self/fd')
+      File.symlink('/proc/self/sched', "/proc/self/fd/0")
+
+      subject.update(nil, nil, nil)
+    end
 
     assert_equal({'pid' => 1234}, discovery.value)
   end
@@ -48,7 +55,7 @@ class HostAgentActivationObserverTest < Minitest::Test
     client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
     discovery = Concurrent::Atom.new(nil)
 
-    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), proc_table: nil)
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), proc_table: nil, socket_proc: @socket_proc)
 
     subject.update(nil, nil, nil)
     assert_nil discovery.value
@@ -58,7 +65,7 @@ class HostAgentActivationObserverTest < Minitest::Test
     client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
     discovery = Concurrent::Atom.new(nil)
 
-    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery)
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, socket_proc: @socket_proc)
     assert_nil subject.update(nil, nil, true)
     assert_nil discovery.value
   end

data/test/backend/host_agent_test.rb

@@ -4,19 +4,34 @@
 require 'test_helper'
 
 class HostAgentTest < Minitest::Test
-  def test_setup
+  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)
-    subject.setup
+
+    FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/ecs', '/proc')
+      subject.spawn_background_thread
+    end
+
+    subject.future.value!
 
     discovery.verify
   ensure

data/test/backend/request_client_test.rb

@@ -36,26 +36,4 @@ class RequestClientTest < Minitest::Test
 
     refute response.ok?
   end
-
-  def test_fileno
-    subject = Instana::Backend::RequestClient.new('example.com', 9292)
-    assert_nil subject.fileno
-  end
-
-  def test_inode
-    subject = Instana::Backend::RequestClient.new('example.com', 9292)
-    subject.define_singleton_method(:fileno) { '0' } # This is the cleanest way to fake it so it works across all test environments
-    FakeFS.with_fresh do
-      FakeFS::FileSystem.clone('test/support/proc', '/proc')
-      Dir.mkdir('/proc/self/fd')
-      File.symlink('/proc/self/sched', '/proc/self/fd/0')
-
-      assert_equal '/proc/self/sched', subject.inode
-    end
-  end
-
-  def test_inode_no_proc
-    subject = Instana::Backend::RequestClient.new('example.com', 9292)
-    assert_nil subject.inode
-  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'
     }
 

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