instana 1.10.1-java

data/lib/instana/config.rb

@@ -0,0 +1,79 @@
+module Instana
+  class Config
+
+    def initialize
+      @config = {}
+      if ENV.key?('INSTANA_AGENT_HOST')
+        @config[:agent_host] = ENV['INSTANA_AGENT_HOST']
+      else
+        @config[:agent_host] = '127.0.0.1'
+      end
+      if ENV.key?('INSTANA_AGENT_PORT')
+        @config[:agent_port] = ENV['INSTANA_AGENT_PORT']
+      else
+        @config[:agent_port] = 42699
+      end
+
+      # Global on/off switch for prebuilt environments
+      # Setting this to false will disable this gem
+      # from doing anything.
+      @config[:enabled] = true
+
+      # Enable/disable metrics globally or individually (default: all enabled)
+      @config[:metrics] = { :enabled => true }
+      @config[:metrics][:gc]     = { :enabled => true }
+      @config[:metrics][:memory] = { :enabled => true }
+      @config[:metrics][:thread] = { :enabled => true }
+
+      # Enable/disable tracing (default: enabled)
+      @config[:tracing] = { :enabled => true }
+
+      if ENV.key?('INSTANA_DEBUG')
+        @config[:collector] = { :enabled => true, :interval => 3 }
+      else
+        @config[:collector] = { :enabled => true, :interval => 1 }
+      end
+
+      # EUM Related
+      @config[:eum_api_key] = nil
+      @config[:eum_baggage] = {}
+
+      # In Ruby, backtrace collection is very expensive so it's
+      # (unfortunately) disabled by default.  If you still want
+      # backtraces, it can be enabled with this config option.
+      # ::Instana.config[:collect_backtraces] = true
+      @config[:collect_backtraces] = false
+
+      @config[:action_controller]  = { :enabled => true }
+      @config[:action_view]        = { :enabled => true }
+      @config[:active_record]      = { :enabled => true }
+      @config[:dalli]              = { :enabled => true }
+      @config[:excon]              = { :enabled => true }
+      @config[:grpc]               = { :enabled => true }
+      @config[:nethttp]            = { :enabled => true }
+      @config[:redis]              = { :enabled => true }
+      @config[:'resque-client']    = { :enabled => true }
+      @config[:'resque-worker']    = { :enabled => true }
+      @config[:'rest-client']      = { :enabled => true }
+      @config[:'sidekiq-client']   = { :enabled => true }
+      @config[:'sidekiq-worker']   = { :enabled => true }
+    end
+
+    def [](key)
+      @config[key.to_sym]
+    end
+
+    def []=(key, value)
+      @config[key.to_sym] = value
+
+      if key == :enabled
+        # Configuring global enable/disable flag, then set the
+        # appropriate children flags.
+        @config[:metrics][:enabled] = value
+        @config[:tracing][:enabled] = value
+      end
+    end
+  end
+end
+
+::Instana.config = ::Instana::Config.new

data/lib/instana/eum/eum-test.js.erb

