instana 1.195.2 → 1.197.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ecd5d44386711b77f9063712fe05c1831771a9c6740c429d75244ed31594730
-  data.tar.gz: a9babf1b336a2502f0d0b9c1bacd5a8e1283519b02f5d32aea8e58523d50d766
+  metadata.gz: a25aa837fcbb248cb39db1f57b7bdc8904810d5e63d87be7e12d912b7b9aea67
+  data.tar.gz: 836dc1f8d7ffc4c8c19e3fa90867a306fe7d407fb88a14481d44bde1dc482285
 SHA512:
-  metadata.gz: 84916aa5ce872b6d309a5b6b97b50e469b98f7a0cae67c29d2be4904e7f120aa464b85b88b4fac4329165d8f77ea7783066a766d69f5809fd85faa1ad989640f
-  data.tar.gz: c94e2ef1d5d72362c64355be70cef8a9835bbe23acd14da29a57c11918c1df0fffafa3ea494a4d87d9349318588d3bc0ee1c6ae5dc9a1b21c3a07271cf487b6f
+  metadata.gz: b8f3ba0fbf4a015ff1522a3c24e6b219594d2c266bc46427a93979e6ee159272d2c23a8fc53e4720021c5c531ad64ffd1d1f2644b8eb41497aaf8950c99ed8b6
+  data.tar.gz: 44e5b93aff42f542eaee494128e973a9447210fbffde21c4b361f1b00729c8b3378634241d64039453ea3dda0dc2a0d207473a0c5631f1f09e77726b2a827532

data/.rubocop.yml

@@ -2,7 +2,7 @@ inherit_from: .rubocop_todo.yml
 
 require:
   - ./extras/license_header.rb
-
+  
 # Remove when we remove .rubocop_todo.yml
 AllCops:
   NewCops: disable
@@ -18,4 +18,8 @@ Style/NilComparison:
   Enabled: false
 
 Style/SoleNestedConditional:
-  Enabled: false
+  Enabled: false
+  
+# Ruby 2.1 compatibility
+Style/SafeNavigation:
+  Enabled: false

data/Rakefile

@@ -22,7 +22,7 @@ Rake::TestTask.new(:test) do |t|
   else
     t.test_files = Dir[
       'test/*_test.rb',
-      'test/{agent,tracing}/*_test.rb'
+      'test/{agent,tracing,backend,snapshot}/*_test.rb'
     ]
   end
 end

data/instana.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   }
 
   spec.licenses      = ['MIT']
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
@@ -38,13 +38,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "fakefs"
 
+  spec.add_runtime_dependency('concurrent-ruby', '>= 1.1')
   spec.add_runtime_dependency('sys-proctable', '>= 1.2.2')
-  spec.add_runtime_dependency('get_process_mem', '>= 0.2.1')
-  spec.add_runtime_dependency('timers', '>= 4.0.4')
   spec.add_runtime_dependency('oj', '>=3.0.11') unless RUBY_PLATFORM =~ /java/i
-
-  # Indirect dependency
-  # https://github.com/instana/ruby-sensor/issues/10
-  spec.add_runtime_dependency('ffi', '>=1.0.11')
 end

data/lib/instana.rb

@@ -1,6 +1,9 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2016
 
+require 'concurrent'
+require 'sys-proctable'
+
 require "instana/setup"
 
 # Boot the instana agent background thread.  If you wish to have greater

data/lib/instana/activator.rb

@@ -7,12 +7,14 @@ module Instana
       attr_reader :trace_point, :activators
 
       def start
+        # :nocov:
         @trace_point = TracePoint.new(:end) do
           activated = ::Instana::Activator.call
           ::Instana.logger.debug { "Activated #{activated.join(', ')}" } unless activated.empty?
         end
 
         @trace_point.enable if enabled?
+        # :nocov:
       end
 
       def call

data/lib/instana/backend/agent.rb

