instana 1.8.3 → 1.9.0.daftrabbit

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfcd505f3b03f60468ec22cc0b83f7db3d8247ab6d43d64fc2102b1998eb125c
-  data.tar.gz: c89980fb311fa8106cdf5cfe63f12c517ebd91f0971d26bec2f7f53d03b2629e
+  metadata.gz: 8b11875e63a40db84acb015973cfcf38b0f7b5d86a3c92a6ca4178582d525a0a
+  data.tar.gz: 78e31a128e0bed068b84a195e06f205a917b6ded8ac018e5493320dcbb202fa3
 SHA512:
-  metadata.gz: 6e1107b870b00d6b5c488a9def75a77daab3b9250b879ff9a6b5c0265a239e5397f564dd879b404b2fb3c4c46b414ccea49e67a9e7677efb4e9efe791168651b
-  data.tar.gz: 92f5f8acbd672ac8c5b0984a85cbb69944aaaab372007f105819cdfb29ec5ca40415d6ff14fa4751fc3a1bd62cf27a1fe000a93c353383b7a2d7331d40c6752d
+  metadata.gz: 645484fc592fc9578e4d7378b198ea867d61dabe25b51365a3545485e7f0a8b8454e4766104b0009178d2e009da64624f9fc8959fd73b6509162188a4ee55839
+  data.tar.gz: c6d2c36eeea6be0b0b09107a10cc9af56a9d12ec4960efe28dc151ff7570fec3ea8638ba6dc4e40a4699d7caf5dc9d79aab2e039e2982809c9286b92aba6bbb3

data/gemfiles/libraries.gemfile

@@ -49,6 +49,7 @@ gem 'excon'
 
 # Memcache
 gem 'dalli'
+gem 'redis', '< 4.0.0'
 
 # Background Job queuing and processing
 if RUBY_VERSION < '2.2'
@@ -57,6 +58,8 @@ else
   gem 'sidekiq', '> 5.0'
 end
 
+gem 'resque'
+
 # Rack v2 dropped support for Ruby 2.2 and higher.
 if RUBY_VERSION < '2.2'
   gem 'rack', '< 2.0'

data/lib/instana/agent.rb

@@ -5,12 +5,21 @@ require 'sys/proctable'
 require 'timers'
 require 'uri'
 require 'thread'
+
+require 'instana/agent/helpers'
+require 'instana/agent/hooks'
+require 'instana/agent/tasks'
+
 include Sys
 
 Oj.default_options = {:mode => :strict}
 
 module Instana
   class Agent
+    include AgentHelpers
+    include AgentHooks
+    include AgentTasks
+
     attr_accessor :state
     attr_accessor :agent_uuid
     attr_accessor :process
@@ -70,21 +79,6 @@ module Instana
       @extra_headers = nil
     end
 
-    # Used post fork to re-initialize state and restart communications with
-    # the host agent.
-    #
-    def after_fork
-      ::Instana.logger.debug "after_fork hook called. Falling back to unannounced state and spawning a new background agent thread."
-
-      # Reseed the random number generator for this
-      # new thread.
-      srand
-
-      transition_to(:unannounced)
-      setup
-      spawn_background_thread
-    end
-
     # Spawns the background thread and calls start.  This method is separated
     # out for those who wish to control which thread the background agent will
     # run in.
@@ -120,7 +114,7 @@ module Instana
       # In case of failure, we try again in 30 seconds.
       @announce_timer = @timers.every(30) do
         if @state == :unannounced
-          if host_agent_ready? && announce_sensor
+          if host_agent_available? && announce_sensor
             transition_to(:announced)
             ::Instana.logger.info "Host agent available. We're in business. (#{@state} pid:#{Process.pid} #{@process[:name]})"
           end
@@ -156,7 +150,7 @@ module Instana
     # called from an already initialized background thread.
     #
     def start
-      if !host_agent_ready?
+      if !host_agent_available?
         if !ENV.key?("INSTANA_QUIET")
           ::Instana.logger.warn "Host agent not available.  Will retry periodically. (Set env INSTANA_QUIET=1 to shut these messages off)"
         end
@@ -279,50 +273,6 @@ module Instana
       Instana.logger.debug e.backtrace.join("\r\n")
     end
 
