instana 1.10.1-java

data/test/instrumentation/sidekiq-client_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class SidekiqClientTest < Minitest::Test
+  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_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']
+    assert_equal false, job_message['X-Instana-T'].nil?
+    assert_equal false, job_message['X-Instana-S'].nil?
+  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 => :intermediate})
+
+    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_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 => :intermediate})
+
+    assert_equal :'sidekiq-client', second_span[:n]
+    assert_equal true, second_span[:error]
+    assert_equal false, second_span[:stack].nil?
+
+    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_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

@@ -0,0 +1,173 @@
+require 'test_helper'
+
+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_equal false, worker_span[:data][:'sidekiq-worker'][:job_id].nil?
+  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_equal false, worker_span[:data][:'sidekiq-worker'][:job_id].nil?
+
+    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_equal job.name, client_span[:data][:'sidekiq-client'][:job]
+  end
+end

data/test/jobs/resque_error_job.rb

@@ -0,0 +1,22 @@
+require "redis"
+require "net/http"
+
+class ErrorJob
+  @queue = :critical
+
+  def self.perform
+    if ENV.key?('REDIS_URL')
+      redis = Redis.new(:url => ENV['REDIS_URL'])
+    elsif ENV.key?('I_REDIS_URL')
+      redis = Redis.new(:url => ENV['I_REDIS_URL'])
+    else
+      redis = Redis.new(:url => 'localhost:6379')
+    end
+
+    dt = Time.now
+    redis.set('ts', dt)
+
+    raise Exception.new("Silly Rabbit, Trix are for kids.")
+    redis.set(:nb_id, 2)
+  end
+end

data/test/jobs/resque_fast_job.rb

@@ -0,0 +1,20 @@
+require "redis"
+require "net/http"
+
+class FastJob
+  @queue = :critical
+
+  def self.perform
+    if ENV.key?('REDIS_URL')
+      redis = Redis.new(:url => ENV['REDIS_URL'])
+    elsif ENV.key?('I_REDIS_URL')
+      redis = Redis.new(:url => ENV['I_REDIS_URL'])
+    else
+      redis = Redis.new(:url => 'redis://localhost:6379')
+    end
+
+    dt = Time.now
+    redis.set('ts', dt)
+    redis.set(:nb_id, 2)
+  end
+end

data/test/jobs/sidekiq_job_1.rb

@@ -0,0 +1,6 @@
+class SidekiqJobOne
+  include Sidekiq::Worker
+
+  def perform(a, b, c)
+  end
+end

data/test/jobs/sidekiq_job_2.rb

@@ -0,0 +1,7 @@
+class SidekiqJobTwo
+  include Sidekiq::Worker
+
+  def perform(a, b, c)
+    raise 'Fail to execute the job'
+  end
+end

data/test/models/block.rb

@@ -0,0 +1,18 @@
+class Block < ActiveRecord::Base
+  def do_work(*args)
+    block = Block.first
+    block.name = "Charlie"
+    block.color = "Black"
+    block.save
+  end
+end
+
+class CreateBlocks < ActiveRecord::Migration
+  def change
+    create_table :blocks do |t|
+      t.string :name
+      t.string :color
+      t.timestamps
+    end
+  end
+end

data/test/servers/grpc_50051.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../apps/grpc_server.rb')
+
+::Instana.logger.info "Booting instrumented gRPC server on port 50051 for tests."
+
+grpc_thread = Thread.new do
+  s = GRPC::RpcServer.new
+  Thread.current[:server] = s
+
+  s.add_http2_port('127.0.0.1:50051', :this_port_is_insecure)
+  s.handle(PingPongServer)
+  s.run_till_terminated
+end
+
+Minitest.after_run do
+  ::Instana.logger.info "Killing gRPC server"
+  grpc_thread[:server].stop
+  sleep 2
+end
+
+sleep 2

data/test/servers/helpers/sidekiq_worker_initializer.rb

@@ -0,0 +1,27 @@
+# This is a helper initializer to boot a local instrumented Sidekiq stack
+# for development and testing.
+#
+# export BUNDLE_GEMFILE=/path/to/ruby-sensor/gemfiles/libraries.gemfile
+# bundle install
+# bundle exec sidekiq -c 2 -q important -r ./test/servers/helpers/sidekiq_worker_initializer.rb
+#
+# In another shell, you can boot a console to queue jobs:
+#
+# export BUNDLE_GEMFILE=/path/to/ruby-sensor/gemfiles/libraries.gemfile
+# bundle install
+# bundle exec rake console
+# > require Dir.pwd + '/test/jobs/sidekiq_job_1.rb'
+# > Instana.tracer.start_or_continue_trace(:sidekiq_demo) do
+# >  ::Sidekiq::Client.push( 'queue' => 'important', 'class' => ::SidekiqJobOne,
+# >                          'args' => [1, 2, 3], 'retry' => false)
+# > end
+#
+
+# Load test jobs.
+require Dir.pwd + '/test/jobs/sidekiq_job_1.rb'
+require Dir.pwd + '/test/jobs/sidekiq_job_2.rb'
+
+require "sidekiq"
+require "instana"
+::Instana.logger.info "Booting instrumented sidekiq worker for tests."
+::Sidekiq.logger.level = ::Logger::DEBUG

data/test/servers/rackapp_6511.rb

@@ -0,0 +1,25 @@
+require 'rack/handler/puma'
+require 'rack/builder'
+require 'instana/rack'
+
+::Instana.logger.info "Booting instrumented background Rackapp on port 6511 for tests."
+
+Thread.new do
+  app = Rack::Builder.new {
+    use ::Instana::Rack
+    map "/" do
+      run Proc.new { |env|
+        [200, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"scene!\"]"]]
+      }
+    end
+    map "/error" do
+      run Proc.new { |env|
+        [500, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"error!\"]"]]
+      }
+    end
+  }
+
+  Rack::Handler::Puma.run(app, {:Host => '127.0.0.1', :Port => 6511})
+end
+
+sleep(2)