instana 1.195.2 → 1.197.0

data/lib/instana/backend/process_info.rb

@@ -0,0 +1,64 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # Wrapper around {Sys::ProcTable} that adds support for reading the /proc
+    # file system for extra information around containers
+    # @since 1.197.0
+    class ProcessInfo < SimpleDelegator
+      def name
+        cmdline
+          .split(' ').first
+      end
+
+      def arguments
+        _, *arguments = cmdline.split(' ')
+        clean_arguments(arguments)
+      end
+
+      def parent_pid
+        if in_container? && sched_pid != pid
+          sched_pid
+        else
+          pid
+        end
+      end
+
+      def from_parent_namespace
+        !in_container? || in_container? && sched_pid != pid
+      end
+
+      def cpuset
+        path = "/proc/#{pid}/cpuset"
+        return unless File.exist?(path)
+
+        File.read(path).strip
+      end
+
+      def in_container?
+        !cpuset.nil? && cpuset != '/'
+      end
+
+      def sched_pid
+        path = '/proc/self/sched'
+        return unless File.exist?(path)
+
+        File.read(path).match(/\d+/).to_s.to_i
+      end
+
+      private
+
+      def clean_arguments(arguments)
+        return arguments unless RbConfig::CONFIG['host_os'].include?('darwin')
+
+        arguments.reject do |a|
+          if a.include?('=')
+            k, = a.split('=', 2)
+            ENV[k]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/instana/backend/request_client.rb

@@ -0,0 +1,73 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'net/http'
+require 'delegate'
+require 'json'
+
+# :nocov:
+begin
+  require 'oj'
+rescue LoadError => _e
+  Instana.logger.warn("Unable to load Oj.")
+end
+# :nocov:
+
+module Instana
+  module Backend
+    # Convince wrapper around {Net::HTTP}.
+    # @since 1.197.0
+    class RequestClient
+      attr_reader :host, :port
+
+      class Response < SimpleDelegator
+        # @return [Hash] the decoded json response
+        def json
+          JSON.parse(body)
+        end
+
+        # @return [Boolean] true if the request was successful
+        def ok?
+          __getobj__.is_a?(Net::HTTPSuccess)
+        end
+      end
+
+      def initialize(host, port, use_ssl: false)
+        @host = host
+        @port = port
+        @client = Net::HTTP.start(host, port, use_ssl: use_ssl)
+      end
+
+      # Send a request to the backend. If data is a {Hash},
+      # encode the object as JSON and set the proper headers.
+      #
+      # @param [String] method request method
+      # @param [String] path request path
+      # @param [Hash, String] data request body
+      # @param [Hash] headers extra request headers to send
+      def send_request(method, path, data = nil, headers = {})
+        body = if data.is_a?(Hash) || data.is_a?(Array)
+                 headers['Content-Type'] = 'application/json'
+                 headers['Accept'] = 'application/json'
+
+                 encode_body(data)
+               else
+                 headers['Content-Type'] = 'application/octet-stream'
+
+                 data
+               end
+
+        response = @client.send_request(method, path, body, headers)
+        Response.new(response)
+      end
+
+      private
+
+      def encode_body(data)
+        # :nocov:
+        defined?(Oj) ? Oj.dump(data, mode: :strict) : JSON.dump(data)
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/instana/backend/serverless_agent.rb

