instana 1.11.6 → 1.209.2

data/test/test_helper.rb

@@ -1,159 +1,63 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-ENV['INSTANA_TEST'] = 'true'
-require "rubygems"
-require "bundler/setup"
-Bundler.require(:default, :test)
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2016
 
-require "minitest/spec"
-require "minitest/autorun"
-require "minitest/reporters"
-require "minitest/debugger" if ENV['DEBUG']
-require "minitest/benchmark"
-require 'webmock/minitest'
+ENV['INSTANA_TEST'] = 'true'
 
-require "instana/test"
-::Instana::Test.setup_environment
+begin
+  require 'simplecov'
+  require 'simplecov_json_formatter'
 
-# Webmock: Whitelist local IPs
-whitelist = ['127.0.0.1', 'localhost', '172.17.0.1', '172.0.12.100']
-allowed_sites = lambda{|uri|
-  whitelist.include?(uri.host)
-}
-::WebMock.disable_net_connect!(allow: allowed_sites)
+  SimpleCov.start do
+    enable_coverage :branch
 
-# Boot background webservers to test against.
-require "./test/servers/rackapp_6511"
+    add_filter %r{^/test/}
 
-case File.basename(ENV['BUNDLE_GEMFILE'])
-when /rails/
-  require './test/servers/rails_3205'
-when /libraries/
-  # Configure gRPC
-  require './test/servers/grpc_50051.rb'
+    add_group(
+      'In Process Collector',
+      [%r{lib/instana/(agent|backend|tracing|collectors|open_tracing|snapshot)}, %r{lib/instana/[^/]+\.rb}]
+    )
 
-  # Hook into sidekiq to control the current mode
-  $sidekiq_mode = :client
-  class << Sidekiq
-    def server?
-      $sidekiq_mode == :server
+    if ENV['APPRAISAL_INITIALIZED']
+      add_group(
+        'Instrumentation',
+        %r{lib/instana/(activators|frameworks|instrumentation)}
+      )
+    else
+      add_filter %r{lib/instana/(activators|frameworks|instrumentation)}
     end
-  end
-
-  ENV['REDIS_URL'] ||= 'redis://127.0.0.1:6379'
-
-  # Configure redis for sidekiq client
-  Sidekiq.configure_client do |config|
-    config.redis = { url: ENV['REDIS_URL'] }
-  end
-
-  # Configure redis for sidekiq worker
-  $sidekiq_mode = :server
-  ::Sidekiq.configure_server do |config|
-    config.redis = { url: ENV['REDIS_URL'] }
-  end
-  $sidekiq_mode = :client
-
-  require './test/servers/sidekiq/worker'
-end
-
-Minitest::Reporters.use! MiniTest::Reporters::SpecReporter.new
-
-# Used to reset the gem to boot state.  It clears out any queued and/or staged
-# traces and resets the tracer to no active trace.
-#
-def clear_all!
-  ::Instana.processor.clear!
-  ::Instana.tracer.clear!
-  nil
-end
-
-def disable_redis_instrumentation
-  ::Redis::Client.class_eval do
-    alias call call_without_instana
-    alias call_pipeline call_pipeline_without_instana
-  end
-end
-
-def enable_redis_instrumentation
-  ::Redis::Client.class_eval do
-    alias call call_with_instana
-    alias call_pipeline call_pipeline_with_instana
-  end
-end
-
-def validate_sdk_span(json_span, sdk_hash = {}, errored = false, ec = 1)
-  assert_equal :sdk, json_span[:n]
-  assert json_span.key?(:k)
-  assert json_span.key?(:d)
-  assert json_span.key?(:ts)
-
-  for k,v in sdk_hash
-    assert_equal v, json_span[:data][:sdk][k]
-  end
-
-  if errored
-    assert_equal true, json_span[:error]
-    assert_equal 1, json_span[:ec]
-  end
-end
 
-def find_spans_by_name(spans, name)
-  result = []
-  for span in spans
-    if span[:n] == :sdk
-      if span[:data][:sdk][:name] == name
-        result << span
-      end
-    elsif span[:n] == name
-      result << span
+    if ENV['CI']
+      formatter SimpleCov::Formatter::JSONFormatter
     end
   end
-  if result.empty?
-    raise Exception.new("No SDK spans (#{name}) could be found")
-  else
-    return result
-  end
+rescue LoadError => _e
+  nil
 end
 
-def find_first_span_by_name(spans, name)
-  for span in spans
-    if span[:n] == :sdk
-      if span[:data][:sdk][:name] == name
-        return span
-      end
-    else
-      if span[:n] == name
-        return span
-      end
-    end
-  end
-  raise Exception.new("Span (#{name}) not found")
-end
+require 'bundler/setup'
+Bundler.require
 
