instana 1.197.0 → 1.199.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a25aa837fcbb248cb39db1f57b7bdc8904810d5e63d87be7e12d912b7b9aea67
-  data.tar.gz: 836dc1f8d7ffc4c8c19e3fa90867a306fe7d407fb88a14481d44bde1dc482285
+  metadata.gz: 59560cefe64546d0f6b072839e04cc21d5abe77087111a66acd48b16433bd6b3
+  data.tar.gz: f56219f6107b11353e51bac144119d698baa3e4d5859929cd59a47627761cb02
 SHA512:
-  metadata.gz: b8f3ba0fbf4a015ff1522a3c24e6b219594d2c266bc46427a93979e6ee159272d2c23a8fc53e4720021c5c531ad64ffd1d1f2644b8eb41497aaf8950c99ed8b6
-  data.tar.gz: 44e5b93aff42f542eaee494128e973a9447210fbffde21c4b361f1b00729c8b3378634241d64039453ea3dda0dc2a0d207473a0c5631f1f09e77726b2a827532
+  metadata.gz: b3c9cc9ab3175e4f47cf722c91a8c40189fe27fd21fd4c71fbcbf1d82c65af205c3afb9636add9418ba2c52a3adf05940c948819700491c9a51d719b40566781
+  data.tar.gz: 0daca1718f70837be8504ab239a034432c50cf46a1380bfcf46b40059638a31455b8904c2b5019b7f880787acbe0462ada2457f135f451a680fa2253b68a0ce0

data/lib/instana/backend/agent.rb

@@ -15,7 +15,15 @@ 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 ENV.key?('K_REVISION') && ENV.key?('INSTANA_ENDPOINT_URL')
+                      ServerlessAgent.new([
+                                            Snapshot::GoogleCloudRunProcess.new,
+                                            Snapshot::GoogleCloudRunInstance.new,
+                                            Snapshot::RubyProcess.new
+                                          ])
+                    elsif @fargate_metadata_uri && ENV.key?('INSTANA_ENDPOINT_URL')
                       ServerlessAgent.new(fargate_snapshots)
                     else
                       HostAgent.new

data/lib/instana/backend/host_agent.rb

@@ -30,6 +30,9 @@ module Instana
         end
       end
 
+      alias start spawn_background_thread
+      alias after_fork spawn_background_thread
+
       # @return [Boolean] true if the agent able to send spans to the backend
       def ready?
         ENV.key?('INSTANA_TEST') || !@discovery.value.nil?

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/secrets.rb

@@ -13,21 +13,31 @@ module Instana
     def remove_from_query(str, secret_values = Instana.agent.secret_values)
       return str unless secret_values
 
-      url = URI(str)
-      params = url.scheme ? CGI.parse(url.query || '') : CGI.parse(url.to_s)
+      begin
+        url = URI(str)
+        params = url.scheme ? CGI.parse(url.query || '') : CGI.parse(url.to_s)
+
+        redacted = redact(params, secret_values)
+
+        url.query = URI.encode_www_form(redacted)
+        url.scheme ? CGI.unescape(url.to_s) : CGI.unescape(url.query)
+      rescue URI::InvalidURIError => _e
+        params = CGI.parse(str || '')
+        redacted = redact(params, secret_values)
+        CGI.unescape(URI.encode_www_form(redacted))
+      end
+    end
+
+    private
 
-      redacted = params.map do |k, v|
+    def redact(params, secret_values)
+      params.map do |k, v|
         needs_redaction = secret_values['list']
           .any? { |t| matcher(secret_values['matcher']).(t,k) }
         [k, needs_redaction ? '<redacted>' : v]
       end
-
-      url.query = URI.encode_www_form(redacted)
-      url.scheme ? CGI.unescape(url.to_s) : CGI.unescape(url.query)
     end
 
-    private
-
     def matcher(name)
       case name
       when 'equals-ignore-case'

data/lib/instana/serverless.rb