-    # When request(s) are received by the host agent, it is sent here
-    # for handling & processing.
-    #
-    # @param json_string [String] the requests from the host agent
-    #
-    def handle_agent_tasks(json_string)
-      tasks = Oj.load(json_string)
-
-      if tasks.is_a?(Hash)
-        process_agent_task(tasks)
-      elsif tasks.is_a?(Array)
-        tasks.each do |t|
-          process_agent_task(t)
-        end
-      end
-    end
-
-    # Process a task sent from the host agent.
-    #
-    # @param task [String] the request json from the host agent
-    #
-    def process_agent_task(task)
-      if task.key?("action")
-        if task["action"] == "ruby.source"
-          payload = ::Instana::Util.get_rb_source(task["args"]["file"])
-        else
-          payload = { :error => "Unrecognized action: #{task["action"]}. An newer Instana gem may be required for this. Current version: #{::Instana::VERSION}" }
-        end
-      else
-        payload = { :error => "Instana Ruby: No action specified in request." }
-      end
-
-      path = "com.instana.plugin.ruby/response.#{@process[:report_pid]}?messageId=#{URI.encode(task['messageId'])}"
-      uri = URI.parse("http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{path}")
-      req = Net::HTTP::Post.new(uri)
-      req.body = Oj.dump(payload)
-      ::Instana.logger.debug "Responding to agent request: #{req.inspect}"
-      make_host_agent_request(req)
-
-    rescue StandardError => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n")
-    end
-
     # Accept and report spans to the host agent.
     #
     # @param traces [Array] An array of [Span]
@@ -340,7 +290,7 @@ module Instana
       uri = URI.parse("http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{path}")
       req = Net::HTTP::Post.new(uri)
 
-      req.body = Oj.dump(spans)
+      req.body = Oj.dump(spans, :omit_nil => true)
       response = make_host_agent_request(req)
 
       if response
@@ -360,7 +310,7 @@ module Instana
     # first check localhost and if not, then attempt on the default gateway
     # for docker in bridged mode.
     #
-    def host_agent_ready?
+    def host_agent_available?
       @discovered ||= run_discovery
 
       if @discovered
@@ -428,31 +378,6 @@ module Instana
       nil
     end
 
-    # Returns the PID that we are reporting to
-    #
-    def report_pid
-      @process[:report_pid]
-    end
-
-    # Indicates if the agent is ready to send metrics
-    # and/or data.
-    #
-    def ready?
-      # In test, we're always ready :-)
-      return true if ENV['INSTANA_GEM_TEST']
-
-      if forked?
-        ::Instana.logger.debug "Instana: detected fork.  Calling after_fork"
-        after_fork
-      end
-
-      @state == :announced
-    rescue => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n") unless ::Instana.test?
-      return false
-    end
-
     private
 
     # Handles any/all steps required in the transtion
@@ -511,37 +436,5 @@ module Instana
       Instana.logger.debug e.backtrace.join("\r\n") unless ::Instana.test?
       return nil
     end
-
-    # Indicates whether we are running in a pid namespace (such as
-    # Docker).
-    #
-    def pid_namespace?
-      return false unless @is_linux
-      Process.pid != get_real_pid
-    end
-
-    # Attempts to determine the true process ID by querying the
-    # /proc/<pid>/sched file.  This works on linux currently.
-    #
-    def get_real_pid
-      raise RuntimeError.new("Unsupported platform: get_real_pid") unless @is_linux
-
-      sched_file = "/proc/#{Process.pid}/sched"
-      pid = Process.pid
-
-      if File.exist?(sched_file)
-        v = File.open(sched_file, &:readline)
-        pid = v.match(/\d+/).to_s.to_i
-      end
-      pid
-    end
-
-    # Determine whether the pid has changed since Agent start.
-    #
-    # @ return [Boolean] true or false to indicate if forked
-    #
-    def forked?
-      @process[:pid] != Process.pid
-    end
   end
 end

data/lib/instana/agent/helpers.rb

