app_perf_rpm 0.0.2

data/lib/app_perf_rpm/instruments/active_record/adapters/sqlite3.rb

@@ -0,0 +1,103 @@
+module AppPerfRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+        module Sqlite3
+          include AppPerfRpm::Utils
+
+          IGNORE_STATEMENTS = {
+            "SCHEMA" => true,
+            "EXPLAIN" => true,
+            "CACHE" => true
+          }
+
+          def ignore_trace?(name)
+            IGNORE_STATEMENTS[name.to_s] ||
+              (name && name.to_sym == :skip_logging) ||
+              name == 'ActiveRecord::SchemaMigration Load'
+          end
+
+          def exec_query_with_trace(sql, name = nil, binds = [])
+            if ::AppPerfRpm::Tracer.tracing?
+              if ignore_trace?(name)
+                exec_query_without_trace(sql, name, binds)
+              else
+                sanitized_sql = sanitize_sql(sql, :sqlite)
+
+                AppPerfRpm::Tracer.trace('activerecord', opts) do |span|
+                  span.options = {
+                    "adapter" => "postgresql",
+                    "query" => sanitized_sql,
+                    "name" => name
+                  }
+
+                  exec_query_without_trace(sql, name, binds)
+                end
+              end
+            else
+              exec_query_without_trace(sql, name, binds)
+            end
+          end
+
+          def exec_delete_with_trace(sql, name = nil, binds = [])
+            if ::AppPerfRpm::Tracer.tracing?
+              if ignore_trace?(name)
+                exec_delete_without_trace(sql, name, binds)
+              else
+                sanitized_sql = sanitize_sql(sql, :sqlite)
+
+                AppPerfRpm::Tracer.trace('activerecord', opts) do |span|
+                  span.options = {
+                    "adapter" => "postgresql",
+                    "query" => sanitized_sql,
+                    "name" => name
+                  }
+
+                  exec_delete_without_trace(sql, name, binds)
+                end
+              end
+            else
+              exec_delete_without_trace(sql, name, binds)
+            end
+          end
+
+          def exec_insert_with_trace(sql, name = nil, binds = [], *args)
+            if ::AppPerfRpm::Tracer.tracing?
+              if ignore_trace?(name)
+                exec_insert_without_trace(sql, name, binds, *args)
+              else
+                sanitized_sql = sanitize_sql(sql, :sqlite)
+
+                AppPerfRpm::Tracer.trace('activerecord', opts) do |span|
+                  span.options = {
+                    "adapter" => "postgresql",
+                    "query" => sanitized_sql,
+                    "name" => name
+                  }
+
+                  exec_insert_without_trace(sql, name, binds, *args)
+                end
+              end
+            else
+              exec_insert_without_trace(sql, name, binds, *args)
+            end
+          end
+
+          def begin_db_transaction_with_trace
+            if ::AppPerfRpm::Tracer.tracing?
+              AppPerfRpm::Tracer.trace('activerecord', opts) do |span|
+                span.options = {
+                  "adapter" => "postgresql",
+                  "query" => "BEGIN"
+                }
+                begin_db_transaction_without_trace
+              end
+            else
+              begin_db_transaction_without_trace
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/instruments/active_record.rb

