instana 1.217.1 → 2.1.0

data/test/instrumentation/redis_test.rb

@@ -1,152 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-
-class RedisTest < Minitest::Test
-  def setup
-    if ENV.key?('REDIS_URL')
-      @redis_url = ENV['REDIS_URL']
-    else
-      @redis_url = "redis://localhost:6379"
-    end
-    @redis_client = Redis.new(url: @redis_url)
-  end
-
-  def test_normal_call
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      @redis_client.set('hello', 'world')
-    end
-
-    assert_redis_trace('SET')
-  end
-
-  def test_normal_call_as_root_exit_span
-    clear_all!
-
-    ::Instana.config[:allow_exit_as_root] = true
-
-    @redis_client.set('hello', 'world')
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-    redis_span = spans[0]
-
-    # first_span is the parent of second_span
-    assert_equal :redis, redis_span[:n]
-
-    data = redis_span[:data]
-
-    uri = URI.parse(@redis_url)
-    assert_equal "#{uri.host}:#{uri.port}", data[:redis][:connection]
-
-    assert_equal "0", data[:redis][:db]
-    assert_equal "SET", data[:redis][:command]
-  end
-
-  def test_georadius
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      @redis_client.georadius('Sicily', '15', '37', '200', 'km', 'WITHCOORD', 'WITHDIST')
-    end
-
-    assert_redis_trace('GEORADIUS')
-  end
-
-  def test_normal_call_with_error
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      begin
-        @redis_client.zadd('hello', 'invalid', 'value')
-      rescue; end
-    end
-
-    assert_redis_trace('ZADD', with_error: 'ERR value is not a valid float')
-  end
-
-  def test_pipeline_call
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      @redis_client.pipelined do |pipeline|
-        pipeline.set('hello', 'world')
-        pipeline.set('other', 'world')
-      end
-    end
-
-    assert_redis_trace('PIPELINE')
-  end
-
-  def test_pipeline_call_with_error
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      begin
-        @redis_client.pipelined do |pipeline|
-          pipeline.set('other', 'world')
-          pipeline.call('invalid')
-        end
-      rescue; end
-    end
-
-    assert_redis_trace('PIPELINE', with_error: "ERR unknown command 'invalid'")
-  end
-
-  def test_multi_call
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      @redis_client.multi do |multi|
-        multi.set('hello', 'world')
-        multi.set('other', 'world')
-      end
-    end
-
-    assert_redis_trace('MULTI')
-  end
-
-  def test_multi_call_with_error
-    clear_all!
-
-    Instana.tracer.start_or_continue_trace(:redis_test) do
-      begin
-        @redis_client.multi do |multi|
-          multi.set('other', 'world')
-          multi.call('invalid')
-        end
-      rescue; end
-    end
-
-    assert_redis_trace('MULTI', with_error: "ERR unknown command 'invalid'")
-  end
-
-  private
-
-  def assert_redis_trace(command, with_error: nil)
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    first_span, second_span = spans.to_a.reverse
-
-    # first_span is the parent of second_span
-    assert_equal first_span[:s], second_span[:p]
-    assert_equal :sdk, first_span[:n]
-    assert_equal :redis, second_span[:n]
-
-    data = second_span[:data]
-
-    uri = URI.parse(@redis_url)
-    assert_equal "#{uri.host}:#{uri.port}", data[:redis][:connection]
-
-    assert_equal "0", data[:redis][:db]
-    assert_equal command, data[:redis][:command]
-
-    if with_error
-      assert_equal true, data[:redis][:error]
-      assert data[:log].key?(:message)
-    end
-  end
-end

data/test/instrumentation/resque_test.rb

