instana 1.10.1-java

data/lib/instana/frameworks/instrumentation/mysql_adapter.rb

@@ -0,0 +1,56 @@
+module Instana
+  module Instrumentation
+    module MysqlAdapter
+      IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE).freeze
+      EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
+
+      # This module supports instrumenting ActiveRecord with the mysql2 adapter.
+      #
+      def self.included(klass)
+        if ActiveRecord::VERSION::STRING >= '3.2'
+          Instana::Util.method_alias(klass, :exec_query)
+
+          @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
+        end
+      end
+
+      # Collect up this DB connection info for reporting.
+      #
+      # @param sql [String]
+      # @return [Hash] Hash of collected KVs
+      #
+      def collect(sql)
+        payload = { :activerecord => {} }
+        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        payload[:activerecord][:adapter] = @config[:adapter]
+        payload[:activerecord][:host] = @config[:host]
+        payload[:activerecord][:db] = @config[:database]
+        payload[:activerecord][:username] = @config[:username]
+        payload
+      end
+
+      # In the spirit of ::ActiveRecord::ExplainSubscriber.ignore_payload?  There are
+      # only certain calls that we're interested in tracing.  e.g. No use to instrument
+      # framework caches.
+      #
+      # @param payload [String]
+      # @return [Boolean]
+      #
+      def ignore_payload?(name, sql)
+        IGNORED_PAYLOADS.include?(name) || sql !~ EXPLAINED_SQLS
+      end
+
+      def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
+        if !::Instana.tracer.tracing? || ignore_payload?(name, sql) ||
+            ::Instana.tracer.current_span[:n] == :activerecord
+          return exec_query_without_instana(sql, name, binds, *args)
+        end
+
+        kv_payload = collect(sql)
+        ::Instana.tracer.trace(:activerecord, kv_payload) do
+          exec_query_without_instana(sql, name, binds, *args)
+        end
+      end
+    end
+  end
+end

data/lib/instana/frameworks/instrumentation/postgresql_adapter.rb

@@ -0,0 +1,71 @@
+module Instana
+  module Instrumentation
+    module PostgreSQLAdapter
+      IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE).freeze
+      EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
+
+      # This module supports instrumenting ActiveRecord with the postgresql adapter.  Only
+      # versions >= 3.1 are supported.
+      #
+      def self.included(klass)
+        if (::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR > 0) ||
+             ::ActiveRecord::VERSION::MAJOR >= 4
+
+          # ActiveRecord 3.1 and up
+          Instana::Util.method_alias(klass, :exec_query)
+          Instana::Util.method_alias(klass, :exec_delete)
+
+          @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
+        end
+      end
+
+      # Collect up this DB connection info for reporting.
+      #
+      # @param sql [String]
+      # @return [Hash] Hash of collected KVs
+      #
+      def collect(sql)
+        payload = { :activerecord => {} }
+        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        payload[:activerecord][:adapter] = @config[:adapter]
+        payload[:activerecord][:host] = @config[:host]
+        payload[:activerecord][:db] = @config[:database]
+        payload[:activerecord][:username] = @config[:username]
+        payload
+      end
+
+      # In the spirit of ::ActiveRecord::ExplainSubscriber.ignore_payload?  There are
+      # only certain calls that we're interested in tracing.  e.g. No use to instrument
+      # framework caches.
+      #
+      # @param payload [String]
+      # @return [Boolean]
+      #
+      def ignore_payload?(name, sql)
+        IGNORED_PAYLOADS.include?(name) || sql !~ EXPLAINED_SQLS
+      end
+
+      def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
+        if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
+          return exec_query_without_instana(sql, name, binds, *args)
+        end
+
+        kv_payload = collect(sql)
+        ::Instana.tracer.trace(:activerecord, kv_payload) do
+          exec_query_without_instana(sql, name, binds, *args)
+        end
+      end
+
+      def exec_delete_with_instana(sql, name = nil, binds = [])
+        if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
+          return exec_delete_without_instana(sql, name, binds)
+        end
+
+        kv_payload = collect(sql)
+        ::Instana.tracer.trace(:activerecord, kv_payload) do
+          exec_delete_without_instana(sql, name, binds)
+        end
+      end
+    end
+  end
+end

