instana 1.195.2 → 1.197.0

data/test/snapshot/fargate_container_test.rb

@@ -0,0 +1,82 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class FargateContainerTest < Minitest::Test
+  def test_snapshot_observed
+    container = JSON.parse(File.read('test/support/ecs/task.json'))['Containers'].first
+    subject = Instana::Snapshot::FargateContainer.new(container, metadata_uri: 'https://10.10.10.10:8080/v3')
+
+    stub_request(:get, 'https://10.10.10.10:8080/v3')
+      .to_return(status: 200, body: File.read('test/support/ecs/container.json'))
+
+    snapshot = subject.snapshot
+
+    assert_equal Instana::Snapshot::FargateContainer::ID, snapshot[:name]
+    assert_equal 'arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3::~internal~ecs~pause', snapshot[:entityId]
+
+    assert_equal "731a0d6a3b4210e2448339bc7015aaa79bfe4fa256384f4102db86ef94cbbc4c", snapshot[:data][:dockerId]
+    assert_equal "ecs-nginx-5-internalecspause-acc699c0cbf2d6d11700", snapshot[:data][:dockerName]
+    assert_equal "~internal~ecs~pause", snapshot[:data][:containerName]
+    assert_equal "amazon/amazon-ecs-pause:0.1.0", snapshot[:data][:image]
+    assert_equal "", snapshot[:data][:imageId]
+    assert_equal "arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3", snapshot[:data][:taskArn]
+    assert_nil snapshot[:data][:taskDefinition]
+    assert_nil snapshot[:data][:taskDefinitionVersion]
+    assert_equal "default", snapshot[:data][:clusterArn]
+    assert_equal "RESOURCES_PROVISIONED", snapshot[:data][:desiredStatus]
+    assert_equal "RESOURCES_PROVISIONED", snapshot[:data][:knownStatus]
+    assert_nil snapshot[:data][:ports]
+    assert_equal({:cpu => 0, :memory => 0}, snapshot[:data][:limits])
+    assert_equal "2018-02-01T20:55:08.366329616Z", snapshot[:data][:createdAt]
+    assert_equal "2018-02-01T20:55:09.058354915Z", snapshot[:data][:startedAt]
+
+    assert_nil subject.source
+  end
+
+  def test_snapshot_current
+    container = JSON.parse(File.read('test/support/ecs/task.json'))['Containers'].last
+    subject = Instana::Snapshot::FargateContainer.new(container, metadata_uri: 'https://10.10.10.10:8080/v3')
+
+    stub_request(:get, 'https://10.10.10.10:8080/v3')
+      .to_return(status: 200, body: File.read('test/support/ecs/container.json'))
+
+    snapshot = subject.snapshot
+
+    assert_equal Instana::Snapshot::FargateContainer::ID, snapshot[:name]
+    assert_equal 'arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3::nginx-curl', snapshot[:entityId]
+
+    assert_equal "43481a6ce4842eec8fe72fc28500c6b52edcc0917f105b83379f88cac1ff3946", snapshot[:data][:dockerId]
+    assert_equal "ecs-nginx-5-nginx-curl-ccccb9f49db0dfe0d901", snapshot[:data][:dockerName]
+    assert_equal "nginx-curl", snapshot[:data][:containerName]
+    assert_equal "nrdlngr/nginx-curl", snapshot[:data][:image]
+    assert_equal "sha256:2e00ae64383cfc865ba0a2ba37f61b50a120d2d9378559dcd458dc0de47bc165", snapshot[:data][:imageId]
+    assert_equal "arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3", snapshot[:data][:taskArn]
+    assert_nil snapshot[:data][:taskDefinition]
+    assert_nil snapshot[:data][:taskDefinitionVersion]
+    assert_equal "default", snapshot[:data][:clusterArn]
+    assert_equal "RUNNING", snapshot[:data][:desiredStatus]
+    assert_equal "RUNNING", snapshot[:data][:knownStatus]
+    assert_nil snapshot[:data][:ports]
+    assert_equal({:cpu => 512, :memory => 512}, snapshot[:data][:limits])
+    assert_equal "2018-02-01T20:55:10.554941919Z", snapshot[:data][:createdAt]
+    assert_equal "2018-02-01T20:55:11.064236631Z", snapshot[:data][:startedAt]
+    assert_equal true, snapshot[:data][:instrumented]
+    assert_equal "ruby", snapshot[:data][:runtime]
+
+    assert_equal({hl: true, cp: "aws", e: "arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3::nginx-curl"}, subject.source)
+  end
+
+  def test_snapshot_error
+    stub_request(:get, 'https://10.10.10.10:8080/v3')
+      .to_return(status: 500)
+
+    container = JSON.parse(File.read('test/support/ecs/task.json'))['Containers'].first
+    subject = Instana::Snapshot::FargateContainer.new(container, metadata_uri: 'https://10.10.10.10:8080/v3')
+
+    assert_raises do
+      subject.snapshot
+    end
+  end
+end

