baseline_red_rpm 1.0.0

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+        module Sqlite3
+          include BaselineRedRpm::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, *args)
+            if ::BaselineRedRpm::Tracer.tracing?
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
+
+                span = BaselineRedRpm.tracer.start_span(name || 'SQL', tags: {
+                  "component" => "ActiveRecord",
+                  "span.kind" => "client",
+                  "db.statement" => sanitized_sql,
+                  "db.user" => connection_config.fetch(:username, 'unknown'),
+                  "db.instance" => connection_config.fetch(:database),
+                  "db.vendor" => adapter,
+                  "db.type" => "sql"
+                })
+                BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_record)
+              end
+            end
+
+            exec_query_without_trace(sql, name, *args)
+          rescue Exception => e
+            if span
+              span.set_tag('error', true)
+              span.log_error(e)
+            end
+            raise
+          ensure
+            span.finish if span
+          end
+
+          def exec_delete_with_trace(sql, name = nil, *args)
+            if ::BaselineRedRpm::Tracer.tracing?
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
+
+                span = BaselineRedRpm.tracer.start_span(name || 'SQL', tags: {
+                  "component" => "ActiveRecord",
+                  "span.kind" => "client",
+                  "db.statement" => sanitized_sql,
+                  "db.user" => connection_config.fetch(:username, 'unknown'),
+                  "db.instance" => connection_config.fetch(:database),
+                  "db.vendor" => adapter,
+                  "db.type" => "sql"
+                })
+                BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_record)
+              end
+            end
+
+            exec_delete_without_trace(sql, name, *args)
+          rescue Exception => e
+            if span
+              span.set_tag('error', true)
+              span.log_error(e)
+            end
+            raise
+          ensure
+            span.finish if span
+          end
+
+          def exec_insert_with_trace(sql, name = nil, *args)
+            if ::BaselineRedRpm::Tracer.tracing?
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
+
+                span = BaselineRedRpm.tracer.start_span(name || 'SQL', tags: {
+                  "component" => "ActiveRecord",
+                  "span.kind" => "client",
+                  "db.statement" => sanitized_sql,
+                  "db.user" => connection_config.fetch(:username, 'unknown'),
+                  "db.instance" => connection_config.fetch(:database),
+                  "db.vendor" => adapter,
+                  "db.type" => "sql"
+                })
+                BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_record)
+              end
+            end
+
+            exec_insert_without_trace(sql, name, binds, *args)
+          rescue Exception => e
+            if span
+              span.set_tag('error', true)
+              span.log_error(e)
+            end
+            raise
+          ensure
+            span.finish if span
+          end
+
+          def begin_db_transaction_with_trace
+            if ::BaselineRedRpm::Tracer.tracing?
+              adapter = connection_config.fetch(:adapter)
+
+              span = BaselineRedRpm.tracer.start_span(name || 'SQL', tags: {
+                "component" => "ActiveRecord",
+                "span.kind" => "client",
+                "db.statement" => "BEGIN",
+                "db.user" => connection_config.fetch(:username, 'unknown'),
+                "db.instance" => connection_config.fetch(:database),
+                "db.vendor" => adapter,
+                "db.type" => "sql"
+              })
+              BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_record)
+            end
+
+            begin_db_transaction_without_trace
+          rescue Exception => e
+            if span
+              span.set_tag('error', true)
+              span.log_error(e)
+            end
+            raise
+          ensure
+            span.finish if span
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/instruments/activerecord_import.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActiveRecordImport
+      include BaselineRedRpm::Utils
+
+      def insert_many_with_trace( sql, values, *args )
+        if ::BaselineRedRpm::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 = connection_config.fetch(:adapter)
+          sanitized_sql = sanitize_sql(base_sql + values.join( ',' ) + post_sql, adapter)
+
+          span = BaselineRedRpm.tracer.start_span(self.class.name || 'sql.query', tags: {
+            "component" => "ActiveRecordImport",
+            "span.kind" => "client",
+            "db.statement" => sanitized_sql,
+            "db.user" => connection_config.fetch(:username, 'unknown'),
+            "db.instance" => connection_config.fetch(:database),
+            "db.vendor" => adapter,
+            "db.type" => "sql"
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_record_import)
+        end
+
+        insert_many_without_trace(sql, values, *args)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+
+if ::BaselineRedRpm.config.instrumentation[:active_record_import][:enabled] &&
+  defined?(ActiveRecord::Import::PostgreSQLAdapter)
+  BaselineRedRpm.logger.info "Initializing activerecord-import tracer."
+
+  ActiveRecord::Import::PostgreSQLAdapter.send(:include, BaselineRedRpm::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/baseline_red_rpm/instruments/emque_consuming.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module EmqueConsuming
+      module Router
+        def route_with_trace(topic, type, message)
+          action = type.to_s.split(".").last
+
+          span = ::BaselineRedRpm.tracer.start_span("#{topic}##{action}", tags: {
+            "component" => "EmqueConsuming",
+            "http.url" => "/#{topic}/#{action}",
+            "peer.address" => Socket.gethostname
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :emque_consuming)
+
+          route_without_trace(topic, type, message)
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
+          end
+          raise
+        ensure
+          span.finish if span
+        end
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:emque_consuming][:enabled] && defined?(Emque::Consuming)
+  BaselineRedRpm.logger.info "Initializing emque-consuming tracer."
+
+  Emque::Consuming::Router.send(:include, BaselineRedRpm::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/baseline_red_rpm/instruments/faraday.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module FaradayConnection
+      def run_request_with_trace(method, url, body, headers, &block)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("faraday", tags: {
+            "component" => "Faraday",
+            "span.kind" => "client"
+          })
+          BaselineRedRpm.tracer.inject(span.context, OpenTracing::FORMAT_RACK, @headers)
+          result = run_request_without_trace(method, url, body, headers, &block)
+          span.set_tag "middleware", @builder.handlers
+          span.set_tag "peer.hostname", @url_prefix.host
+          span.set_tag "peer.port", @url_prefix.port
+          span.set_tag "http.protocol", @url_prefix.scheme
+          span.set_tag "http.url", url
+          span.set_tag "http.method", method
+          span.set_tag "http.status_code", result.status
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :faraday)
+          span.finish
+        else
+          result = run_request_without_trace(method, url, body, headers, &block)
+        end
+        result
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:faraday][:enabled] && defined?(::Faraday)
+  ::BaselineRedRpm.logger.info "Initializing faraday tracer."
+
+  ::Faraday::Connection.send(:include, BaselineRedRpm::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/baseline_red_rpm/instruments/grape.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module GrapeMiddleware
+
+      def call_with_trace(env)
+        req = ::Rack::Request.new(env)
+
+        if BaselineRedRpm::Tracer.tracing?
+          request_method = req.request_method.to_s.upcase
+          path = req.path
+          endpoint = env["api.endpoint"]
+
+          if endpoint && endpoint.options
+            options = endpoint.options
+            request_method = options[:method].first.to_s.upcase
+            klass = options[:for]
+            namespace = endpoint.namespace
+            namespace = "" if namespace == "/"
+
+            path = options[:path].first.to_s
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
+          end
+
+          action = path.to_s.split("/").last
+          operation = "#{klass}##{action}"
+
+          span = BaselineRedRpm.tracer.start_span(operation, tags: {
+            "component" => "Grape",
+            "span.kind" => "client",
+            "class.name" => @app.class.name,
+            "http.path" => path,
+            "http.method" => request_method
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :rack)
+        end
+
+        begin
+          call_without_trace(env)
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
+          end
+          raise
+        ensure
+          span.finish if span
+        end
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:grape][:enabled] && defined?(::Grape)
+  ::BaselineRedRpm.logger.info "Initializing grape tracer."
+  ::Grape::Middleware::Base.send(:include, BaselineRedRpm::Instruments::GrapeMiddleware)
+  ::Grape::Middleware::Base.class_eval do
+    alias_method :call_without_trace, :call
+    alias_method :call, :call_with_trace
+  end
+end

data/lib/baseline_red_rpm/instruments/net_http.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+if ::BaselineRedRpm.config.instrumentation[:net_http][:enabled] && defined?(Net::HTTP)
+  ::BaselineRedRpm.logger.info "Initializing net-http tracer."
+
+  Net::HTTP.class_eval do
+    def request_with_trace(*args, &block)
+      if ::BaselineRedRpm::Tracer.tracing?
+        span = ::BaselineRedRpm.tracer.start_span("net-http", tags: {
+          "component" => "NetHttp",
+          "span.kind" => "client"
+        })
+
+        if args.length && args[0]
+          req = args[0]
+          BaselineRedRpm.tracer.inject(span.context, OpenTracing::FORMAT_RACK, req)
+          span.set_tag "http.protocol", (use_ssl? ? "https" : "http")
+          span.set_tag "http.url", req.path
+          span.set_tag "http.method", req.method
+          span.set_tag "peer.hostname", addr_port
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :net_http)
+        end
+
+        response = request_without_trace(*args, &block)
+
+        span.exit
+        span.set_tag "http.status_code", response.code
+
+        if (response.code.to_i >= 300 || response.code.to_i <= 308) && response.header["Location"]
+          span.set_tag "http.redirect", response.header["Location"]
+        end
+
+        span.finish
+      else
+        response = request_without_trace(*args, &block)
+      end
+      response
+    end
+
+    alias request_without_trace request
+    alias request request_with_trace
+  end
+end

data/lib/baseline_red_rpm/instruments/rack.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module RackModule
+      def call(env)
+        req = ::Rack::Request.new(env)
+
+        #if ::BaselineRedRpm::Tracer.in_trace? &&
+        #  ::BaselineRedRpm.config.instrumentation[:rack][:trace_middleware]
+        #  BaselineRedRpm::Tracer.trace("rack-middleware") do |span|
+        #    span.set_tag "type", "web"
+        #    span.set_tag "domain", req.host
+        #    span.set_tag "url", req.path
+        #    span.set_tag "class", @app.class.name
+        #
+        #    status, headers, body = @app.call env
+        #  end
+        #else
+        span = BaselineRedRpm.tracer.start_span("rack")
+        span.set_tag "type", "web"
+        span.set_tag "domain", req.host
+        span.set_tag "url", req.path
+        span.set_tag "class", @app.class.name
+        span.set_tag "backtrace", ::BaselineRedRpm::Backtrace.backtrace
+        span.set_tag "source", ::BaselineRedRpm::Backtrace.source_extract
+
+        @app.call(env)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:rack][:enabled]
+  ::BaselineRedRpm.logger.info "Initializing rack tracer."
+
+  if ::BaselineRedRpm.config.instrumentation[:rack][:trace_middleware]
+    ::BaselineRedRpm.logger.info "Initializing rack-middleware tracer."
+  end
+
+  module BaselineRedRpm
+    module Instruments
+      class Rack
+        attr_reader :app
+
+        #include BaselineRedRpm::Instruments::RackModule
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          req = ::Rack::Request.new(env)
+
+          unless ignore_path?(req.path)
+            extracted_ctx = BaselineRedRpm.tracer.extract(OpenTracing::FORMAT_RACK, env)
+            BaselineRedRpm::Tracer.sample!(extracted_ctx, !!req.params["app-perf-sample"])
+
+            if BaselineRedRpm::Tracer.tracing?
+              span = BaselineRedRpm.tracer.start_span(@app.class.name, :child_of => extracted_ctx, tags: {
+                "component" => "Rack",
+                "span.kind" => "client"
+              })
+              BaselineRedRpm::Utils.log_source_and_backtrace(span, :rack)
+            end
+          end
+
+          status, headers, response = @app.call(env)
+
+          if span
+            span.set_tag "peer.address", req.host
+            span.set_tag "peer.port", req.port
+            span.set_tag "http.method", req.request_method
+            span.set_tag "http.url", req.path
+            span.set_tag "http.status_code", status
+          end
+
+          [status, headers, response]
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
+          end
+          raise
+        ensure
+          span.finish if span
+          BaselineRedRpm::Tracer.sample_off!
+        end
+
+        def ignore_path?(path)
+          path.to_s =~ BaselineRedRpm.config.ignore_paths
+        end
+      end
+    end
+  end
+=begin
+  module ActionDispatch
+    class MiddlewareStack
+      class BaselineRedRack
+        include BaselineRedRpm::Instruments::RackModule
+
+        def initialize(app)
+          @app = app
+        end
+      end
+
+      class Middleware
+        def build(app)
+          BaselineRedRack.new(klass.new(app, *args, &block))
+        end
+      end
+
+      def build(app = nil, &block)
+        app ||= block
+        raise "BaselineRedRack#build requires an app" unless app
+        middlewares.reverse.inject(BaselineRedRack.new(app)) {|a, e| e.build(a)}
+      end
+    end
+  end
+=end
+end