instana 1.217.1 → 2.1.0

data/test/instrumentation/sidekiq-client_test.rb

@@ -1,169 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-require 'support/apps/sidekiq/boot'
-
-class SidekiqClientTest < Minitest::Test
-  def setup
-    ::Sidekiq::Queue.new('some_random_queue').clear
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def test_config_defaults
-    assert ::Instana.config[:'sidekiq-client'].is_a?(Hash)
-    assert ::Instana.config[:'sidekiq-client'].key?(:enabled)
-    assert_equal true, ::Instana.config[:'sidekiq-client'][:enabled]
-  end
-
-  def test_enqueue
-    clear_all!
-    Instana.tracer.start_or_continue_trace(:sidekiqtests) do
-      disable_redis_instrumentation
-      ::Sidekiq::Client.push(
-        'queue' => 'some_random_queue',
-        'class' => ::SidekiqJobOne,
-        'args' => [1, 2, 3],
-        'retry' => false
-      )
-      enable_redis_instrumentation
-    end
-
-    queue = ::Sidekiq::Queue.new('some_random_queue')
-    job = queue.first
-
-    assert_job_enqueued(job)
-    assert_normal_trace_recorded(job)
-  end
-
-  def test_enqueue_as_root_exit_span
-    clear_all!
-    ::Instana.config[:allow_exit_as_root] = true
-    disable_redis_instrumentation
-    ::Sidekiq::Client.push(
-      'queue' => 'some_random_queue',
-      'class' => ::SidekiqJobOne,
-      'args' => [1, 2, 3],
-      'retry' => false
-    )
-    ::Instana.config[:allow_exit_as_root] = false
-    enable_redis_instrumentation
-
-    queue = ::Sidekiq::Queue.new('some_random_queue')
-    job = queue.first
-
-    assert_job_enqueued(job)
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-
-    first_span = spans[0]
-
-    assert_equal :'sidekiq-client', first_span[:n]
-    assert_equal 'some_random_queue', first_span[:data][:'sidekiq-client'][:queue]
-    assert_equal 'SidekiqJobOne', first_span[:data][:'sidekiq-client'][:job]
-    assert_equal "false", first_span[:data][:'sidekiq-client'][:retry]
-    assert first_span[:data][:'sidekiq-client'][:'redis-url']
-    assert_equal job['jid'], first_span[:data][:'sidekiq-client'][:job_id]
-  end
-
-  def test_enqueue_failure
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:sidekiqtests) do
-      disable_redis_instrumentation
-      add_sidekiq_exception_middleware
-      begin
-        ::Sidekiq::Client.push(
-          'queue' => 'some_random_queue',
-          'class' => ::SidekiqJobTwo,
-          'args' => [1, 2, 3],
-          'retry' => false
-        )
-      rescue; end
-      enable_redis_instrumentation
-      remove_sidekiq_exception_middleware
-    end
-
-    queue = ::Sidekiq::Queue.new('some_random_queue')
-    assert_equal 0, queue.size
-
-    assert_failure_trace_recorded
-  end
-
-  private
-
-  def assert_job_enqueued(job)
-    job_message = JSON.parse(job.value)
-
-    assert_equal 'some_random_queue', job_message['queue']
-    assert_equal 'SidekiqJobOne', job_message['class']
-    assert_equal [1, 2, 3], job_message['args']
-    assert_equal false, job_message['retry']
-    refute_nil   job_message['X-Instana-T']
-    refute_nil   job_message['X-Instana-S']
-  end
-
-  def assert_normal_trace_recorded(job)
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    assert_equal first_span[:s], second_span[:p]
-    validate_sdk_span(first_span, {:name => :sidekiqtests, :type => :entry})
-
-    assert_equal :'sidekiq-client', second_span[:n]
-    assert_equal 'some_random_queue', second_span[:data][:'sidekiq-client'][:queue]
-    assert_equal 'SidekiqJobOne', second_span[:data][:'sidekiq-client'][:job]
-    assert_equal "false", second_span[:data][:'sidekiq-client'][:retry]
-    assert       second_span[:data][:'sidekiq-client'][:'redis-url']
-    assert_equal job['jid'], second_span[:data][:'sidekiq-client'][:job_id]
-  end
-
-  def assert_failure_trace_recorded
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    first_span = spans[1]
-    second_span = spans[0]
-
-    assert_equal first_span[:s], second_span[:p]
-    validate_sdk_span(first_span, {:name => :sidekiqtests, :type => :entry})
-
-    assert_equal :'sidekiq-client', second_span[:n]
-    assert_equal true, second_span[:error]
-    refute_nil   second_span[:stack]
-
-    assert_equal 'some_random_queue', second_span[:data][:'sidekiq-client'][:queue]
-    assert_equal 'SidekiqJobTwo', second_span[:data][:'sidekiq-client'][:job]
-    assert_equal "false", second_span[:data][:'sidekiq-client'][:retry]
-    assert       second_span[:data][:'sidekiq-client'][:'redis-url']
-    assert_equal 'Fail to enqueue job', second_span[:data][:log][:message]
-  end
-
-  SidekiqMiddlewareException = Class.new do
-    def call(*_args)
-      raise 'Fail to enqueue job'
-    end
-  end
-
-  def add_sidekiq_exception_middleware
-    Sidekiq.configure_client do |config|
-      config.client_middleware do |chain|
-        chain.add SidekiqMiddlewareException
-      end
-    end
-  end
-
-  def remove_sidekiq_exception_middleware
-    Sidekiq.configure_client do |config|
-      config.client_middleware do |chain|
-        chain.remove SidekiqMiddlewareException
-      end
-    end
-  end
-end