@@ -0,0 +1,118 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # @since 1.197.0
+    class ServerlessAgent
+      DEFAULT_SECRETS = 'contains-ignore-case:key,password,secret'.freeze
+      attr_reader :timer
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(snapshots,
+                     timer_class: Concurrent::TimerTask,
+                     processor: ::Instana.processor,
+                     logger: ::Instana.logger,
+                     backend_uri: ENV['INSTANA_ENDPOINT_URL'],
+                     secrets: ENV.fetch('INSTANA_SECRETS', DEFAULT_SECRETS), headers: ENV.fetch('INSTANA_EXTRA_HTTP_HEADERS', ''))
+        @snapshots = snapshots
+        @processor = processor
+        @logger = logger
+        @timer = timer_class.new(execution_interval: 1, run_now: true) { send_bundle }
+        @backend_uri = URI(backend_uri)
+        @client = Backend::RequestClient.new(@backend_uri.host, @backend_uri.port, use_ssl: @backend_uri.scheme == "https")
+        @secrets = secrets
+        @headers = headers
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def setup; end
+
+      def spawn_background_thread
+        @timer.execute
+      end
+
+      # @return [Boolean] true if the agent able to send spans to the backend
+      def ready?
+        true
+      end
+
+      # @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
+        else
+          @logger.warn('Unable to find a snapshot which provides a source.')
+          {}
+        end
+      end
+
+      # @return [Array] extra headers to include in the trace
+      def extra_headers
+        @headers.split(';')
+      end
+
+      # @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 = {
+          spans: spans,
+          metrics: {
+            plugins: agent_snapshots
+          }
+        }
+
+        path = "#{@backend_uri.path}/bundle"
+        response = @client.send_request('POST', path, bundle, request_headers)
+
+        return if response.ok?
+
+        @logger.warn("Recived a `#{response.code}` when sending data.")
+      end
+
+      def agent_snapshots
+        @snapshots.map do |snapshot|
+          begin # rubocop:disable Style/RedundantBegin, Lint/RedundantCopDisableDirective
+            snapshot.snapshot
+          rescue StandardError => e
+            @logger.error(e.message)
+            nil
+          end
+        end.compact
+      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
+        else
+          @logger.warn('Unable to find a snapshot which provides a host_name.')
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/instana/base.rb

@@ -4,16 +4,13 @@
 require "logger"
 require "instana/version"
 require "instana/util"
-require "instana/helpers"
 
 module Instana
   class << self
     attr_accessor :agent
-    attr_accessor :collector
     attr_accessor :tracer
     attr_accessor :processor
     attr_accessor :config
-    attr_accessor :logger
     attr_accessor :pid
     attr_reader :secrets
 
@@ -24,36 +21,20 @@ module Instana
     # to run" state.
     #
     def setup
-      @agent  = ::Instana::Agent.new
+      @agent  = ::Instana::Backend::Agent.new
       @tracer = ::Instana::Tracer.new
       @processor = ::Instana::Processor.new
-      @collector = ::Instana::Collector.new
       @secrets = ::Instana::Secrets.new
     end
-  end
-end
-
-# Setup the logger as early as possible
-
-# Default Logger outputs to STDOUT
-::Instana.logger = Logger.new(STDOUT)
-
-# Can instead log to a file that is rotated every 10M
-# ::Instana.logger = Logger.new("instana.log", 10, 1073741824)
 
-if ENV.key?('INSTANA_GEM_TEST')
-  ::Instana.logger.level = Logger::DEBUG
-elsif ENV.key?('INSTANA_GEM_DEV') || ENV.key?('INSTANA_DEBUG')
-  ::Instana.logger.level = Logger::DEBUG
-elsif ENV.key?('INSTANA_QUIET')
-  ::Instana.logger.level = Logger::FATAL
-else
-  ::Instana.logger.level = Logger::WARN
-end
+    def logger
+      @logger ||= ::Instana::LoggerDelegator.new(Logger.new(STDOUT))
+    end
 
-::Instana.logger.formatter = proc do |severity, datetime, progname, msg|
-  "#{datetime}: #{severity.rjust(5)} Instana: #{progname} #{msg}\n"
+    def logger=(val)
+      @logger.__setobj__(val)
+    end
+  end
 end
 
-
 ::Instana.logger.info "Stan is on the scene.  Starting Instana instrumentation version #{::Instana::VERSION}"

data/lib/instana/config.rb

@@ -3,26 +3,21 @@
 
 module Instana
   class Config
-
-    def initialize
+    def initialize(logger: ::Instana.logger, agent_host: ENV['INSTANA_AGENT_HOST'], agent_port: ENV['INSTANA_AGENT_PORT'])
       @config = {}
-      if ENV.key?('INSTANA_AGENT_HOST')
-        ::Instana.logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{ENV['INSTANA_AGENT_HOST']})"
-        @config[:agent_host] = ENV['INSTANA_AGENT_HOST']
+      if agent_host
+        logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{ENV['INSTANA_AGENT_HOST']})"
+        @config[:agent_host] = agent_host
       else
         @config[:agent_host] = '127.0.0.1'
       end
