instana 1.11.7 → 1.192.1

data/lib/instana/instrumentation/instrumented_request.rb

@@ -0,0 +1,68 @@
+# Note: We really only need "cgi/util" here but Ruby 2.4.1 has an issue:
+# https://bugs.ruby-lang.org/issues/13539
+require "cgi"
+
+module Instana
+  class InstrumentedRequest < Rack::Request
+    def skip_trace?
+      # Honor X-Instana-L
+      @env.has_key?('HTTP_X_INSTANA_L') && @env['HTTP_X_INSTANA_L'].start_with?('0')
+    end
+
+    def incoming_context
+      context = {}
+
+      if @env['HTTP_X_INSTANA_T']
+        context[:trace_id] = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_T'])
+        context[:span_id] = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_S']) if @env['HTTP_X_INSTANA_S']
+        context[:level] = @env['HTTP_X_INSTANA_L'][0] if @env['HTTP_X_INSTANA_L']
+      end
+
+      context
+    end
+
+    def extra_header_tags
+      return nil unless ::Instana.agent.extra_headers
+      headers = {}
+
+      ::Instana.agent.extra_headers.each do |custom_header|
+        # Headers are available in this format: HTTP_X_CAPTURE_THIS
+        rack_header = 'HTTP_' + custom_header.upcase
+        rack_header.tr!('-', '_')
+
+        headers[custom_header.to_sym] = @env[rack_header] if @env.has_key?(rack_header)
+      end
+
+      headers
+    end
+
+    def request_tags
+      {
+        method: request_method,
+        url: CGI.unescape(path_info),
+        host: host_with_port,
+        header: extra_header_tags
+      }.compact
+    end
+
+    def correlation_data
+      @correlation_data ||= parse_correlation_data
+    end
+
+    private
+
+    def parse_correlation_data
+      return {} unless @env.has_key?('HTTP_X_INSTANA_L')
+      _level, *tokens = @env['HTTP_X_INSTANA_L'].split(/[,=;]/)
+      data = tokens
+        .map { |t| t.strip }
+        .each_slice(2)
+        .select { |a| a.length == 2 }.to_h
+
+      {
+        type: data['correlationType'],
+        id: data['correlationId']
+      }.compact
+    end
+  end
+end

data/lib/instana/instrumentation/net-http.rb

@@ -32,6 +32,8 @@ if defined?(::Net::HTTP) && ::Instana.config[:nethttp][:enabled]
           kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
         end
       end
+      
+      kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
 
       # The core call
       response = request_without_instana(*args, &block)

data/lib/instana/instrumentation/rack.rb

@@ -1,6 +1,4 @@
-# Note: We really only need "cgi/util" here but Ruby 2.4.1 has an issue:
-# https://bugs.ruby-lang.org/issues/13539
-require "cgi"
+require 'instana/instrumentation/instrumented_request'
 
 module Instana
   class Rack
@@ -8,58 +6,20 @@ module Instana
       @app = app
     end
 
-    def collect_kvs(env)
-      kvs = {}
-      kvs[:http] = {}
-      kvs[:http][:method] = env['REQUEST_METHOD']
-      kvs[:http][:url] = ::CGI.unescape(env['PATH_INFO'])
-
-      if env.key?('HTTP_HOST')
-        kvs[:http][:host] = env['HTTP_HOST']
-      elsif env.key?('SERVER_NAME')
-        kvs[:http][:host] = env['SERVER_NAME']
-      end
-
-      if ENV.key?('INSTANA_SERVICE_NAME')
-        kvs[:service] = ENV['INSTANA_SERVICE_NAME']
-      end
-
-      if ::Instana.agent.extra_headers
-        ::Instana.agent.extra_headers.each { |custom_header|
-          # Headers are available in this format: HTTP_X_CAPTURE_THIS
-          rack_header = 'HTTP_' + custom_header.upcase
-          rack_header.tr!('-', '_')
-
-          if env.key?(rack_header)
-            unless kvs[:http].key?(:header)
-              kvs[:http][:header] = {}
-            end
-            kvs[:http][:header][custom_header.to_sym] = env[rack_header]
-          end
-        }
-      end
-      return kvs
-    end
-
     def call(env)
-      # Check incoming context
-      incoming_context = {}
-      if env.key?('HTTP_X_INSTANA_T')
-        incoming_context[:trace_id]  = ::Instana::Util.header_to_id(env['HTTP_X_INSTANA_T'])
-        incoming_context[:span_id]   = ::Instana::Util.header_to_id(env['HTTP_X_INSTANA_S']) if env.key?('HTTP_X_INSTANA_S')
-        incoming_context[:level]     = env['HTTP_X_INSTANA_L'] if env.key?('HTTP_X_INSTANA_L')
+      req = InstrumentedRequest.new(env)
+      return @app.call(env) if req.skip_trace?
+      kvs = {
+        http: req.request_tags,
+        service: ENV['INSTANA_SERVICE_NAME']
+      }.compact
 
-        # Honor X-Instana-L
-        if incoming_context[:level] and incoming_context[:level].length > 0
-          if incoming_context[:level][0] == "0"
-            return @app.call(env)
-          end
-        end
-      end
+      current_span = ::Instana.tracer.log_start_or_continue(:rack, {}, req.incoming_context)
 