data/test/instrumentation/sidekiq-worker_test.rb

@@ -1,180 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-require 'support/apps/sidekiq/boot'
-
-class SidekiqServerTest < Minitest::Test
-  def test_config_defaults
-    assert ::Instana.config[:'sidekiq-worker'].is_a?(Hash)
-    assert ::Instana.config[:'sidekiq-worker'].key?(:enabled)
-    assert_equal true, ::Instana.config[:'sidekiq-worker'][:enabled]
-  end
-
-  def test_successful_worker_starts_new_trace
-    clear_all!
-    $sidekiq_mode = :server
-    inject_instrumentation
-
-    disable_redis_instrumentation
-    ::Sidekiq.redis_pool.with do |redis|
-      redis.sadd('queues'.freeze, 'important')
-      redis.lpush(
-        'queue:important',
-        <<-JSON
-        {
-          "class":"SidekiqJobOne",
-          "args":[1,2,3],
-          "queue":"important",
-          "jid":"123456789"
-        }
-        JSON
-      )
-    end
-    enable_redis_instrumentation
-    sleep 1
-
-    spans = Instana.processor.queued_spans
-    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
-    assert_successful_worker_span(worker_span)
-
-    $sidekiq_mode = :client
-  end
-
-  def test_failed_worker_starts_new_trace
-    clear_all!
-    $sidekiq_mode = :server
-    inject_instrumentation
-
-    disable_redis_instrumentation
-    ::Sidekiq.redis_pool.with do |redis|
-      redis.sadd('queues'.freeze, 'important')
-      redis.lpush(
-        'queue:important',
-        <<-JSON
-        {
-          "class":"SidekiqJobTwo",
-          "args":[1,2,3],
-          "queue":"important",
-          "jid":"123456789"
-        }
-        JSON
-      )
-    end
-    enable_redis_instrumentation
-
-    sleep 1
-
-    spans = Instana.processor.queued_spans
-    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
-    assert_failed_worker_span(worker_span)
-
-    $sidekiq_mode = :client
-  end
-
-  def test_successful_worker_continues_previous_trace
-    clear_all!
-    $sidekiq_mode = :server
-    inject_instrumentation
-
-    Instana.tracer.start_or_continue_trace(:sidekiqtests) do
-      disable_redis_instrumentation
-      ::Sidekiq::Client.push(
-        'queue' => 'important',
-        'class' => ::SidekiqJobOne,
-        'args' => [1, 2, 3]
-      )
-      enable_redis_instrumentation
-    end
-    sleep 1
-    spans = Instana.processor.queued_spans
-
-    sdk_span = find_spans_by_name(spans, :sidekiqtests).first
-    validate_sdk_span(sdk_span)
-
-    client_span = find_spans_by_name(spans, :'sidekiq-client').first
-    assert_client_span(client_span, ::SidekiqJobOne)
-
-    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
-    assert_successful_worker_span(worker_span)
-
-    # Worker trace and client trace are in the same trace
-    assert_equal worker_span[:t], client_span[:t]
-    assert_equal worker_span[:p], client_span[:s]
-
-    $sidekiq_mode = :client
-  end
-
-  def test_failed_worker_continues_previous_trace
-    clear_all!
-    $sidekiq_mode = :server
-    inject_instrumentation
-
-    Instana.tracer.start_or_continue_trace(:sidekiqtests) do
-      disable_redis_instrumentation
-      ::Sidekiq::Client.push(
-        'queue' => 'important',
-        'class' => ::SidekiqJobTwo,
-        'args' => [1, 2, 3]
-      )
-      enable_redis_instrumentation
-    end
-    sleep 1
-
-    spans = Instana.processor.queued_spans
-
-    sdk_span = find_spans_by_name(spans, :sidekiqtests).first
-    validate_sdk_span(sdk_span)
-
-    client_span = find_spans_by_name(spans, :'sidekiq-client').first
-    assert_client_span(client_span, ::SidekiqJobTwo)
-
-    worker_span = find_spans_by_name(spans, :'sidekiq-worker').first
-    assert_failed_worker_span(worker_span)
-
-    # Worker trace and client trace are in the same trace
-    assert_equal worker_span[:t], client_span[:t]
-    assert_equal worker_span[:p], client_span[:s]
-
-    $sidekiq_mode = :client
-  end
-
-  private
-
-  def inject_instrumentation
-    # Add the instrumentation again to ensure injection in server mode
-    ::Sidekiq.configure_server do |cfg|
-      cfg.server_middleware do |chain|
-        chain.add ::Instana::Instrumentation::SidekiqWorker
-      end
-    end
-  end
-
-  def assert_successful_worker_span(worker_span)
-    assert_equal :'sidekiq-worker', worker_span[:n]
-
-    assert_equal 'important', worker_span[:data][:'sidekiq-worker'][:queue]
-    assert_equal 'SidekiqJobOne', worker_span[:data][:'sidekiq-worker'][:job]
-    assert       worker_span[:data][:'sidekiq-worker'][:'redis-url']
-    refute_nil   worker_span[:data][:'sidekiq-worker'][:job_id]
-  end
-
-  def assert_failed_worker_span(worker_span)
-    assert_equal :'sidekiq-worker', worker_span[:n]
-
-    assert_equal 'important', worker_span[:data][:'sidekiq-worker'][:queue]
-    assert_equal 'SidekiqJobTwo', worker_span[:data][:'sidekiq-worker'][:job]
-    assert       worker_span[:data][:'sidekiq-worker'][:'redis-url']
-    refute_nil   worker_span[:data][:'sidekiq-worker'][:job_id]
-
-    assert_equal true, worker_span[:data][:'sidekiq-worker'][:error]
-    assert_equal 'Fail to execute the job', worker_span[:data][:log][:message]
-  end
-
-  def assert_client_span(client_span, job)
-    assert_equal :'sidekiq-client', client_span[:n]
-    assert_equal 'important', client_span[:data][:'sidekiq-client'][:queue]
-    assert       client_span[:data][:'sidekiq-client'][:'redis-url']
-    assert_equal job.name, client_span[:data][:'sidekiq-client'][:job]
-  end
-end

