instana 1.195.4 → 1.197.0.pre1

data/lib/instana/tracing/span_context.rb

@@ -18,7 +18,7 @@ module Instana
     def initialize(tid, sid, level = 1, baggage = {})
       @trace_id = tid
       @span_id = sid
-      @level = level
+      @level = Integer(level || 1)
       @baggage = baggage || {}
     end
 

data/lib/instana/util.rb

@@ -5,30 +5,6 @@ module Instana
   module Util
     class << self
       ID_RANGE = -2**63..2**63-1
-      # Debugging helper method
-      #
-      def pry!
-        # Only valid for development or test environments
-        #env = ENV['RACK_ENV'] || ENV['RAILS_ENV']
-        #return unless %w(development, test).include? env
-        require 'pry-byebug'
-
-        if defined?(PryByebug)
-          Pry.commands.alias_command 'c', 'continue'
-          Pry.commands.alias_command 's', 'step'
-          Pry.commands.alias_command 'n', 'next'
-          Pry.commands.alias_command 'f', 'finish'
-
-          Pry::Commands.command(/^$/, 'repeat last command') do
-            _pry_.run_command Pry.history.to_a.last
-          end
-        end
-
-        binding.pry
-      rescue LoadError
-        ::Instana.logger.warn("No debugger in bundle.  Couldn't load pry-byebug.")
-      end
-
       # Retrieves and returns the source code for any ruby
       # files requested by the UI via the host agent
       #
@@ -47,6 +23,7 @@ module Instana
       # Method to collect up process info for snapshots.  This
       # is generally used once per process.
       #
+      # :nocov:
       def take_snapshot
         data = {}
 
@@ -86,53 +63,12 @@ module Instana
         ::Instana.logger.debug { e.backtrace.join("\r\n") }
         return data
       end
-
-      # Used in class initialization and after a fork, this method
-      # collects up process information
-      #
-      def collect_process_info
-        process = {}
-        cmdline_file = "/proc/#{Process.pid}/cmdline"
-
-        # If there is a /proc filesystem, we read this manually so
-        # we can split on embedded null bytes.  Otherwise (e.g. OSX, Windows)
-        # use ProcTable.
-        if File.exist?(cmdline_file)
-          cmdline = IO.read(cmdline_file).split(?\x00)
-        else
-          # Attempt to support older versions of sys-proctable and ffi.
-          #
-          # Alternatively we could use Sys::ProcTable::VERSION here but the
-          # consistency across historical versions is unknown.  Alternative
-          # to the alternative, would be Ruby metaprogramming using the `arity`
-          # and `parameters` methods.
-          # e.g ProcTable.method(:ps).arity/parameters
-          if Gem.loaded_specs.key?("sys-proctable") &&
-            (Gem.loaded_specs["sys-proctable"].version >= Gem::Version.new("1.2.0"))
-            cmdline = ProcTable.ps(:pid => Process.pid).cmdline.split(' ')
-          else
-            cmdline = ProcTable.ps(Process.pid).cmdline.split(' ')
-          end
-        end
-
-        if RUBY_PLATFORM =~ /darwin/i
-          cmdline.delete_if{ |e| e.include?('=') }
-          process[:name] = cmdline.join(' ')
-        else
-          process[:name] = cmdline.shift
-          process[:arguments] = cmdline
-        end
-
-        process[:pid] = Process.pid
-        # This is usually Process.pid but in the case of containers, the host agent
-        # will return to us the true host pid in which we use to report data.
-        process[:report_pid] = nil
-        process
-      end
+      # :nocov:
 
       # Best effort to determine a name for the instrumented application
       # on the dashboard.
       #
+      # :nocov:
       def get_app_name
         if ENV.key?('INSTANA_SERVICE_NAME')
           return ENV['INSTANA_SERVICE_NAME']
@@ -169,6 +105,7 @@ module Instana
         Instana.logger.debug { e.backtrace.join("\r\n") }
         return "Ruby"
       end
+      # :nocov:
 
       # Get the current time in milliseconds from the epoch
       #

data/lib/instana/version.rb

@@ -2,6 +2,6 @@
 # (c) Copyright Instana Inc. 2016
 
 module Instana
-  VERSION = "1.195.4"
+  VERSION = "1.197.0.pre1"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/lib/opentracing.rb

@@ -1,9 +1,32 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2017
 
-require "instana/opentracing/tracer"
-require "instana/opentracing/carrier"
+require "instana/open_tracing/carrier"
+require "instana/open_tracing/instana_tracer"
+
+module OpenTracing
+  class << self
+    # Text format for #inject and #extract
+    FORMAT_TEXT_MAP = 1
+
+    # Binary format for #inject and #extract
+    FORMAT_BINARY = 2
+
+    # Ruby Specific format to handle how Rack changes environment variables.
+    FORMAT_RACK = 3
+
+    attr_accessor :global_tracer
+
+    def method_missing(method_name, *args, &block)
+      @global_tracer.send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(name, all)
+      @global_tracer.respond_to?(name, all)
+    end
+  end
+end
 
 # Set the global tracer to our OT tracer
 # which supports the OT specification
