app_perf_rpm 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a066a37d5f3c2f7880ef434988ca092e512e741
-  data.tar.gz: a781dcbc4d6c97fe97fd807d6eaa8859450a45a2
+  metadata.gz: 049ed9d70578f19385c19d57d2a9794be48518a0
+  data.tar.gz: 5ebeb333e89d38319a413d92f4a7e41f5bd11348
 SHA512:
-  metadata.gz: d0c35afab0e3d636277c7b308f0c81186ee5a6cfe3f01997c0e559e63b327e5e09103063ee5e6d026f69357c00387e326e013affa98d9de64d0fcf92ea29989c
-  data.tar.gz: 1bed1af8e426808af7702eedfc810f7508f8b510acb0c49f621dbbf17c343e5a1bc6a3f47571ba18b4ba3cb3614e4ef1f2c2cd629ee5fb7348310ed0d4f2b6c8
+  metadata.gz: 50cfe054972dcb5a8ba179383c4ad7433a4a84c13d2c70f73afe6dd1401715e82d8bcecab2311b8e2a737de84507376eb5794b6e4e624ecbfda9c5a3a86ae3f3
+  data.tar.gz: 9ac2e437821c812c0c345dc61c32067ad35d7dc45c7614ae5f5bf6e1e85a89ee10b13f2c99ec83ecbe58ce4a3dda8c40211bf7901b23e41284d8903b146820f5

data/lib/app_perf_rpm/backtrace.rb

@@ -8,7 +8,7 @@ module AppPerfRpm
       end
 
       def clean(backtrace)
-        backtrace
+        Array(backtrace)
           .map {|b| clean_line(b) }
           .select {|b| b !~ %r{lib/app_perf_rpm} }
       end
@@ -27,7 +27,7 @@ module AppPerfRpm
       #end
 
       def source_extract(_backtrace = Kernel.caller(0))