-      if ENV.key?('INSTANA_AGENT_PORT')
-        ::Instana.logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{ENV['INSTANA_AGENT_PORT']})"
-        @config[:agent_port] = ENV['INSTANA_AGENT_PORT']
+      if agent_port
+        logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{ENV['INSTANA_AGENT_PORT']})"
+        @config[:agent_port] = agent_port
       else
         @config[:agent_port] = 42699
       end
 
-      # This option has been DEPRECATED. Use the INSTANA_DISABLE environment variable instead.
-      # https://docs.instana.io/ecosystem/ruby/configuration/
-      @config[:enabled] = true
-
       # Enable/disable metrics globally or individually (default: all enabled)
       @config[:metrics] = { :enabled => true }
       @config[:metrics][:gc]     = { :enabled => true }
@@ -56,7 +51,7 @@ module Instana
       @config[:sanitize_sql] = true
 
       # W3 Trace Context Support
-      @config[:w3_trace_correlation] = ENV.fetch('INSTANA_W3C_TRACE_CORRELATION', 'true').eql?('true')
+      @config[:w3_trace_correlation] = ENV['INSTANA_DISABLE_W3C_TRACE_CORRELATION'].nil?
 
       @config[:action_controller]  = { :enabled => true }
       @config[:action_view]        = { :enabled => true }
@@ -80,15 +75,6 @@ module Instana
 
     def []=(key, value)
       @config[key.to_sym] = value
-
-      if key == :enabled
-        # Configuring global enable/disable flag, then set the
-        # appropriate children flags.
-        @config[:metrics][:enabled] = value
-        @config[:tracing][:enabled] = value
-
-        ::Instana.logger.warn "::Instana.config[:enabled] has been deprecated.  Set INSTANA_DISABLE environment variable to any value instead."
-      end
     end
   end
 end

data/lib/instana/instrumentation/excon.rb

@@ -5,7 +5,7 @@ module Instana
   module Instrumentation
     class Excon < ::Excon::Middleware::Base
       def request_call(datum)
-        return @stack.request_call(datum) unless ::Instana.tracer.tracing? || !Instana.tracer.current_span.exit_span?
+        return @stack.request_call(datum) unless traceable?
 
         payload = { :http => {} }
         path, query = datum[:path].split('?', 2)
@@ -24,19 +24,21 @@ module Instana
         end
 
         # Set request headers; encode IDs as hexadecimal strings
-        datum[:headers]['X-Instana-T'] = t_context.trace_id_header
-        datum[:headers]['X-Instana-S'] = t_context.span_id_header
+        datum[:headers]['X-Instana-L'] = t_context.level.to_s
 
-        if ::Instana.config[:w3_trace_correlation]
-          datum[:headers]['Traceparent'] = t_context.trace_parent_header
-          datum[:headers]['Tracestate'] = t_context.trace_state_header
+        if t_context.active?
+          datum[:headers]['X-Instana-T'] = t_context.trace_id_header
+          datum[:headers]['X-Instana-S'] = t_context.span_id_header
         end
 
+        datum[:headers]['Traceparent'] = t_context.trace_parent_header
+        datum[:headers]['Tracestate'] = t_context.trace_state_header unless t_context.trace_state_header.empty?
+
         @stack.request_call(datum)
       end
 
       def error_call(datum)
-        return @stack.error_call(datum) unless ::Instana.tracer.tracing? || !Instana.tracer.current_span.exit_span?
+        return @stack.error_call(datum) unless traceable?
 
         if datum[:pipeline] == true
           ::Instana.tracer.log_async_error(datum[:error], datum[:instana_span])
@@ -49,7 +51,7 @@ module Instana
       def response_call(datum)
         # FIXME: Will connect exceptions call a response?
         #
-        return @stack.response_call(datum) unless ::Instana.tracer.tracing? || !Instana.tracer.current_span.exit_span?
+        return @stack.response_call(datum) unless traceable?
 
         result =  @stack.response_call(datum)
 
@@ -72,6 +74,13 @@ module Instana
         end
         result
       end