data/test/secrets_test.rb

@@ -1,112 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class SecretsTest < Minitest::Test
-  def setup
-    @subject = Instana::Secrets.new(logger: Logger.new('/dev/null'))
-  end
-
-  def test_equals_ignore_case
-    sample_config = {
-      "matcher"=>"equals-ignore-case",
-      "list"=>["key"]
-    }
-
-    url = url_for(%w(key Str kEy KEY))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy KEY)
-  end
-
-  def test_equals
-    sample_config = {
-      "matcher"=>"equals",
-      "list"=>["key", "kEy"]
-    }
-
-    url = url_for(%w(key Str kEy KEY))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(key kEy)
-  end
-
-  def test_contains_ignore_case
-    sample_config = {
-      "matcher"=>"contains-ignore-case",
-      "list"=>["stan"]
-    }
-
-    url = url_for(%w(instantiate conTESTant sample))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate conTESTant)
-  end
-
-  def test_contains
-    sample_config = {
-      "matcher"=>"contains",
-      "list"=>["stan"]
-    }
-
-    url = url_for(%w(instantiate conTESTant sample))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
-  end
-
-  def test_regexp
-    sample_config = {
-      "matcher"=>"regex",
-      "list"=>["l{2}"]
-    }
-
-    url = url_for(%w(ball foot move))
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(ball)
-  end
-
-  def test_invalid
-    sample_config = {
-      "matcher"=>"test_invalid",
-      "list"=>["key"]
-    }
-
-    url = url_for(%w(key Str kEy KEY))
-    assert_redacted @subject.remove_from_query(url, sample_config), []
-  end
-
-  def test_without_scheme
-    sample_config = {
-      "matcher"=>"contains",
-      "list"=>["stan"]
-    }
-
-    url = 'example.com?instantiate=true'
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(instantiate)
-  end
-
-  def test_without_url
-    sample_config = {
-      "matcher"=>"contains",
-      "list"=>["stan"]
-    }
-
-    url = 'filter[instantiate]=true'
-    assert_redacted @subject.remove_from_query(url, sample_config), %w(filter[instantiate]), raw_str: true
-  end
-
-  def test_with_nil
-    sample_config = {
-      "matcher"=>"contains",
-      "list"=>["stan"]
-    }
-
-    assert_nil @subject.remove_from_query(nil, sample_config)
-  end
-
-  private
-
-  def url_for(keys)
-    url = URI('http://example.com')
-    url.query = URI.encode_www_form(keys.map { |k| [k, rand(1..100)]})
-    url.to_s
-  end
-
-  def assert_redacted(str, keys, raw_str: false)
-    params = raw_str ? CGI.parse(str) : CGI.parse(URI(str).query)
-    assert_equal keys, params.select { |_, v| v == %w(<redacted>) }.keys, 'to be redacted'
-  end
-end