@@ -0,0 +1,57 @@
+module AppPerfRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:active_record][:enabled] &&
+  defined?(::ActiveRecord)
+  AppPerfRpm.logger.info "Initializing activerecord tracer."
+
+  if defined?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+    require 'app_perf_rpm/instruments/active_record/adapters/sqlite3'
+    ::ActiveRecord::ConnectionAdapters::SQLite3Adapter.send(:include,
+      ::AppPerfRpm::Instruments::ActiveRecord::Adapters::Sqlite3
+    )
+    ::ActiveRecord::ConnectionAdapters::SQLite3Adapter.class_eval do
+      alias_method :exec_query_without_trace, :exec_query
+      alias_method :exec_query, :exec_query_with_trace
+
+      alias_method :exec_delete_without_trace, :exec_delete
+      alias_method :exec_delete, :exec_delete_with_trace
+    end
+  end
+
+  if defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+    require 'app_perf_rpm/instruments/active_record/adapters/postgresql'
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include,
+      ::AppPerfRpm::Instruments::ActiveRecord::Adapters::Postgresql
+    )
+
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      alias_method :exec_query_without_trace, :exec_query
+      alias_method :exec_query, :exec_query_with_trace
+
+      alias_method :exec_delete_without_trace, :exec_delete
+      alias_method :exec_delete, :exec_delete_with_trace
+    end
+  end
+
+  if defined?(::ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+    require 'app_perf_rpm/instruments/active_record/adapters/mysql2'
+    ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include,
+      ::AppPerfRpm::Instruments::ActiveRecord::Adapters::Mysql2
+    )
+
+    ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.class_eval do
+      if (::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR == 0) ||
+          ::ActiveRecord::VERSION::MAJOR == 2
+        alias_method :execute_without_trace, :execute
+        alias_method :execute, :execute_with_trace
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/instruments/activerecord_import.rb

@@ -0,0 +1,47 @@
+module AppPerfRpm
+  module Instruments
+    module ActiveRecordImport
+      include AppPerfRpm::Utils
+
+      def insert_many_with_trace( sql, values, *args )
+        if ::AppPerfRpm::Tracer.tracing?
+          sql_copy = sql.dup
+          base_sql, post_sql = if sql_copy.dup.is_a?( String )
+            [sql_copy, '']
+          elsif sql.is_a?( Array )
+            [sql_copy.shift, sql_copy.join( ' ' )]
+          end
+
+          adapter = ::ActiveRecord::Base.connection_config[:adapter]
+
+          sanitized_sql = sanitize_sql(base_sql + values.join( ',' ) + post_sql, adapter)
+
+          AppPerfRpm::Tracer.trace('activerecord') do |span|
+            span.options = {
+              "adapter" => adapter,
+              "query" => sanitized_sql,
+              "name" => self.class.name
+            }
+
+            insert_many_without_trace(sql, values, *args)
+          end
+        else
+          insert_many_without_trace(sql, values, *args)
+        end
+      end
+    end
+  end
+end
+
+
+if ::AppPerfRpm.configuration.instrumentation[:active_record_import][:enabled] &&
+  defined?(ActiveRecord::Import::PostgreSQLAdapter)
+  AppPerfRpm.logger.info "Initializing activerecord-import tracer."
+
+  ActiveRecord::Import::PostgreSQLAdapter.send(:include, AppPerfRpm::Instruments::ActiveRecordImport)
+
+  ActiveRecord::Import::PostgreSQLAdapter.class_eval do
+    alias_method :insert_many_without_trace, :insert_many
+    alias_method :insert_many, :insert_many_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/emque_consuming.rb

@@ -0,0 +1,31 @@
+module AppPerfRpm
+  module Instruments
+    module EmqueConsuming
+      module Router
+        def route_with_trace(topic, type, message)
+          action = type.to_s.split(".").last
+
+          ::AppPerfRpm::Tracer.start_trace("emque-consuming", opts) do |span|
+            span.controller = topic
+            span.action = action
+            span.url = "/#{topic}/#{action}"
+            span.domain = Socket.gethostname
+
+            route_without_trace(topic, type, message)
+          end
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:emque_consuming][:enabled] && defined?(Emque::Consuming)
+  AppPerfRpm.logger.info "Initializing emque-consuming tracer."
+
+  Emque::Consuming::Router.send(:include, AppPerfRpm::Instruments::EmqueConsuming::Router)
+
+  Emque::Consuming::Router.class_eval do
+    alias_method :route_without_trace, :route
+    alias_method :route, :route_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/faraday.rb