data/lib/instana/frameworks/rails.rb

@@ -0,0 +1,42 @@
+require "instana/rack"
+
+if defined?(::Rails)
+
+  if ::Rails::VERSION::MAJOR < 3
+    ::Rails.configuration.after_initialize do
+      # 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|
+          # 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
+
+        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
+  end
+end

data/lib/instana/frameworks/roda.rb

@@ -0,0 +1,6 @@
+require "instana/rack"
+
+if defined?(::Roda)
+  ::Instana.logger.info "Instrumenting Roda"
+  Roda.use ::Instana::Rack
+end

data/lib/instana/frameworks/sinatra.rb

@@ -0,0 +1,9 @@
+require "instana/rack"
+
+# This instrumentation will insert Rack into Sinatra _and_ Padrino since
+# the latter is based on Sinatra
+
+if defined?(::Sinatra)
+  ::Instana.logger.info "Instrumenting Sinatra"
+  ::Sinatra::Base.use ::Instana::Rack
+end

data/lib/instana/helpers.rb

@@ -0,0 +1,40 @@
+module Instana
+  module Helpers
+    EUM_SNIPPET= (File.read(File.dirname(__FILE__) + '/eum/eum.js.erb')).freeze
+    EUM_TEST_SNIPPET= (File.read(File.dirname(__FILE__) + '/eum/eum-test.js.erb')).freeze
+
+    class << self
+
+      # Returns a processed javascript snippet to be placed within the HEAD tag of an HTML page.
+      #
+      def eum_snippet(api_key, kvs = {})
+        return nil if !::Instana.tracer.tracing?
+
+        ::Instana.config[:eum_api_key] = api_key
+        ::Instana.config[:eum_baggage] = kvs
+
+        ERB.new(EUM_SNIPPET).result
+      rescue => e
+        Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        Instana.logger.debug { e.backtrace.join("\r\n") }
+        return nil
+      end
+
+      # Returns a processed javascript snippet to be placed within the HEAD tag of an HTML page.
+      # This one is used for testing only
+      #
+      def eum_test_snippet(api_key, kvs = {})
+        return nil if !::Instana.tracer.tracing?
+
+        ::Instana.config[:eum_api_key] = api_key
+        ::Instana.config[:eum_baggage] = kvs
+
+        ERB.new(EUM_TEST_SNIPPET).result
+      rescue => e
+        Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        Instana.logger.debug { e.backtrace.join("\r\n") }
+        return nil
+      end
+    end
+  end
+end

data/lib/instana/instrumentation.rb

@@ -0,0 +1,21 @@
+module Instana
+  AUTOLOAD_DIRECTORIES = [:instrumentation, :frameworks].freeze
+end
+
+
+if !ENV.key?('INSTANA_DISABLE_AUTO_INSTR') || ENV['INSTANA_DISABLE_AUTO_INSTR'] === 'false'
+  #
+  # Load all of the files in the specified subdirectories
+  #
+  ::Instana::AUTOLOAD_DIRECTORIES.each do |d|
+    pattern = File.join(File.dirname(__FILE__), d.to_s, '*.rb')
+    Dir.glob(pattern) do |f|
+      begin
+        require f
+      rescue => e
+        Instana.logger.error "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        Instana.logger.debug { e.backtrace.join("\r\n") }
+      end
+    end
+  end
+end

data/lib/instana/instrumentation/dalli.rb