@@ -1,188 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2018
-
-require 'test_helper'
-require 'support/apps/resque/boot'
-
-::Resque.redis = ENV['REDIS_URL']
-
-class ResqueClientTest < Minitest::Test
-  def setup
-    clear_all!
-    ENV['FORK_PER_JOB'] = 'false'
-    Resque.redis.redis.flushall
-    @worker = Resque::Worker.new(:critical)
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def test_enqueue
-    ::Instana.tracer.start_or_continue_trace(:'resque-client_test') do
-      ::Resque.enqueue(FastJob)
-    end
-
-    resque_job = Resque.reserve('critical')
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
-    resque_span = find_first_span_by_name(spans, :'resque-client')
-
-    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
-
-    assert_equal :"resque-client", resque_span[:n]
-    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
-    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
-    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
-
-    assert_equal resque_job.args.first['trace_id'], resque_span[:t]
-    assert_equal resque_job.args.first['span_id'], resque_span[:s]
-  end
-
-  def test_enqueue_as_root_exit_span
-    ::Instana.config[:allow_exit_as_root] = true
-    ::Resque.enqueue(FastJob)
-    ::Instana.config[:allow_exit_as_root] = false
-
-    resque_job = Resque.reserve('critical')
-    spans = ::Instana.processor.queued_spans
-    assert_equal 1, spans.length
-
-    resque_span = spans[0]
-
-    assert_equal :"resque-client", resque_span[:n]
-    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
-    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
-    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
-
-    assert_equal resque_job.args.first['trace_id'], resque_span[:t]
-    assert_equal resque_job.args.first['span_id'], resque_span[:s]
-  end
-
-  def test_enqueue_to
-    ::Instana.tracer.start_or_continue_trace(:'resque-client_test') do
-      ::Resque.enqueue_to(:critical, FastJob)
-    end
-
-    resque_job = Resque.reserve('critical')
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
-    resque_span = find_first_span_by_name(spans, :'resque-client')
-
-    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
-    assert_equal :"resque-client", resque_span[:n]
-    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
-    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
-    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
-
-    assert_equal resque_job.args.first['trace_id'], resque_span[:t]
-    assert_equal resque_job.args.first['span_id'], resque_span[:s]
-  end
-
-  def test_dequeue
-    ::Instana.tracer.start_or_continue_trace(:'resque-client_test', '', {}) do
-      ::Resque.dequeue(FastJob, { :generate => :farfalla })
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-
-    sdk_span = find_first_span_by_name(spans, :'resque-client_test')
-    resque_span = find_first_span_by_name(spans, :'resque-client')
-
-    assert_equal :'resque-client_test', sdk_span[:data][:sdk][:name]
-    assert_equal :"resque-client", resque_span[:n]
-    assert_equal "FastJob", resque_span[:data][:'resque-client'][:job]
-    assert_equal :critical, resque_span[:data][:'resque-client'][:queue]
-    assert_equal false, resque_span[:data][:'resque-client'].key?(:error)
-  end
-
-  def test_worker_job
-    ::Instana.tracer.start_or_continue_trace(:'resque-client_test') do
-      ::Resque.enqueue_to(:critical, FastJob)
-    end
-
-    resque_job = Resque.reserve('critical')
-    @worker.work_one_job(resque_job)
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 5, spans.length
-
-    client_span = spans[0]
-    resque_span = spans[4]
-    redis1_span = spans[3]
-    redis2_span = spans[2]
-
-    assert_equal :'resque-client', client_span[:n]
-
-    assert_equal :'resque-worker', resque_span[:n]
-    assert_equal client_span[:s], resque_span[:p]
-    assert_equal false, resque_span.key?(:error)
-    assert_equal false, resque_span.key?(:ec)
-    assert_equal "FastJob", resque_span[:data][:'resque-worker'][:job]
-    assert_equal "critical", resque_span[:data][:'resque-worker'][:queue]
-    assert_equal false, resque_span[:data][:'resque-worker'].key?(:error)
-
-    assert_equal :redis, redis1_span[:n]
-    assert_equal "SET", redis1_span[:data][:redis][:command]
-    assert_equal :redis, redis2_span[:n]
-    assert_equal "SET", redis2_span[:data][:redis][:command]
-  end
-
-  def test_worker_job_no_propagate
-    ::Instana.config[:'resque-client'][:propagate] = false
-    ::Instana.tracer.start_or_continue_trace(:'resque-client_test') do
-      ::Resque.enqueue_to(:critical, FastJob)
-    end
-
-    resque_job = Resque.reserve('critical')
-    @worker.work_one_job(resque_job)
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 5, spans.length
-
-    client_span = spans[0]
-    resque_span = spans[4]
-    redis1_span = spans[3]
-    redis2_span = spans[2]
-
-    assert_equal :'resque-client', client_span[:n]
-
-    assert_equal :'resque-worker', resque_span[:n]
-    refute_equal client_span[:s], resque_span[:p]
-    assert_equal false, resque_span.key?(:error)
-    assert_equal false, resque_span.key?(:ec)
-    assert_equal "FastJob", resque_span[:data][:'resque-worker'][:job]
-    assert_equal "critical", resque_span[:data][:'resque-worker'][:queue]
-    assert_equal false, resque_span[:data][:'resque-worker'].key?(:error)
-
-    assert_equal :redis, redis1_span[:n]
-    assert_equal "SET", redis1_span[:data][:redis][:command]
-    assert_equal :redis, redis2_span[:n]
-    assert_equal "SET", redis2_span[:data][:redis][:command]
-  ensure
-    ::Instana.config[:'resque-client'][:propagate] = true
-  end
-
-  def test_worker_error_job
-    Resque::Job.create(:critical, ErrorJob)
-    @worker.work(0)
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 5, spans.length
-
-    resque_span = find_first_span_by_name(spans, :'resque-worker')
-
-    assert_equal :'resque-worker', resque_span[:n]
-    assert_equal true, resque_span.key?(:error)
-    assert_equal 1, resque_span[:ec]
-    assert_equal "ErrorJob", resque_span[:data][:'resque-worker'][:job]
-    assert_equal "critical", resque_span[:data][:'resque-worker'][:queue]
-    assert_equal "Exception: Silly Rabbit, Trix are for kids.", resque_span[:data][:'resque-worker'][:error]
-    assert_equal Array, resque_span[:stack].class
-  end
-end