@@ -0,0 +1,58 @@
+module AgentHelpers
+  # Indicates whether we are running in a pid namespace (such as
+  # Docker).
+  #
+  def pid_namespace?
+    return false unless @is_linux
+    Process.pid != get_real_pid
+  end
+
+  # Attempts to determine the true process ID by querying the
+  # /proc/<pid>/sched file.  This works on linux currently.
+  #
+  def get_real_pid
+    raise RuntimeError.new("Unsupported platform: get_real_pid") unless @is_linux
+
+    sched_file = "/proc/#{Process.pid}/sched"
+    pid = Process.pid
+
+    if File.exist?(sched_file)
+      v = File.open(sched_file, &:readline)
+      pid = v.match(/\d+/).to_s.to_i
+    end
+    pid
+  end
+
+  # Returns the PID that we are reporting to
+  #
+  def report_pid
+    @process[:report_pid]
+  end
+
+  # Determine whether the pid has changed since Agent start.
+  #
+  # @ return [Boolean] true or false to indicate if forked
+  #
+  def forked?
+    @process[:pid] != Process.pid
+  end
+
+  # Indicates if the agent is ready to send metrics
+  # and/or data.
+  #
+  def ready?
+    # In test, we're always ready :-)
+    return true if ENV['INSTANA_GEM_TEST']
+
+    if !@is_resque_worker && forked?
+      ::Instana.logger.debug "Instana: detected fork. (this pid: #{Process.pid}/#{Process.ppid})  Calling after_fork"
+      after_fork
+    end
+
+    @state == :announced
+  rescue => e
+    Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+    Instana.logger.debug e.backtrace.join("\r\n") unless ::Instana.test?
+    return false
+  end
+end

data/lib/instana/agent/hooks.rb

@@ -0,0 +1,37 @@
+module AgentHooks
+  # Used post fork to re-initialize state and restart communications with
+  # the host agent.
+  #
+  def after_fork
+    ::Instana.logger.debug "after_fork hook called. Falling back to unannounced state and spawning a new background agent thread."
+
+    # Reseed the random number generator for this
+    # new thread.
+    srand
+
+    transition_to(:unannounced)
+
+    setup
+    spawn_background_thread
+  end
+
+  def before_resque_fork
+    ::Instana.logger.debug "before_resque_fork hook called. pid/ppid: #{Process.pid}/#{Process.ppid}"
+    @is_resque_worker = true
+  end
+
+  def after_resque_fork
+    ::Instana.logger.debug "after_resque_fork hook called. pid/ppid: #{Process.pid}/#{Process.ppid}"
+
+    # Reseed the random number generator for this
+    # new thread.
+    srand
+
+    ::Instana.config[:metrics][:enabled] = false
+
+    @process[:pid] = Process.pid
+
+    setup
+    spawn_background_thread
+  end
+end

data/lib/instana/agent/tasks.rb

@@ -0,0 +1,45 @@
+module AgentTasks
+  # When request(s) are received by the host agent, it is sent here
+  # for handling & processing.
+  #
+  # @param json_string [String] the requests from the host agent
+  #
+  def handle_agent_tasks(json_string)
+    tasks = Oj.load(json_string)
+
+    if tasks.is_a?(Hash)
+      process_agent_task(tasks)
+    elsif tasks.is_a?(Array)
+      tasks.each do |t|
+        process_agent_task(t)
+      end
+    end
+  end
+
+  # Process a task sent from the host agent.
+  #
+  # @param task [String] the request json from the host agent
+  #
+  def process_agent_task(task)
+    if task.key?("action")
+      if task["action"] == "ruby.source"
+        payload = ::Instana::Util.get_rb_source(task["args"]["file"])
+      else
+        payload = { :error => "Unrecognized action: #{task["action"]}. An newer Instana gem may be required for this. Current version: #{::Instana::VERSION}" }
+      end
+    else
+      payload = { :error => "Instana Ruby: No action specified in request." }
+    end
+
+    path = "com.instana.plugin.ruby/response.#{@process[:report_pid]}?messageId=#{URI.encode(task['messageId'])}"
+    uri = URI.parse("http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{path}")
+    req = Net::HTTP::Post.new(uri)
+    req.body = Oj.dump(payload)
+    ::Instana.logger.debug "Responding to agent request: #{req.inspect}"
+    make_host_agent_request(req)
+
+  rescue StandardError => e
+    Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+    Instana.logger.debug e.backtrace.join("\r\n")
+  end
+end