-def find_span_by_id(spans, id)
-  for span in spans
-    if span[:s] == id
-      return span
-    end
-  end
-  raise Exception.new("Span with id (#{id}) not found")
-end
+require "minitest/spec"
+require "minitest/autorun"
+require "minitest/reporters"
+require 'fakefs/safe'
 
-# Finds the first span in +spans+ for which +block+ returns true
-#
-#     ar_span = find_first_span_by_qualifier(ar_spans) do |span|
-#       span[:data][:activerecord][:sql] == sql
-#     end
-#
-# This helper will raise an exception if no span evaluates to true against he provided block.
-#
-# +spans+: +Array+ of spans to search
-# +block+: The Ruby block to evaluate against each span
-def find_first_span_by_qualifier(spans, &block)
-  spans.each do |span|
-    if block.call(span)
-      return span
-    end
-  end
-  raise Exception.new("Span with qualifier not found")
-end
+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) && ENV.key?('APPRAISAL_INITIALIZED') }
+)
+
+Dir['test/support/*.rb'].each { |f| load(f) }
+
+if ENV['CI']
+  Minitest::Reporters.use!([
+                             Minitest::Reporters::JUnitReporter.new('_junit', false),
+                             Minitest::Reporters::SpecReporter.new
+                           ])
+else
+  Minitest::Reporters.use!([
+                             MiniTest::Reporters::SpecReporter.new
+                           ])
+end
+Minitest::Test.include(Instana::TestHelpers)

data/test/tracing/custom_test.rb

@@ -1,3 +1,6 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2016
+
 require 'test_helper'
 
 class CustomTracingTest < Minitest::Test
@@ -36,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
@@ -110,7 +111,6 @@ class CustomTracingTest < Minitest::Test
 
       ::Instana.tracer.log_entry(:custom_span, kvs)
       raise "custom tracing error.  This is only a test"
-      ::Instana.tracer.log_info({:on_info_kv => 1})
     rescue => e
       ::Instana.tracer.log_error(e)
     ensure

data/test/tracing/id_management_test.rb

@@ -1,4 +1,8 @@
 
+
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2016
+
 require 'test_helper'
 
 class TracerIDMgmtTest < Minitest::Test
@@ -49,82 +53,28 @@ class TracerIDMgmtTest < Minitest::Test
     converted_id = Instana::Util.header_to_id(header_id)
 
     # Assert that it is an Integer
-    assert converted_id.is_a?(Integer)
+    assert converted_id.is_a?(String)
   end
 
   def test_header_to_id_conversion_with_bogus_header
     # Bogus nil arg
     bogus_result = Instana::Util.header_to_id(nil)
-    assert_equal 0, bogus_result
+    assert_equal '', bogus_result
 
     # Bogus Integer arg
     bogus_result = Instana::Util.header_to_id(1234)
-    assert_equal 0, bogus_result
+    assert_equal '', bogus_result
 
     # Bogus Array arg
     bogus_result = Instana::Util.header_to_id([1234])
-    assert_equal 0, bogus_result
-  end
-
-  def test_id_conversion_back_and_forth
-    # id --> header --> id
-    original_id = ::Instana::Util.generate_id
-    header_id = Instana::Util.id_to_header(original_id)
-    converted_back_id = Instana::Util.header_to_id(header_id)
-    assert original_id == converted_back_id
-
-    # header --> id --> header
-    original_header_id = "c025ee93b1aeda7b"
-    id = Instana::Util.header_to_id(original_header_id)
-    converted_back_header_id = Instana::Util.id_to_header(id)
-    assert_equal original_header_id, converted_back_header_id
-
-    # Test a random value
-    id = -7815363404733516491
-    header = "938a406416457535"
-
-    result = Instana::Util.header_to_id(header)
-    assert_equal id, result
-
-    result = Instana::Util.id_to_header(id)
-    assert_equal header, result
-
-    10000.times do
-      original_id = ::Instana::Util.generate_id
-      header_id = Instana::Util.id_to_header(original_id)
-      converted_back_id = Instana::Util.header_to_id(header_id)
-      assert original_id == converted_back_id
-    end
-  end
+    assert_equal '', bogus_result
 
-  def test_id_max_value_and_conversion
-    max_id = 9223372036854775807
-    min_id = -9223372036854775808
-    max_hex = "7fffffffffffffff"
-    min_hex = "8000000000000000"
-
-    assert_equal max_hex, Instana::Util.id_to_header(max_id)
-    assert_equal min_hex, Instana::Util.id_to_header(min_id)
-
-    assert_equal max_id, Instana::Util.header_to_id(max_hex)
-    assert_equal min_id, Instana::Util.header_to_id(min_hex)
+    # Invalid characters/length
+    bogus_result = Instana::Util.header_to_id('qwerty')
+    assert_equal '', bogus_result
   end
 
