instana 1.197.0.pre1 → 1.199.0

data/lib/instana/instrumentation/rack.rb

@@ -12,7 +12,6 @@ module Instana
 
     def call(env)
       req = InstrumentedRequest.new(env)
-      return @app.call(env) if req.skip_trace?
       kvs = {
         http: req.request_tags,
         service: ENV['INSTANA_SERVICE_NAME']
@@ -34,12 +33,16 @@ module Instana
 
         if req.continuing_from_trace_parent?
           current_span[:tp] = true
-          current_span[:lt] = req.incoming_context[:external_trace_id]
+        end
+
+        if req.external_trace_id?
+          current_span[:lt] = req.external_trace_id
         end
 
         if req.synthetic?
           current_span[:sy] = true
         end
+
         # In case some previous middleware returned a string status, make sure that we're dealing with
         # an integer.  In Ruby nil.to_i, "asdfasdf".to_i will always return 0 from Ruby versions 1.8.7 and newer.
         # So if an 0 status is reported here, it indicates some other issue (e.g. no status from previous middleware)
@@ -70,15 +73,17 @@ module Instana
       if ::Instana.tracer.tracing?
         if headers
           # Set response headers; encode as hex string
-          headers['X-Instana-T'] = trace_context.trace_id_header
-          headers['X-Instana-S'] = trace_context.span_id_header
-          headers['X-Instana-L'] = '1'
+          if trace_context.active?
+            headers['X-Instana-T'] = trace_context.trace_id_header
+            headers['X-Instana-S'] = trace_context.span_id_header
+            headers['X-Instana-L'] = '1'
 
-          if ::Instana.config[:w3_trace_correlation]
-            headers['Traceparent'] = trace_context.trace_parent_header
             headers['Tracestate'] = trace_context.trace_state_header
+          else
+            headers['X-Instana-L'] = '0'
           end
 
+          headers['Traceparent'] = trace_context.trace_parent_header
           headers['Server-Timing'] = "intid;desc=#{trace_context.trace_id_header}"
         end
 

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

@@ -0,0 +1,39 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Snapshot
+    # @since 1.198.0
+    class LambdaFunction
+      ID = "com.instana.plugin.aws.lambda".freeze
+
+      def entity_id
+        Thread.current[:instana_function_arn]
+      end
+
+      def data
+        {}
+      end
+
+      def snapshot
+        {
+          name: ID,
+          entityId: entity_id,
+          data: data
+        }
+      end
+
+      def source
+        {
+          hl: true,
+          cp: "aws",
+          e: entity_id
+        }
+      end
+
+      def host_name
+        entity_id
+      end
+    end
+  end
+end

data/lib/instana/tracing/processor.rb

@@ -5,7 +5,7 @@ require 'thread'
 
 module Instana
   class Processor
-    def initialize
+    def initialize(logger: ::Instana.logger)
       # The main queue before being reported to the
       # host agent.  Spans in this queue are complete
       # and ready to be sent.
@@ -14,12 +14,22 @@ module Instana
       # This is the maximum number of spans we send to the host
       # agent at once.
       @batch_size = 3000
+      @logger = logger
+      @pid = $PROCESS_ID
     end
 
     # Adds a span to the span queue
     #
     # @param [Trace] - the trace to be added to the queue
     def add_span(span)
+      # :nocov:
+      if @pid != $PROCESS_ID
+        @logger.info("Proces `#{@pid}` has forked into #{$PROCESS_ID}. Resetting discovery.")
+        ::Instana.agent.spawn_background_thread
+        @pid = $PROCESS_ID
+      end
+      # :nocov:
+
       @queue.push(span)
     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
@@ -28,9 +28,15 @@ module Instana
       if parent_ctx.is_a?(::Instana::SpanContext)
         @is_root = false
 
-        @data[:t] = parent_ctx.trace_id       # Trace ID
+        # If we have a parent trace, link to it
+        if parent_ctx.trace_id
+          @data[:t] = parent_ctx.trace_id       # Trace ID
+          @data[:p] = parent_ctx.span_id        # Parent ID
+        else
+          @data[:t] = ::Instana::Util.generate_id
+        end
+
         @data[:s] = ::Instana::Util.generate_id # Span ID
-        @data[:p] = parent_ctx.span_id        # Parent ID
 
         @baggage = parent_ctx.baggage.dup
         @level = parent_ctx.level

data/lib/instana/tracing/span_context.rb

@@ -31,19 +31,22 @@ module Instana
     end
 
     def trace_parent_header
-      return '' unless valid?
-
-      trace = (@baggage[:external_trace_id] || @trace_id).rjust(32, '0')
-      parent = @span_id.rjust(16, '0')
+      trace = (@baggage[:external_trace_id] || trace_id_header).rjust(32, '0')
+      parent = span_id_header.rjust(16, '0')
       flags = @level == 1 ? "01" : "00"
 
       "00-#{trace}-#{parent}-#{flags}"
     end
 
     def trace_state_header
-      return '' unless valid?
+      external_state = @baggage[:external_state] || ''
+      state = external_state.split(/,/)
+
+      if @level == 1
+        state = state.reject { |s| s.start_with?('in=') }
+        state.unshift("in=#{trace_id_header};#{span_id_header}")
+      end
 
-      state = ["in=#{trace_id_header};#{span_id_header}", @baggage[:external_state]]
       state.compact.join(',')
     end
 
@@ -51,10 +54,12 @@ module Instana
       { :trace_id => @trace_id, :span_id => @span_id }
     end
 
-    private
-
     def valid?
-      @baggage && @trace_id && @span_id
+      @baggage && @trace_id && !@trace_id.emtpy?
+    end
+
+    def active?
+      @level == 1
     end
   end
 end