data/test/snapshot/fargate_process_test.rb

@@ -0,0 +1,35 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class FargateProcessTest < Minitest::Test
+  def setup
+    @subject = Instana::Snapshot::FargateProcess.new(metadata_uri: 'https://10.10.10.10:8080/v3')
+  end
+
+  def test_snapshot
+    stub_request(:get, 'https://10.10.10.10:8080/v3')
+      .to_return(status: 200, body: File.read('test/support/ecs/container.json'))
+    stub_request(:get, 'https://10.10.10.10:8080/v3/task')
+      .to_return(status: 200, body: File.read('test/support/ecs/task.json'))
+
+    snapshot = @subject.snapshot
+
+    assert_equal Instana::Snapshot::FargateProcess::ID, snapshot[:name]
+    assert_equal Process.pid.to_s, snapshot[:entityId]
+
+    assert_equal 'docker', snapshot[:data][:containerType]
+    assert_equal '43481a6ce4842eec8fe72fc28500c6b52edcc0917f105b83379f88cac1ff3946', snapshot[:data][:container]
+    assert_equal 'arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3', snapshot[:data][:'com.instana.plugin.host.name']
+  end
+
+  def test_snapshot_error
+    stub_request(:get, 'https://10.10.10.10:8080/v3')
+      .to_return(status: 500)
+
+    assert_raises do
+      @subject.snapshot
+    end
+  end
+end

data/test/snapshot/fargate_task_test.rb

@@ -0,0 +1,49 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class FargateTaskTest < Minitest::Test
+  def setup
+    @subject = Instana::Snapshot::FargateTask.new(metadata_uri: 'https://10.10.10.10:8080/v3')
+
+    ENV['INSTANA_ZONE'] = 'test'
+    ENV['INSTANA_TAGS'] = 'test=a,b,c'
+  end
+
+  def teardown
+    ENV['INSTANA_ZONE'] = nil
+    ENV['INSTANA_TAGS'] = nil
+  end
+
+  def test_snapshot
+    stub_request(:get, 'https://10.10.10.10:8080/v3/task')
+      .to_return(status: 200, body: File.read('test/support/ecs/task.json'))
+
+    snapshot = @subject.snapshot
+
+    assert_equal Instana::Snapshot::FargateTask::ID, snapshot[:name]
+    assert_equal 'arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3', snapshot[:entityId]
+
+    assert_equal "arn:aws:ecs:us-east-2:012345678910:task/9781c248-0edd-4cdb-9a93-f63cb662a5d3", snapshot[:data][:taskArn]
+    assert_equal "default", snapshot[:data][:clusterArn]
+    assert_equal "nginx", snapshot[:data][:taskDefinition]
+    assert_equal "5", snapshot[:data][:taskDefinitionVersion]
+    assert_equal "us-east-2b", snapshot[:data][:availabilityZone]
+    assert_equal "RUNNING", snapshot[:data][:desiredStatus]
+    assert_equal "RUNNING", snapshot[:data][:knownStatus]
+    assert_equal "2018-02-01T20:55:09.372495529Z", snapshot[:data][:pullStartedAt]
+    assert_equal "2018-02-01T20:55:10.552018345Z", snapshot[:data][:pullStoppedAt]
+    assert_equal "test", snapshot[:data][:instanaZone]
+    assert_equal({"test" => "a", "b" => nil, "c" => nil}, snapshot[:data][:tags])
+  end
+
+  def test_snapshot_error
+    stub_request(:get, 'https://10.10.10.10:8080/v3/task')
+      .to_return(status: 500)
+
+    assert_raises do
+      @subject.snapshot
+    end
+  end
+end

data/test/snapshot/ruby_process_test.rb

@@ -0,0 +1,14 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class RubyProcessTest < Minitest::Test
+  def test_snapshot
+    subject = Instana::Snapshot::RubyProcess.new
+    snapshot = subject.snapshot
+
+    assert_equal Instana::Snapshot::RubyProcess::ID, snapshot[:name]
+    assert_equal Process.pid.to_s, snapshot[:entityId]
+  end
+end

data/test/support/mock_timer.rb

@@ -0,0 +1,20 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+class MockTimer
+  attr_reader :opts, :block, :running
+
+  def initialize(*args, &blk)
+    @opts = args.first
+    @block = blk
+    @running = false
+  end
+
+  def shutdown
+    @running = false
+  end
+
+  def execute
+    @running = true
+  end
+end

data/test/test_helper.rb

@@ -10,11 +10,22 @@ begin
   SimpleCov.start do
     enable_coverage :branch
 