+
+      private
+
+      def traceable?
+        ::Instana.tracer.tracing? &&
+          (!Instana.tracer.current_span.exit_span? || Instana.tracer.current_span.name == :excon)
+      end
     end
   end
 end

data/lib/instana/instrumentation/instrumented_request.rb

@@ -18,16 +18,33 @@ module Instana
     end
 
     def incoming_context
-      context = if @env['HTTP_X_INSTANA_T']
+      context = if !correlation_data.empty?
+                  {}
+                elsif @env['HTTP_X_INSTANA_T']
                   context_from_instana_headers
-                elsif @env['HTTP_TRACEPARENT'] && ::Instana.config[:w3_trace_correlation]
+                elsif @env['HTTP_TRACEPARENT']
                   context_from_trace_parent
+                elsif @env['HTTP_TRACESTATE']
+                  context_from_trace_state
                 else
                   {}
                 end
 
       context[:level] = @env['HTTP_X_INSTANA_L'][0] if @env['HTTP_X_INSTANA_L']
 
+      unless ::Instana.config[:w3_trace_correlation]
+        trace_state = parse_trace_state
+
+        if context[:from_w3] && trace_state.empty?
+          context.delete(:span_id)
+          context[:from_w3] = false
+        elsif context[:from_w3] && !trace_state.empty?
+          context[:trace_id] = trace_state[:t]
+          context[:span_id] = trace_state[:p]
+          context[:from_w3] = false
+        end
+      end
+
       context
     end
 
@@ -69,19 +86,43 @@ module Instana
     end
 
     def continuing_from_trace_parent?
-      incoming_context.include?(:external_trace_id)
+      incoming_context[:from_w3]
     end
 
     def synthetic?
       @env.has_key?('HTTP_X_INSTANA_SYNTHETIC') && @env['HTTP_X_INSTANA_SYNTHETIC'].eql?('1')
     end
 
+    def long_instana_id?
+      ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_T']).length == 32
+    end
+
+    def external_trace_id?
+      continuing_from_trace_parent? || long_instana_id?
+    end
+
+    def external_trace_id
+      incoming_context[:long_instana_id] || incoming_context[:external_trace_id]
+    end
+
     private
 
     def context_from_instana_headers
+      sanitized_t = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_T'])
+      sanitized_s = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_S'])
+      external_trace_id = if @env['HTTP_TRACEPARENT']
+                            context_from_trace_parent[:external_trace_id]
+                          elsif long_instana_id?
+                            sanitized_t
+                          end
+
       {
-        trace_id: ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_T']),
-        span_id: ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_S'])
+        span_id: sanitized_s,
+        trace_id: long_instana_id? ? sanitized_t[16..-1] : sanitized_t, # rubocop:disable Style/SlicingWithRange, Lint/RedundantCopDisableDirective
+        long_instana_id: long_instana_id? ? sanitized_t : nil,
+        external_trace_id: external_trace_id,
+        external_state: @env['HTTP_TRACESTATE'],
+        from_w3: false
       }.compact
     end
 
@@ -90,14 +131,28 @@ module Instana
       matches = @env['HTTP_TRACEPARENT'].match(W3_TRACE_PARENT_FORMAT)
       return {} unless matches
 
+      trace_id = ::Instana::Util.header_to_id(matches['trace'][16..-1]) # rubocop:disable Style/SlicingWithRange, Lint/RedundantCopDisableDirective
+      span_id = ::Instana::Util.header_to_id(matches['parent'])
+
       {
         external_trace_id: matches['trace'],
         external_state: @env['HTTP_TRACESTATE'],
-        trace_id: ::Instana::Util.header_to_id(matches['trace'][16..-1]), # rubocop:disable Style/SlicingWithRange, Lint/RedundantCopDisableDirective
-        span_id: ::Instana::Util.header_to_id(matches['parent'])
+        trace_id: trace_id,
+        span_id: span_id,
+        from_w3: true
       }
     end
 
+    def context_from_trace_state
+      state = parse_trace_state
+
+      {
+        trace_id: state[:t],
+        span_id: state[:p],
+        from_w3: false
+      }.compact
+    end
+
     def parse_trace_state
       return {} unless @env.has_key?('HTTP_TRACESTATE')
       token = @env['HTTP_TRACESTATE']