@@ -0,0 +1,16 @@
+<script nonce="68afd870-ae85-48c6-9689-9a5c359d5a1f">
+  (function(i,s,o,g,r,a,m){i['InstanaEumObject']=r;i[r]=i[r]||function(){
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+      m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+      })(window,document,'script','//eum-test-fullstack-0-us-west-2.instana.io/eum.min.js','ineum');
+
+  ineum('reportingUrl', '//eum-test-fullstack-0-us-west-2.instana.io');
+  ineum('apiKey', '<%=::Instana.config[:eum_api_key]%>');
+  ineum('traceId', '<%=::Instana.tracer.trace_id_header%>');
+
+  <% if !::Instana.config[:eum_baggage].empty? %>
+    <% ::Instana.config[:eum_baggage].each do |k, v| %>
+      ineum('meta', '<%=k%>', '<%=v%>');
+    <% end %>
+  <% end %>
+</script>

data/lib/instana/eum/eum.js.erb

@@ -0,0 +1,14 @@
+<script>
+  (function(i,s,o,g,r,a,m){i['InstanaEumObject']=r;i[r]=i[r]||function(){
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+      m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+      })(window,document,'script','//eum.instana.io/eum.min.js','ineum');
+  ineum('apiKey', '<%=::Instana.config[:eum_api_key]%>');
+  ineum('traceId', '<%=::Instana.tracer.trace_id_header%>');
+
+  <% if !::Instana.config[:eum_baggage].empty? %>
+    <% ::Instana.config[:eum_baggage].each do |k, v| %>
+      ineum('meta', '<%=k%>', '<%=v%>');
+    <% end %>
+  <% end %>
+</script>

data/lib/instana/frameworks/cuba.rb

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

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

@@ -0,0 +1,58 @@
+module Instana
+  module Instrumentation
+    module AbstractMysqlAdapter
+      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, :execute)
+
+          @@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 execute_with_instana(sql, name = nil)
+        tracing = ::Instana.tracer.tracing?
+        if !tracing || ignore_payload?(name, sql)
+          return execute_without_instana(sql, name)
+        elsif ::Instana.tracer.current_span[:n] == :activerecord
+          return execute_without_instana(sql, name)
+        end
+
+        kv_payload = collect(sql)
+        ::Instana.tracer.trace(:activerecord, kv_payload) do
+          execute_without_instana(sql, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+module Instana
+  module Instrumentation
+
+    # Contains the methods common to both ::Instana::Instrumentation::ActionController
+    # and ::Instana::Instrumentation::ActionControllerLegacy
+    #
+    module ActionControllerCommon
+
+      # Indicates whether a Controller rescue handler is in place.  If so, this affects
+      # error logging and reporting. (Hence the need for this method).
+      #
+      # @return [Boolean]
+      #
+      def has_rails_handler?(exception)
+        found = false
+        rescue_handlers.detect do |klass_name, _handler|
+          # Rescue handlers can be specified as strings or constant names
+          klass = self.class.const_get(klass_name) rescue nil
+          klass ||= klass_name.constantize rescue nil
+          found = exception.is_a?(klass) if klass
+        end
+        found
+      rescue => e
+        ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+        return false
+      end
+
+      # Render can be called with many options across the various supported
+      # versions of Rails.  This method attempts to make sense and provide
+      # insight into what is happening (rendering a layout, file, nothing,
+      # plaintext etc.)
+      def get_render_topic(opts)
+        if opts.key?(:layout)
+          case opts[:layout]
+          when FalseClass
+            name = "Without layout"
+          when String
+            name = opts[:layout]
+          when Proc
+            name = "Proc"
+          else
+            name = "Default"
+          end
+        end
+
+        return name if name
+
+        if opts.key?(:template)
+          name ||= opts[:template]
+        elsif opts.key?(:file)
+          name ||= opts[:file]
+        elsif opts.key?(:nothing)
+          name = "Nothing"
+        elsif opts.key?(:plain)
+          name = "Plaintext"
+        elsif opts.key?(:json)
+          name = "JSON"
+        elsif opts.key?(:xml)
+          name = "XML"
+        elsif opts.key?(:body)
+          name = "Raw"
+        elsif opts.key?(:js)
+          name = "Javascript"
+        end
+        name
+      end
+    end
+
+    # Used in ActionPack versions 5 and beyond, this module provides
+    # instrumentation for ActionController (a part of ActionPack)
+    #
+    module ActionController
+      include ::Instana::Instrumentation::ActionControllerCommon
+
+      # This is the Rails 5 version of the process_action method where we use prepend to
+      # instrument the class method instead of using the older alias_method_chain.
+      #
+      def process_action(*args)
+        kv_payload = { :actioncontroller => {} }
+        kv_payload[:actioncontroller][:controller] = self.class.name
+        kv_payload[:actioncontroller][:action] = action_name
+
+        ::Instana.tracer.log_entry(:actioncontroller, kv_payload)
+
+        super(*args)
+      rescue Exception => e
+        ::Instana.tracer.log_error(e) unless has_rails_handler?(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:actioncontroller)
+      end
+
+      # The Instana wrapper method for ActionController::Base.render
+      # for versions 5+.
+      #
+      def render(*args, &blk)
+        # Figure out what's being rendered
+        if args.length > 0 && args[0].is_a?(Hash)
+          name = get_render_topic(args[0])
+        end
+        name ||= "Default"
+
+        ::Instana.tracer.log_entry(:actionview, :actionview => { :name => name })
+
+        super(*args, &blk)
+      rescue Exception => e
+        ::Instana.tracer.log_error(e) unless has_rails_handler?(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:actionview)
+      end
+    end
+
+    # Used in ActionPack versions 4 and earlier, this module provides
+    # instrumentation for ActionController (a part of ActionPack)
+    #
+    module ActionControllerLegacy
+      include ::Instana::Instrumentation::ActionControllerCommon
+
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :process_action, :instana
+          alias_method_chain :render, :instana
+        end
+      end
+
+      # The Instana wrapper method for ActionController::Base.process_action
+      # for versions 3 and 4.
+      #
+      def process_action_with_instana(*args)
+        kv_payload = { :actioncontroller => {} }
+        kv_payload[:actioncontroller][:controller] = self.class.name
+        kv_payload[:actioncontroller][:action] = action_name
+
+        ::Instana.tracer.log_entry(:actioncontroller, kv_payload)
+
+        process_action_without_instana(*args)
+      rescue Exception => e
+        ::Instana.tracer.log_error(e) unless has_rails_handler?(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:actioncontroller)
+      end
+
+      # The Instana wrapper method for ActionController::Base.render
+      # for versions 3 and 4.
+      #
+      def render_with_instana(*args, &blk)
+        if args.length > 0 && args[0].is_a?(Hash)
+          name = get_render_topic(args[0])
+        end
+        name ||= "Default"
+        ::Instana.tracer.log_entry(:actionview, :actionview => { :name => name })
+        render_without_instana(*args, &blk)
+      rescue Exception => e
+        ::Instana.tracer.log_error(e) unless has_rails_handler?(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:actionview)
+      end
+    end
+  end
+end
+
+if defined?(::ActionController) && ::Instana.config[:action_controller][:enabled] && ::ActionPack::VERSION::MAJOR >= 2
+  ::Instana.logger.info "Instrumenting ActionController"
+  if ActionPack::VERSION::MAJOR >= 5
+    ::ActionController::Base.send(:prepend, ::Instana::Instrumentation::ActionController)
+  else
+    ::ActionController::Base.send(:include, ::Instana::Instrumentation::ActionControllerLegacy)
+  end
+end
+
+# ActionController::API was introduced in Ruby on Rails 5 but was originally an independent project before being
+# rolled into the Rails ActionPack.  In case, someone is using the independent project or potentially backported
+# the rails version to and older Ruby on Rails version, we only limit in a minimal way re: version checking.
+#
+# We allow ActionController::API instrumentation in version of Ruby on Rails 3 and higher.
+#
+if defined?(::ActionController::API) && ::Instana.config[:action_controller][:enabled] && ::ActionPack::VERSION::MAJOR >= 3
+  ::Instana.logger.info "Instrumenting ActionController API"
+  ::ActionController::API.send(:prepend, ::Instana::Instrumentation::ActionController)
+end

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

@@ -0,0 +1,43 @@
+module Instana
+  module Instrumentation
+    module ActionViewRenderer
+      def self.included(klass)
+        ::Instana::Util.method_alias(klass, :render_partial)
+        ::Instana::Util.method_alias(klass, :render_collection)
+      end
+
+      def render_partial_with_instana
+        kv_payload = { :render => {} }
+        kv_payload[:render][:type] = :partial
+        kv_payload[:render][:name] = @options[:partial].to_s if @options.is_a?(Hash)
+
+        ::Instana.tracer.log_entry(:render, kv_payload)
+        render_partial_without_instana
+      rescue Exception => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:render)
+      end
+
+      def render_collection_with_instana
+        kv_payload = { :render => {} }
+        kv_payload[:render][:type] = :collection
+        kv_payload[:render][:name] = @path.to_s
+
+        ::Instana.tracer.log_entry(:render, kv_payload)
+        render_collection_without_instana
+      rescue Exception => e
+        ::Instana.tracer.log_error(e)
+        raise
+      ensure
+        ::Instana.tracer.log_exit(:render)
+      end
+    end
+  end
+end
+
+if defined?(::ActionView) && ::Instana.config[:action_view][:enabled] && ::ActionPack::VERSION::STRING >= '3.1'
+  ::Instana.logger.info "Instrumenting ActionView"
+  ::ActionView::PartialRenderer.send(:include, ::Instana::Instrumentation::ActionViewRenderer)
+end

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

@@ -0,0 +1,27 @@
+
+require "instana/frameworks/instrumentation/mysql_adapter"
+require "instana/frameworks/instrumentation/abstract_mysql_adapter"
+require "instana/frameworks/instrumentation/mysql2_adapter"
+require "instana/frameworks/instrumentation/postgresql_adapter"
+
+if defined?(::ActiveRecord) && ::Instana.config[:active_record][:enabled]
+
+  # Mysql
+  if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+    ::Instana.logger.info "Instrumenting ActiveRecord (mysql)"
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, ::Instana::Instrumentation::MysqlAdapter)
+    ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:include, ::Instana::Instrumentation::AbstractMysqlAdapter)
+  end
+
+  # Mysql2
+  if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+    ::Instana.logger.info "Instrumenting ActiveRecord (mysql2)"
+    ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include, ::Instana::Instrumentation::Mysql2Adapter)
+  end
+
+  # Postgres
+  if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+    ::Instana.logger.info "Instrumenting ActiveRecord (postgresql)"
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, ::Instana::Instrumentation::PostgreSQLAdapter)
+  end
+end

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

@@ -0,0 +1,81 @@
+module Instana
+  module Instrumentation
+    module Mysql2Adapter
+      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)
+        # ActiveRecord 3.1 and up only (for now possibly)
+        if ActiveRecord::VERSION::STRING > '3.0'
+          Instana::Util.method_alias(klass, :exec_delete)
+          Instana::Util.method_alias(klass, :exec_insert)
+          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_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
+
+      def exec_insert_with_instana(sql, name = 'SQL', binds = [], *args)
+        if !::Instana.tracer.tracing? || ignore_payload?(name, sql)
+          return exec_insert_without_instana(sql, name, binds, *args)
+        end
+
+        kv_payload = collect(sql)
+        ::Instana.tracer.trace(:activerecord, kv_payload) do
+          exec_insert_without_instana(sql, name, binds, *args)
+        end
+      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