app_perf_rpm 0.0.5 → 0.0.6

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

@@ -19,82 +19,123 @@ 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, :sqlite)
+              unless ignore_trace?(name)
+                adapter = connection_config.fetch(:adapter)
+                sanitized_sql = sanitize_sql(sql, adapter)
 
-                AppPerfRpm::Tracer.trace('activerecord', opts) do |span|
-                  span.options = {
-                    "adapter" => "postgresql",
-                    "query" => sanitized_sql,
-                    "name" => name
-                  }
-
-                  exec_query_without_trace(sql, name, binds)
-                end
+                span = AppPerfRpm.tracer.start_span('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, :sqlite)
-
-                AppPerfRpm::Tracer.trace('activerecord', opts) 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_delete_without_trace(sql, name, binds)
-                end
+                span = AppPerfRpm.tracer.start_span('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, :sqlite)
-
-                AppPerfRpm::Tracer.trace('activerecord', opts) 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('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', opts) do |span|
-                span.options = {
-                  "adapter" => "postgresql",
-                  "query" => "BEGIN"
-                }
-                begin_db_transaction_without_trace
-              end
-            else
-              begin_db_transaction_without_trace
+              adapter = connection_config.fetch(:adapter)
+
+              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

data/lib/app_perf_rpm/instruments/active_record.rb

@@ -7,7 +7,7 @@ module AppPerfRpm
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:active_record][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:active_record][:enabled] &&
   defined?(::ActiveRecord)
   AppPerfRpm.logger.info "Initializing activerecord tracer."
 

data/lib/app_perf_rpm/instruments/activerecord_import.rb

@@ -12,29 +12,38 @@ module AppPerfRpm
             [sql_copy.shift, sql_copy.join( ' ' )]
           end
 
-          adapter = ::ActiveRecord::Base.connection_config[:adapter]
-
+          adapter = connection_config.fetch(: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
-            }
+          span = AppPerfRpm.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"
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-            insert_many_without_trace(sql, values, *args)
-          end
-        else
-          insert_many_without_trace(sql, values, *args)
+        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 ::AppPerfRpm.configuration.instrumentation[:active_record_import][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:active_record_import][:enabled] &&
   defined?(ActiveRecord::Import::PostgreSQLAdapter)
   AppPerfRpm.logger.info "Initializing activerecord-import tracer."
 

data/lib/app_perf_rpm/instruments/emque_consuming.rb

@@ -5,21 +5,30 @@ module AppPerfRpm
         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
+          span = ::AppPerfRpm.tracer.start_span("#{topic}##{action}", tags: {
+            "component" => "EmqueConsuming",
+            "http.url" => "/#{topic}/#{action}",
+            "peer.address" => Socket.gethostname
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
 
-            route_without_trace(topic, type, message)
+          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 ::AppPerfRpm.configuration.instrumentation[:emque_consuming][:enabled] && defined?(Emque::Consuming)
+if ::AppPerfRpm.config.instrumentation[:emque_consuming][:enabled] && defined?(Emque::Consuming)
   AppPerfRpm.logger.info "Initializing emque-consuming tracer."
 
   Emque::Consuming::Router.send(:include, AppPerfRpm::Instruments::EmqueConsuming::Router)

data/lib/app_perf_rpm/instruments/faraday.rb

@@ -2,31 +2,41 @@ 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")
+        if ::AppPerfRpm::Tracer.tracing?
+          span = ::AppPerfRpm.tracer.start_span("faraday", tags: {
+            "component" => "Faraday",
+            "span.kind" => "client"
+          })
+          AppPerfRpm.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
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
           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)
+          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 ::AppPerfRpm.configuration.instrumentation[:faraday][:enabled] && defined?(::Faraday)
+if ::AppPerfRpm.config.instrumentation[:faraday][:enabled] && defined?(::Faraday)
   ::AppPerfRpm.logger.info "Initializing faraday tracer."
 
   ::Faraday::Connection.send(:include, AppPerfRpm::Instruments::FaradayConnection)

data/lib/app_perf_rpm/instruments/net_http.rb

@@ -1,29 +1,35 @@
-if ::AppPerfRpm.configuration.instrumentation[:net_http][:enabled] && defined?(Net::HTTP)
+if ::AppPerfRpm.config.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")
+        span = ::AppPerfRpm.tracer.start_span("net-http", {
+          "component" => "NetHttp",
+          "span.kind" => "client"
+        })
 
         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
+          AppPerfRpm.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
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
         end
 
         response = request_without_trace(*args, &block)
 
-        span.finish
-        span.options["status"] = response.code
+        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.options["location"] = response.header["Location"]
+          span.set_tag "http.redirect", response.header["Location"]
         end
 
-        trace.submit(opts)
+        span.finish
       else
         response = request_without_trace(*args, &block)
       end

data/lib/app_perf_rpm/instruments/rack.rb

@@ -3,54 +3,103 @@ module AppPerfRpm
     module RackModule
       def call(env)
         req = ::Rack::Request.new(env)
-        status, headers, body = nil, nil, nil
 
-        if ::AppPerfRpm::Tracer.in_trace? &&
-          ::AppPerfRpm.configuration.instrumentation[:rack][:trace_middleware]
-          AppPerfRpm::Tracer.trace("rack-middleware") do |span|
-            span.type = "web"
-            span.domain = req.host
-            span.url = req.path
-            span.options["class"] = @app.class.name
+        #if ::AppPerfRpm::Tracer.in_trace? &&
+        #  ::AppPerfRpm.config.instrumentation[:rack][:trace_middleware]
+        #  AppPerfRpm::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 = AppPerfRpm.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", ::AppPerfRpm::Backtrace.backtrace
+        span.set_tag "source", ::AppPerfRpm::Backtrace.source_extract
 
-            status, headers, body = @app.call env
-          end
-        else
-          AppPerfRpm::Tracer.start_trace("rack") do |span|
-            span.type = "web"
-            span.domain = req.host
-            span.url = req.path
-            span.options["class"] = @app.class.name
-
-            status, headers, body = @app.call env
-          end
+        @app.call(env)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
-
-        [status, headers, body]
+        raise
+      ensure
+        span.finish if span
       end
     end
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:rack][:enabled]
+if ::AppPerfRpm.config.instrumentation[:rack][:enabled]
   ::AppPerfRpm.logger.info "Initializing rack tracer."
 
-  if ::AppPerfRpm.configuration.instrumentation[:rack][:trace_middleware]
+  if ::AppPerfRpm.config.instrumentation[:rack][:trace_middleware]
     ::AppPerfRpm.logger.info "Initializing rack-middleware tracer."
   end
 
   module AppPerfRpm
     module Instruments
       class Rack
-        include AppPerfRpm::Instruments::RackModule
+        attr_reader :app
+
+        #include AppPerfRpm::Instruments::RackModule
 
         def initialize(app)
           @app = app
         end
+
+        def call(env)
+          req = ::Rack::Request.new(env)
+
+          unless ignore_path?(req.path)
+            extracted_ctx = AppPerfRpm.tracer.extract(OpenTracing::FORMAT_RACK, env)
+            AppPerfRpm::Tracer.sample!(extracted_ctx)
+
+            if AppPerfRpm::Tracer.tracing?
+              span = AppPerfRpm.tracer.start_span(@app.class.name, :child_of => extracted_ctx, tags: {
+                "component" => "Rack",
+                "span.kind" => "client"
+              })
+              span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+              span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+            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
+        end
+
+        def ignore_path?(path)
+          path.to_s =~ AppPerfRpm.config.ignore_paths
+        end
       end
     end
   end
-
+=begin
   module ActionDispatch
     class MiddlewareStack
       class AppPerfRack
@@ -74,4 +123,5 @@ if ::AppPerfRpm.configuration.instrumentation[:rack][:enabled]
       end
     end
   end
+=end
 end

data/lib/app_perf_rpm/instruments/redis.rb

@@ -1,30 +1,66 @@
 module AppPerf
   module Instruments
     module Redis
-      def call_with_trace(command, &block)
+      include AppPerfRpm::Utils
+
+      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)
+          span = ::AppPerfRpm.tracer.start_span("redis", tags: {
+            "component" => "Redis",
+            "span.kind" => "client",
+            "peer.address" => self.host,
+            "peer.port" => self.port,
+            "db.type" => "redis",
+            "db.vendor" => "redis",
+            "db.instance" => self.db,
+            "db.statement" => format_redis_command(*command)
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
+
+        call_without_trace(*command, &block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
 
-      def call_pipeline_with_trace(pipeline)
+      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)
+          span = ::AppPerfRpm.tracer.start_span("redis", tags: {
+            "component" => "Redis",
+            "span.kind" => "client",
+            "peer.address" => self.host,
+            "peer.port" => self.port,
+            "db.type" => "redis",
+            "db.vendor" => "redis",
+            "db.instance" => self.db,
+            "db.statement" => pipeline[0].commands.map { |c| format_redis_command(c) }.join("\n")
+          })
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
+
+        call_pipeline_without_trace(*pipeline)
+      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[:redis][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:redis][:enabled] &&
   defined?(::Redis)
   ::AppPerfRpm.logger.info "Initializing redis tracer."