instana 1.195.4 → 1.197.0.pre1

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,84 @@
+# (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
+      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)
+        @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
+
+      # @return [Integer, NilClass] the fileno of the Net::HTTP socket or nil if it can't be identified
+      def fileno
+        socket = @client.instance_variable_get('@socket')
+        io = socket && socket.instance_variable_get('@io')
+        io && io.fileno
+      end
+
+      # @return [String] the inode asscoated with the Net::HTTP socket or nil if it can't be identified
+      def inode
+        path = "/proc/self/fd/#{fileno}"
+        return unless File.exist?(path) && fileno
+
+        File.readlink(path)
+      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
+            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 }
@@ -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/logger_delegator.rb

@@ -0,0 +1,31 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  class LoggerDelegator < SimpleDelegator
+    def initialize(obj)
+      obj.level = level_from_environment
+      super(obj)
+    end
+
+    private
+
+    def level_from_environment
+      # :nocov:
+      return Logger::FATAL if ENV.key?('INSTANA_TEST') || ENV.key?('RACK_TEST')
+      return Logger::DEBUG if ENV.key?('INSTANA_DEBUG')
+
+      case ENV['INSTANA_LOG_LEVEL']
+      when 'debug'
+        Logger::DEBUG
+      when 'warn'
+        Logger::WARN
+      when 'error'
+        Logger::ERROR
+      else
+        Logger::INFO
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/instana/open_tracing/instana_tracer.rb

@@ -0,0 +1,99 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'delegate'
+# :nocov:
+module OpenTracing
+  class InstanaTracer < SimpleDelegator
+    Span = ::Instana::Span
+
+    # Start a new span
+    #
+    # @param operation_name [String] The name of the operation represented by the span
+    # @param child_of [Span] A span to be used as the ChildOf reference
+    # @param start_time [Time] the start time of the span
+    # @param tags [Hash] Starting tags for the span
+    #
+    # @return [Span]
+    #
+    def start_span(operation_name, child_of: nil, start_time: ::Instana::Util.now_in_ms, tags: nil)
+      new_span = if child_of && (child_of.is_a?(::Instana::Span) || child_of.is_a?(::Instana::SpanContext))
+                   Span.new(operation_name, parent_ctx: child_of, start_time: start_time)
+                 else
+                   Span.new(operation_name, start_time: start_time)
+                 end
+      new_span.set_tags(tags) if tags
+      new_span
+    end
+
+    # Start a new span which is the child of the current span
+    #
+    # @param operation_name [String] The name of the operation represented by the span
+    # @param child_of [Span] A span to be used as the ChildOf reference
+    # @param start_time [Time] the start time of the span
+    # @param tags [Hash] Starting tags for the span
+    #
+    # @return [Span]
+    #
+    def start_active_span(operation_name, child_of: active_span, start_time: ::Instana::Util.now_in_ms, tags: nil)
+      ::Instana.tracer.current_span = start_span(operation_name, child_of: child_of, start_time: start_time, tags: tags)
+      block_given? ? yield(::Instana.tracer.current_span) : ::Instana.tracer.current_span
+    end
+
+    # Returns the currently active span
+    #
+    # @return [Span]
+    #
+    def active_span
+      ::Instana.tracer.current_span
+    end
+
+    # Inject a span into the given carrier
+    #
+    # @param span_context [SpanContext]
+    # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+    # @param carrier [Carrier]
+    #
+    def inject(span_context, format, carrier)
+      case format
+      when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY
+        ::Instana.logger.debug 'Unsupported inject format'
+      when OpenTracing::FORMAT_RACK
+        carrier['X-Instana-T'] = ::Instana::Util.id_to_header(span_context.trace_id)
+        carrier['X-Instana-S'] = ::Instana::Util.id_to_header(span_context.span_id)
+      else
+        ::Instana.logger.debug 'Unknown inject format'
+      end
+    end
+
+    # Extract a span from a carrier
+    #
+    # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+    # @param carrier [Carrier]
+    #
+    # @return [SpanContext]
+    #
+    def extract(format, carrier)
+      case format
+      when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY
+        ::Instana.logger.debug 'Unsupported extract format'
+      when OpenTracing::FORMAT_RACK
+        ::Instana::SpanContext.new(::Instana::Util.header_to_id(carrier['HTTP_X_INSTANA_T']),
+                                   ::Instana::Util.header_to_id(carrier['HTTP_X_INSTANA_S']))
+      else
+        ::Instana.logger.debug 'Unknown inject format'
+        nil
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      ::Instana.logger.warn { "You are invoking `#{m}` on Instana::Tracer via OpenTracing." }
+      super(method, *args, &block)
+    end
+
+    def respond_to_missing?(*)
+      super(method)
+    end
+  end
+end
+# :nocov: