instana 2.0.0 → 2.1.0

data/test/support/apps/sidekiq/jobs/sidekiq_job_1.rb

@@ -1,9 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-class SidekiqJobOne
-  include Sidekiq::Worker
-
-  def perform(a, b, c)
-  end
-end

data/test/support/apps/sidekiq/jobs/sidekiq_job_2.rb

@@ -1,10 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-class SidekiqJobTwo
-  include Sidekiq::Worker
-
-  def perform(a, b, c)
-    raise 'Fail to execute the job'
-  end
-end

data/test/support/apps/sidekiq/worker.rb

@@ -1,37 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'sidekiq/launcher'
-require 'sidekiq/cli'
-require 'sidekiq/api'
-require 'sidekiq/processor'
-
-require_relative 'jobs/sidekiq_job_1'
-require_relative 'jobs/sidekiq_job_2'
-
-::Instana.logger.info "Booting instrumented sidekiq worker for tests."
-::Sidekiq.logger.level = ::Logger::FATAL
-
-sidekiq_version = Gem::Specification.find_by_name('sidekiq').version
-cli = ::Sidekiq::CLI.instance
-cli.parse(['sidekiq', '-r', __FILE__, '-C', "#{File.dirname(__FILE__)}/config.yaml"])
-
-config_or_options = if sidekiq_version >= Gem::Version.new('6.5.0')
-                      cli.config
-                    else
-                      cli.send :options
-                    end
-
-sidekiq_thread = Thread.new do
-  launcher = ::Sidekiq::Launcher.new(
-    config_or_options
-  )
-  launcher.run
-  Thread.current[:worker] = launcher
-end
-
-Minitest.after_run do
-  ::Instana.logger.info "Killing Sidekiq worker"
-  sidekiq_thread[:worker].stop
-  sleep 1
-end

data/test/support/helpers.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-module Instana
-  module TestHelpers
-    # 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
-      ::Instana.config[:redis][:enabled] = false
-    end
-
-    def enable_redis_instrumentation
-      ::Instana.config[:redis][:enabled] = true
-    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)
-
-      sdk_hash.each do |k, v|
-        assert_equal v, json_span[:data][:sdk][k]
-      end
-
-      return unless errored
-
-      assert_equal true, json_span[:error]
-      assert_equal 1, json_span[:ec]
-    end
-
-    def find_spans_by_name(spans, name)
-      spans.select do |span|
-        (span[:n] == :sdk && span[:data][:sdk][:name] == name) || span[:n] == name
-      end.tap do |result|
-        raise StandardError, "No SDK spans (#{name}) could be found" if result.empty?
-      end
-    end
-
-    def find_first_span_by_name(spans, name)
-      spans.each do |span|
-        case span[:n]
-        when :sdk
-          return span if span[:data][:sdk][:name] == name
-        when name
-          return span
-        end
-      end
-      raise StandardError, "Span (#{name}) not found"
-    end
-
-    def find_span_by_id(spans, id)
-      spans.each do |span|
-        return span if span[:s] == id
-      end
-      raise StandardError, "Span with id (#{id}) not found"
-    end
-
-    # 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|
-        return span if block.call(span)
-      end
-      raise StandardError, 'Span with qualifier not found'
-    end
-  end
-end

data/test/support/mock_timer.rb

@@ -1,20 +0,0 @@
-# (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

@@ -1,69 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-ENV['INSTANA_TEST'] = 'true'
-
-begin
-  require 'simplecov'
-  require 'simplecov_json_formatter'
-
-  SimpleCov.start do
-    enable_coverage :branch
-
-    add_filter %r{^/test/}
-
-    if ENV['CIRCLE_BUILD_NUM']
-      command_name "Job #{ENV['CIRCLE_BUILD_NUM']}"
-    elsif ENV['COVERAGE_PATH']
-      coverage_dir ENV['COVERAGE_PATH']
-    end
-    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
-
-    formatter SimpleCov::Formatter::MultiFormatter.new(
-      [
-        SimpleCov::Formatter::HTMLFormatter,
-        SimpleCov::Formatter::JSONFormatter
-      ]
-    )
-  end
-rescue LoadError => _e
-  nil
-end
-
-require 'bundler/setup'
-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) && ENV.key?('APPRAISAL_INITIALIZED') }
-)
-
-Dir['test/support/*.rb'].each { |f| load(f) }
-
-minitest_reporters_to_use = []
-if ENV['CIRCLE_BUILD_NUM']
-  minitest_reporters_to_use.append(Minitest::Reporters::JUnitReporter.new('_junit', false))
-elsif ENV['COVERAGE_PATH']
-  minitest_reporters_to_use.append(Minitest::Reporters::JUnitReporter.new("#{ENV['COVERAGE_PATH']}/_junit", false))
-end
-minitest_reporters_to_use.append(Minitest::Reporters::SpecReporter.new)
-Minitest::Reporters.use!(minitest_reporters_to_use)
-Minitest::Test.include(Instana::TestHelpers)

data/test/trace/custom_test.rb

@@ -1,233 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-require 'test_helper'
-
-class CustomTracingTest < Minitest::Test
-  def test_custom_tracing
-    clear_all!
-
-    assert_equal false, ::Instana.tracer.tracing?
-    # Start tracing
-    span = ::Instana.tracer.start_span(:custom_trace, attributes: {:one => 1})
-    assert_equal true, ::Instana.tracer.tracing?
-    span.add_attributes({:info_logged => 1})
-    # End tracing
-    span.add_attributes({:close_one => 1})
-    span.finish
-    assert_equal false, ::Instana.tracer.tracing?
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-
-    first_span = spans.first
-    assert_equal :sdk, first_span[:n]
-
-    assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts].positive?
-    assert first_span[:d].is_a?(Integer)
-    assert first_span[:d].between?(0, 5)
-
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:sdk)
-    assert first_span[:data][:sdk].key?(:custom)
-    assert first_span[:data][:sdk][:custom].key?(:tags)
-    assert_equal :custom_trace, first_span[:data][:sdk][:name]
-    assert_equal 1, first_span[:data][:sdk][:custom][:tags][:one]
-
-    # Custom tracing root spans should default to entry type
-    assert_equal 1, first_span[:k]
-    assert_equal :entry, first_span[:data][:sdk][:type]
-
-    assert first_span.key?(:f)
-    assert_equal ::Instana.agent.source, first_span[:f]
-  end
-
-  # automagic (TM) as seen in the docs:
-  # https://www.ibm.com/docs/en/instana-observability/current?topic=ruby-tracing-sdk#the-instana-ruby-tracing-sdk
-  def test_custom_tracing_with_nested_automagic
-    clear_all!
-    assert_equal false, ::Instana.tracer.tracing?
-
-    kvs = {}
-    kvs[:on_entry_kv] = 1
-    kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
-    kvs[:return] = true
-
-    # Start tracing
-    span = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
-    assert_equal true, ::Instana.tracer.tracing?
-
-    # Now the automagic
-    ::Instana.tracer.in_span(:custom_span, attributes: kvs) do
-      answer = 42 * 1
-      active_span = ::Instana.tracer.current_span
-      active_span.set_tag(:answer, answer)
-
-      # And now nested automagic
-      ::Instana.tracer.in_span(:custom_span2, attributes: kvs) do
-        was_here = 'stan'
-        active_span = ::Instana.tracer.current_span
-        active_span.set_tag(:was_here, was_here)
-      end
-    end
-
-    # End tracing
-    span.add_attributes({:on_trace_end => 1})
-    span.finish
-    assert_equal false, ::Instana.tracer.tracing?
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    second_span = find_first_span_by_name(spans, :custom_span)
-    third_span = find_first_span_by_name(spans, :custom_span2)
-
-    assert_equal :sdk, second_span[:n]
-    assert second_span.key?(:data)
-    assert second_span[:data].key?(:sdk)
-    assert second_span[:data][:sdk].key?(:custom)
-    assert second_span[:data][:sdk][:custom].key?(:tags)
-    assert :custom_span, second_span[:data][:sdk][:name]
-    assert :unknown, second_span[:data][:sdk][:type]
-    assert [[1, 2, 3], "test_arg", :ok], second_span[:data][:sdk][:arguments]
-    assert true, second_span[:data][:sdk][:return]
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_entry_kv]
-    assert_equal 42, second_span[:data][:sdk][:custom][:tags][:answer]
-
-    assert_equal :sdk, third_span[:n]
-    assert third_span.key?(:data)
-    assert third_span[:data].key?(:sdk)
-    assert third_span[:data][:sdk].key?(:custom)
-    assert third_span[:data][:sdk][:custom].key?(:tags)
-    assert :custom_span, third_span[:data][:sdk][:name]
-    assert :unknown, third_span[:data][:sdk][:type]
-    assert [[1, 2, 3], "test_arg", :ok], third_span[:data][:sdk][:arguments]
-    assert true, third_span[:data][:sdk][:return]
-    assert_equal 1, third_span[:data][:sdk][:custom][:tags][:on_entry_kv]
-    assert_equal 'stan', third_span[:data][:sdk][:custom][:tags][:was_here]
-  end
-
-  def test_custom_tracing_with_args
-    clear_all!
-    assert_equal false, ::Instana.tracer.tracing?
-
-    # Start tracing
-    span1 = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
-    assert_equal true, ::Instana.tracer.tracing?
-
-    kvs = {}
-    kvs[:on_entry_kv] = 1
-    kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
-    kvs[:return] = true
-
-    span2 = ::Instana.tracer.start_span(:custom_span, attributes: kvs)
-    span2.set_tags({:on_info_kv => 1})
-    span2.set_tags({:on_exit_kv => 1})
-    span2.finish
-
-    # End tracing
-    span1.set_tags({:on_trace_end => 1})
-    span1.finish
-
-    assert_equal false, ::Instana.tracer.tracing?
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = find_first_span_by_name(spans, :rack)
-    second_span = find_first_span_by_name(spans, :custom_span)
-
-    assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts].positive?
-    assert first_span[:d].is_a?(Integer)
-    assert first_span[:d].between?(0, 5)
-
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:on_trace_start)
-    assert_equal 1, first_span[:data][:on_trace_start]
-    assert first_span[:data].key?(:on_trace_end)
-    assert_equal 1, first_span[:data][:on_trace_end]
-
-    assert_equal :sdk, second_span[:n]
-    assert second_span.key?(:data)
-    assert second_span[:data].key?(:sdk)
-    assert second_span[:data][:sdk].key?(:custom)
-    assert second_span[:data][:sdk][:custom].key?(:tags)
-    assert :custom_span, second_span[:data][:sdk][:name]
-    assert :unknown, second_span[:data][:sdk][:type]
-    assert [[1, 2, 3], "test_arg", :ok], second_span[:data][:sdk][:arguments]
-    assert true, second_span[:data][:sdk][:return]
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_entry_kv]
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_info_kv]
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_exit_kv]
-  end
-
-  def test_custom_tracing_with_error # rubocop:disable Metrics/MethodLength
-    clear_all!
-    assert_equal false, ::Instana.tracer.tracing?
-
-    # Start tracing
-    span1 = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
-    assert_equal true, ::Instana.tracer.tracing?
-
-    begin
-      kvs = {}
-      kvs[:on_entry_kv] = 1
-      kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
-      kvs[:return] = true
-
-      span2 = ::Instana.tracer.start_span(:custom_span, attributes: kvs)
-      raise "custom tracing error.  This is only a test"
-    rescue => e
-      span2.record_exception(e)
-    ensure
-      span2.set_tags(:on_exit_kv => 1)
-      span2.finish
-    end
-    span1.set_tags(:on_trace_end => 1)
-    span1.finish
-    assert_equal false, ::Instana.tracer.tracing?
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = find_first_span_by_name(spans, :rack)
-    second_span = find_first_span_by_name(spans, :custom_span)
-
-    assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts].positive?
-    assert first_span[:d].is_a?(Integer)
-    assert first_span[:d].between?(0, 5)
-
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:on_trace_start)
-    assert_equal 1, first_span[:data][:on_trace_start]
-    assert first_span[:data].key?(:on_trace_end)
-    assert_equal 1, first_span[:data][:on_trace_end]
-
-    assert second_span[:ts].is_a?(Integer)
-    assert second_span[:ts].positive?
-    assert second_span[:d].is_a?(Integer)
-    assert second_span[:d].between?(0, 5)
-
-    assert_equal :sdk, second_span[:n]
-    assert second_span.key?(:data)
-    assert second_span[:data].key?(:sdk)
-    assert second_span[:data][:sdk].key?(:custom)
-    assert second_span[:data][:sdk][:custom].key?(:tags)
-    assert :custom_span, second_span[:data][:sdk][:name]
-    assert :unknown, second_span[:data][:sdk][:type]
-    assert [[1, 2, 3], "test_arg", :ok], second_span[:data][:sdk][:arguments]
-    assert true, second_span[:data][:sdk][:return]
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_entry_kv]
-    assert !second_span[:data][:sdk][:custom][:tags].key?(:on_info_kv)
-    assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_exit_kv]
-
-    # Check the error
-    assert_equal true, second_span[:error]
-    assert_equal 1, second_span[:ec]
-  end
-end

data/test/trace/id_management_test.rb

@@ -1,78 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-require 'test_helper'
-
-class TracerIDMgmtTest < Minitest::Test
-  def test_id_to_header_conversion
-    # Test passing a standard Integer ID
-    original_id = ::Instana::Util.generate_id
-    converted_id = Instana::Util.id_to_header(original_id)
-
-    # Assert that it is a string and there are no non-hex characters
-    assert converted_id.is_a?(String)
-    assert !converted_id[/\H/]
-
-    # Test passing a standard Integer ID as a String
-    original_id = ::Instana::Util.generate_id
-    converted_id = Instana::Util.id_to_header(original_id)
-
-    # Assert that it is a string and there are no non-hex characters
-    assert converted_id.is_a?(String)
-    assert !converted_id[/\H/]
-  end
-
-  def test_id_to_header_conversion_with_bogus_id
-    # Test passing an empty String
-    converted_id = Instana::Util.id_to_header('')
-
-    # Assert that it is a string and there are no non-hex characters
-    assert converted_id.is_a?(String)
-    assert converted_id == ''
-
-    # Test passing a nil
-    converted_id = Instana::Util.id_to_header(nil)
-
-    # Assert that it is a string and there are no non-hex characters
-    assert converted_id.is_a?(String)
-    assert converted_id == ''
-
-    # Test passing an Array
-    converted_id = Instana::Util.id_to_header([])
-
-    # Assert that it is a string and there are no non-hex characters
-    assert converted_id.is_a?(String)
-    assert converted_id == ''
-  end
-
-  def test_header_to_id_conversion
-    # Get a hex string to test against & convert
-    header_id = Instana::Util.id_to_header(::Instana::Util.generate_id)
-    converted_id = Instana::Util.header_to_id(header_id)
-
-    # Assert that it is an 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 '', bogus_result
-
-    # Bogus Integer arg
-    bogus_result = Instana::Util.header_to_id(1234)
-    assert_equal '', bogus_result
-
-    # Bogus Array arg
-    bogus_result = Instana::Util.header_to_id([1234])
-    assert_equal '', bogus_result
-
-    # Invalid characters/length
-    bogus_result = Instana::Util.header_to_id('qwerty')
-    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/trace/instrumented_logger_test.rb

@@ -1,39 +0,0 @@
-# (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.in_span(: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/trace/processor_test.rb

@@ -1,58 +0,0 @@
-# (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(trace_id: '9', span_id: '8', level: 0)
-    span = Instana::Span.new(:rack, span_context)
-    span2 = Instana::Span.new(:"net-http")
-
-    subject.on_finish(span)
-    subject.on_finish(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.on_finish(false)
-
-    assert_equal [], subject.queued_spans
-  end
-
-  def test_send
-    ENV['INSTANA_TEST'] = nil
-
-    subject = Instana::Processor.new
-    span = Instana::Span.new(:rack)
-    subject.on_finish(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/trace/span_context_test.rb

@@ -1,22 +0,0 @@
-# (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_id: 'trace', span_id: 'span')
-    assert_equal({trace_id: 'trace', span_id: 'span'}, subject.to_hash)
-  end
-
-  def test_invalid
-    subject = Instana::SpanContext.new(trace_id: nil, span_id: nil)
-    refute subject.valid?
-  end
-
-  def test_flags_level_zero
-    subject = Instana::SpanContext.new(trace_id: 'trace', span_id: 'span', level: 0, baggage: {external_state: 'cn=test'})
-    assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
-    assert_equal 'cn=test', subject.trace_state_header
-  end
-end