@@ -0,0 +1,78 @@
+module Instana
+  module Instrumentation
+    module Dalli
+      def self.included(klass)
+        ::Instana::Util.method_alias(klass, :perform)
+        ::Instana::Util.method_alias(klass, :get_multi)
+      end
+
+      def perform_with_instana(*args, &blk)
+        if !::Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:memcache)
+          do_skip = true
+          return perform_without_instana(*args, &blk)
+        end
+
+        op, key, *_opts = args
+
+        entry_payload = { :memcache => {} }
+        entry_payload[:memcache][:namespace] = @options[:namespace] if @options.key?(:namespace)
+        entry_payload[:memcache][:command] = op
+        entry_payload[:memcache][:key] = key
+
+        ::Instana.tracer.log_entry(:memcache, entry_payload)
+        result = perform_without_instana(*args, &blk)
+
+        kv_payload = { :memcache => {}}
+        if op == :get
+          kv_payload[:memcache][:hit] = result ? 1 : 0
+        end
+        result
+      rescue => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:memcache, kv_payload) unless do_skip
+      end
+
+      def get_multi_with_instana(*keys)
+        entry_payload = { :memcache => {} }
+        entry_payload[:memcache][:namespace] = @options[:namespace] if @options.key?(:namespace)
+        entry_payload[:memcache][:command] = :get_multi
+        entry_payload[:memcache][:keys] = keys.flatten.join(", ")
+
+        ::Instana.tracer.log_entry(:memcache, entry_payload)
+        result = get_multi_without_instana(*keys)
+
+        exit_payload = { :memcache => {} }
+        exit_payload[:memcache][:hits] = result.length
+        result
+      rescue => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:memcache, exit_payload)
+      end
+    end
+
+    module DalliServer
+      def self.included(klass)
+        ::Instana::Util.method_alias(klass, :request)
+      end
+
+      def request_with_instana(op, *args)
+        if ::Instana.tracer.tracing? || ::Instana.tracer.tracing_span?(:memcache)
+          info_payload = { :memcache => {} }
+          info_payload[:memcache][:server] = "#{@hostname}:#{@port}"
+          ::Instana.tracer.log_info(info_payload)
+        end
+        request_without_instana(op, *args)
+      end
+    end
+  end
+end
+
+if defined?(::Dalli) && ::Instana.config[:dalli][:enabled]
+  ::Instana.logger.info "Instrumenting Dalli"
+  ::Dalli::Client.send(:include, ::Instana::Instrumentation::Dalli)
+  ::Dalli::Server.send(:include, ::Instana::Instrumentation::DalliServer)
+end

data/lib/instana/instrumentation/excon.rb

@@ -0,0 +1,74 @@
+if defined?(::Excon) && ::Instana.config[:excon][:enabled]
+  module Instana
+    module Instrumentation
+      class Excon < ::Excon::Middleware::Base
+        def request_call(datum)
+          return @stack.request_call(datum) unless ::Instana.tracer.tracing?
+
+          payload = { :http => {} }
+          path = datum[:path].split('?').first
+          payload[:http][:url] = "#{datum[:connection].instance_variable_get(:@socket_key)}#{path}"
+          payload[:http][:method] = datum[:method] if datum.key?(:method)
+
+          if datum[:pipeline] == true
+            # Pass the context along in the datum so we get back on response
+            # and can close out the async span
+            datum[:instana_span] = ::Instana.tracer.log_async_entry(:excon, payload)
+            t_context = datum[:instana_span].context
+          else
+            ::Instana.tracer.log_entry(:excon, payload)
+            t_context = ::Instana.tracer.context
+          end
+
+          # Set request headers; encode IDs as hexadecimal strings
+          datum[:headers]['X-Instana-T'] = t_context.trace_id_header
+          datum[:headers]['X-Instana-S'] = t_context.span_id_header
+
+          @stack.request_call(datum)
+        end
+
+        def error_call(datum)
+          return @stack.error_call(datum) unless ::Instana.tracer.tracing?
+
+          if datum[:pipeline] == true
+            ::Instana.tracer.log_async_error(datum[:error], datum[:instana_span])
+          else
+            ::Instana.tracer.log_error(datum[:error])
+          end
+          @stack.error_call(datum)
+        end
+
+        def response_call(datum)
+          # FIXME: Will connect exceptions call a response?
+          #
+          return @stack.response_call(datum) unless ::Instana.tracer.tracing?
+
+          result =  @stack.response_call(datum)
+
+          status = datum[:status]
+          if !status && datum.key?(:response) && datum[:response].is_a?(Hash)
+            status = datum[:response][:status]
+          end
+
+          if 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
+
+          if datum[:pipeline] == true
+            # Pickup context of this async span from datum[:instana_span]
+            ::Instana.tracer.log_async_exit(:excon, { :http => {:status => status } }, datum[:instana_span])
+          else
+            ::Instana.tracer.log_exit(:excon, { :http => {:status => status } })
+          end
+          result
+        end
+      end
+    end
+  end
+
+  ::Instana.logger.info "Instrumenting Excon"
+  ::Excon.defaults[:middlewares].unshift(::Instana::Instrumentation::Excon)
+end
+