data/test/instrumentation/rest_client_test.rb

@@ -1,107 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
-
-require 'test_helper'
-require 'support/apps/http_endpoint/boot'
-
-class RestClientTest < Minitest::Test
-  def setup
-    # See https://github.com/rest-client/rest-client/issues/612
-    OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers] = OpenSSL::SSL::SSLContext.new.ciphers
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def test_config_defaults
-    assert ::Instana.config[:'rest-client'].is_a?(Hash)
-    assert ::Instana.config[:'rest-client'].key?(:enabled)
-    assert_equal true, ::Instana.config[:'rest-client'][:enabled]
-  end
-
-  def test_basic_get
-    clear_all!
-    WebMock.allow_net_connect!
-
-    url = "http://127.0.0.1:6511/"
-
-    Instana.tracer.start_or_continue_trace('restclient-test') do
-      RestClient.get url
-    end
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 4, spans.length
-
-    rack_span = find_first_span_by_name(spans, :rack)
-    sdk_span = find_first_span_by_name(spans, :'restclient-test')
-    rest_span = find_first_span_by_name(spans, :'rest-client')
-    net_span = find_first_span_by_name(spans, :'net-http')
-
-    validate_sdk_span(sdk_span, {:name => :'restclient-test', :type => :entry})
-    validate_sdk_span(rest_span, {:name => :'rest-client', :type => :intermediate})
-
-    # Span name validation
-    assert_equal :rack, rack_span[:n]
-    assert_equal :sdk, sdk_span[:n]
-    assert_equal :sdk, rest_span[:n]
-    assert_equal :"net-http", net_span[:n]
-
-    # Trace IDs and relationships
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, rest_span[:t]
-    assert_equal trace_id, net_span[:t]
-    assert_equal trace_id, rack_span[:t]
-
-    assert_equal sdk_span[:s], rest_span[:p]
-    assert_equal rest_span[:s], net_span[:p]
-    assert_equal net_span[:s], rack_span[:p]
-
-    # data keys/values
-    refute_nil net_span.key?(:data)
-    refute_nil net_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", net_span[:data][:http][:url]
-    assert_equal "200", net_span[:data][:http][:status]
-
-    WebMock.disable_net_connect!
-  end
-
-  def test_basic_get_as_root_exit_span
-    clear_all!
-    ::Instana.config[:allow_exit_as_root] = true
-    WebMock.allow_net_connect!
-
-    url = "http://127.0.0.1:6511/"
-
-    RestClient.get url
-
-    spans = ::Instana.processor.queued_spans
-    assert_equal 3, spans.length
-
-    rack_span = find_first_span_by_name(spans, :rack)
-    rest_span = find_first_span_by_name(spans, :'rest-client')
-    net_span = find_first_span_by_name(spans, :'net-http')
-
-    # Span name validation
-    assert_equal :rack, rack_span[:n]
-    assert_equal :sdk, rest_span[:n]
-    assert_equal :"net-http", net_span[:n]
-
-    # Trace IDs and relationships
-    trace_id = net_span[:t]
-    assert_equal trace_id, rest_span[:t]
-    assert_equal trace_id, rack_span[:t]
-
-    assert_nil rest_span[:p]
-    assert_equal rest_span[:s], net_span[:p]
-    assert_equal net_span[:s], rack_span[:p]
-
-    # data keys/values
-    refute_nil net_span.key?(:data)
-    refute_nil net_span[:data].key?(:http)
-    assert_equal "http://127.0.0.1:6511/", net_span[:data][:http][:url]
-    assert_equal "200", net_span[:data][:http][:status]
-
-    WebMock.disable_net_connect!
-  end
-end