-OpenTracing.global_tracer = ::Instana.tracer
+OpenTracing.global_tracer = OpenTracing::InstanaTracer.new(::Instana.tracer)

data/test/backend/agent_test.rb

@@ -0,0 +1,54 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class AgentTest < Minitest::Test
+  def test_host
+    subject = Instana::Backend::Agent.new
+    assert_nil subject.delegate
+    subject.setup
+    assert subject.delegate.is_a?(Instana::Backend::HostAgent)
+  end
+
+  def test_fargate
+    ENV['ECS_CONTAINER_METADATA_URI'] = 'https://10.10.10.10:9292/v3'
+    ENV['INSTANA_ENDPOINT_URL'] = 'http://example.com'
+
+    stub_request(:get, 'https://10.10.10.10:9292/v3/task')
+      .to_return(status: 200, body: File.read('test/support/ecs/task.json'))
+
+    subject = Instana::Backend::Agent.new(fargate_metadata_uri: 'https://10.10.10.10:9292/v3')
+    assert_nil subject.delegate
+    subject.setup
+    assert subject.delegate.is_a?(Instana::Backend::ServerlessAgent)
+  ensure
+    ENV['INSTANA_ENDPOINT_URL'] = nil
+    ENV['ECS_CONTAINER_METADATA_URI'] = nil
+  end
+
+  def test_fargate_error
+    ENV['ECS_CONTAINER_METADATA_URI'] = 'https://10.10.10.10:9292/v3'
+    ENV['INSTANA_ENDPOINT_URL'] = 'http://example.com'
+
+    stub_request(:get, 'https://10.10.10.10:9292/v3/task')
+      .to_return(status: 500)
+
+    subject = Instana::Backend::Agent.new(logger: Logger.new('/dev/null'))
+    assert_nil subject.delegate
+    subject.setup
+    assert subject.delegate.is_a?(Instana::Backend::ServerlessAgent)
+  ensure
+    ENV['INSTANA_ENDPOINT_URL'] = nil
+    ENV['ECS_CONTAINER_METADATA_URI'] = nil
+  end
+
+  def test_delegate_super
+    subject = Instana::Backend::Agent.new
+    assert_raises NoMethodError do
+      subject.invalid
+    end
+
+    refute subject.respond_to?(:invalid)
+  end
+end

data/test/backend/gc_snapshot_test.rb

@@ -0,0 +1,11 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class GcSnapshotTest < Minitest::Test
+  def test_report
+    subject = Instana::Backend::GCSnapshot.instance
+    assert subject.report.is_a?(Hash)
+  end
+end

data/test/backend/host_agent_activation_observer_test.rb

@@ -0,0 +1,65 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class HostAgentActivationObserverTest < Minitest::Test
+  def test_standard_discovery
+    stub_request(:put, "http://10.10.10.10:9292/com.instana.plugin.ruby.discovery")
+      .and_timeout
+      .and_return(status: 500, body: '{"ok": false}')
+      .and_return(status: 200, body: '{"pid": 1234}')
+
+    stub_request(:head, "http://10.10.10.10:9292/com.instana.plugin.ruby.1234")
+      .and_return(status: 500, body: '{"ok": false}')
+      .and_return(status: 200, body: '{"ok": true}')
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1)
+
+    subject.update(nil, nil, nil)
+    assert_equal({'pid' => 1234}, discovery.value)
+  end
+
+  def test_linux_discovery
+    stub_request(:put, "http://10.10.10.10:9292/com.instana.plugin.ruby.discovery")
+      .and_return(status: 200, body: '{"pid": 1234}')
+
+    stub_request(:head, "http://10.10.10.10:9292/com.instana.plugin.ruby.1234")
+      .and_return(status: 200, body: '{"ok": true}')
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    # This is the cleanest way to fake it so it works across all test environments
+    client.define_singleton_method(:fileno) { '0' }
+    client.define_singleton_method(:inode) { '0' }
+
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), max_wait_tries: 1)
+
+    subject.update(nil, nil, nil)
+
+    assert_equal({'pid' => 1234}, discovery.value)
+  end
+
+  def test_discovery_standard_error
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery, wait_time: 0, logger: Logger.new('/dev/null'), proc_table: nil)
+
+    subject.update(nil, nil, nil)
+    assert_nil discovery.value
+  end
+
+  def test_value_present
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentActivationObserver.new(client, discovery)
+    assert_nil subject.update(nil, nil, true)
+    assert_nil discovery.value
+  end
+end

data/test/backend/host_agent_lookup_test.rb