@@ -0,0 +1,60 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # Wrapper class around the various transport backends
+    # @since 1.197.0
+    class Agent
+      attr_reader :delegate
+
+      def initialize(fargate_metadata_uri: ENV['ECS_CONTAINER_METADATA_URI'], logger: ::Instana.logger)
+        @delegate = nil
+        @logger = logger
+        @fargate_metadata_uri = fargate_metadata_uri
+      end
+
+      def setup
+        @delegate = if @fargate_metadata_uri && ENV.key?('INSTANA_ENDPOINT_URL')
+                      ServerlessAgent.new(fargate_snapshots)
+                    else
+                      HostAgent.new
+                    end
+
+        @delegate.setup
+      end
+
+      def method_missing(mth, *args, &block)
+        if @delegate.respond_to?(mth)
+          @delegate.public_send(mth, *args, &block)
+        else
+          super(mth, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(mth, include_all = false)
+        @delegate.respond_to?(mth, include_all)
+      end
+
+      private
+
+      def fargate_snapshots
+        metadata_uri = URI(@fargate_metadata_uri)
+        client = Backend::RequestClient.new(metadata_uri.host, metadata_uri.port, use_ssl: metadata_uri.scheme == "https")
+        response = client.send_request('GET', "#{metadata_uri.path}/task")
+
+        if response.ok?
+          docker = response
+                   .json['Containers']
+                   .map { |c| [Snapshot::DockerContainer.new(c), Snapshot::FargateContainer.new(c)] }
+                   .flatten
+
+          docker + [Snapshot::FargateProcess.new, Snapshot::RubyProcess.new, Snapshot::FargateTask.new]
+        else
+          @logger.warn("Received #{response.code} when requesting containers.")
+          []
+        end
+      end
+    end
+  end
+end

data/lib/instana/backend/gc_snapshot.rb

@@ -0,0 +1,41 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'singleton'
+
+module Instana
+  module Backend
+    # Keeps track of garbage collector related metrics
+    # @since 1.197.0
+    class GCSnapshot
+      include Singleton
+
+      def initialize
+        ::GC::Profiler.enable
+
+        @last_major_count = 0
+        @last_minor_count = 0
+      end
+
+      def report
+        stats = ::GC.stat
+        total_time = ::GC::Profiler.total_time * 1000
+
+        ::GC::Profiler.clear
+
+        payload = {
+          totalTime: total_time,
+          heap_live: stats[:heap_live_slots] || stats[:heap_live_num],
+          heap_free: stats[:heap_free_slots] || stats[:heap_free_num],
+          minorGcs: stats[:minor_gc_count] - @last_minor_count,
+          majorGcs: stats[:major_gc_count] - @last_major_count
+        }
+
+        @last_major_count = stats[:major_gc_count]
+        @last_minor_count = stats[:minor_gc_count]
+
+        payload
+      end
+    end
+  end
+end

data/lib/instana/backend/host_agent.rb

@@ -0,0 +1,74 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # @since 1.197.0
+    class HostAgent
+      attr_reader :future
+
+      def initialize(discovery: Concurrent::Atom.new(nil), logger: ::Instana.logger)
+        @discovery = discovery
+        @logger = logger
+        @future = nil
+      end
+
+      def setup; end
+
+      def spawn_background_thread
+        return if ENV.key?('INSTANA_TEST')
+
+        @future = Concurrent::Promises.future do
+          client = until_not_nil { HostAgentLookup.new.call }
+          @discovery.delete_observers
+          @discovery
+            .with_observer(HostAgentActivationObserver.new(client, @discovery))
+            .with_observer(HostAgentReportingObserver.new(client, @discovery))
+
+          @discovery.swap { nil }
+          client
+        end
+      end
+
+      # @return [Boolean] true if the agent able to send spans to the backend
+      def ready?
+        ENV.key?('INSTANA_TEST') || !@discovery.value.nil?
+      end
+
+      # @return [Hash, NilClass] the backend friendly description of the current in process collector
+      def source
+        {
+          e: discovery_value['pid'],
+          h: discovery_value['agentUuid']
+        }.compact
+      end
+
+      # @return [Array] extra headers to include in the trace
+      def extra_headers
+        discovery_value['extraHeaders']
+      end
+
+      # @return [Hash] values which are removed from urls sent to the backend
+      def secret_values
+        discovery_value['secrets']
+      end
+
+      private
+
+      def until_not_nil
+        loop do
+          result = yield
+          return result unless result.nil?
+
+          @logger.debug("Waiting on a connection to the agent.")
+          sleep(1)
+        end
+      end
+
+      def discovery_value
+        v = @discovery.value
+        v || {}
+      end
+    end
+  end
+end

data/lib/instana/backend/host_agent_activation_observer.rb

@@ -0,0 +1,97 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # Process which is responsible for initiating monitoring of a Ruby program with a local agent.
+    # @since 1.197.0
+    class HostAgentActivationObserver
+      DISCOVERY_URL = '/com.instana.plugin.ruby.discovery'.freeze
+      ENTITY_DATA_URL = '/com.instana.plugin.ruby.%i'.freeze
+      class DiscoveryError < StandardError; end
+
+      # @param [RequestClient] client used to make requests to the backend
+      # @param [Concurrent::Atom] discovery object used to store discovery response in
+      def initialize(client, discovery, wait_time: 1, logger: ::Instana.logger, max_wait_tries: 60, proc_table: Sys::ProcTable, socket_proc: default_socket_proc) # rubocop:disable Metrics/ParameterLists
+        @client = client
+        @discovery = discovery
+        @wait_time = wait_time
+        @logger = logger
+        @max_wait_tries = max_wait_tries
+        @proc_table = proc_table
+        @socket_proc = socket_proc
+      end
+
+      def update(_time, _old_version, new_version)
+        return unless new_version.nil?
+
+        socket = @socket_proc.call(@client)
+
+        try_forever_with_backoff do
+          payload = discovery_payload(socket)
+          discovery_response = @client.send_request('PUT', DISCOVERY_URL, payload)
+
+          raise DiscoveryError, "Discovery response was #{discovery_response.code} with `#{payload}`." unless discovery_response.ok?
+
+          discovery = discovery_response.json
+          @logger.debug("Discovery complete (`#{discovery}`). Waiting for agent.")
+          wait_for_backend(discovery['pid'])
+          @logger.debug("Agent ready.")
+          @discovery.swap { discovery }
+        end
+
+        socket.close
+      end
+
+      private
+
+      def discovery_payload(socket)
+        proc_table = @proc_table.ps(pid: Process.pid)
+        process = ProcessInfo.new(proc_table)
+
+        payload = {
+          name: process.name,
+          args: process.arguments,
+          pid: process.parent_pid,
+          pidFromParentNS: process.from_parent_namespace,
+          cpuSetFileContent: process.cpuset
+        }
+
+        inode_path = "/proc/self/fd/#{socket.fileno}"
+        if socket.fileno && File.exist?(inode_path)
+          payload[:fd] = socket.fileno
+          payload[:inode] = File.readlink(inode_path)
+        end
+
+        payload.compact
+      end
+
+      def wait_for_backend(pid)
+        response = @max_wait_tries.times do
+          path = format(ENTITY_DATA_URL, pid)
+          wait_response = @client.send_request('HEAD', path)
+
+          break(wait_response) if wait_response.ok?
+
+          sleep(1)
+        end
+
+        raise DiscoveryError, "The backend didn't respond in time." unless response.is_a?(RequestClient::Response) && response.ok?
+      end
+
+      def try_forever_with_backoff
+        yield
+      rescue DiscoveryError, Net::OpenTimeout => e
+        @logger.warn(e)
+        sleep(@wait_time)
+        retry
+      rescue StandardError => e
+        @logger.error(%(#{e}\n#{e.backtrace.join("\n")}))
+      end
+
+      def default_socket_proc
+        ->(c) { TCPSocket.new(c.host, c.port) }
+      end
+    end
+  end
+end

data/lib/instana/backend/host_agent_lookup.rb

@@ -0,0 +1,57 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'csv'
+
+module Instana
+  module Backend
+    # Utility class to discover the agent that a given instance of the collector
+    # needs to communicate with.
+    # @since 1.197.0
+    class HostAgentLookup
+      def initialize(host = ::Instana.config[:agent_host], port = ::Instana.config[:agent_port], destination: '00000000')
+        @host = host
+        @port = port
+        @destination = destination
+      end
+
+      # @return [RequestClient, NilClass] the request client to use to communicate with the agent or nil if no agent could be found
+      def call
+        host_listening?(@host, @port) || host_listening?(default_gateway, @port)
+      end
+
+      private
+
+      # @return [RequestClient, nil] the request client if it responds to '/' with a success
+      def host_listening?(host, port)
+        client = RequestClient.new(host, port)
+        client.send_request('GET', '/').ok? ? client : nil
+      rescue Net::OpenTimeout, Errno::ECONNREFUSED => _e
+        nil
+      end
+
+      # @return [String] the default gateway to attempt to connect to or the @host if a default gateway can not be identified
+      def default_gateway
+        return @host unless File.exist?('/proc/self/net/route')
+
+        routes = CSV.read(
+          '/proc/self/net/route',
+          headers: :first_row,
+          col_sep: "\t",
+          header_converters: [->(v) { v.strip }],
+          converters: [->(v) { v.strip }]
+        )
+
+        route = routes.detect { |r| r['Destination'] == @destination }
+        return @host unless route
+
+        route['Gateway']
+          .split(/([0-9A-Z]{2})/)
+          .reject(&:empty?)
+          .reverse
+          .map { |s| s.to_i(16) }
+          .join('.')
+      end
+    end
+  end
+end

data/lib/instana/backend/host_agent_reporting_observer.rb

@@ -0,0 +1,106 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # Process which is responsible for reporting metrics and tracing to the local agent
+    # @since 1.197.0
+    class HostAgentReportingObserver
+      ENTITY_DATA_URL = '/com.instana.plugin.ruby.%i'.freeze
+      RESPONSE_DATA_URL = '/com.instana.plugin.ruby/response.%i?messageId=%s'.freeze
+      TRACES_DATA_URL = "/com.instana.plugin.ruby/traces.%i".freeze
+
+      attr_reader :report_timer
+
+      # @param [RequestClient] client used to make requests to the backend
+      # @param [Concurrent::Atom] discovery object used to store discovery response in
+      def initialize(client, discovery, logger: ::Instana.logger, timer_class: Concurrent::TimerTask, processor: ::Instana.processor)
+        @client = client
+        @discovery = discovery
+        @logger = logger
+        @report_timer = timer_class.new(execution_interval: 1, run_now: true) { report_to_backend }
+        @nonce = Time.now
+        @processor = processor
+      end
+
+      def update(time, _old_version, new_version)
+        return unless time > @nonce
+
+        @nonce = time
+        new_version.nil? ? @report_timer.shutdown : @report_timer.execute
+      end
+
+      private
+
+      def report_to_backend
+        report_metrics if ::Instana.config[:metrics][:enabled]
+        report_traces if ::Instana.config[:tracing][:enabled]
+      rescue StandardError => e
+        @logger.error(%(#{e}\n#{e.backtrace.join("\n")}))
+      end
+
+      def report_traces
+        discovery = @discovery.value
+        return unless discovery
+
+        path = format(TRACES_DATA_URL, discovery['pid'])
+
+        @processor.send do |spans|
+          response = @client.send_request('POST', path, spans)
+
+          unless response.ok?
+            @discovery.swap { nil }
+            break
+          end
+
+          @logger.debug("Sent `#{spans.count}` spans to `#{path}` and got `#{response.code}`.")
+        end
+      end
+
+      def report_metrics
+        discovery = @discovery.value
+        return unless discovery
+
+        path = format(ENTITY_DATA_URL, discovery['pid'])
+        payload = metrics_payload(discovery).merge(Util.take_snapshot)
+        response = @client.send_request('POST', path, payload)
+
+        if response.ok?
+          handle_agent_tasks(response, discovery) unless response.body.empty?
+        else
+          @discovery.swap { nil }
+        end
+
+        @logger.debug("Sent `#{payload}` to `#{path}` and got `#{response.code}`.")
+      end
+
+      def handle_agent_tasks(response, discovery)
+        payload = response.json
+        payload = [payload] if payload.is_a?(Hash)
+        payload
+          .select { |t| t['action'] == 'ruby.source' }
+          .each do |action|
+            payload = ::Instana::Util.get_rb_source(action['args']['file'])
+            path = format(RESPONSE_DATA_URL, discovery['pid'], action['messageId'])
+            @client.send_request('POST', path, payload)
+          end
+      rescue StandardError => e
+        @logger.debug("Error processing agent task #{e.inspect}")
+      end
+
+      def metrics_payload(discovery)
+        proc_table = Sys::ProcTable.ps(pid: Process.pid)
+        process = ProcessInfo.new(proc_table)
+
+        {
+          pid: discovery['pid'],
+          name: Util.get_app_name,
+          exec_args: process.arguments,
+          gc: GCSnapshot.instance.report,
+          thread: {count: ::Thread.list.count},
+          memory: {rss_size: proc_table.rss / 1024} # Bytes to Kilobytes
+        }
+      end
+    end
+  end
+end