instana 1.197.0 → 1.198.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a25aa837fcbb248cb39db1f57b7bdc8904810d5e63d87be7e12d912b7b9aea67
-  data.tar.gz: 836dc1f8d7ffc4c8c19e3fa90867a306fe7d407fb88a14481d44bde1dc482285
+  metadata.gz: 0b2d93394311ee04b29279b946a5b2d6bf74e567aecbeccef6ffa13b07224002
+  data.tar.gz: ba3febaf1f2089a0547ae9e30596de784bcc7636bb98906c287638233cfdc8a6
 SHA512:
-  metadata.gz: b8f3ba0fbf4a015ff1522a3c24e6b219594d2c266bc46427a93979e6ee159272d2c23a8fc53e4720021c5c531ad64ffd1d1f2644b8eb41497aaf8950c99ed8b6
-  data.tar.gz: 44e5b93aff42f542eaee494128e973a9447210fbffde21c4b361f1b00729c8b3378634241d64039453ea3dda0dc2a0d207473a0c5631f1f09e77726b2a827532
+  metadata.gz: 74d25b236d861ec5eb144780a34e7b44b13f747ca843ee7bc25c3387eba63fbe0f3128a63bf19828a17e7bd02ebe51164f9f72c52070bd46a2d291e433ab4caa
+  data.tar.gz: 2ce25e5cea1b1a38831a481e571603fe99b67143ee7653c38081e1df5c8989f13f02e6490dad28500c63fff99277937b9be7052d0f7cf679ce0c46ce36cb5c21

data/lib/instana/backend/agent.rb

@@ -15,7 +15,9 @@ module Instana
       end
 
       def setup
-        @delegate = if @fargate_metadata_uri && ENV.key?('INSTANA_ENDPOINT_URL')
+        @delegate = if ENV.key?('_HANDLER')
+                      ServerlessAgent.new([Snapshot::LambdaFunction.new])
+                    elsif @fargate_metadata_uri && ENV.key?('INSTANA_ENDPOINT_URL')
                       ServerlessAgent.new(fargate_snapshots)
                     else
                       HostAgent.new

data/lib/instana/backend/request_client.rb

@@ -33,9 +33,10 @@ module Instana
       end
 
       def initialize(host, port, use_ssl: false)
+        timeout = Integer(ENV.fetch('INSTANA_TIMEOUT', 500))
         @host = host
         @port = port
-        @client = Net::HTTP.start(host, port, use_ssl: use_ssl)
+        @client = Net::HTTP.start(host, port, use_ssl: use_ssl, read_timeout: timeout)
       end
 
       # Send a request to the backend. If data is a {Hash},

data/lib/instana/backend/serverless_agent.rb

@@ -39,12 +39,10 @@ module Instana
 
       # @return [Hash, NilClass] the backend friendly description of the current in process collector
       def source
-        return @source if @source
-
         snapshot = @snapshots.detect { |s| s.respond_to?(:source) }
 
         if snapshot
-          @source = snapshot.source
+          snapshot.source
         else
           @logger.warn('Unable to find a snapshot which provides a source.')
           {}
@@ -58,21 +56,10 @@ module Instana
 
       # @return [Hash] values which are removed from urls sent to the backend
       def secret_values
-        # TODO: Parse from env
         matcher, *keys = @secrets.split(/[:,]/)
         {'matcher' => matcher, 'list' => keys}
       end
 
