instana 1.10.1-java

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

@@ -0,0 +1,66 @@
+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
+
+      ::Instana.tracer.log_entry(:'net-http')
+
+      # 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
+
+      # 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}"
+        else
+          kv_payload[:http][:url] = "http://#{@address}:#{@port}#{request.path}"
+        end
+      end
+
+      # The core call
+      response = request_without_instana(*args, &block)
+
+      # Debug only check: Pickup response headers; convert back to base 10 integer and validate
+      if ENV.key?('INSTANA_DEBUG') && response.key?('X-Instana-T')
+        if ::Instana.tracer.trace_id != ::Instana::Util.header_to_id(response.header['X-Instana-T'])
+          ::Instana.logger.debug "#{Thread.current}: Trace ID mismatch on net/http response! ours: #{::Instana.tracer.trace_id} theirs: #{their_trace_id}"
+        end
+      end
+
+      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
+
+      response
+    rescue => e
+      ::Instana.tracer.log_error(e)
+      raise
+    ensure
+      ::Instana.tracer.log_exit(:'net-http', kv_payload) unless do_skip
+    end
+
+    Instana.logger.info "Instrumenting Net::HTTP"
+
+    alias request_without_instana request
+    alias request request_with_instana
+  }
+end

data/lib/instana/instrumentation/rack.rb

@@ -0,0 +1,77 @@
+# 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 Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      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)
+            kvs["http.#{custom_header}"] = env[rack_header]
+          end
+        }
+      end
+
+      # 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')
+      end
+
+      ::Instana.tracer.log_start_or_continue(:rack, {}, incoming_context)
+
+      status, headers, response = @app.call(env)
+
+      if ::Instana.tracer.tracing?
+        kvs[:http][:status] = status
+
+        if !status.is_a?(Integer) || status.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
+
+        # 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
+        span_id = ::Instana.tracer.current_span.id
+      end
+
+      [status, headers, response]
+    rescue Exception => e
+      ::Instana.tracer.log_error(e)
+      raise
+    ensure
+      if headers && ::Instana.tracer.tracing?
+        # Set reponse headers; encode as hex string
+        headers['X-Instana-T'] = ::Instana::Util.id_to_header(trace_id)
+        headers['X-Instana-S'] = ::Instana::Util.id_to_header(span_id)
+      end
+      ::Instana.tracer.log_end(:rack, kvs)
+    end
+  end
+end

data/lib/instana/instrumentation/redis.rb

@@ -0,0 +1,82 @@
+module Instana
+  module Instrumentation
+    class Redis
+      def self.get_host(client)
+        client.host
+      end
+
+      def self.get_port(client)
+        client.port
+      end
+
+      def self.pipeline_command(pipeline)
+        pipeline.is_a?(::Redis::Pipeline::Multi) ? 'MULTI' : 'PIPELINE'
+      end
+    end
+  end
+end
+
+if defined?(::Redis) && ::Instana.config[:redis][:enabled]
+  ::Redis::Client.class_eval do
+    def call_with_instana(*args, &block)
+      kv_payload = { redis: {} }
+
+      if !Instana.tracer.tracing?
+        return call_without_instana(*args, &block)
+      end
+
+      host = ::Instana::Instrumentation::Redis.get_host(self)
+      port = ::Instana::Instrumentation::Redis.get_port(self)
+      kv_payload[:redis] = {
+        connection: "#{host}:#{port}",
+        db: db,
+        command: args[0][0].to_s.upcase
+      }
+      ::Instana.tracer.log_entry(:redis, kv_payload)
+
+      call_without_instana(*args, &block)
+    rescue => e
+      kv_payload[:redis][:error] = true
+      ::Instana.tracer.log_info(kv_payload)
+      ::Instana.tracer.log_error(e)
+      raise
+    ensure
+      ::Instana.tracer.log_exit(:redis, {})
+    end
+
+    ::Instana.logger.info "Instrumenting Redis"
+
+    alias call_without_instana call
+    alias call call_with_instana
+
+    def call_pipeline_with_instana(*args, &block)
+      kv_payload = { redis: {} }
+
+      if !Instana.tracer.tracing?
+        return call_pipeline_without_instana(*args, &block)
+      end
+
+      pipeline = args.first
+      host = ::Instana::Instrumentation::Redis.get_host(self)
+      port = ::Instana::Instrumentation::Redis.get_port(self)
+      kv_payload[:redis] = {
+        connection: "#{host}:#{port}",
+        db: db,
+        command: ::Instana::Instrumentation::Redis.pipeline_command(pipeline)
+      }
+      ::Instana.tracer.log_entry(:redis, kv_payload)
+
+      call_pipeline_without_instana(*args, &block)
+    rescue => e
+      kv_payload[:redis][:error] = true
+      ::Instana.tracer.log_info(kv_payload)
+      ::Instana.tracer.log_error(e)
+      raise
+    ensure
+      ::Instana.tracer.log_exit(:redis, {})
+    end
+
+    alias call_pipeline_without_instana call_pipeline
+    alias call_pipeline call_pipeline_with_instana
+  end
+end

