instana 1.195.4 → 1.197.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0068c5ce2a6bf7c75d517562cec424a612a31d8d938fabb7651151f52b3cc5ea'
-  data.tar.gz: cffa225ebc37b1a19a6a20d2418af57cd6e559a3635df17b5244bc2d603eaa20
+  metadata.gz: 58219b994af0387dcc4c672577b19c9570e487998be17d315a92902d6e1d86e6
+  data.tar.gz: 60e586b644f60545ebe6c7690d3ba673354d2133937b3b2bf95db04fbe8f58c4
 SHA512:
-  metadata.gz: '0991b7a36fe13c5e4b8ebf93647f3a933087c0f92b8e94e2a3b4a8f7c8bcc24712560f4caf550328bc5390a51f59c334483e48b8be4b78236164b2d557608625'
-  data.tar.gz: bd5ab3d0ba9f0d80a5b7c86068afb04f3889321fa5a154e43e97f89f577e244e481e0b2208a3fb76ae04452b26bcd32657ca2ea9cd6133230a7e53a8904fc52f
+  metadata.gz: 4d4ca8c71a1613c05e5f1fec02e5857c544013f0043d4b95e31fc900b81903ba5f3c08abd075afc4643e7761cd54a7595939ad9149575589b44b8e43722ea89a
+  data.tar.gz: 737447ad9f8ed3c6aef72bead3e66128b83ac1d346bc35f00ad1bd3e0b485f4cd8080faabf8817da23a788f229d32db1739e98484637fd8e70b852b415447d97

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,57 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # @since 1.197.0
+    class HostAgent
+      def initialize(discovery: Concurrent::Atom.new(nil))
+        @discovery = discovery
+        @client = nil
+      end
+
+      def setup
+        return if ENV.key?('INSTANA_TEST')
+
+        @client = HostAgentLookup.new.call
+        @discovery
+          .with_observer(HostAgentActivationObserver.new(@client, @discovery))
+          .with_observer(HostAgentReportingObserver.new(@client, @discovery))
+      end
+
+      def spawn_background_thread
+        @discovery.swap { nil }
+      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 discovery_value
+        v = @discovery.value
+        v || {}
+      end
+    end
+  end
+end

data/lib/instana/backend/host_agent_activation_observer.rb

@@ -0,0 +1,87 @@
+# (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: 60, logger: ::Instana.logger, max_wait_tries: 60, proc_table: Sys::ProcTable) # rubocop:disable Metrics/ParameterLists
+        @client = client
+        @discovery = discovery
+        @wait_time = wait_time
+        @logger = logger
+        @max_wait_tries = max_wait_tries
+        @proc_table = proc_table
+      end
+
+      def update(_time, _old_version, new_version)
+        return unless new_version.nil?
+
+        try_forever_with_backoff do
+          payload = discovery_payload
+          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
+      end
+
+      private
+
+      def discovery_payload
+        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
+        }
+
+        if @client.fileno && @client.inode
+          payload[:fd] = @client.fileno
+          payload[:inode] = @client.inode
+        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.error(e)
+        sleep(@wait_time)
+        retry
+      rescue StandardError => e
+        @logger.error(%(#{e}\n#{e.backtrace.join("\n")}))
+      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