@@ -0,0 +1,139 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'base64'
+require 'zlib'
+
+# :nocov:
+begin
+  require 'instana/instrumentation/instrumented_request'
+rescue LoadError => _e
+  Instana.logger.warn("Unable to Instana::InstrumentedRequest. HTTP based triggers won't generate spans.")
+end
+# :nocov:
+
+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) { defined?(::Instana::InstrumentedRequest) && 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) { defined?(::Instana::InstrumentedRequest) && 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,9 @@ 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/snapshot/google_cloud_run_instance'
+require 'instana/snapshot/google_cloud_run_process'
 
 require 'instana/backend/host_agent_lookup'
 require 'instana/backend/host_agent_activation_observer'

data/lib/instana/snapshot/google_cloud_run_instance.rb

@@ -0,0 +1,69 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Snapshot
+    # @since 1.199
+    class GoogleCloudRunInstance
+      ID = 'com.instana.plugin.gcp.run.revision.instance'.freeze
+
+      def initialize(metadata_uri: 'http://metadata.google.internal')
+        @metadata_uri = URI(metadata_uri)
+        @client = Backend::RequestClient.new(@metadata_uri.host, @metadata_uri.port, use_ssl: @metadata_uri.scheme == "https")
+      end
+
+      def entity_id
+        lookup('/computeMetadata/v1/instance/id')
+      end
+
+      def data
+        {
+          runtime: 'ruby',
+          region: gcp_region,
+          service: ENV['K_SERVICE'],
+          configuration: ENV['K_CONFIGURATION'],
+          revision: ENV['K_REVISION'],
+          instanceId: entity_id,
+          port: ENV['PORT'],
+          numericProjectId: lookup('/computeMetadata/v1/project/numeric-project-id'),
+          projectId: lookup('/computeMetadata/v1/project/project-id')
+        }.compact
+      end
+
+      def snapshot
+        {
+          name: ID,
+          entityId: entity_id,
+          data: data
+        }
+      end
+
+      def source
+        {
+          hl: true,
+          cp: 'gcp',
+          e: entity_id
+        }
+      end
+
+      def host_name
+        "gcp:cloud-run:revision:#{ENV['K_REVISION']}"
+      end
+
+      private
+
+      def gcp_region
+        lookup('/computeMetadata/v1/instance/zone').split('/').last
+      end
+
+      def lookup(resource)
+        path = @metadata_uri.path + resource
+        response = @client.send_request('GET', path, nil, {'Metadata-Flavor' => 'Google'})
+
+        raise "Unable to get `#{path}`. Got `#{response.code}` `#{response['location']}`." unless response.ok?
+
+        response.body
+      end
+    end
+  end
+end

data/lib/instana/snapshot/google_cloud_run_process.rb

@@ -0,0 +1,58 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Snapshot
+    # @since 1.199.0
+    class GoogleCloudRunProcess
+      ID = 'com.instana.plugin.process'.freeze
+
+      def initialize(metadata_uri: 'http://metadata.google.internal')
+        @metadata_uri = URI(metadata_uri)
+        @client = Backend::RequestClient.new(@metadata_uri.host, @metadata_uri.port, use_ssl: @metadata_uri.scheme == "https")
+        @start_time = Time.now
+      end
+
+      def entity_id
+        Process.pid.to_s
+      end
+
+      def data
+        proc_table = Sys::ProcTable.ps(pid: Process.pid)
+        process = Backend::ProcessInfo.new(proc_table)
+
+        {
+          pid: process.pid.to_i,
+          env: ENV.to_h,
+          exec: process.name,
+          args: process.arguments,
+          user: process.uid,
+          group: process.gid,
+          start: @start_time.to_i * 1000,
+          containerType: 'gcpCloudRunInstance',
+          container: lookup('/computeMetadata/v1/instance/id'),
+          "com.instana.plugin.host.name": "gcp:cloud-run:revision:#{ENV['K_REVISION']}"
+        }
+      end
+
+      def snapshot
+        {
+          name: ID,
+          entityId: entity_id,
+          data: data
+        }
+      end
+
+      private
+
+      def lookup(resource)
+        path = @metadata_uri.path + resource
+        response = @client.send_request('GET', path, nil, {'Metadata-Flavor' => 'Google'})
+
+        raise "Unable to get `#{path}`. Got `#{response.code}` `#{response['location']}`." unless response.ok?
+
+        response.body
+      end
+    end
+  end
+end

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.199.2"
   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/secrets_test.rb

@@ -78,6 +78,16 @@ class SecretsTest < Minitest::Test
     assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
   end
 
+  def test_without_url
+    sample_config = {
+      "matcher"=>"contains",
+      "list"=>["stan"]
+    }
+
+    url = 'filter[instantiate]=true'
+    assert_redacted @subject.remove_from_query(url, sample_config), %w(filter[instantiate]), raw_str: true
+  end
+
   private
 
   def url_for(keys)
@@ -86,9 +96,9 @@ class SecretsTest < Minitest::Test
     url.to_s
   end
 
-  def assert_redacted(str, keys)
-    url = URI(str)
-    params = CGI.parse(url.query)
+  def assert_redacted(str, keys, raw_str: false)
+    params = raw_str ? CGI.parse(str) : CGI.parse(URI(str).query)
+    pp params
 
     assert_equal keys, params.select { |_, v| v == %w(<redacted>) }.keys, 'to be redacted'
   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

data/test/snapshot/google_cloud_run_instance_test.rb

@@ -0,0 +1,74 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class GoogleCloudRunInstanceTest < Minitest::Test
+  def test_snapshot
+    ENV['K_SERVICE'] = 'test_service'
+    ENV['K_CONFIGURATION'] = 'test_config'
+    ENV['K_REVISION'] = 'test_revision'
+    ENV['PORT'] = 'test_port'
+
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/id')
+      .to_return(status: 200, body: 'test_instance_id')
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/zone')
+      .to_return(status: 200, body: 'region/number/test_region')
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/project/numeric-project-id')
+      .to_return(status: 200, body: 'numericProjectId')
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/project/project-id')
+      .to_return(status: 200, body: 'projectId')
+
+    subject = Instana::Snapshot::GoogleCloudRunInstance.new(metadata_uri: 'http://10.10.10.10/')
+    snapshot = subject.snapshot
+
+    assert_equal Instana::Snapshot::GoogleCloudRunInstance::ID, snapshot[:name]
+    assert_equal 'test_instance_id', snapshot[:entityId]
+
+    assert_equal "ruby", snapshot[:data][:runtime]
+    assert_equal "test_region", snapshot[:data][:region]
+    assert_equal "test_service", snapshot[:data][:service]
+    assert_equal "test_config", snapshot[:data][:configuration]
+    assert_equal "test_revision", snapshot[:data][:revision]
+    assert_equal "test_instance_id", snapshot[:data][:instanceId]
+    assert_equal "test_port", snapshot[:data][:port]
+    assert_equal "numericProjectId", snapshot[:data][:numericProjectId]
+    assert_equal "projectId", snapshot[:data][:projectId]
+  ensure
+    ENV['K_SERVICE'] = nil
+    ENV['K_CONFIGURATION'] = nil
+    ENV['K_REVISION'] = nil
+    ENV['PORT'] = nil
+  end
+
+  def test_snapshot_error
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/id')
+      .to_return(status: 500)
+
+    subject = Instana::Snapshot::GoogleCloudRunInstance.new(metadata_uri: 'http://10.10.10.10/')
+
+    assert_raises do
+      subject.snapshot
+    end
+  end
+
+  def test_source
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/id')
+      .to_return(status: 200, body: 'test_instance_id')
+    subject = Instana::Snapshot::GoogleCloudRunInstance.new(metadata_uri: 'http://10.10.10.10/')
+    source = subject.source
+
+    assert source[:hl]
+    assert_equal 'gcp', source[:cp]
+    assert_equal 'test_instance_id', source[:e]
+  end
+
+  def test_host_name
+    ENV['K_REVISION'] = 'test_revision'
+    subject = Instana::Snapshot::GoogleCloudRunInstance.new(metadata_uri: 'http://10.10.10.10/')
+
+    assert_equal 'gcp:cloud-run:revision:test_revision', subject.host_name
+  ensure
+    ENV['K_REVISION'] = nil
+  end
+end

data/test/snapshot/google_cloud_run_process_test.rb

@@ -0,0 +1,33 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class GoogleCloudRunProcessTest < Minitest::Test
+  def test_snapshot
+    ENV['K_REVISION'] = 'test'
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/id')
+      .to_return(status: 200, body: 'test_instance_id')
+
+    subject = Instana::Snapshot::GoogleCloudRunProcess.new(metadata_uri: 'http://10.10.10.10/')
+    snapshot = subject.snapshot
+
+    assert_equal Instana::Snapshot::GoogleCloudRunProcess::ID, snapshot[:name]
+    assert_equal 'test_instance_id', snapshot[:data][:container]
+    assert_equal 'gcpCloudRunInstance', snapshot[:data][:containerType]
+    assert_equal 'gcp:cloud-run:revision:test', snapshot[:data][:'com.instana.plugin.host.name']
+  ensure
+    ENV['K_REVISION'] = nil
+  end
+
+  def test_snapshot_error
+    stub_request(:get, 'http://10.10.10.10//computeMetadata/v1/instance/id')
+      .to_return(status: 500)
+
+    subject = Instana::Snapshot::GoogleCloudRunProcess.new(metadata_uri: 'http://10.10.10.10/')
+
+    assert_raises do
+      subject.snapshot
+    end
+  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.199.2
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2021-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -255,12 +255,15 @@ 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
 - lib/instana/snapshot/fargate_container.rb
 - lib/instana/snapshot/fargate_process.rb
 - lib/instana/snapshot/fargate_task.rb
+- lib/instana/snapshot/google_cloud_run_instance.rb
+- lib/instana/snapshot/google_cloud_run_process.rb
 - lib/instana/snapshot/lambda_function.rb
 - lib/instana/snapshot/ruby_process.rb
 - lib/instana/tracer.rb
@@ -307,11 +310,15 @@ 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/google_cloud_run_instance_test.rb
+- test/snapshot/google_cloud_run_process_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
@@ -368,6 +375,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,7 +390,10 @@ test_files:
 - test/snapshot/deltable_test.rb
 - test/snapshot/fargate_task_test.rb
 - test/snapshot/ruby_process_test.rb
+- test/snapshot/google_cloud_run_process_test.rb
+- test/snapshot/lambda_function_test.rb
 - test/snapshot/fargate_container_test.rb
+- test/snapshot/google_cloud_run_instance_test.rb
 - test/backend/host_agent_activation_observer_test.rb
 - test/backend/host_agent_reporting_observer_test.rb
 - test/backend/gc_snapshot_test.rb