data/lib/instana/instrumentation/resque.rb

@@ -0,0 +1,131 @@
+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 = {}
+        kvs[:'resque-worker'] = {}
+
+        begin
+          if ENV.key?('INSTANA_SERVICE_NAME')
+            kvs[:service] = ENV['INSTANA_SERVICE_NAME']
+          end
+          kvs[:'resque-worker'][:job] = job.payload['class'].to_s
+          kvs[:'resque-worker'][: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', 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/instrumentation/rest-client.rb

@@ -0,0 +1,34 @@
+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
+        # 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)
+      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.info "Instrumenting RestClient"
+  ::RestClient::Request.send(:include, ::Instana::Instrumentation::RestClientRequest)
+end

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

@@ -0,0 +1,45 @@
+module Instana
+  module Instrumentation
+    class SidekiqClient
+      def call(worker_class, msg, queue, _redis_pool)
+        kv_payload = { :'sidekiq-client' => {} }
+        kv_payload[:'sidekiq-client'][:queue] = queue
+        kv_payload[:'sidekiq-client'][:job] = worker_class
+        kv_payload[:'sidekiq-client'][:retry] = msg['retry'].to_s
+        ::Instana.tracer.log_entry(:'sidekiq-client', kv_payload)
+
+        # Temporary until we move connection collection to redis
+        # instrumentation
+        Sidekiq.redis_pool.with do |client|
+          opts = client.respond_to?(:connection) ? client.connection : client.client.options
+          kv_payload[:'sidekiq-client'][:'redis-url'] = "#{opts[:host]}:#{opts[:port]}"
+        end
+
+        context = ::Instana.tracer.context
+        if context
+          msg['X-Instana-T'] = context.trace_id_header
+          msg['X-Instana-S'] = context.span_id_header
+        end
+
+        result = yield
+
+        kv_payload[:'sidekiq-client'][:job_id] = result['jid']
+        result
+      rescue => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:'sidekiq-client', kv_payload)
+      end
+    end
+  end
+end
+
+if defined?(::Sidekiq) && ::Instana.config[:'sidekiq-client'][:enabled]
+  ::Sidekiq.configure_client do |cfg|
+    cfg.client_middleware do |chain|
+      ::Instana.logger.info "Instrumenting Sidekiq client"
+      chain.add ::Instana::Instrumentation::SidekiqClient
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Instana
+  module Instrumentation
+    class SidekiqWorker
+      def call(_worker, msg, _queue)
+        kv_payload = { :'sidekiq-worker' => {} }
+        kv_payload[:'sidekiq-worker'][:job_id] = msg['jid']
+        kv_payload[:'sidekiq-worker'][:queue] = msg['queue']
+        kv_payload[:'sidekiq-worker'][:job] = msg['class']
+        kv_payload[:'sidekiq-worker'][:retry] = msg['retry'].to_s
+
+        # Temporary until we move connection collection to redis
+        # instrumentation
+        Sidekiq.redis_pool.with do |client|
+          opts = client.respond_to?(:connection) ? client.connection : client.client.options
+          kv_payload[:'sidekiq-worker'][:'redis-url'] = "#{opts[:host]}:#{opts[:port]}"
+        end
+
+        if ENV.key?('INSTANA_SERVICE_NAME')
+          kv_payload[:service] = ENV['INSTANA_SERVICE_NAME']
+        end
+
+        context = {}
+        if msg.key?('X-Instana-T')
+          trace_id = msg.delete('X-Instana-T')
+          span_id = msg.delete('X-Instana-S')
+          context[:trace_id] = ::Instana::Util.header_to_id(trace_id)
+          context[:span_id] = ::Instana::Util.header_to_id(span_id) if span_id
+        end
+
+        ::Instana.tracer.log_start_or_continue(
+          :'sidekiq-worker', kv_payload, context
+        )
+
+        yield
+      rescue => e
+        kv_payload[:'sidekiq-worker'][:error] = true
+        ::Instana.tracer.log_info(kv_payload)
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_end(:'sidekiq-worker', {}) if ::Instana.tracer.tracing?
+      end
+    end
+  end
+end
+
+if defined?(::Sidekiq) && ::Instana.config[:'sidekiq-worker'][:enabled]
+  ::Sidekiq.configure_server do |cfg|
+    cfg.server_middleware do |chain|
+      ::Instana.logger.info "Instrumenting Sidekiq worker"
+      chain.add ::Instana::Instrumentation::SidekiqWorker
+    end
+  end
+end