-    add_group 'Frameworks', 'lib/instana/frameworks'
-    add_group 'Instrumentation', 'lib/instana/instrumentation'
-
     add_filter %r{^/test/}
 
+    add_group(
+      'In Process Collector',
+      [%r{lib/instana/(agent|backend|tracing|collectors|open_tracing|snapshot)}, %r{lib/instana/[^/]+\.rb}]
+    )
+
+    if ENV['APPRAISAL_INITIALIZED']
+      add_group(
+        'Instrumentation',
+        %r{lib/instana/(activators|frameworks|instrumentation)}
+      )
+    else
+      add_filter %r{lib/instana/(activators|frameworks|instrumentation)}
+    end
+
     if ENV['CI']
       formatter SimpleCov::Formatter::JSONFormatter
     end
@@ -29,11 +40,12 @@ Bundler.require
 require "minitest/spec"
 require "minitest/autorun"
 require "minitest/reporters"
+require 'fakefs/safe'
 
 require 'webmock/minitest'
 # Webmock: Whitelist local IPs
 WebMock.disable_net_connect!(
-  allow: ->(uri) { %w[localhost 127.0.0.1 172.17.0.1 172.0.12.100].include?(uri.host) }
+  allow: ->(uri) { %w[localhost 127.0.0.1 172.17.0.1 172.0.12.100].include?(uri.host) && ENV.key?('APPRAISAL_INITIALIZED') }
 )
 
 Dir['test/support/*.rb'].each { |f| load(f) }

data/test/tracing/custom_test.rb

@@ -39,9 +39,7 @@ class CustomTracingTest < Minitest::Test
     assert_equal :entry, first_span[:data][:sdk][:type]
 
     assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    assert_equal ::Instana.agent.source, first_span[:f]
   end
 
   def test_custom_tracing_with_args

data/test/tracing/id_management_test.rb

@@ -69,4 +69,8 @@ class TracerIDMgmtTest < Minitest::Test
     bogus_result = Instana::Util.header_to_id([1234])
     assert_equal '', bogus_result
   end
+
+  def test_long_id_trim
+    assert_equal 16, Instana::Util.id_to_header(::Instana::Util.generate_id(2)).length
+  end
 end

data/test/tracing/opentracing_test.rb

@@ -34,8 +34,6 @@ module Instana
   end
 end
 
-OpenTracing.global_tracer = ::Instana.tracer
-
 class OpenTracerTest < Minitest::Test
   include Rack::Test::Methods
 
@@ -60,6 +58,8 @@ class OpenTracerTest < Minitest::Test
     assert OpenTracing.global_tracer.respond_to?(:inject)
     assert OpenTracing.global_tracer.respond_to?(:extract)
 
+    assert OpenTracing.respond_to?(:start_span)
+
     assert defined?(OpenTracing::Carrier)
     carrier = OpenTracing::Carrier.new
     assert carrier.respond_to?(:[])
@@ -356,4 +356,17 @@ class OpenTracerTest < Minitest::Test
     span = OpenTracing.start_active_span(:rack)
     assert_equal OpenTracing.active_span, span
   end
+
+  def test_active_span_block
+    clear_all!
+
+    obj = OpenTracing.start_active_span(:rack) { 1 }
+    assert_equal 1, obj
+  end
+
+  def test_span_rename
+    span = OpenTracing.start_active_span(:rack)
+    span.operation_name = 'test'
+    assert_equal 'test', span.name
+  end
 end

data/test/tracing/processor_test.rb

@@ -0,0 +1,58 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class ProcessorTest < Minitest::Test
+  def test_queued_spans_empty
+    subject = Instana::Processor.new
+    assert_equal [], subject.queued_spans
+  end
+
+  def test_queued_spans_valid_level
+    clear_all!
+    subject = Instana::Processor.new
+
+    span_context = Instana::SpanContext.new('9', '8', 0)
+    span = Instana::Span.new(:rack, parent_ctx: span_context)
+    span2 = Instana::Span.new(:"net-http")
+
+    subject.add_span(span)
+    subject.add_span(span2)
+
+    spans = subject.queued_spans
+    valid_span, = spans
+
+    assert_equal 1, spans.length
+    assert_equal :"net-http", valid_span[:n]
+  end
+
+  def test_queued_spans_invalid_type
+    subject = Instana::Processor.new
+    subject.add_span(false)
+
+    assert_equal [], subject.queued_spans
+  end
+
+  def test_send
+    ENV['INSTANA_TEST'] = nil
+
+    subject = Instana::Processor.new
+    span = Instana::Span.new(:rack)
+    subject.add_span(span)
+
+    was_invoked = false
+
+    subject.send do |spans|
+      was_invoked = true
+      rack_span, = spans
+
+      assert_equal 1, spans.length
+      assert_equal :rack, rack_span[:n]
+    end
+
+    assert was_invoked
+  ensure
+    ENV['INSTANA_TEST'] = 'true'
+  end
+end

