instana 1.13.0 → 1.193.3

data/lib/instana/instrumentation/sidekiq-client.rb

@@ -34,12 +34,3 @@ module Instana
     end
   end
 end
-
-if defined?(::Sidekiq) && ::Instana.config[:'sidekiq-client'][:enabled]
-  ::Sidekiq.configure_client do |cfg|
-    cfg.client_middleware do |chain|
-      ::Instana.logger.debug "Instrumenting Sidekiq client"
-      chain.add ::Instana::Instrumentation::SidekiqClient
-    end
-  end
-end

data/lib/instana/instrumentation/sidekiq-worker.rb

@@ -43,12 +43,3 @@ module Instana
     end
   end
 end
-
-if defined?(::Sidekiq) && ::Instana.config[:'sidekiq-worker'][:enabled]
-  ::Sidekiq.configure_server do |cfg|
-    cfg.server_middleware do |chain|
-      ::Instana.logger.debug "Instrumenting Sidekiq worker"
-      chain.add ::Instana::Instrumentation::SidekiqWorker
-    end
-  end
-end

data/lib/instana/secrets.rb

@@ -2,25 +2,25 @@ require 'uri'
 require 'cgi'
 
 module Instana
-  class Secrets    
+  class Secrets
     def remove_from_query(str, secret_values = Instana.agent.secret_values)
       return str unless secret_values
-      
+
       url = URI(str)
-      params = CGI.parse(url.query)
-      
+      params = CGI.parse(url.query || '')
+
       redacted = params.map do |k, v|
         needs_redaction = secret_values['list']
           .any? { |t| matcher(secret_values['matcher']).(t,k) }
         [k, needs_redaction ? '<redacted>' : v]
       end
-      
+
       url.query = URI.encode_www_form(redacted)
       CGI.unescape(url.to_s)
     end
-    
+
     private
-    
+
     def matcher(name)
       case name
       when 'equals-ignore-case'

data/lib/instana/setup.rb

@@ -7,10 +7,12 @@ require "instana/collector"
 require "instana/secrets"
 require "instana/tracer"
 require "instana/tracing/processor"
-require "instana/instrumentation"
+
+require 'instana/activator'
 
 ::Instana.setup
 ::Instana.agent.setup
+::Instana::Activator.start
 
 # Register the metric collectors
 unless RUBY_PLATFORM == 'java'.freeze

data/lib/instana/tracer.rb

@@ -100,6 +100,12 @@ module Instana
       else
         self.current_span = Span.new(name)
       end
+      
+      if incoming_context.is_a?(Hash) && incoming_context[:correlation] && !incoming_context[:correlation].empty?
+        self.current_span[:crid] = incoming_context[:correlation][:id]
+        self.current_span[:crtp] = incoming_context[:correlation][:type]
+      end
+      
       self.current_span.set_tags(kvs) unless kvs.empty?
       self.current_span
     end

data/lib/instana/tracing/span.rb

@@ -3,8 +3,8 @@ module Instana
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
                          :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
-                         :redis, :'resque-client', :'resque-worker' ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker' ].freeze
+                         :redis, :'resque-client', :'resque-worker', :'graphql.server'  ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server' ].freeze
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
                    :'rpc-client', :'sidekiq-client', :redis ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
@@ -57,9 +57,6 @@ module Instana
       end
 
       if ::Instana.config[:collect_backtraces]
-        # For entry spans, add a backtrace fingerprint
-        add_stack(limit: 2) if ENTRY_SPANS.include?(name)
-
         # Attach a backtrace to all exit spans
         add_stack if EXIT_SPANS.include?(name)
       end
@@ -76,9 +73,11 @@ module Instana
     #
     # @param limit [Integer] Limit the backtrace to the top <limit> frames
     #
-    def add_stack(limit: nil, stack: Kernel.caller)
+    def add_stack(limit: 30, stack: Kernel.caller)
       frame_count = 0