data/lib/instana/config.rb

@@ -49,12 +49,14 @@ module Instana
       @config[:active_record]      = { :enabled => true }
       @config[:dalli]              = { :enabled => true }
       @config[:excon]              = { :enabled => true }
+      @config[:grpc]               = { :enabled => true }
       @config[:nethttp]            = { :enabled => true }
+      @config[:redis]              = { :enabled => true }
+      @config[:'resque-client']    = { :enabled => true }
+      @config[:'resque-worker']    = { :enabled => true }
       @config[:'rest-client']      = { :enabled => true }
-      @config[:grpc]               = { :enabled => true }
       @config[:'sidekiq-client']   = { :enabled => true }
       @config[:'sidekiq-worker']   = { :enabled => true }
-      @config[:redis]              = { :enabled => true }
     end
 
     def [](key)

data/lib/instana/frameworks/rails.rb

@@ -1,26 +1,40 @@
 require "instana/rack"
 
 if defined?(::Rails)
-  # In Rails, let's use the Rails logger
-  ::Instana.logger = ::Rails.logger if ::Rails.logger
 
   if ::Rails::VERSION::MAJOR < 3
     ::Rails.configuration.after_initialize do
-      ::Instana.logger.info "Instrumenting Rack"
-      ::Rails.configuration.middleware.insert 0, ::Instana::Rack
+      # In Rails, let's use the Rails logger
+      ::Instana.logger = ::Rails.logger if ::Rails.logger
+
+      if ::Instana.config[:tracing][:enabled]
+        ::Instana.logger.info "Instrumenting Rack"
+        ::Rails.configuration.middleware.insert 0, ::Instana::Rack
+      else
+        ::Instana.logger.info "Rack: Tracing disabled via config.  Not enabling middleware."
+      end
     end
   else
     module ::Instana
       class Railtie < ::Rails::Railtie
         initializer 'instana.rack' do |app|
-          ::Instana.logger.info "Instrumenting Rack"
-          app.config.middleware.insert 0, ::Instana::Rack
+          # In Rails, let's use the Rails logger
+          ::Instana.logger = ::Rails.logger if ::Rails.logger
+
+          if ::Instana.config[:tracing][:enabled]
+            ::Instana.logger.info "Instrumenting Rack"
+            app.config.middleware.insert 0, ::Instana::Rack
+          else
+            ::Instana.logger.info "Rack: Tracing disabled via config.  Not enabling middleware."
+          end
         end
 
-        config.after_initialize do
-          require "instana/frameworks/instrumentation/active_record"
-          require "instana/frameworks/instrumentation/action_controller"
-          require "instana/frameworks/instrumentation/action_view"
+        if ::Instana.config[:tracing][:enabled]
+          config.after_initialize do
+            require "instana/frameworks/instrumentation/active_record"
+            require "instana/frameworks/instrumentation/action_controller"
+            require "instana/frameworks/instrumentation/action_view"
+          end
         end
       end
     end

data/lib/instana/instrumentation/resque.rb