data/test/instrumentation/sequel_test.rb

@@ -1,105 +0,0 @@
-# (c) Copyright IBM Corp. 2024
-
-require 'test_helper'
-require 'sequel'
-
-class SequelTest < Minitest::Test
-  def setup
-    skip unless ENV['DATABASE_URL']
-    db_url = ENV['DATABASE_URL'].sub("sqlite3", "sqlite")
-    @db = Sequel.connect(db_url)
-    @db.create_table!(:blocks) do
-      String :name
-      String :color
-    end
-    @model = @db[:blocks]
-  end
-
-  def teardown
-    @db.drop_table(:blocks)
-    @db.disconnect
-  end
-
-  def test_config_defaults
-    assert ::Instana.config[:sanitize_sql] == true
-    assert ::Instana.config[:sequel].is_a?(Hash)
-    assert ::Instana.config[:sequel].key?(:enabled)
-    assert_equal true, ::Instana.config[:sequel][:enabled]
-  end
-
-  def test_create
-    Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-      @model.insert(name: 'core', color: 'blue')
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    data = span[:data][:sequel]
-    assert data[:sql].start_with?('INSERT INTO')
-  end
-
-  def test_read
-    @model.insert(name: 'core', color: 'blue')
-    Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-      @model.where(name: 'core').first
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    data = span[:data][:sequel]
-    assert data[:sql].start_with?('SELECT')
-    assert_nil span[:ec]
-  end
-
-  def test_update
-    @model.insert(name: 'core', color: 'blue')
-    Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-      @model.where(name: 'core').update(color: 'red')
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    data = span[:data][:sequel]
-    assert data[:sql].start_with?('UPDATE')
-    assert_nil span[:ec]
-    assert_equal 'red', @model.where(name: 'core').first[:color]
-  end
-
-  def test_delete
-    @model.insert(name: 'core', color: 'blue')
-    Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-      @model.where(name: 'core').delete
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    data = span[:data][:sequel]
-    assert data[:sql].start_with?('DELETE')
-    assert_nil span[:ec]
-    assert_nil @model.where(name: 'core').first
-  end
-
-  def test_raw
-    Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-      @db.run('SELECT 1')
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    data = span[:data][:sequel]
-    assert 'SELECT 1', data[:sql]
-    assert_nil span[:ec]
-  end
-
-  def test_raw_error
-    assert_raises Sequel::DatabaseError do
-      Instana::Tracer.start_or_continue_trace(:sequel_test, {}) do
-        @db.run('INVALID')
-      end
-    end
-    spans = ::Instana.processor.queued_spans
-    assert_equal 2, spans.length
-    span = find_first_span_by_name(spans, :sequel)
-    assert_equal 1, span[:ec]
-  end
-end

data/test/instrumentation/shoryuken_test.rb

@@ -1,47 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-require 'ostruct'
-
-class ShoryukenTest < Minitest::Test
-  def setup
-    clear_all!
-    @middleware = Instana::Instrumentation::Shoryuken.new
-  end
-
-  def test_start_trace_with_context
-    id = Instana::Util.generate_id
-    message = OpenStruct.new(
-      queue_url: 'http://example.com',
-      message_attributes: {
-        "X_INSTANA_T" => OpenStruct.new(string_value: id),
-        "X_INSTANA_S" => OpenStruct.new(string_value: id),
-        "X_INSTANA_L" => OpenStruct.new(string_value: '1')
-      }
-    )
-
-    @middleware.call(nil, nil, message, nil) {}
-
-    span = ::Instana.processor.queued_spans.first
-
-    assert_equal id, span[:t]
-    assert_equal id, span[:p]
-    assert_equal 'entry', span[:data][:sqs][:sort]
-    assert_equal 'http://example.com', span[:data][:sqs][:queue]
-  end
-
-  def test_start_trace
-    message = OpenStruct.new(
-      queue_url: 'http://example.com'
-    )
-
-    @middleware.call(nil, nil, message, nil) {}
-
-    span = ::Instana.processor.queued_spans.first
-
-    assert_nil span[:p]
-    assert_equal 'entry', span[:data][:sqs][:sort]
-    assert_equal 'http://example.com', span[:data][:sqs][:queue]
-  end
-end