@@ -0,0 +1,37 @@
+module AppPerfRpm
+  module Instruments
+    module FaradayConnection
+      def run_request_with_trace(method, url, body, headers, &block)
+        if ::AppPerfRpm.tracing?
+          span = ::AppPerfRpm::Tracer.start_span("faraday")
+          result = run_request_without_trace(method, url, body, headers, &block)
+          span.finish
+          span.options = {
+            "middleware" => @builder.handlers,
+            "protocol" => @url_prefix.scheme,
+            "remote_host" => @url_prefix.host,
+            "remote_port" => @url_prefix.port,
+            "service_url" => url,
+            "http_method" => method,
+            "http_status" => result.status
+          }
+          span.submit(opts)
+
+          result
+        else
+          run_request_without_trace(method, url, body, headers, &block)
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:faraday][:enabled] && defined?(::Faraday)
+  ::AppPerfRpm.logger.info "Initializing faraday tracer."
+
+  ::Faraday::Connection.send(:include, AppPerfRpm::Instruments::FaradayConnection)
+  ::Faraday::Connection.class_eval do
+    alias_method :run_request_without_trace, :run_request
+    alias_method :run_request, :run_request_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/net_http.rb

@@ -0,0 +1,36 @@
+if ::AppPerfRpm.configuration.instrumentation[:net_http][:enabled] && defined?(Net::HTTP)
+  ::AppPerfRpm.logger.info "Initializing net-http tracer."
+
+  Net::HTTP.class_eval do
+    def request_with_trace(*args, &block)
+      if ::AppPerfRpm::Tracer.tracing?
+        span = ::AppPerfRpm::Tracer.start_span("net-http")
+
+        if args.length && args[0]
+          req = args[0]
+          span.options["protocol"] = use_ssl? ? "https" : "http"
+          span.options["path"] = req.path
+          span.options["method"] = req.method
+          span.options["remote_host"] = addr_port
+        end
+
+        response = request_without_trace(*args, &block)
+
+        span.finish
+        span.options["status"] = response.code
+
+        if (response.code.to_i >= 300 || response.code.to_i <= 308) && response.header["Location"]
+          span.options["location"] = response.header["Location"]
+        end
+
+        trace.submit(opts)
+      else
+        response = request_without_trace(*args, &block)
+      end
+      response
+    end
+
+    alias request_without_trace request
+    alias request request_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/rack.rb

@@ -0,0 +1,41 @@
+module AppPerfRpm
+  module Instruments
+    class Rack
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        req = ::Rack::Request.new(env)
+
+        incoming_trace = env["HTTP_X_APP_PERF_TRACE"]
+        incoming_trace_id = env["HTTP_X_APP_PERF_TRACE_ID"]
+
+        opts = {}
+        if incoming_trace.to_s.eql?("1")
+          opts.merge!("trace_id" => incoming_trace_id)
+        end
+
+        if ignore_path?(req.path)
+          @status, @headers, @response = @app.call(env)
+        else
+          AppPerfRpm::Tracer.start_trace("rack", opts) do |span|
+            span.type = "web"
+            span.domain = req.host
+            span.url = req.path
+
+            @status, @headers, @response = @app.call(env)
+          end
+        end
+
+        [@status, @headers, @response]
+      end
+
+      def ignore_path?(path)
+        path.to_s =~ /\/assets/
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/instruments/rack_middleware.rb

@@ -0,0 +1,69 @@
+module AppPerfRpm
+  module Instruments
+    class RackMiddleware
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+        self.extend(AppPerfRpmRack)
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      module AppPerfRpmRack
+        def self.extended(object)
+          object.singleton_class.class_eval do
+            alias_method :call_without_tracing, :call
+            alias_method :call, :call_with_tracing
+            public :call
+          end
+
+          object.instance_eval do
+            recursive_app_perf
+          end
+        end
+
+        private
+
+        def recursive_app_perf
+          return if @app.nil?
+          return unless @app.respond_to?(:call)
+          @app.extend(AppPerfRpmRack)
+        end
+
+        def call_with_tracing(env)
+          req = ::Rack::Request.new(env)
+
+          incoming_trace = env["HTTP_X_APP_PERF_TRACE"]
+          incoming_trace_id = env["HTTP_X_APP_PERF_TRACE_ID"]
+
+          opts = {}
+          if incoming_trace.to_s.eql?("1")
+            opts.merge!("trace_id" => incoming_trace_id)
+          end
+
+          if !::AppPerfRpm::Tracer.tracing? || ignore_path?(req.path)
+            @status, @headers, @response = @app.call_without_tracing(env)
+          else
+            AppPerfRpm::Tracer.trace("rack-middleware", opts) do |span|
+              span.type = "web"
+              span.domain = req.host
+              span.url = req.path
+              span.options["class"] = self.class.name
+
+              @status, @headers, @response = @app.call_without_tracing(env)
+            end
+          end
+
+          [@status, @headers, @response]
+        end
+
+        def ignore_path?(path)
+          path.to_s =~ /\/assets/
+        end
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/instruments/redis.rb