data/test/tracing/span_context_test.rb

@@ -0,0 +1,21 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class SpanContextTest < Minitest::Test
+  def test_to_hash
+    subject = Instana::SpanContext.new('trace', 'span')
+    assert_equal({trace_id: 'trace', span_id: 'span'}, subject.to_hash)
+  end
+
+  def test_invalid
+    subject = Instana::SpanContext.new(nil, nil)
+    refute subject.valid?
+  end
+
+  def test_flags_level_zero
+    subject = Instana::SpanContext.new('trace', 'span', 0)
+    assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
+  end
+end

data/test/tracing/span_test.rb

@@ -0,0 +1,136 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class SpanTest < Minitest::Test
+  def test_getters_setters
+    span = Instana::Span.new(:test)
+
+    assert_equal span[:s], span.id
+    assert_equal span[:t], span.trace_id
+    assert_equal span[:p], span.parent_id
+    assert_equal span[:d], span.duration
+
+    span.parent_id = 'test'
+    assert_equal 'test', span.parent_id
+
+    span.name = 'test'
+    assert_equal 'test', span[:data][:sdk][:name]
+
+    span[:t] = 'test'
+    assert span.key?(:t)
+    assert_equal 'test', span[:t]
+
+    assert span.inspect
+  end
+
+  def test_builtin_span_rename
+    span = Instana::Span.new(:"net-http")
+    assert_equal :"net-http", span.name
+
+    span.name = 'test'
+    assert_equal 'test', span.name
+  end
+
+  def test_exit_span
+    span = Instana::Span.new(:"net-http")
+    assert span.exit_span?
+  end
+
+  def test_span_from_contetx
+    context = Instana::SpanContext.new('test', 'test', 0)
+    span = Instana::Span.new(:test, parent_ctx: context)
+
+    assert_equal 'test', span.parent_id
+    assert_equal 'test', span.trace_id
+  end
+
+  def test_span_from_contetx_invalid
+    context = Instana::SpanContext.new(nil, nil, 1)
+    span = Instana::Span.new(:test, parent_ctx: context)
+
+    assert_nil span.parent_id
+    refute_equal context.span_id, span.trace_id
+    assert_equal 1, span.context.level
+  end
+
+  def test_span_collect_backtraces
+    Instana.config[:collect_backtraces] = true
+    span = Instana::Span.new(:excon)
+    assert span[:stack]
+  ensure
+    Instana.config[:collect_backtraces] = false
+  end
+
+  def test_span_stack_over_limit
+    def inner(depth = 50, &blk) # rubocop:disable Lint/NestedMethodDefinition
+      return blk.call if depth.zero?
+
+      inner(depth - 1, &blk)
+    end
+
+    inner do
+      span = Instana::Span.new(:excon)
+      span.add_stack(limit: 500)
+      assert_equal 40, span[:stack].length
+    end
+  end
+
+  def test_multiple_errors
+    span = Instana::Span.new(:activerecord)
+    span.set_tag(:activerecord, {})
+
+    span.add_error(StandardError.new('Test1'))
+    span.add_error(StandardError.new('Test2'))
+
+    assert_equal 2, span[:ec]
+    assert_equal 'Test2', span[:data][:activerecord][:error]
+  end
+
+  def test_add_error_nil
+    span = Instana::Span.new(:activerecord)
+    span.add_error(nil)
+
+    assert_equal 1, span[:ec]
+  end
+
+  def test_set_tag_merge
+    span = Instana::Span.new(:excon)
+    span.set_tag(1024, {a: 1})
+    span.set_tag(1024, {b: 2})
+
+    assert_equal({'1024' => {a: 1, b: 2}}, span[:data])
+  end
+
+  def test_set_tags_non_hash
+    span = Instana::Span.new(:excon)
+    assert_nil span.set_tags(0)
+  end
+
+  def test_tags_standard
+    span = Instana::Span.new(:excon)
+    span.set_tag(:test, {a: 1})
+
+    assert_equal({test: {a: 1}}, span.tags)
+    assert_equal({a: 1}, span.tags(:test))
+  end
+
+  def test_log_standard
+    span = Instana::Span.new(:excon)
+    span.log(:test, Time.now, a: 1)
+
+    assert_equal({log: {a: 1}}, span.tags)
+  end
+
+  def test_log_error
+    time = Minitest::Mock.new
+    time.expect(:to_f, nil)
+
+    span = Instana::Span.new(:sdk)
+    span.log(:test, time, a: 1)
+
+    assert_equal({}, span.tags)
+    time.verify
+  end
+end