baseline_red_rpm 1.0.0

data/lib/baseline_red_rpm/instruments/action_view.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+if ::BaselineRedRpm.config.instrumentation[:action_view][:enabled] && defined?(::ActionView)
+  if defined?(Rails) && Rails::VERSION::MAJOR == 2
+    ActionView::Partials.module_eval do
+      alias :render_partial_without_trace :render_partial
+      def render_partial(options = {})
+        if ::BaselineRedRpm::Tracer.tracing? && options.key?(:partial) && options[:partial].is_a?(String)
+          span = BaselineRedRpm.tracer.start_span("render_partial", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.controller" => @_request.path_parameters['controller'],
+            "view.action" => @_request.path_parameters['action'],
+            "view.template" => options[:partial]
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_partial_without_trace(options)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+
+      alias :render_partial_collection_without_trace :render_partial_collection
+      def render_partial_collection(options = {})
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_partial_collection", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.controller" => @_request.path_parameters['controller'],
+            "view.action" => @_request.path_parameters['action'],
+            "view.template" => @path
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_partial_collection_without_trace(options)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+
+  if defined?(Rails) && Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
+    ::ActionView::Partials::PartialRenderer.class_eval do
+      alias :render_partial_without_trace :render_partial
+      def render_partial
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_partial", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.template" => @options[:partial]
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_partial_without_trace
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+
+      alias :render_collection_without_trace :render_collection
+      def render_collection
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_collection", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.template" => @path
+          })
+          if @_request
+            span.set_tag('view.controller', @_request.path_parameters['controller'])
+            span.set_tag('view.action', @_request.path_parameters['action'])
+          end
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_collection_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
+
+    ::ActionView::Rendering.class_eval do
+      alias :_render_template_without_trace _render_template
+
+      def _render_template(template, layout = nil, options = {})
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_template")
+          span.set_tag "view.template", template
+          span.set_tag "view.layout", layout
+          span.set_tag "component", "ActionView"
+          span.set_tag "span.kind", "client"
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        _render_template_without_trace(template, layout, options)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+
+  if defined?(Rails) && Rails.version >= '3.1.0'
+    ActionView::PartialRenderer.class_eval do
+      alias :render_partial_without_trace :render_partial
+      def render_partial
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_partial", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.template" => @options[:partial]
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_partial_without_trace
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+
+      alias :render_collection_without_trace :render_collection
+      def render_collection
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("render_collection", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.template" => @path
+          })
+          if @_request
+            span.set_tag('view.controller', @_request.path_parameters['controller'])
+            span.set_tag('view.action', @_request.path_parameters['action'])
+          end
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_collection_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
+
+    ::ActionView::TemplateRenderer.class_eval do
+      alias :render_template_without_trace :render_template
+
+      def render_template(template, layout_name = nil, locals = {})
+        if ::BaselineRedRpm::Tracer.tracing?
+	  layout = if layout_name
+                     if layout_name.is_a?(String)
+                       layout_name
+                     elsif layout_name.is_a?(Proc)
+                       layout_name.call
+                     elsif method(:find_layout).arity == 3
+                       find_layout(layout_name, locals, [formats.first])
+                     elsif locals
+                       find_layout(layout_name, locals)
+                     end
+                   end
+          span = BaselineRedRpm.tracer.start_span("render_template")
+          span.set_tag "view.layout", layout ? layout.inspect : ""
+          span.set_tag "view.template", template.inspect
+          span.set_tag "component", "ActionView"
+          span.set_tag "span.kind", "client"
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_view)
+        end
+
+        render_template_without_trace(template, layout_name, locals)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+
+  BaselineRedRpm.logger.info "Initializing actionview tracer."
+end

data/lib/baseline_red_rpm/instruments/active_model_serializer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+if ::BaselineRedRpm.config.instrumentation[:action_view][:enabled] &&
+  defined?(::ActiveModel) &&
+  defined?(::ActiveModel::Serializer) &&
+  defined?(::ActiveModel::Serializer::CollectionSerializer) &&
+  defined?(::ActiveModel::Serializer::ArraySerializer)
+  [
+    ::ActiveModel::Serializer,
+    ::ActiveModel::Serializer::CollectionSerializer,
+    ::ActiveModel::Serializer::ArraySerializer
+  ].each do |klass|
+    klass.class_eval do
+      alias :as_json_without_trace :as_json
+      def as_json(*args)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = BaselineRedRpm.tracer.start_span("ActiveModel::Serializer", tags: {
+            "serializer" => self.class.to_s
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :active_model_serializer)
+        end
+
+        as_json_without_trace(*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
+
+  BaselineRedRpm.logger.info "Initializing activemodel/serializer tracer."
+end

data/lib/baseline_red_rpm/instruments/active_record.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:active_record][:enabled] &&
+  defined?(::ActiveRecord)
+  BaselineRedRpm.logger.info "Initializing activerecord tracer."
+
+  if defined?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+    require 'baseline_red_rpm/instruments/active_record/adapters/sqlite3'
+    ::ActiveRecord::ConnectionAdapters::SQLite3Adapter.send(:include,
+      ::BaselineRedRpm::Instruments::ActiveRecord::Adapters::Sqlite3
+    )
+    ::ActiveRecord::ConnectionAdapters::SQLite3Adapter.class_eval do
+      if Rails.version < "3.1"
+        alias_method :exec_query_without_trace, :execute
+        alias_method :execute, :exec_query_with_trace
+      else
+        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
+  end
+
+  if defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+    require 'baseline_red_rpm/instruments/active_record/adapters/postgresql'
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include,
+      ::BaselineRedRpm::Instruments::ActiveRecord::Adapters::Postgresql
+    )
+
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      if Rails.version < "3.1"
+        alias_method :exec_query_without_trace, :execute
+        alias_method :execute, :exec_query_with_trace
+      else
+        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
+  end
+
+  if defined?(::ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+    require 'baseline_red_rpm/instruments/active_record/adapters/mysql2'
+    ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include,
+      ::BaselineRedRpm::Instruments::ActiveRecord::Adapters::Mysql2
+    )
+
+    ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.class_eval do
+      alias_method :execute_without_trace, :execute
+      alias_method :execute, :execute_with_trace
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+        module Mysql2
+          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 execute_with_trace(sql, name = nil)
+            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
+
+            execute_without_trace(sql, name)
+          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/active_record/adapters/postgresql.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActiveRecord
+      module Adapters
+        module Postgresql
+          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, *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)
+              sanitized_sql = sanitize_sql(sql, adapter)
+
+              span = BaselineRedRpm.tracer.start_span('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