@@ -0,0 +1,39 @@
+module AppPerf
+  module Instruments
+    module Redis
+      def call_with_trace(command, &block)
+        if ::AppPerfRpm::Tracer.tracing?
+          ::AppPerfRpm::Tracer.trace("redis") do |span|
+            call_without_trace(command, &block)
+          end
+        else
+          call_without_trace(command, &block)
+        end
+      end
+
+      def call_pipeline_with_trace(pipeline)
+        if ::AppPerfRpm::Tracer.tracing?
+          ::AppPerfRpm::Tracer.trace("redis") do |span|
+            call_pipeline_without_trace(pipeline)
+          end
+        else
+          call_pipeline_without_trace(pipeline)
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:redis][:enabled] &&
+  defined?(::Redis)
+  ::AppPerfRpm.logger.info "Initializing redis tracer."
+
+  ::Redis::Client.send(:include, ::AppPerf::Instruments::Redis)
+
+  ::Redis::Client.class_eval do
+    alias_method :call_without_trace, :call
+    alias_method :call, :call_with_trace
+    alias_method :call_pipeline_without_trace, :call_pipeline
+    alias_method :call_pipeline, :call_pipeline_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/sequel.rb

@@ -0,0 +1,92 @@
+module AppPerfRpm
+  module Instruments
+    module Sequel
+      def sanitize_sql(sql)
+        regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
+        sql.to_s.gsub(regexp, '?')
+      end
+
+      def parse_opts(sql, opts)
+        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
+          db_opts = @opts
+        elsif @pool
+          db_opts = @pool.db.opts
+        else
+          db_opts = @db.opts
+        end
+
+        if ::Sequel::VERSION > '4.36.0' && !sql.is_a?(String)
+          # In 4.37.0, sql was converted to a prepared statement object
+          sql = sql.prepared_sql unless sql.is_a?(Symbol)
+        end
+
+        {
+          "name" => opts[:type],
+          "query" => sanitize_sql(sql),
+          "database" => db_opts[:database],
+          "host" => db_opts[:host],
+          "adapter" => db_opts[:adapter]
+        }
+      end
+    end
+
+    module SequelDatabase
+      include ::AppPerfRpm::Instruments::Sequel
+
+      def run_with_trace(sql, options = ::Sequel::OPTS)
+        if ::AppPerfRpm::Tracer.tracing?
+          begin
+            ::AppPerfRpm::Tracer.trace("sequel") do |span|
+              span.options = parse_opts(sql, options)
+
+              run_without_trace(sql, options)
+            end
+          rescue => e
+            ::AppPerfRpm.logger.error e.inspect
+            raise
+          end
+        else
+          run_without_trace(sql, options)
+        end
+      end
+    end
+
+    module SequelDataset
+      include ::AppPerfRpm::Instruments::Sequel
+
+      def execute_with_trace(sql, options = ::Sequel::OPTS, &block)
+        if ::AppPerfRpm::Tracer.tracing?
+          begin
+            ::AppPerfRpm::Tracer.trace("sequel", opts) do |span|
+              span.options = parse_opts(sql, options)
+
+              execute_without_trace(sql, options, &block)
+            end
+          rescue => e
+            ::AppPerfRpm.logger.error e.inspect
+            raise
+          end
+        else
+          execute_without_trace(sql, options, &block)
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:sequel][:enabled] && defined?(::Sequel)
+  ::AppPerfRpm.logger.info "Initializing sequel tracer."
+
+  ::Sequel::Database.send(:include, AppPerfRpm::Instruments::SequelDatabase)
+  ::Sequel::Dataset.send(:include, AppPerfRpm::Instruments::SequelDataset)
+
+  ::Sequel::Database.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+
+  ::Sequel::Dataset.class_eval do
+    alias_method :execute_without_trace, :execute
+    alias_method :execute, :execute_with_trace
+  end
+end