-        Array(_backtrace).select {|bt| bt[/^#{::AppPerfRpm.configuration.app_root.to_s}\//] }.map do |trace|
+        Array(_backtrace).select {|bt| bt[/^#{::AppPerfRpm.config.app_root.to_s}\//] }.map do |trace|
           file, line_number = extract_file_and_line_number(trace)
           source_to_hash(file, line_number)
         end
@@ -41,14 +41,14 @@ module AppPerfRpm
         }
       end
 
-      private
-
       def clean_line(line)
         line
-          .sub(/#{::AppPerfRpm.configuration.app_root.to_s}\//, "[APP_PATH]/")
+          .sub(/#{::AppPerfRpm.config.app_root.to_s}\//, "[APP_PATH]/")
           .sub(gems_regexp, '\2 (\3) [GEM_PATH]/\4')
       end
 
+      private
+
       def gems_regexp
         gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
         if gems_paths
@@ -59,8 +59,8 @@ module AppPerfRpm
       end
 
       def source_fragment(path, line)
-        return unless AppPerfRpm.configuration.app_root
-        full_path = AppPerfRpm.configuration.app_root.join(path)
+        return unless AppPerfRpm.config.app_root
+        full_path = AppPerfRpm.config.app_root.join(path)
         if File.exist?(full_path)
           File.open(full_path, "r") do |file|
             start = [line - 3, 0].max

data/lib/app_perf_rpm/configuration.rb

@@ -9,10 +9,11 @@ module AppPerfRpm
                   :ssl,
                   :sample_rate,
                   :sample_threshold,
-                  :dispatch_interval,
+                  :flush_interval,
                   :application_name,
                   :instrumentation,
-                  :agent_disabled
+                  :agent_disabled,
+                  :ignore_paths
 
     def initialize
       reload
@@ -27,10 +28,11 @@ module AppPerfRpm
         self.application_name ||= "Default"
         self.sample_rate ||= 10 # Percentage of request to sample
         self.sample_threshold ||= 0 # Minimum amount of duration to sample
-        self.dispatch_interval ||= 60 # In seconds
+        self.flush_interval ||= 60 # In seconds
         self.agent_disabled ||= default_if_blank(ENV["APP_PERF_AGENT_DISABLED"], false)
+        self.ignore_paths ||= /\/assets/
         self.instrumentation = {
-          :rack                 => { :enabled => true, :backtrace => false, :trace_middleware => true },
+          :rack                 => { :enabled => true, :backtrace => false, :trace_middleware => false },
           :active_record        => { :enabled => true, :backtrace => false },
           :active_record_import => { :enabled => true, :backtrace => false },
           :action_view          => { :enabled => true, :backtrace => false },

data/lib/app_perf_rpm/instruments/action_controller.rb

@@ -3,34 +3,51 @@ module AppPerfRpm
     module ActionController
       def process_action_with_trace(method_name, *args)
         if ::AppPerfRpm::Tracer.tracing?
-          AppPerfRpm::Tracer.trace('actioncontroller') do |span|
-            span.controller = self.class.name
-            span.action = self.action_name
+          operation = "#{self.class.name}##{self.action_name}"
+          span = AppPerfRpm.tracer.start_span(operation, tags: {
+            "component" => "ActionController",
+            "span.kind" => "client"
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            process_action_without_trace(method_name, *args)
-          end
-        else
-          process_action_without_trace(method_name, *args)
+        process_action_without_trace(method_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 perform_action_with_trace(*arguments)
         if ::AppPerfRpm::Tracer.tracing?
-          AppPerfRpm::Tracer.trace('actioncontroller') do |span|
-            span.controller = @_request.path_parameters['controller']
-            span.action = @_request.path_parameters['action']
-
-            perform_action_without_trace(*arguments)
-          end
-        else
-          perform_action_without_trace(*arguments)
+          operation = "#{@_request.path_parameters['controller']}##{@_request.path_parameters['action']}"
+          span = AppPerfRpm.tracer.start_span(operation, tags: {
+            "component" => "ActionController",
+            "span.kind" => "client"
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
+        perform_action_without_trace(*arguments)
+      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 ::AppPerfRpm.configuration.instrumentation[:action_controller][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:action_controller][:enabled] &&
   defined?(::ActionController)
   AppPerfRpm.logger.info "Initializing actioncontroller tracer."
 

data/lib/app_perf_rpm/instruments/action_view.rb

@@ -1,46 +1,54 @@
-if ::AppPerfRpm.configuration.instrumentation[:action_view][:enabled] && defined?(::ActionView)
+if ::AppPerfRpm.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 ::AppPerfRpm::Tracer.tracing? && options.key?(:partial) && options[:partial].is_a?(String)
-          opts = {
-            "method" => "render_partial",
-            "name" => options[:partial]
-          }
-
-          opts["backtrace"] = ::AppPerfRpm::Backtrace.backtrace
-          opts["source"] = ::AppPerfRpm::Backtrace.source_extract
-
-          AppPerfRpm::Tracer.trace("actionview", opts) do |span|
-            span.controller = @_request.path_parameters['controller']
-            span.action = @_request.path_parameters['action']
-            span.backtrace = ::AppPerfRpm::Backtrace.backtrace
-            span.source = ::AppPerfRpm::Backtrace.source_extract
+          span = AppPerfRpm.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]
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            render_partial_without_trace(options)
-          end
-        else
-          render_partial_without_trace(options)
+        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 ::AppPerfRpm::Tracer.tracing?
-          AppPerfRpm::Tracer.trace("actionview") do |span|
-            span.backtrace = ::AppPerfRpm::Backtrace.backtrace
-            span.source = ::AppPerfRpm::Backtrace.source_extract
-            span.options = {
-              "method" => "render_partial_collection",
-              "name" => @path
-            }
+          span = AppPerfRpm.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
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            render_partial_collection_without_trace(options)
-          end
-        else
-          render_partial_collection_without_trace(options)
+        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
   else
@@ -48,35 +56,49 @@ if ::AppPerfRpm.configuration.instrumentation[:action_view][:enabled] && defined
       alias :render_partial_without_trace :render_partial
       def render_partial
         if ::AppPerfRpm::Tracer.tracing?
-          AppPerfRpm::Tracer.trace("actionview") do |span|
-            span.backtrace = ::AppPerfRpm::Backtrace.backtrace
-            span.source = ::AppPerfRpm::Backtrace.source_extract
-            span.options = {
-              "method" => "render_partial",
-              "name" => @options[:partial]
-            }
+          span = AppPerfRpm.tracer.start_span("render_partial", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.template" => @options[:partial]
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            render_partial_without_trace
-          end
-        else
-          render_partial_without_trace
+        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 ::AppPerfRpm::Tracer.tracing?
-          AppPerfRpm::Tracer.trace("actionview") do |span|
-            span.options = {
-              "method" => "render_collection",
-              "name" => @path
-            }
+          span = AppPerfRpm.tracer.start_span("render_collection", tags: {
+            "component" => "ActionView",
+            "span.kind" => "client",
+            "view.controller" => @_request.path_parameters['controller'],
+            "view.action" => @_request.path_parameters['action'],
+            "view.template" => @path
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            render_collection_without_trace
-          end
-        else
-          render_collection_without_trace
+        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
 
@@ -99,25 +121,31 @@ if ::AppPerfRpm.configuration.instrumentation[:action_view][:enabled] && defined
             @path = path
           end
 
-          AppPerfRpm::Tracer.trace("actionview") do |span|
-            if layout
-              span.options = {
-                "method" => "render_with_layout",
-                "name" => layout.identifier,
-                "path" => @path,
-                "layout" => layout
-              }
-            else
-              span.options = {
-                "method" => "render_without_layout",
-                "path" => @path
-              }
+          if layout
+            span = AppPerfRpm.tracer.start_span("render_with_layout")
+            # span.set_tag "view.layout", layout
+            span.set_tag "view.template", layout.identifier
+          else
+            span = AppPerfRpm.tracer.start_span("render_without_layout")
+            if @path
+              span.set_tag "view.template", @path.call
             end
-            render_with_layout_without_trace(path, locals, *args, &block)
           end
-        else
-          render_with_layout_without_trace(path, locals, *args, &block)
+          span.set_tag "component", "ActionView"
+          span.set_tag "span.kind", "client"
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
+
+        render_with_layout_without_trace(path, locals, *args, &block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
     end
   end

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

@@ -19,24 +19,33 @@ module AppPerfRpm
 
           def execute_with_trace(sql, name = nil)
             if ::AppPerfRpm::Tracer.tracing?
-              if ignore_trace?(name)
-                execute_without_trace(sql, name)
-              else
-                sanitized_sql = sanitize_sql(sql, :mysql2)
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
 
-                AppPerfRpm::Tracer.trace('activerecord') do |span|
-                  span.options ={
-                    "adapter" => "mysql2",
-                    "query" => sanitized_sql,
-                    "name" => name
-                  }
-
-                  execute_without_trace(sql, name)
-                end
+                span = AppPerfRpm.tracer.start_span(name || 'sql.query', 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"
+                })
+                span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+                span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
               end
-            else
-              execute_without_trace(sql, name)
             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

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

@@ -19,81 +19,124 @@ module AppPerfRpm
 
           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, :postgres)
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
 
-                AppPerfRpm::Tracer.trace('activerecord') do |span|
-                  span.options = {
-                    "adapter" => "postgresql",
-                    "query" => sanitized_sql,
-                    "name" => name
-                  }
-                  exec_query_without_trace(sql, name, binds)
-                end
+                span = AppPerfRpm.tracer.start_span(name || 'sql.query', 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"
+                })
+                span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+                span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
               end
-            else
-              exec_query_without_trace(sql, name, binds)
             end
+
+            exec_query_without_trace(sql, name, binds)
+          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, binds = [])
             if ::AppPerfRpm::Tracer.tracing?
-              if ignore_trace?(name)
-                exec_delete_without_trace(sql, name, binds)
-              else
-                sanitized_sql = sanitize_sql(sql)
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
 
-                AppPerfRpm::Tracer.trace('activerecord') do |span|
-                  span.options = {
-                    "adapter" => "postgresql",
-                    "query" => sanitized_sql,
-                    "name" => name
-                  }
-                  exec_delete_without_trace(sql, name, binds)
-                end
+                span = AppPerfRpm.tracer.start_span(name || 'sql.query', 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"
+                })
+                span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+                span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
               end
-            else
-              exec_delete_without_trace(sql, name, binds)
             end
+
+            exec_delete_without_trace(sql, name, binds)
+          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, binds = [], *args)
             if ::AppPerfRpm::Tracer.tracing?
-              if ignore_trace?(name)
-                exec_insert_without_trace(sql, name, binds, *args)
-              else
-                sanitized_sql = sanitize_sql(sql, :postgres)
-
-                AppPerfRpm::Tracer.trace('activerecord') do |span|
-                  span.options = {
-                    "adapter" => "postgresql",
-                    "query" => sanitized_sql,
-                    "name" => name
-                  }
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
 
-                  exec_insert_without_trace(sql, name, binds, *args)
-                end
+                span = AppPerfRpm.tracer.start_span(name || 'sql.query', 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"
+                })
+                span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+                span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
               end
-            else
-              exec_insert_without_trace(sql, name, binds, *args)
             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 ::AppPerfRpm::Tracer.tracing?
-              AppPerfRpm::Tracer.trace('activerecord') do |span|
-                span.options = {
-                  "adapter" => "postgresql",
-                  "query" => "BEGIN"
-                }
+              adapter = connection_config.fetch(:adapter)
+              sanitized_sql = sanitize_sql(sql, adapter)
 
-                begin_db_transaction_without_trace
-              end
-            else
-              begin_db_transaction_without_trace
+              span = AppPerfRpm.tracer.start_span('sql.query', 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"
+              })
+              span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+              span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+            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