-      kvs = collect_kvs(env)
-
-      ::Instana.tracer.log_start_or_continue(:rack, {}, incoming_context)
+      unless req.correlation_data.empty?
+        current_span[:crid] = req.correlation_data[:id]
+        current_span[:crtp] = req.correlation_data[:type]
+      end
 
       status, headers, response = @app.call(env)
 
@@ -76,6 +36,11 @@ module Instana
           ::Instana.tracer.log_error(nil)
         end
 
+        # If the framework instrumentation provides a path template,
+        # pass it into the span here.
+        # See: https://www.instana.com/docs/tracing/custom-best-practices/#path-templates-visual-grouping-of-http-endpoints
+        kvs[:http][:path_tpl] = env['INSTANA_HTTP_PATH_TEMPLATE'] if env['INSTANA_HTTP_PATH_TEMPLATE']
+
         # Save the IDs before the trace ends so we can place
         # them in the response headers in the ensure block
         trace_id = ::Instana.tracer.current_span.trace_id

data/lib/instana/secrets.rb

@@ -0,0 +1,42 @@
+require 'uri'
+require 'cgi'
+
+module Instana
+  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)
+      
+      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'
+        ->(expected, actual) { expected.casecmp(actual) == 0 }
+      when 'equals'
+        ->(expected, actual) { (expected <=> actual) == 0 }
+      when 'contains-ignore-case'
+        ->(expected, actual) { actual.downcase.include?(expected) }
+      when 'contains'
+        ->(expected, actual) { actual.include?(expected) }
+      when 'regex'
+        ->(expected, actual) { !Regexp.new(expected).match(actual).nil? }
+      else
+        ::Instana.logger.warn("Matcher #{name} is not supported.")
+        lambda { false }
+      end
+    end
+  end
+end

data/lib/instana/setup.rb

@@ -4,6 +4,7 @@ require "instana/base"
 require "instana/config"
 require "instana/agent"
 require "instana/collector"
+require "instana/secrets"
 require "instana/tracer"
 require "instana/tracing/processor"
 require "instana/instrumentation"

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
@@ -303,6 +307,15 @@ module Instana
     # a String, Numeric, or Boolean it will be encoded with to_s
     #
     def set_tag(key, value)
+      if ![Symbol, String].include?(key.class)
+        key = key.to_s
+      end
+
+      # If <value> is not a Symbol, String, Array, Hash or Numeric - convert to string
+      if ![Symbol, String, Array, TrueClass, FalseClass, Hash].include?(value.class) && !value.is_a?(Numeric)
+        value = value.to_s
+      end
+
       if custom?
         @data[:data][:sdk][:custom] ||= {}
         @data[:data][:sdk][:custom][:tags] ||= {}

data/lib/instana/util.rb

@@ -225,53 +225,39 @@ module Instana
         (time.to_f * 1000).floor
       end
 
-      # Generate a random 64bit ID
+      # Generate a random 64bit/128bit ID
       #
-      # @return [Integer] a random 64bit integer
+      # @param size [Integer] Number of 64 bit integers used to generate the id
       #
-      def generate_id
-        # Max value is 9223372036854775807 (signed long in Java)
-        rand(ID_RANGE)
+      # @return [String] a random 64bit/128bit hex encoded string
+      #
+      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.11.7"
+  VERSION = "1.192.1"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/apps/cuba.rb

@@ -7,6 +7,10 @@ Cuba.define do
     on "hello" do
       res.write "Hello Instana!"
     end
+    
+    on "greet/:name" do |name|
+      res.write "Hello, #{name}"
+    end
 
     on root do
       res.redirect '/hello'

data/test/apps/roda.rb

@@ -6,5 +6,8 @@ class InstanaRodaApp < Roda
     r.get "hello" do
       "Hello Roda + Instana"
     end
+    r.get "greet", String do |name|
+      "Hello, #{name}!"
+    end
   end
 end

data/test/apps/sinatra.rb

@@ -2,4 +2,8 @@ class InstanaSinatraApp < ::Sinatra::Base
   get '/' do
     "Hello Sinatra!"
   end
+  
+  get '/greet/:name' do
+    "Hello, #{params[:name]}!"
+  end
 end

data/test/config_test.rb

@@ -10,28 +10,12 @@ class ConfigTest < Minitest::Test
     assert_equal '127.0.0.1', ::Instana.config[:agent_host]
     assert_equal 42699, ::Instana.config[:agent_port]
 
-    assert ::Instana.config[:enabled]
     assert ::Instana.config[:tracing][:enabled]
     assert ::Instana.config[:metrics][:enabled]
 
     ::Instana.config[:metrics].each do |k, v|
+      next unless v.is_a? Hash
       assert_equal true, ::Instana.config[:metrics][k].key?(:enabled)
     end
   end
-
-  def test_that_global_affects_children
-    # Disabling the gem should explicitly disable
-    # metrics and tracing flags
-    ::Instana.config[:enabled] = false
-
-    assert_equal false, ::Instana.config[:tracing][:enabled]
-    assert_equal false, ::Instana.config[:metrics][:enabled]
-
-    # Enabling the gem should explicitly enable
-    # metrics and tracing flags
-    ::Instana.config[:enabled] = true
-
-    assert_equal ::Instana.config[:tracing][:enabled]
-    assert_equal ::Instana.config[:metrics][:enabled]
-  end
 end