data/lib/app_perf_rpm/instruments/sidekiq.rb

@@ -0,0 +1,55 @@
+module AppPerfRpm
+  class SidekiqServer
+    def call(*args)
+      worker, msg, queue = args
+
+      result = AppPerfRpm::Tracer.start_trace("sidekiq-worker") do |span|
+        span.type = "job"
+        span.controller = "Sidekiq_#{queue}"
+        span.action = msg["wrapped"]
+        span.url = "/sidekiq/#{queue}/#{msg['wrapped']}"
+        span.domain = Socket.gethostname
+        span.options = {
+          "job_name" => worker.class.to_s,
+          "queue" => queue
+        }
+
+        yield
+      end
+
+      result
+    end
+  end
+
+  class SidekiqClient
+    def call(*args)
+      if ::AppPerfRpm::Tracer.tracing?
+        worker, msg, queue = args
+
+        result = AppPerfRpm::Tracer.trace("sidekiq-client") do |span|
+          yield
+        end
+      else
+        result = yield
+      end
+      result
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:sidekiq][:enabled] &&
+  defined?(::Sidekiq)
+  AppPerfRpm.logger.info "Initializing sidekiq tracer."
+
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::AppPerfRpm::SidekiqServer
+    end
+  end
+
+  ::Sidekiq.configure_client do |config|
+    config.client_middleware do |chain|
+      chain.add ::AppPerfRpm::SidekiqClient
+    end
+  end
+end

data/lib/app_perf_rpm/instruments/sinatra.rb

@@ -0,0 +1,68 @@
+module AppPerfRpm
+  module Instruments
+    module Sinatra
+      module Base
+        def dispatch_with_trace
+          if ::AppPerfRpm::Tracer.tracing?
+            ::AppPerfRpm::Tracer.trace("sinatra") do |span|
+              span.controller = self.class.to_s
+              span.action = env["PATH_INFO"]
+
+              dispatch_without_trace
+            end
+          else
+            dispatch_without_trace
+          end
+        end
+
+        def handle_exception_with_trace(boom)
+          handle_exception_without_trace(boom)
+        end
+      end
+
+      module Templates
+        def render_with_trace(engine, data, options = {}, locals = {}, &block)
+          if ::AppPerfRpm::Tracer.tracing?
+            name = data
+
+            ::AppPerfRpm::Tracer.trace("sinatra") do |span|
+              span.options = {
+                "engine" => engine,
+                "name" => name,
+                "type" => "render",
+                "file" => __FILE__,
+                "line_number" => __LINE__
+              }
+
+              render_without_trace(engine, data, options, locals, &block)
+            end
+          else
+            render_without_trace(engine, data, options, locals, &block)
+          end
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:sinatra][:enabled] &&
+  defined?(::Sinatra)
+  ::AppPerfRpm.logger.info "Initializing sinatra tracer."
+
+  ::Sinatra::Base.use AppPerfRpm::Instruments::Rack
+
+  unless defined?(::Padrino)
+    ::Sinatra::Base.send(:include, ::AppPerfRpm::Instruments::Sinatra::Base)
+    ::Sinatra::Base.class_eval do
+      alias_method :dispatch_without_trace, :dispatch!
+      alias_method :dispatch!, :dispatch_with_trace
+      alias_method :handle_exception_without_trace, :handle_exception!
+      alias_method :handle_exception!, :handle_exception_with_trace
+    end
+
+    ::Sinatra::Templates.send(:include, ::AppPerfRpm::Instruments::Sinatra::Templates)
+    ::Sinatra::Base.class_eval do
+      alias_method :render_without_trace, :render
+    end
+  end
+end