data/lib/instana/instrumentation/grpc.rb

@@ -0,0 +1,84 @@
+call_types = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
+
+if defined?(GRPC::ActiveCall) && ::Instana.config[:grpc][:enabled]
+  call_types.each do |call_type|
+    GRPC::ClientStub.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{call_type}_with_instana(method, *others, **options)
+        kvs = { rpc: {} }
+
+        unless ::Instana.tracer.tracing?
+          return #{call_type}_without_instana(method, *others, **options)
+        end
+
+        kvs[:rpc][:flavor] = :grpc
+        kvs[:rpc][:host] = @host
+        kvs[:rpc][:call] = method
+        kvs[:rpc][:call_type] = :#{call_type}
+
+        ::Instana.tracer.log_entry(:'rpc-client', kvs)
+
+        context = ::Instana.tracer.context
+        if context
+          options[:metadata] = (options[:metadata] || {}).merge(
+            'x-instana-t' => context.trace_id_header,
+            'x-instana-s' => context.span_id_header
+          )
+        end
+
+        #{call_type}_without_instana(method, *others, **options)
+      rescue => e
+        kvs[:rpc][:error] = true
+        ::Instana.tracer.log_info(kvs)
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:'rpc-client', {})
+      end
+
+      alias #{call_type}_without_instana #{call_type}
+      alias #{call_type} #{call_type}_with_instana
+    RUBY
+  end
+  ::Instana.logger.info 'Instrumenting GRPC client'
+end
+
+if defined?(GRPC::RpcDesc) && ::Instana.config[:grpc][:enabled]
+  call_types.each do |call_type|
+    GRPC::RpcDesc.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def handle_#{call_type}_with_instana(active_call, mth, *others)
+        kvs = { rpc: {} }
+        metadata = active_call.metadata
+
+        incoming_context = {}
+        if metadata.key?('x-instana-t')
+          incoming_context[:trace_id]  = ::Instana::Util.header_to_id(metadata['x-instana-t'])
+          incoming_context[:span_id]   = ::Instana::Util.header_to_id(metadata['x-instana-s']) if metadata.key?('x-instana-s')
+          incoming_context[:level]     = metadata['x-instana-l'] if metadata.key?('x-instana-l')
+        end
+
+        kvs[:rpc][:flavor] = :grpc
+        kvs[:rpc][:host] = Socket.gethostname
+        kvs[:rpc][:call] = "/\#{mth.owner.service_name}/\#{name}"
+        kvs[:rpc][:call_type] = :#{call_type}
+        kvs[:rpc][:peer] = { address: active_call.peer }
+
+        ::Instana.tracer.log_start_or_continue(
+          :'rpc-server', kvs, incoming_context
+        )
+
+        handle_#{call_type}_without_instana(active_call, mth, *others)
+      rescue => e
+        kvs[:rpc][:error] = true
+        ::Instana.tracer.log_info(kvs)
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_end(:'rpc-server', {}) if ::Instana.tracer.tracing?
+      end
+
+      alias handle_#{call_type}_without_instana handle_#{call_type}
+      alias handle_#{call_type} handle_#{call_type}_with_instana
+    RUBY
+  end
+  ::Instana.logger.info 'Instrumenting GRPC server'
+end