@@ -0,0 +1,127 @@
+require 'socket'
+
+module Instana
+  module Instrumentation
+    module ResqueClient
+      def self.included(klass)
+        klass.send :extend, ::Resque
+        ::Instana::Util.method_alias(klass, :enqueue)
+        ::Instana::Util.method_alias(klass, :enqueue_to)
+        ::Instana::Util.method_alias(klass, :dequeue)
+      end
+
+      def collect_kvs(op, klass, args)
+        kvs = {}
+
+        begin
+          kvs[:job] = klass.to_s
+          kvs[:queue] = klass.instance_variable_get(:@queue)
+        rescue => e
+          Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        end
+
+        { :'resque-client' => kvs }
+      end
+
+      def enqueue_with_instana(klass, *args)
+        if Instana.tracer.tracing?
+          kvs = collect_kvs(:enqueue, klass, args)
+
+          Instana.tracer.trace(:'resque-client', kvs) do
+            enqueue_without_instana(klass, *args)
+          end
+        else
+          enqueue_without_instana(klass, *args)
+        end
+      end
+
+      def enqueue_to_with_instana(queue, klass, *args)
+        if Instana.tracer.tracing? && !Instana.tracer.tracing_span?(:'resque-client')
+          kvs = collect_kvs(:enqueue_to, klass, args)
+          kvs[:Queue] = queue.to_s if queue
+
+          Instana.tracer.trace(:'resque-client', kvs) do
+            enqueue_to_without_instana(queue, klass, *args)
+          end
+        else
+          enqueue_to_without_instana(queue, klass, *args)
+        end
+      end
+
+      def dequeue_with_instana(klass, *args)
+        if Instana.tracer.tracing?
+          kvs = collect_kvs(:dequeue, klass, args)
+
+          Instana.tracer.trace(:'resque-client', kvs) do
+            dequeue_without_instana(klass, *args)
+          end
+        else
+          dequeue_without_instana(klass, *args)
+        end
+      end
+    end
+
+    module ResqueWorker
+      def self.included(klass)
+        ::Instana::Util.method_alias(klass, :perform)
+      end
+
+      def perform_with_instana(job)
+        kvs = {}
+
+        begin
+          kvs[:job] = job.payload['class'].to_s
+          kvs[:queue] = job.queue
+        rescue => e
+          ::Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if Instana::Config[:verbose]
+        end
+
+        Instana.tracer.start_or_continue_trace(:'resque-worker', { :'resque-worker' => kvs }) do
+          perform_without_instana(job)
+        end
+      end
+    end
+
+    module ResqueJob
+      def self.included(klass)
+        ::Instana::Util.method_alias(klass, :fail)
+      end
+
+      def fail_with_instana(exception)
+        if Instana.tracer.tracing?
+          ::Instana.tracer.log_info(:'resque-worker' => { :error => "#{exception.class}: #{exception}"})
+          ::Instana.tracer.log_error(exception)
+        end
+      rescue Exception => e
+        ::Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if Instana::Config[:verbose]
+      ensure
+        fail_without_instana(exception)
+      end
+    end
+  end
+end
+
+if defined?(::Resque) && RUBY_VERSION >= '1.9.3'
+
+  if ::Instana.config[:'resque-client'][:enabled]
+    ::Instana.logger.info 'Instrumenting Resque Client'
+    ::Instana::Util.send_include(::Resque,         ::Instana::Instrumentation::ResqueClient)
+  end
+
+  if ::Instana.config[:'resque-worker'][:enabled]
+    ::Instana.logger.info 'Instrumenting Resque Worker'
+
+    ::Instana::Util.send_include(::Resque::Worker, ::Instana::Instrumentation::ResqueWorker)
+    ::Instana::Util.send_include(::Resque::Job,    ::Instana::Instrumentation::ResqueJob)
+
+    ::Resque.before_fork do |job|
+      ::Instana.agent.before_resque_fork
+    end
+    ::Resque.after_fork do |job|
+      ::Instana.agent.after_resque_fork
+    end
+
+    # Set this so we assure that any remaining collected traces are reported at_exit
+    ENV['RUN_AT_EXIT_HOOKS'] = "1"
+  end
+end

data/lib/instana/tracing/span.rb

@@ -2,9 +2,11 @@ module Instana
   class Span
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
-                         :'rpc-server', :'sidekiq-client', :'sidekiq-worker', :redis].freeze
-    ENTRY_SPANS = [ :rack, :'rpc-server', :'sidekiq-worker' ].freeze
-    EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'rpc-client', :'sidekiq-client', :redis ].freeze
+                         :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
+                         :redis, :'resque-client', :'resque-worker' ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker' ].freeze
+    EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
+                   :'rpc-client', :'sidekiq-client', :redis ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
 
     attr_accessor :parent

data/lib/instana/util.rb

@@ -160,16 +160,19 @@ module Instana
       #
       def get_app_name
         if ENV.key?('INSTANA_SERVICE_NAME')
-          name = ENV['INSTANA_SERVICE_NAME']
+          return ENV['INSTANA_SERVICE_NAME']
+        end
 
-        elsif defined?(::RailsLts) || defined?(::Rails)
-          name = Rails.application.class.to_s.split('::')[0]
 