+      sanitized_stack = []
       @data[:stack] = []
+      limit = 40 if limit > 40
 
       stack.each do |i|
         # If the stack has the full instana gem version in it's path
@@ -86,18 +85,23 @@ module Instana
         if !i.match(/instana\/instrumentation\/rack.rb/).nil? ||
           (i.match(::Instana::VERSION_FULL).nil? && i.match('lib/instana/').nil?)
 
-          break if limit && frame_count >= limit
-
           x = i.split(':')
 
-          @data[:stack] << {
+          sanitized_stack << {
             :c => x[0],
             :n => x[1],
             :m => x[2]
           }
-         frame_count = frame_count + 1 if limit
         end
       end
+
+      if sanitized_stack.length > limit
+        # (limit * -1) gives us negative form of <limit> used for
+        # slicing from the end of the list. e.g. stack[-30, 30]
+        @data[:stack] = sanitized_stack[limit*-1, limit]
+      else
+        @data[:stack] = sanitized_stack
+      end
     end
 
     # Log an error into the span

data/lib/instana/util.rb

@@ -2,46 +2,6 @@ module Instana
   module Util
     class << self
       ID_RANGE = -2**63..2**63-1
-
-      # An agnostic approach to method aliasing.
-      #
-      # @param klass [Object] The class or module that holds the method to be alias'd.
-      # @param method [Symbol] The name of the method to be aliased.
-      #
-      def method_alias(klass, method)
-        if klass.method_defined?(method.to_sym) ||
-            klass.private_method_defined?(method.to_sym)
-
-          with = "#{method}_with_instana"
-          without = "#{method}_without_instana"
-
-          klass.class_eval do
-            alias_method without, method.to_s
-            alias_method method.to_s, with
-          end
-        else
-          ::Instana.logger.debug "No such method (#{method}) to alias on #{klass}"
-        end
-      end
-
-      # Calls on target_class to 'extend' cls
-      #
-      # @param target_cls [Object] the class/module to do the 'extending'
-      # @param cls [Object] the class/module to be 'extended'
-      #
-      def send_extend(target_cls, cls)
-        target_cls.send(:extend, cls) if defined?(target_cls)
-      end
-
-      # Calls on <target_cls> to include <cls> into itself.
-      #
-      # @param target_cls [Object] the class/module to do the 'including'
-      # @param cls [Object] the class/module to be 'included'
-      #
-      def send_include(target_cls, cls)
-        target_cls.send(:include, cls) if defined?(target_cls)
-      end
-
       # Debugging helper method
       #
       def pry!
@@ -225,53 +185,39 @@ module Instana
         (time.to_f * 1000).floor
       end
 
-      # Generate a random 64bit ID
+      # Generate a random 64bit/128bit ID
+      #
+      # @param size [Integer] Number of 64 bit integers used to generate the id
       #
-      # @return [Integer] a random 64bit integer
+      # @return [String] a random 64bit/128bit hex encoded string
       #
-      def generate_id
-        # Max value is 9223372036854775807 (signed long in Java)
-        rand(ID_RANGE)
+      def generate_id(size = 1)
+        Array.new(size) { rand(ID_RANGE) }
+          .pack('q>*')
+          .unpack('H*')
+          .first
       end
 
       # Convert an ID to a value appropriate to pass in a header.
       #
-      # @param id [Integer] the id to be converted
+      # @param id [String] the id to be converted
       #
       # @return [String]
       #
       def id_to_header(id)
-        unless id.is_a?(Integer) || id.is_a?(String)
-          Instana.logger.debug "id_to_header received a #{id.class}: returning empty string"
-          return String.new
-        end
-        [id.to_i].pack('q>').unpack('H*')[0].gsub(/^0+/, '')
-      rescue => e
-        Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug { e.backtrace.join("\r\n") }
+        return '' unless id.is_a?(String)
+        # Only send 64bit IDs downstream for now
+        id.length == 32 ? id[16..-1] : id
       end
 
       # Convert a received header value into a valid ID
       #
       # @param header_id [String] the header value to be converted
       #
-      # @return [Integer]
+      # @return [String]
       #
       def header_to_id(header_id)
-        if !header_id.is_a?(String)
-          Instana.logger.debug "header_to_id received a #{header_id.class}: returning 0"
-          return 0
-        end
-        if header_id.length < 16
-          # The header is less than 16 chars.  Prepend
-          # zeros so we can convert correctly
-          missing = 16 - header_id.length
-          header_id = ("0" * missing) + header_id
-        end
-        [header_id].pack("H*").unpack("q>")[0]
-      rescue => e
-        Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug { e.backtrace.join("\r\n") }
+        header_id.is_a?(String) && header_id.match(/\A[a-z\d]{16,32}\z/i) ? header_id : ''
       end
     end
   end

data/lib/instana/version.rb

@@ -1,4 +1,4 @@
 module Instana
-  VERSION = "1.13.0"
+  VERSION = "1.193.3"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/activator_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class ActivatorTest < Minitest::Test
+  def test_start
+    refute_nil Instana::Activator.trace_point
+    assert Instana::Activator.trace_point.enabled?
+  end
+
+  def test_klass_call
+    assert_equal [], Instana::Activator.call
+  end
+
+  def test_instance_call
+    subject = Class.new(Instana::Activator) do
+      def can_instrument?
+        true
+      end
+
+      def instrument
+        true
+      end
+    end
+
+    assert_equal 1, Instana::Activator.call.length
+    assert subject.call
+  end
+end

data/test/frameworks/cuba_test.rb

@@ -1,57 +1,55 @@
-if defined?(::Cuba)
-  require 'test_helper'
-  require File.expand_path(File.dirname(__FILE__) + '/../apps/cuba')
-  require 'rack/test'
+require 'test_helper'
+require 'rack/test'
 
-  class CubaTest < Minitest::Test
-    include Rack::Test::Methods
+class CubaTest < Minitest::Test
+  include Rack::Test::Methods
+  APP = Rack::Builder.parse_file('test/support/apps/cuba/config.ru').first
 
-    def app
-      Cuba
-    end
+  def app
+    APP
+  end
 
-    def test_basic_get
-      clear_all!
+  def test_basic_get
+    clear_all!
 
-      r = get '/hello'
-      assert last_response.ok?
+    r = get '/hello'
+    assert last_response.ok?
 
-      assert r.headers.key?("X-Instana-T")
-      assert r.headers.key?("X-Instana-S")
+    assert r.headers.key?("X-Instana-T")
+    assert r.headers.key?("X-Instana-S")
 
-      spans = ::Instana.processor.queued_spans
-      assert_equal 1, spans.count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.count
 
-      first_span = spans.first
-      assert_equal :rack, first_span[:n]
-      assert first_span.key?(:data)
-      assert first_span[:data].key?(:http)
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert first_span.key?(:data)
+    assert first_span[:data].key?(:http)
 
-      assert first_span[:data][:http].key?(:method)
-      assert_equal "GET", first_span[:data][:http][:method]
+    assert first_span[:data][:http].key?(:method)
+    assert_equal "GET", first_span[:data][:http][:method]
 
-      assert first_span[:data][:http].key?(:url)
-      assert_equal "/hello", first_span[:data][:http][:url]
+    assert first_span[:data][:http].key?(:url)
+    assert_equal "/hello", first_span[:data][:http][:url]
 
-      assert first_span[:data][:http].key?(:status)
-      assert_equal 200, first_span[:data][:http][:status]
+    assert first_span[:data][:http].key?(:status)
+    assert_equal 200, first_span[:data][:http][:status]
 
-      assert first_span[:data][:http].key?(:host)
-      assert_equal "example.org", first_span[:data][:http][:host]
-    end
+    assert first_span[:data][:http].key?(:host)
+    assert_equal "example.org", first_span[:data][:http][:host]
+  end
 
-    def test_path_template
-      clear_all!
+  def test_path_template
+    clear_all!
 
-      r = get '/greet/instana'
-      assert last_response.ok?
+    r = get '/greet/instana'
+    assert last_response.ok?
 
-      spans = ::Instana.processor.queued_spans
-      assert_equal 1, spans.count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.count
 
-      first_span = spans.first
-      assert_equal :rack, first_span[:n]
-      assert_equal '/greet/{name}', first_span[:data][:http][:path_tpl]
-    end
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert_equal '/greet/{name}', first_span[:data][:http][:path_tpl]
   end
 end

data/test/frameworks/roda_test.rb

@@ -1,58 +1,56 @@
 
-if defined?(::Roda)
-  require 'test_helper'
-  require File.expand_path(File.dirname(__FILE__) + '/../apps/roda')
-  require 'rack/test'
+require 'test_helper'
+require 'rack/test'
 
-  class RodaTest < Minitest::Test
-    include Rack::Test::Methods
+class RodaTest < Minitest::Test
+  include Rack::Test::Methods
+  APP = Rack::Builder.parse_file('test/support/apps/roda/config.ru').first
 
-    def app
-      InstanaRodaApp
-    end
+  def app
+    APP
+  end
+
+  def test_basic_get
+    clear_all!
 
-    def test_basic_get
-      clear_all!
+    r = get '/hello'
+    assert last_response.ok?
 
-      r = get '/hello'
-      assert last_response.ok?
+    assert r.headers.key?("X-Instana-T")
+    assert r.headers.key?("X-Instana-S")
 
-      assert r.headers.key?("X-Instana-T")
-      assert r.headers.key?("X-Instana-S")
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.count
 
-      spans = ::Instana.processor.queued_spans
-      assert_equal 1, spans.count
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert first_span.key?(:data)
+    assert first_span[:data].key?(:http)
 
-      first_span = spans.first
-      assert_equal :rack, first_span[:n]
-      assert first_span.key?(:data)
-      assert first_span[:data].key?(:http)
+    assert first_span[:data][:http].key?(:method)
+    assert_equal "GET", first_span[:data][:http][:method]
 
-      assert first_span[:data][:http].key?(:method)
-      assert_equal "GET", first_span[:data][:http][:method]
+    assert first_span[:data][:http].key?(:url)
+    assert_equal "/hello", first_span[:data][:http][:url]
 
-      assert first_span[:data][:http].key?(:url)
-      assert_equal "/hello", first_span[:data][:http][:url]
+    assert first_span[:data][:http].key?(:status)
+    assert_equal 200, first_span[:data][:http][:status]
 
-      assert first_span[:data][:http].key?(:status)
-      assert_equal 200, first_span[:data][:http][:status]
+    assert first_span[:data][:http].key?(:host)
+    assert_equal "example.org", first_span[:data][:http][:host]
+  end
 
-      assert first_span[:data][:http].key?(:host)
-      assert_equal "example.org", first_span[:data][:http][:host]
-    end
-    
-    def test_path_template
-      clear_all!
+  def test_path_template
+    clear_all!
 
-      r = get '/greet/instana'
-      assert last_response.ok?
+    r = get '/greet/instana'
+    assert last_response.ok?
 
-      spans = ::Instana.processor.queued_spans
-      assert_equal 1, spans.count
+    spans = ::Instana.processor.queued_spans
+    assert_equal 1, spans.count
 
-      first_span = spans.first
-      assert_equal :rack, first_span[:n]
-      assert_equal '/greet/{name}', first_span[:data][:http][:path_tpl]
-    end
+    first_span = spans.first
+    assert_equal :rack, first_span[:n]
+    assert_equal '/greet/{name}', first_span[:data][:http][:path_tpl]
   end
 end