instana 1.13.0 → 1.193.3

data/lib/instana/instrumentation/instrumented_request.rb

@@ -0,0 +1,69 @@
+# 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 'rack/request'
+
+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

@@ -1,61 +1,57 @@
 require 'net/http'
 
-if defined?(::Net::HTTP) && ::Instana.config[:nethttp][:enabled]
-  Net::HTTP.class_eval {
-
-    def request_with_instana(*args, &block)
-      if !Instana.tracer.tracing? || !started?
-        do_skip = true
-        return request_without_instana(*args, &block)
-      end
+module Instana
+  module Instrumentation
+    module NetHTTPInstrumentation
+      def request(*args, &block)
+        if !Instana.tracer.tracing? || !started?
+          do_skip = true
+          return super(*args, &block)
+        end
 
-      ::Instana.tracer.log_entry(:'net-http')
+        ::Instana.tracer.log_entry(:'net-http')
 
-      # Send out the tracing context with the request
-      request = args[0]
+        # Send out the tracing context with the request
+        request = args[0]
 
-      # Set request headers; encode IDs as hexadecimal strings
-      t_context = ::Instana.tracer.context
-      request['X-Instana-T'] = t_context.trace_id_header
-      request['X-Instana-S'] = t_context.span_id_header
+        # Set request headers; encode IDs as hexadecimal strings
+        t_context = ::Instana.tracer.context
+        request['X-Instana-T'] = t_context.trace_id_header
+        request['X-Instana-S'] = t_context.span_id_header
 
-      # Collect up KV info now in case any exception is raised
-      kv_payload = { :http => {} }
-      kv_payload[:http][:method] = request.method
+        # Collect up KV info now in case any exception is raised
+        kv_payload = { :http => {} }
+        kv_payload[:http][:method] = request.method
 
-      if request.uri
-        kv_payload[:http][:url] = request.uri.to_s
-      else
-        if use_ssl?
-          kv_payload[:http][:url] = "https://#{@address}:#{@port}#{request.path}"
+        if request.uri
+          kv_payload[:http][:url] = request.uri.to_s
         else
-          kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
+          if use_ssl?
+            kv_payload[:http][:url] = "https://#{@address}:#{@port}#{request.path}"
+          else
+            kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
+          end
         end
-      end
-      
-      kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
-
-      # The core call
-      response = request_without_instana(*args, &block)
 
-      kv_payload[:http][:status] = response.code
-      if response.code.to_i.between?(500, 511)
-        # Because of the 5xx response, we flag this span as errored but
-        # without a backtrace (no exception)
-        ::Instana.tracer.log_error(nil)
-      end
+        kv_payload[:http][:url] = ::Instana.secrets.remove_from_query(kv_payload[:http][:url])
 
-      response
-    rescue => e
-      ::Instana.tracer.log_error(e)
-      raise
-    ensure
-      ::Instana.tracer.log_exit(:'net-http', kv_payload) unless do_skip
-    end
+        # The core call
+        response = super(*args, &block)
 
-    ::Instana.logger.debug "Instrumenting Net::HTTP"
+        kv_payload[:http][:status] = response.code
+        if response.code.to_i.between?(500, 511)
+          # Because of the 5xx response, we flag this span as errored but
+          # without a backtrace (no exception)
+          ::Instana.tracer.log_error(nil)
+        end
 
-    alias request_without_instana request
-    alias request request_with_instana
-  }
+        response
+      rescue => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:'net-http', kv_payload) unless do_skip
+      end
+    end
+  end
 end

data/lib/instana/instrumentation/rack.rb

@@ -1,6 +1,5 @@
-# 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 'rack'
+require 'instana/instrumentation/instrumented_request'
 
 module Instana
   class Rack
@@ -8,59 +7,21 @@ 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')
-
-        # 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
+      req = InstrumentedRequest.new(env)
+      return @app.call(env) if req.skip_trace?
+      kvs = {
+        http: req.request_tags,
+        service: ENV['INSTANA_SERVICE_NAME']
+      }.compact
+
+      current_span = ::Instana.tracer.log_start_or_continue(:rack, {}, req.incoming_context)
+
+      unless req.correlation_data.empty?
+        current_span[:crid] = req.correlation_data[:id]
+        current_span[:crtp] = req.correlation_data[:type]
       end
 
-      kvs = collect_kvs(env)
-
-      ::Instana.tracer.log_start_or_continue(:rack, {}, incoming_context)
-
       status, headers, response = @app.call(env)
 
       if ::Instana.tracer.tracing?

data/lib/instana/instrumentation/redis.rb

@@ -1,11 +1,11 @@
-if defined?(::Redis) && ::Instana.config[:redis][:enabled]
-  ::Redis::Client.class_eval do
-    def call_with_instana(*args, &block)
+module Instana
+  module RedisInstrumentation
+    def call(*args, &block)
       kv_payload = { redis: {} }
       dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
-        return call_without_instana(*args, &block)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name) || !Instana.config[:redis][:enabled]
+        return super(*args, &block)
       end
 
       begin
@@ -19,7 +19,7 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
           nil
         end
 
-        call_without_instana(*args, &block)
+        super(*args, &block)
       rescue => e
         ::Instana.tracer.log_info({ redis: {error: true} })
         ::Instana.tracer.log_error(e)