@@ -0,0 +1,78 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class HostAgentLookupTest < Minitest::Test
+  def test_lookup
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_return(status: 200)
+
+    subject = Instana::Backend::HostAgentLookup.new('10.10.10.10', 42699)
+    client = subject.call
+
+    assert client
+    assert client.send_request('GET', '/').ok?
+  end
+
+  def test_lookup_no_agent
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_timeout
+
+    subject = Instana::Backend::HostAgentLookup.new('10.10.10.10', 42699)
+
+    client = FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/ecs', '/proc')
+
+      subject.call
+    end
+
+    assert_nil client
+  end
+
+  def test_lookup_agent_error
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_return(status: 500)
+
+    subject = Instana::Backend::HostAgentLookup.new('10.10.10.10', 42699)
+
+    client = FakeFS.with_fresh do
+      FakeFS::FileSystem.clone('test/support/ecs', '/proc')
+
+      subject.call
+    end
+
+    assert_nil client
+  end
+
+  def test_lookup_with_gateway
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_timeout
+    stub_request(:get, "http://172.18.0.1:42699/")
+      .to_return(status: 200)
+
+    subject = Instana::Backend::HostAgentLookup.new('10.10.10.10', 42699)
+
+    client = FakeFS do
+      FakeFS::FileSystem.clone('test/support/proc', '/proc')
+      subject.call
+    end
+
+    assert client
+    assert client.send_request('GET', '/').ok?
+  end
+
+  def test_lookup_with_gateway_no_destination
+    stub_request(:get, "http://10.10.10.10:42699/")
+      .to_timeout
+
+    subject = Instana::Backend::HostAgentLookup.new('10.10.10.10', 42699, destination: '11111111')
+
+    client = FakeFS do
+      FakeFS::FileSystem.clone('test/support/proc', '/proc')
+      subject.call
+    end
+
+    assert_nil client
+  end
+end

data/test/backend/host_agent_reporting_observer_test.rb

@@ -0,0 +1,192 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class HostAgentReportingObserverTest < Minitest::Test
+  def test_start_stop
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    refute subject.report_timer.running
+
+    subject.update(Time.now, nil, true)
+    assert subject.report_timer.running
+
+    subject.update(Time.now, nil, nil)
+    refute subject.report_timer.running
+
+    subject.update(Time.now - 500, nil, true)
+    refute subject.report_timer.running
+  end
+
+  def test_report
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.0")
+      .to_return(status: 200)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 0})
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  end
+
+  def test_report_fail
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.0")
+      .to_return(status: 500)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 0})
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+    assert_nil discovery.value
+  end
+
+  def test_agent_action
+    action = JSON.dump(
+      action: 'ruby.source',
+      messageId: 'test',
+      args: {file: 'test_helper.rb'}
+    )
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.0")
+      .to_return(status: 200, body: action)
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby/response.0?messageId=test")
+      .to_return(status: 200)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 0})
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  end
+
+  def test_agent_actions
+    action = JSON.dump([
+                         action: 'ruby.source',
+                         messageId: 'test',
+                         args: {file: 'test_helper.rb'}
+                       ])
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.0")
+      .to_return(status: 200, body: action)
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby/response.0?messageId=test")
+      .to_return(status: 200)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 0})
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  end
+
+  def test_agent_action_error
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.0")
+      .to_return(status: 200, body: 'INVALID')
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 0})
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  end
+
+  def test_disable_metrics
+    ::Instana.config[:metrics][:enabled] = false
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  ensure
+    ::Instana.config[:metrics][:enabled] = true
+  end
+
+  def test_disable_tracing
+    ::Instana.config[:tracing][:enabled] = false
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new(nil)
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer)
+
+    subject.report_timer.block.call
+  ensure
+    ::Instana.config[:tracing][:enabled] = true
+  end
+
+  def test_report_traces
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.1234")
+      .to_return(status: 200)
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby/traces.1234")
+      .to_return(status: 200)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 1234})
+
+    processor = Class.new do
+      def send
+        yield([{n: 'test'}])
+      end
+    end.new
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer, processor: processor)
+
+    subject.report_timer.block.call
+    refute_nil discovery.value
+  end
+
+  def test_report_traces_error
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.1234")
+      .to_return(status: 200)
+
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby/traces.1234")
+      .to_return(status: 500)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 1234})
+
+    processor = Class.new do
+      def send
+        yield([{n: 'test'}])
+      end
+    end.new
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer, processor: processor)
+
+    subject.report_timer.block.call
+    assert_nil discovery.value
+  end
+
+  def test_report_standard_error
+    stub_request(:post, "http://10.10.10.10:9292/com.instana.plugin.ruby.1234")
+      .to_return(status: 200)
+
+    client = Instana::Backend::RequestClient.new('10.10.10.10', 9292)
+    discovery = Concurrent::Atom.new({'pid' => 1234})
+
+    processor = Class.new do
+      def send
+        raise 'Standard Error'
+      end
+    end.new
+
+    subject = Instana::Backend::HostAgentReportingObserver.new(client, discovery, timer_class: MockTimer, processor: processor, logger: Logger.new('/dev/null'))
+
+    subject.report_timer.block.call
+    assert_equal({"pid" => 1234}, discovery.value)
+  end
+end