-      private
-
-      def request_headers
-        {
-          'X-Instana-Host' => host_name,
-          'X-Instana-Key' => ENV['INSTANA_AGENT_KEY'],
-          'X-Instana-Time' => (Time.now.to_i * 1000).to_s
-        }
-      end
-
       def send_bundle
         spans = @processor.queued_spans
         bundle = {
@@ -90,6 +77,16 @@ module Instana
         @logger.warn("Recived a `#{response.code}` when sending data.")
       end
 
+      private
+
+      def request_headers
+        {
+          'X-Instana-Host' => host_name,
+          'X-Instana-Key' => ENV['INSTANA_AGENT_KEY'],
+          'X-Instana-Time' => (Time.now.to_i * 1000).to_s
+        }
+      end
+
       def agent_snapshots
         @snapshots.map do |snapshot|
           begin # rubocop:disable Style/RedundantBegin, Lint/RedundantCopDisableDirective
@@ -102,12 +99,10 @@ module Instana
       end
 
       def host_name
-        return @host_name if @host_name
-
         snapshot = @snapshots.detect { |s| s.respond_to?(:host_name) }
 
         if snapshot
-          @host_name = snapshot.host_name
+          snapshot.host_name
         else
           @logger.warn('Unable to find a snapshot which provides a host_name.')
           ''

data/lib/instana/base.rb

@@ -13,6 +13,7 @@ module Instana
     attr_accessor :config
     attr_accessor :pid
     attr_reader :secrets
+    attr_reader :serverless
 
     ##
     # setup
@@ -25,6 +26,7 @@ module Instana
       @tracer = ::Instana::Tracer.new
       @processor = ::Instana::Processor.new
       @secrets = ::Instana::Secrets.new
+      @serverless = ::Instana::Serverless.new
     end
 
     def logger

data/lib/instana/serverless.rb

@@ -0,0 +1,133 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'base64'
+require 'zlib'
+
+require 'instana/instrumentation/instrumented_request'
+
+module Instana
+  # @since 1.198.0
+  class Serverless
+    def initialize(agent: ::Instana.agent, tracer: ::Instana.tracer, logger: ::Instana.logger)
+      @agent = agent
+      @tracer = tracer
+      @logger = logger
+    end
+
+    def wrap_aws(event, context, &block)
+      Thread.current[:instana_function_arn] = [context.invoked_function_arn, context.function_version].join(':')
+      trigger, event_tags, span_context = trigger_from_event(event)
+
+      tags = {
+        lambda: {
+          arn: context.invoked_function_arn,
+          functionName: context.function_name,
+          functionVersion: context.function_version,
+          runtime: 'ruby',
+          trigger: trigger
+        }
+      }
+
+      if event_tags.key?(:http)
+        tags = tags.merge(event_tags)
+      else
+        tags[:lambda] = tags[:lambda].merge(event_tags)
+      end
+
+      @tracer.start_or_continue_trace(:'aws.lambda.entry', tags, span_context, &block)
+    ensure
+      begin
+        @agent.send_bundle
+      rescue StandardError => e
+        @logger.error(e.message)
+      end
+      Thread.current[:instana_function_arn] = nil
+    end
+
+    private
+
+    def trigger_from_event(event) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      case event
+      when ->(e) { e.is_a?(Hash) && e.key?('requestContext') && e['requestContext'].key?('elb') }
+        request = InstrumentedRequest.new(event_to_rack(event))
+        ['aws:application.load.balancer', {http: request.request_tags}, request.incoming_context]
+      when ->(e) { e.is_a?(Hash) && e.key?('httpMethod') && e.key?('path') && e.key?('headers') }
+        request = InstrumentedRequest.new(event_to_rack(event))
+        ['aws:api.gateway', {http: request.request_tags}, request.incoming_context]
+      when ->(e) { e.is_a?(Hash) && e['source'] == 'aws.events' && e['detail-type'] == 'Scheduled Event' }
+        tags = decode_cloudwatch_events(event)
+        ['aws:cloudwatch.events', {cw: tags}, {}]
+      when ->(e) { e.is_a?(Hash) && e.key?('awslogs') }
+        tags = decode_cloudwatch_logs(event)
+        ['aws:cloudwatch.logs', {cw: tags}, {}]
+      when ->(e) { e.is_a?(Hash) && e.key?('Records') && e['Records'].is_a?(Array) && e['Records'].first && e['Records'].first['source'] == 'aws:s3' }
+        tags = decode_s3(event)
+        ['aws:s3', {s3: tags}, {}]
+      when ->(e) { e.is_a?(Hash) && e.key?('Records') && e['Records'].is_a?(Array) && e['Records'].first && e['Records'].first['source'] == 'aws:sqs' }
+        tags = decode_sqs(event)
+        ['aws:sqs', {sqs: tags}, {}]
+      else
+        ['aws:api.gateway.noproxy', {}, {}]
+      end
+    end
+
+    def event_to_rack(event)
+      event['headers']
+        .transform_keys { |k| "HTTP_#{k.gsub('-', '_').upcase}" }
+        .merge(
+          'QUERY_STRING' => URI.encode_www_form(event['queryStringParameters'] || {}),
+          'PATH_INFO' => event['path'],
+          'REQUEST_METHOD' => event['httpMethod']
+        )
+    end
+
+    def decode_cloudwatch_events(event)
+      {
+        events: {
+          id: event['id'],
+          resources: event['resources']
+        }
+      }
+    end
+
+    def decode_cloudwatch_logs(event)
+      logs = begin
+        payload = JSON.parse(Zlib::Inflate.inflate(Base64.decode64(event['awslogs']['data'])))
+
+        {
+          group: payload['logGroup'],
+          stream: payload['logStream']
+        }
+      rescue StandardError => e
+        {
+          decodingError: e.message
+        }
+      end
+
+      {logs: logs}
+    end
+
+    def decode_s3(event)
+      span_events = event['Records'].map do |record|
+        {
+          name: record['eventName'],
+          bucket: record['s3'] && record['s3']['bucket'] ? record['s3']['bucket']['name'] : nil,
+          object: record['s3'] && record['s3']['object'] ? record['s3']['object']['key'] : nil
+        }
+      end
+
+      {events: span_events}
+    end
+
+    def decode_sqs(event)
+      span_events = event['Records'].map do |record|
+        {
+          queue: record['eventSourceARN']
+        }
+      end
+
+      {messages: span_events}
+    end
+  end
+end

data/lib/instana/setup.rb

@@ -9,6 +9,8 @@ require "instana/secrets"
 require "instana/tracer"
 require "instana/tracing/processor"
 
+require 'instana/serverless'
+
 require 'instana/activator'
 
 require 'instana/backend/request_client'
@@ -21,6 +23,7 @@ require 'instana/snapshot/fargate_process'
 require 'instana/snapshot/fargate_task'
 require 'instana/snapshot/fargate_container'
 require 'instana/snapshot/docker_container'
+require 'instana/snapshot/lambda_function'
 
 require 'instana/backend/host_agent_lookup'
 require 'instana/backend/host_agent_activation_observer'

data/lib/instana/snapshot/lambda_function.rb

@@ -1,5 +1,8 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
 module Instana
-  module Backend
+  module Snapshot
     # @since 1.198.0
     class LambdaFunction
       ID = "com.instana.plugin.aws.lambda".freeze
@@ -22,15 +25,15 @@ module Instana
 
       def source
         {
-
+          hl: true,
+          cp: "aws",
+          e: entity_id
         }
       end
 
       def host_name
         entity_id
       end
-
-
     end
   end
 end

data/lib/instana/tracing/span.rb

@@ -6,8 +6,8 @@ module Instana
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
                          :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
-                         :redis, :'resque-client', :'resque-worker', :'graphql.server', :dynamodb, :s3, :sns, :sqs  ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server', :sqs ].freeze
+                         :redis, :'resque-client', :'resque-worker', :'graphql.server', :dynamodb, :s3, :sns, :sqs, :'aws.lambda.entry'  ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server', :sqs, :'aws.lambda.entry' ].freeze
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
                    :'rpc-client', :'sidekiq-client', :redis, :dynamodb, :s3, :sns, :sqs ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze

data/lib/instana/version.rb

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

data/test/backend/agent_test.rb

@@ -43,6 +43,19 @@ 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_delegate_super
     subject = Instana::Backend::Agent.new
     assert_raises NoMethodError do

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

data/test/snapshot/lambda_function_test.rb

@@ -0,0 +1,37 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class LambdaFunctionTest < Minitest::Test
+  def setup
+    @subject = Instana::Snapshot::LambdaFunction.new
+  end
+
+  def test_snapshot
+    Thread.current[:instana_function_arn] = 'test'
+
+    assert_equal Instana::Snapshot::LambdaFunction::ID, @subject.snapshot[:name]
+    assert_equal Thread.current[:instana_function_arn], @subject.snapshot[:entityId]
+  ensure
+    Thread.current[:instana_function_arn] = nil
+  end
+
+  def test_source
+    Thread.current[:instana_function_arn] = 'test'
+
+    assert @subject.source[:hl]
+    assert_equal 'aws', @subject.source[:cp]
+    assert_equal Thread.current[:instana_function_arn], @subject.source[:e]
+  ensure
+    Thread.current[:instana_function_arn] = nil
+  end
+
+  def test_host_name
+    Thread.current[:instana_function_arn] = 'test'
+
+    assert_equal Thread.current[:instana_function_arn], @subject.host_name
+  ensure
+    Thread.current[:instana_function_arn] = nil
+  end
+end

data/test/tracing/id_management_test.rb

@@ -68,6 +68,10 @@ class TracerIDMgmtTest < Minitest::Test
     # Bogus Array arg
     bogus_result = Instana::Util.header_to_id([1234])
     assert_equal '', bogus_result
+
+    # Invalid characters/length
+    bogus_result = Instana::Util.header_to_id('qwerty')
+    assert_equal '', bogus_result
   end
 
   def test_long_id_trim

data/test/tracing/span_context_test.rb

@@ -15,7 +15,8 @@ class SpanContextTest < Minitest::Test
   end
 
   def test_flags_level_zero
-    subject = Instana::SpanContext.new('trace', 'span', 0)
+    subject = Instana::SpanContext.new('trace', 'span', 0, {external_state: 'cn=test'})
     assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
+    assert_equal 'cn=test', subject.trace_state_header
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 1.197.0
+  version: 1.198.0.pre1
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2021-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -255,6 +255,7 @@ files:
 - lib/instana/open_tracing/instana_tracer.rb
 - lib/instana/rack.rb
 - lib/instana/secrets.rb
+- lib/instana/serverless.rb
 - lib/instana/setup.rb
 - lib/instana/snapshot/deltable.rb
 - lib/instana/snapshot/docker_container.rb
@@ -307,11 +308,13 @@ files:
 - test/instrumentation/sidekiq-client_test.rb
 - test/instrumentation/sidekiq-worker_test.rb
 - test/secrets_test.rb
+- test/serverless_test.rb
 - test/snapshot/deltable_test.rb
 - test/snapshot/docker_container_test.rb
 - test/snapshot/fargate_container_test.rb
 - test/snapshot/fargate_process_test.rb
 - test/snapshot/fargate_task_test.rb
+- test/snapshot/lambda_function_test.rb
 - test/snapshot/ruby_process_test.rb
 - test/support/apps/active_record/active_record.rb
 - test/support/apps/grpc/boot.rb
@@ -358,9 +361,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.6
 signing_key: 
@@ -368,6 +371,7 @@ specification_version: 4
 summary: Ruby Distributed Tracing & Metrics Sensor for Instana
 test_files:
 - test/config_test.rb
+- test/serverless_test.rb
 - test/activator_test.rb
 - test/tracing/span_context_test.rb
 - test/tracing/span_test.rb
@@ -382,6 +386,7 @@ test_files:
 - test/snapshot/deltable_test.rb
 - test/snapshot/fargate_task_test.rb
 - test/snapshot/ruby_process_test.rb
+- test/snapshot/lambda_function_test.rb
 - test/snapshot/fargate_container_test.rb
 - test/backend/host_agent_activation_observer_test.rb
 - test/backend/host_agent_reporting_observer_test.rb