@@ -29,17 +29,12 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
       end
     end
 
-    ::Instana.logger.debug "Instrumenting Redis"
-
-    alias call_without_instana call
-    alias call call_with_instana
-
-    def call_pipeline_with_instana(*args, &block)
+    def call_pipeline(*args, &block)
       kv_payload = { redis: {} }
       dnt_spans = [:redis, :'resque-client', :'sidekiq-client']
 
-      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name)
-        return call_pipeline_without_instana(*args, &block)
+      if !Instana.tracer.tracing? || dnt_spans.include?(::Instana.tracer.current_span.name) || !Instana.config[:redis][:enabled]
+        return super(*args, &block)
       end
 
       begin
@@ -54,7 +49,7 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
           nil
         end
 
-        call_pipeline_without_instana(*args, &block)
+        super(*args, &block)
       rescue => e
         ::Instana.tracer.log_info({ redis: {error: true} })
         ::Instana.tracer.log_error(e)
@@ -63,8 +58,5 @@ if defined?(::Redis) && ::Instana.config[:redis][:enabled]
         ::Instana.tracer.log_exit(:redis, kv_payload)
       end
     end
-
-    alias call_pipeline_without_instana call_pipeline
-    alias call_pipeline call_pipeline_with_instana
   end
 end

data/lib/instana/instrumentation/resque.rb

@@ -3,11 +3,8 @@ require 'socket'
 module Instana
   module Instrumentation
     module ResqueClient
-      def self.included(klass)
+      def self.prepended(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)
@@ -23,50 +20,46 @@ module Instana
         { :'resque-client' => kvs }
       end
 
-      def enqueue_with_instana(klass, *args)
+      def enqueue(klass, *args)
         if Instana.tracer.tracing?
           kvs = collect_kvs(:enqueue, klass, args)
 
           Instana.tracer.trace(:'resque-client', kvs) do
-            enqueue_without_instana(klass, *args)
+            super(klass, *args)
           end
         else
-          enqueue_without_instana(klass, *args)
+          super(klass, *args)
         end
       end
 
-      def enqueue_to_with_instana(queue, klass, *args)
+      def enqueue_to(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)
+            super(queue, klass, *args)
           end
         else
-          enqueue_to_without_instana(queue, klass, *args)
+          super(queue, klass, *args)
         end
       end
 
-      def dequeue_with_instana(klass, *args)
+      def dequeue(klass, *args)
         if Instana.tracer.tracing?
           kvs = collect_kvs(:dequeue, klass, args)
 
           Instana.tracer.trace(:'resque-client', kvs) do
-            dequeue_without_instana(klass, *args)
+            super(klass, *args)
           end
         else
-          dequeue_without_instana(klass, *args)
+          super(klass, *args)
         end
       end
     end
 
     module ResqueWorker
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :perform)
-      end
-
-      def perform_with_instana(job)
+      def perform(job)
         kvs = {}
         kvs[:'resque-worker'] = {}
 
@@ -81,17 +74,13 @@ module Instana
         end
 
         Instana.tracer.start_or_continue_trace(:'resque-worker', kvs) do
-          perform_without_instana(job)
+          super(job)
         end
       end
     end
 
     module ResqueJob
-      def self.included(klass)
-        ::Instana::Util.method_alias(klass, :fail)
-      end
-
-      def fail_with_instana(exception)
+      def fail(exception)
         if Instana.tracer.tracing?
           ::Instana.tracer.log_info(:'resque-worker' => { :error => "#{exception.class}: #{exception}"})
           ::Instana.tracer.log_error(exception)
@@ -99,33 +88,8 @@ module Instana
       rescue Exception => e
         ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" } if Instana::Config[:verbose]
       ensure
-        fail_without_instana(exception)
+        super(exception)
       end
     end
   end
 end
-
-if defined?(::Resque) && RUBY_VERSION >= '1.9.3'
-
-  if ::Instana.config[:'resque-client'][:enabled]
-    ::Instana.logger.debug 'Instrumenting Resque Client'
-    ::Instana::Util.send_include(::Resque,         ::Instana::Instrumentation::ResqueClient)
-  end
-
-  if ::Instana.config[:'resque-worker'][:enabled]
-    ::Instana.logger.debug '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/instrumentation/rest-client.rb

@@ -1,34 +1,19 @@
 module Instana
   module Instrumentation
     module RestClientRequest
-      def self.included(klass)
-        if klass.method_defined?(:execute)
-          klass.class_eval do
-            alias execute_without_instana execute
-            alias execute execute_with_instana
-          end
-        end
-      end
-
-      def execute_with_instana & block
+      def execute(&block)
         # Since RestClient uses net/http under the covers, we just
         # provide span visibility here.  HTTP related KVs are reported
         # in the Net::HTTP instrumentation
         ::Instana.tracer.log_entry(:'rest-client')
 
-        execute_without_instana(&block)
+        super(&block)
       rescue => e
         ::Instana.tracer.log_error(e)
         raise
       ensure
         ::Instana.tracer.log_exit(:'rest-client')
       end
-
     end
   end
 end
-
-if defined?(::RestClient::Request) && ::Instana.config[:'rest-client'][:enabled]
-  ::Instana.logger.debug "Instrumenting RestClient"
-  ::RestClient::Request.send(:include, ::Instana::Instrumentation::RestClientRequest)
-end