-  def test_that_leading_zeros_handled_correctly
-
-    header = ::Instana::Util.id_to_header(16)
-    assert_equal "10", header
-
-    id = ::Instana::Util.header_to_id("10")
-    assert_equal 16, id
-
-    id = ::Instana::Util.header_to_id("0000000000000010")
-    assert_equal 16, id
-
-    id = ::Instana::Util.header_to_id("88b6c735206ca42")
-    assert_equal 615705016619420226, id
-
-    id = ::Instana::Util.header_to_id("088b6c735206ca42")
-    assert_equal 615705016619420226, id
+  def test_long_id_trim
+    assert_equal 16, Instana::Util.id_to_header(::Instana::Util.generate_id(2)).length
   end
 end

data/test/tracing/instrumented_logger_test.rb

@@ -0,0 +1,39 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+require 'test_helper'
+
+class InstrumentedLoggerTest < Minitest::Test
+  def setup
+    clear_all!
+  end
+
+  def test_log_warn_error
+    subject = Instana::InstrumentedLogger.new('/dev/null')
+
+    Instana::Tracer.start_or_continue_trace(:test_logging) do
+      subject.warn('warn')
+      subject.debug('test')
+      subject.error('error')
+    end
+
+    spans = ::Instana.processor.queued_spans
+
+    warn_span, error_span, = *spans
+
+    assert_equal :log, warn_span[:n]
+    assert_equal 'warn', warn_span[:data][:log][:message]
+    assert_equal 'Warn', warn_span[:data][:log][:level]
+
+    assert_equal :log, error_span[:n]
+    assert_equal 'error', error_span[:data][:log][:message]
+    assert_equal 'Error', error_span[:data][:log][:level]
+  end
+
+  def test_no_trace
+    subject = Instana::InstrumentedLogger.new('/dev/null')
+    subject.warn('warn')
+
+    assert_equal [], ::Instana.processor.queued_spans
+  end
+end

data/test/tracing/opentracing_test.rb

@@ -1,3 +1,6 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2017
+
 require 'test_helper'
 require 'rack/test'
 require 'rack/lobster'
@@ -31,8 +34,6 @@ module Instana
   end
 end
 
-OpenTracing.global_tracer = ::Instana.tracer
-
 class OpenTracerTest < Minitest::Test
   include Rack::Test::Methods
 
@@ -57,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?(:[])
@@ -301,7 +304,7 @@ class OpenTracerTest < Minitest::Test
     assert_equal second_span[:s], third_span[:p]
 
     # Every span should have baggage
-    assert_equal(nil, entry_span.context.baggage)
+    assert_equal({}, entry_span.context.baggage)
     assert_equal({:my_bag=>1}, ac_span.context.baggage)
     assert_equal({:my_bag=>1}, av_span.context.baggage)
   end
@@ -328,9 +331,9 @@ class OpenTracerTest < Minitest::Test
     spans = ::Instana.processor.queued_spans
     assert_equal 3, spans.length
 
-    assert_equal(nil, entry_span.context.baggage)
+    assert_equal({}, entry_span.context.baggage)
     assert_equal({:my_bag=>1}, ac_span.context.baggage)
-    assert_equal(nil, av_span.context.baggage)
+    assert_equal({}, av_span.context.baggage)
   end
 
   def test_start_active_span
@@ -353,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,22 @@
+# (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, {external_state: 'cn=test'})
+    assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
+    assert_equal 'cn=test', subject.trace_state_header
+  end
+end

data/test/tracing/span_test.rb

@@ -0,0 +1,165 @@
+# (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_backtrace_cleaner
+    Instana.config[:collect_backtraces] = true
+    Instana.config[:backtrace_cleaner] =
+      ->(trace) { trace.filter { |line| line.include?("lib/instana") } }
+    span = Instana::Span.new(:excon)
+
+    assert_equal 1, span[:stack].size
+  ensure
+    Instana.config[:backtrace_cleaner] = nil
+    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
+
+  def test_inc_processed_counts
+    clear_all!
+
+    span = Instana::Span.new(:excon)
+    span.close
+
+    metrics = Instana.processor.span_metrics
+
+    assert_equal 1, metrics[:opened]
+    assert_equal 1, metrics[:closed]
+
+    metrics = Instana.processor.span_metrics
+
+    assert_equal 0, metrics[:opened]
+    assert_equal 0, metrics[:closed]
+  end
+end