-        else
-          name = File.basename($0)
+        if defined?(::Resque) && ($0 =~ /resque-#{Resque::Version}/)
+          return "Resque Worker"
+        end
+
+        if defined?(::RailsLts) || defined?(::Rails)
+          return Rails.application.class.to_s.split('::')[0]
         end
 
-        return name
+        return File.basename($0)
       rescue Exception => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
         Instana.logger.debug e.backtrace.join("\r\n")

data/lib/instana/version.rb

@@ -1,4 +1,4 @@
 module Instana
-  VERSION = "1.8.3"
+  VERSION = "1.9.0.daftrabbit"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/agent/agent_test.rb

@@ -7,7 +7,7 @@ class AgentTest < Minitest::Test
   def test_agent_host_detection
     url = "http://#{::Instana.config[:agent_host]}:#{::Instana.config[:agent_port]}/"
     stub_request(:get, url)
-    assert_equal true, ::Instana.agent.host_agent_ready?
+    assert_equal true, ::Instana.agent.host_agent_available?
   end
 
   def test_successful_discovery
@@ -57,7 +57,7 @@ class AgentTest < Minitest::Test
     stub_request(:get, localhost_url).to_raise(Errno::ECONNREFUSED)
     docker_url = "http://#{::Instana.agent.instance_variable_get(:@default_gateway)}:#{::Instana.config[:agent_port]}/"
     stub_request(:get, docker_url).to_timeout
-    assert_equal false, ::Instana.agent.host_agent_ready?
+    assert_equal false, ::Instana.agent.host_agent_available?
   end
 
   def test_announce_sensor
@@ -137,6 +137,6 @@ class AgentTest < Minitest::Test
     stub_request(:get, localhost_url).to_timeout
     docker_url = "http://#{::Instana.agent.instance_variable_get(:@default_gateway)}:#{::Instana.config[:agent_port]}/"
     stub_request(:get, docker_url).to_timeout
-    assert_equal false, ::Instana.agent.host_agent_ready?
+    assert_equal false, ::Instana.agent.host_agent_available?
   end
 end

data/test/instrumentation/resque_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+require_relative "../jobs/resque_fast_job"
+require_relative "../jobs/resque_error_job"
+require 'resque'
+
+if ENV.key?('REDIS_URL')
+  ::Resque.redis = ENV['REDIS_URL']
+else
+  ::Resque.redis = 'localhost:6379'
+end
+
+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
+  end
+
+  def test_enqueue
+    ::Instana.tracer.start_or_continue_trace('resque-client_test') do
+      ::Resque.enqueue(FastJob)
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+
+    spans = traces[0].spans.to_a
+    assert_equal 3, spans.count
+
+    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
+
+    assert_equal :"resque-client", spans[1][:n]
+    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
+    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
+    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
+
+    assert_equal :redis, spans[2][:n]
+  end
+
+  def test_enqueue_to
+    ::Instana.tracer.start_or_continue_trace('resque-client_test') do
+      ::Resque.enqueue_to(:critical, FastJob)
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+
+    spans = traces[0].spans.to_a
+    assert_equal 3, spans.count
+
+    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
+    assert_equal :"resque-client", spans[1][:n]
+    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
+    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
+    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
+    assert_equal :redis, spans[2][:n]
+  end
+
+  def test_dequeue
+    ::Instana.tracer.start_or_continue_trace('resque-client_test', '', {}) do
+      ::Resque.dequeue(FastJob, { :generate => :farfalla })
+    end
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+
+    spans = traces[0].spans.to_a
+    assert_equal 3, spans.count
+
+    assert_equal :'resque-client_test', spans[0][:data][:sdk][:name]
+    assert_equal :"resque-client", spans[1][:n]
+    assert_equal "FastJob", spans[1][:data][:'resque-client'][:job]
+    assert_equal :critical, spans[1][:data][:'resque-client'][:queue]
+    assert_equal false, spans[1][:data][:'resque-client'].key?(:error)
+    assert_equal :redis, spans[2][:n]
+  end
+
+  def test_worker_job
+    Resque::Job.create(:critical, FastJob)
+    @worker.work(0)
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+
+    spans = traces[0].spans.to_a
+    assert_equal 3, spans.count
+
+    resque_span = spans[0]
+    redis1_span = spans[1]
+    redis2_span = spans[2]
+
+    assert_equal :'resque-worker', resque_span[:n]
+    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_error_job
+    Resque::Job.create(:critical, ErrorJob)
+    @worker.work(0)
+
+    traces = Instana.processor.queued_traces
+    assert_equal 1, traces.count
+
+    spans = traces[0].spans.to_a
+    resque_span = spans[0]
+    assert_equal 5, spans.count
+
+    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/jobs/resque_error_job.rb

@@ -0,0 +1,16 @@
+require "redis"
+require "net/http"
+
+class ErrorJob
+  @queue = :critical
+
+  def self.perform
+    redis = Redis.new(url: ENV['REDIS_URL'])
+
+    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,14 @@
+require "redis"
+require "net/http"
+
+class FastJob
+  @queue = :critical
+
+  def self.perform
+    redis = Redis.new(url: ENV['REDIS_URL'])
+
+    dt = Time.now
+    redis.set('ts', dt)
+    redis.set(:nb_id, 2)
+  end
+end

data/test/test_helper.rb

@@ -14,12 +14,16 @@ require 'webmock/minitest'
 require "instana/test"
 ::Instana::Test.setup_environment
 
+# 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)
+
 # Boot background webservers to test against.
 require "./test/servers/rackapp_6511"
 
-# Allow localhost calls to the internal rails servers
-::WebMock.disable_net_connect!(allow_localhost: true)
-
 case File.basename(ENV['BUNDLE_GEMFILE'])
 when /rails50|rails42|rails32/
   require './test/servers/rails_3205'

data/test/tracing/custom_test.rb

@@ -10,7 +10,7 @@ class CustomTracingTest < Minitest::Test
     assert_equal true, ::Instana.tracer.tracing?
     ::Instana.tracer.log_info({:info_logged => 1})
     # End tracing
-    ::Instana.tracer.log_end(:rack, {:close_one => 1})
+    ::Instana.tracer.log_end(:custom_trace, {:close_one => 1})
     assert_equal false, ::Instana.tracer.tracing?
 
     traces = ::Instana.processor.queued_traces

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 1.8.3
+  version: 1.9.0.daftrabbit
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-19 00:00:00.000000000 Z
+date: 2018-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -201,6 +201,9 @@ files:
 - instana.gemspec
 - lib/instana.rb
 - lib/instana/agent.rb
+- lib/instana/agent/helpers.rb
+- lib/instana/agent/hooks.rb
+- lib/instana/agent/tasks.rb
 - lib/instana/base.rb
 - lib/instana/collector.rb
 - lib/instana/collectors/gc.rb
@@ -228,6 +231,7 @@ files:
 - lib/instana/instrumentation/net-http.rb
 - lib/instana/instrumentation/rack.rb
 - lib/instana/instrumentation/redis.rb
+- lib/instana/instrumentation/resque.rb
 - lib/instana/instrumentation/rest-client.rb
 - lib/instana/instrumentation/sidekiq-client.rb
 - lib/instana/instrumentation/sidekiq-worker.rb
@@ -272,9 +276,12 @@ files:
 - test/instrumentation/grpc_test.rb
 - test/instrumentation/net-http_test.rb
 - test/instrumentation/redis_test.rb
+- test/instrumentation/resque_test.rb
 - test/instrumentation/rest-client_test.rb
 - test/instrumentation/sidekiq-client_test.rb
 - test/instrumentation/sidekiq-worker_test.rb
+- test/jobs/resque_error_job.rb
+- test/jobs/resque_fast_job.rb
 - test/jobs/sidekiq_job_1.rb
 - test/jobs/sidekiq_job_2.rb
 - test/models/block.rb
@@ -305,9 +312,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6
@@ -340,9 +347,12 @@ test_files:
 - test/instrumentation/grpc_test.rb
 - test/instrumentation/net-http_test.rb
 - test/instrumentation/redis_test.rb
+- test/instrumentation/resque_test.rb
 - test/instrumentation/rest-client_test.rb
 - test/instrumentation/sidekiq-client_test.rb
 - test/instrumentation/sidekiq-worker_test.rb
+- test/jobs/resque_error_job.rb
+- test/jobs/resque_fast_job.rb
 - test/jobs/sidekiq_job_1.rb
 - test/jobs/sidekiq_job_2.rb
 - test/models/block.rb