stackify-ruby-apm 1.11.0 → 1.14.2

data/lib/stackify_apm/spies/log4r.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Monkey patch for the Log4r::Outputter class for logging log message.
+#
+module StackifyRubyAPM
+  module Spies
+    class Log4rSpy
+      def install
+        Log4r::Outputter.module_eval do
+          alias_method 'canonical_log_without_apm', 'canonical_log'
+
+          # Log message formatted to a logevent object
+          def canonical_log(logevent)
+            return canonical_log_without_apm(logevent) unless StackifyRubyAPM.current_transaction
+
+            begin
+              name = 'log4r'
+              type = 'ext.log4r'
+              log_message = ''
+              exception = nil
+              msg = logevent.data
+
+              case msg
+              when ::String
+                log_message = msg
+              when ::Exception
+                log_message = msg.message
+                exception = "(#{ msg.class })\n#{ msg.backtrace.join("\n") if msg.backtrace }"
+              else
+                log_message = msg.inspect
+              end
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Log',
+                SUBCATEGORY: 'Log4r',
+                LEVEL: Log4r::LNAMES[logevent.level] || 'ANY',
+                MESSAGE: log_message,
+                PREFIX: 'TRUE'
+              )
+
+              if exception
+                ctx.EXCEPTION = exception
+              end
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[Log4rSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[Log4rSpy] #{e.inspect}"
+              return canonical_log_without_apm(logevent)
+            end
+
+            StackifyRubyAPM.span name, type, context: ctx do
+              canonical_log_without_apm(logevent)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Log4r::Outputter', 'log4r', Log4rSpy.new
+  end
+end

data/lib/stackify_apm/spies/logger.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+#
+# Monkey patch for the Logger class for logging log messages.
+#
+module StackifyRubyAPM
+  module Spies
+    class LoggerSpy
+      NAME = 'logger'
+      TYPE = 'core.devlog'
+
+      def install
+        Logger.class_eval do
+          alias_method 'debug_without_apm', 'debug'
+          alias_method 'info_without_apm', 'info'
+          alias_method 'warn_without_apm', 'warn'
+          alias_method 'error_without_apm', 'error'
+          alias_method 'fatal_without_apm', 'fatal'
+          alias_method 'unknown_without_apm', 'unknown'
+
+          def debug(progname = nil, &block)
+            return debug_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('DEBUG', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              debug_without_apm(progname, &block)
+            end
+          end
+
+          def info(progname = nil, &block)
+            return info_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('INFO', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              info_without_apm(progname, &block)
+            end
+          end
+
+          def warn(progname = nil, &block)
+            return warn_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('WARN', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              warn_without_apm(progname, &block)
+            end
+          end
+
+          def error(progname = nil, &block)
+            return error_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('ERROR', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              error_without_apm(progname, &block)
+            end
+          end
+
+          def fatal(progname = nil, &block)
+            return fatal_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('FATAL', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              fatal_without_apm(progname, &block)
+            end
+          end
+
+          def unknown(progname = nil, &block)
+            return unknown_without_apm(progname, &block) unless StackifyRubyAPM.current_transaction
+            ctx = StackifyRubyAPM::Spies::LoggerSpy.get_log_context('UNKNOWN', nil, progname, &block)
+            StackifyRubyAPM.span NAME, TYPE, context: ctx do
+              unknown_without_apm(progname, &block)
+            end
+          end
+        end
+      end
+
+      # create and return logger span context
+      def self.get_log_context(severity, message, progname)
+        ctx = nil
+
+        begin
+          log_message = ''
+          exception = nil
+
+          if message.nil?
+            msg = progname
+          else
+            msg = message
+          end
+
+          case msg
+          when ::String
+            log_message = msg
+          when ::Exception
+            log_message = msg.message
+            exception = "(#{ msg.class })\n#{ msg.backtrace.join("\n") if msg.backtrace }"
+          else
+            log_message = msg.inspect
+          end
+
+          ctx = Span::Context.new(
+            CATEGORY: 'Log',
+            SUBCATEGORY: 'Logger',
+            LEVEL: severity || 'ANY',
+            MESSAGE: log_message,
+            PREFIX: 'TRUE'
+          )
+
+          if exception
+            ctx.EXCEPTION = exception
+          end
+        rescue Exception => e
+          StackifyRubyAPM.agent.error "[LoggerSpy] Error: creating span context."
+          StackifyRubyAPM.agent.error "[LoggerSpy] #{e.inspect}"
+        end
+
+        ctx
+      end
+    end
+
+    register 'Logger', 'logger', LoggerSpy.new
+  end
+end

data/lib/stackify_apm/spies/logging.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+#
+# Monkey patch for the Logging::Logger class for logging log messages.
+#
+module StackifyRubyAPM
+  module Spies
+    class LoggingSpy
+      LVL_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).freeze
+
+      def install
+        Logging::Logger.class_eval do
+          alias_method 'log_event_without_apm', 'log_event'
+
+          # Log message formatted to an event object
+          def log_event(event)
+            return log_event_without_apm(event) unless StackifyRubyAPM.current_transaction
+
+            begin
+              name = 'logging'
+              type = 'ext.logging'
+              log_message = ''
+              exception = nil
+
+              obj = event.data
+
+              case obj
+              when String;
+                log_message = obj
+              when Exception
+                log_message = obj.message
+                exception = "(#{ obj.class.name })\n#{ obj.backtrace.join("\n") if obj.backtrace }"
+              when nil;
+                log_message = "(#{obj.class.name}) nil"
+              else
+                log_message = obj.to_s
+              end
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Log',
+                SUBCATEGORY: 'Logging',
+                LEVEL: LVL_LABEL[event.level] || 'ANY',
+                MESSAGE: log_message,
+                PREFIX: 'TRUE'
+              )
+
+              if exception
+                ctx.EXCEPTION = exception
+              end
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[LoggingSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[LoggingSpy] #{e.inspect}"
+              return log_event_without_apm(event)
+            end
+
+            StackifyRubyAPM.span name, type, context: ctx do
+              log_event_without_apm(event)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Logging::Logger', 'logging', LoggingSpy.new
+  end
+end

data/lib/stackify_apm/spies/mongo.rb

@@ -55,7 +55,9 @@ module StackifyRubyAPM
           #
           ctx = Span::Context.new(
             CATEGORY: 'MongoDB',
-            MONGODB_COLLECTION: col
+            MONGODB_COLLECTION: col,
+            OPERATION: event.command_name.to_s,
+            URL: event.address.to_s
           )
 
           # Creates new span from Mongo event

data/lib/stackify_apm/spies/net_http.rb

@@ -15,28 +15,34 @@ module StackifyRubyAPM
             return request_without_apm(req, body, &block) unless StackifyRubyAPM.current_transaction
             return request_without_apm(req, body, &block) if started? && req['span']
 
-            # Data configuration
-            #
-            host, = req['host'] && req['host'].split(':')
-            method = req.method
+            begin
+              # Data configuration
+              #
+              host, = req['host'] && req['host'].split(':')
+              method = req.method
 
-            host ||= address
+              host ||= address
 
-            # For Ruby version 2.2.x, 2.3.x, 2.4.x we need to parse it and get the <scheme> & <host>/<path>
-            updated_uri = req.uri.scheme + '://' + req.uri.host + req.uri.path if defined?(req.uri.host)
+              # For Ruby version 2.2.x, 2.3.x, 2.4.x we need to parse it and get the <scheme> & <host>/<path>
+              updated_uri = req.uri.scheme + '://' + req.uri.host + req.uri.path if defined?(req.uri.host)
 
-            name = "#{method} #{host}"
-            type = "ext.net_http.#{method}"
+              name = "#{method} #{host}"
+              type = "ext.net_http.#{method}"
 
-            # Builds span context
-            #
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: req.uri.nil? ? host : updated_uri,
-              STATUS: '',
-              METHOD: method
-            )
+              # Builds span context
+              #
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: req.uri.nil? ? host : updated_uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[NetHTTPSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[NetHTTPSpy] #{e.inspect}"
+              return request_without_apm(req, body, &block)
+            end
 
             # Creates new span from HTTP result
             #
@@ -45,8 +51,20 @@ module StackifyRubyAPM
               #
               req['span'] = true
               result = request_without_apm(req, body, &block)
-              status_code = result.code.to_i
-              ctx.update_status(status_code)
+              begin
+                status_code = result.code.to_i
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(req.body || "")
+                  ctx.update_request_headers(req.each_header || Hash.new)
+                  ctx.update_response_body(result.body || "")
+                  ctx.update_response_headers(result.each_header || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[NetHTTPSpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[NetHTTPSpy] #{e.inspect}"
+              end
               return result
             end
           end

data/lib/stackify_apm/spies/redis.rb

@@ -14,41 +14,50 @@ module StackifyRubyAPM
           alias_method 'call_without_apm', 'call'
 
           def call(command, &block)
-            name = command[0].upcase.to_s
-            type = 'db.redis'
-            redis_details = command[1].is_a?(String) ? command[1].split(':') : []
-            redis_nspace = !redis_details.blank? ? redis_details[0] : ''
-            redis_key = ''
+            begin
+              name = command[0].upcase.to_s
+              type = 'db.redis'
+              redis_details = command[1].is_a?(String) ? command[1].split(':') : []
+              # use length instead of .blank?
+              # reason: will throw error if activesupport missing
+              redis_nspace = redis_details.length ? redis_details[0] : ''
+              redis_key = ''
 
-            # Checks CACHEKEY value
-            if !redis_details.blank? && redis_details[1]
-              # Initially sets the CACHEKEY value
-              args = redis_details[1].split('/')
-              redis_key = args[0]
+              # Checks CACHEKEY value
+              if redis_details.length && redis_details[1]
+                # Initially sets the CACHEKEY value
+                args = redis_details[1].split('/')
+                redis_key = args[0]
 
-              # If command has passed __method__, it will be included in the CACHEKEY value
-              # Possible formats:
-              # `<namespace:key/method_name/expires_in=300/ttl=60/>`
-              # `<namespace:key/expires_in=300/ttl=60/>`
-              redis_key = args[0..1].join('/') if args.length > 1 && !args[1].include?('=')
-            end
+                # If command has passed __method__, it will be included in the CACHEKEY value
+                # Possible formats:
+                # `<namespace:key/method_name/expires_in=300/ttl=60/>`
+                # `<namespace:key/expires_in=300/ttl=60/>`
+                redis_key = args[0..1].join('/') if args.length > 1 && !args[1].include?('=')
+              end
 
-            return call_without_apm(command, &block) if command[0] == :auth
+              return call_without_apm(command, &block) if command[0] == :auth
 
-            context = {
-              PROVIDER: 'Redis',
-              CATEGORY: 'Cache',
-              SUBCATEGORY: 'Execute',
-              COMPONENT_CATEGORY: 'Cache',
-              COMPONENT_DETAIL: 'Execute',
-              THREAD_ID: Thread.current.object_id,
-              OPERATION: name
-            }.tap do |hash|
-              hash[:CACHEKEY] = redis_key unless redis_key.empty?
-              hash[:CACHENAME] = redis_nspace unless redis_nspace.empty?
-            end
+              context = {
+                PROVIDER: 'Redis',
+                CATEGORY: 'Cache',
+                SUBCATEGORY: 'Execute',
+                COMPONENT_CATEGORY: 'Cache',
+                COMPONENT_DETAIL: 'Execute',
+                THREAD_ID: Thread.current.object_id,
+                OPERATION: name,
+                URL: "#{self.options[:host]}:#{self.options[:port]}"
+              }.tap do |hash|
+                hash[:CACHEKEY] = redis_key unless redis_key.empty?
+                hash[:CACHENAME] = redis_nspace unless redis_nspace.empty?
+              end
 
-            ctx = Span::Context.new(context)
+              ctx = Span::Context.new(context)
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[RedisSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[RedisSpy] #{e.inspect}"
+              return call_without_apm(command, &block)
+            end
 
             StackifyRubyAPM.span name, type, context: ctx do
               call_without_apm(command, &block)

data/lib/stackify_apm/spies/sequel.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'stackify_apm/helper/database_helper'
+
 #
 # This class monkey patch the sequel.rb gem with the request method.
 #
@@ -33,17 +35,12 @@ module StackifyRubyAPM
             name = summarize sql
             db_adapter = ''
             db_adapter = args[0].class.to_s.gsub('::Database', '').downcase if args[0]
+            payload = {sql: sql, db_adapter: db_adapter, binds: defined?(args[1]) ? args[1]: []}
+            statement = query_variables(payload)
+            check_prepared_stmt(statement, payload)
+            ctx = Span::Context.new(statement)
 
-            context = Span::Context.new(
-              CATEGORY: 'Database',
-              SUBCATEGORY: 'Execute',
-              COMPONENT_CATEGORY: 'DB Query',
-              COMPONENT_DETAIL: 'Execute SQL Query',
-              SQL: sql,
-              PROVIDER: get_profiler(db_adapter)
-            )
-
-            StackifyRubyAPM.span(name, TYPE, context: context, &block)
+            StackifyRubyAPM.span(name, TYPE, context: ctx, &block)
           end
 
           # rubocop:disable Lint/UselessAssignment
@@ -55,7 +52,27 @@ module StackifyRubyAPM
                 end
               end || DEFAULT
           end
-          require 'stackify_apm/helper/database_helper'
+
+          def query_variables(payload)
+            props = get_common_db_properties
+            props[:PROVIDER] = get_profiler(payload[:db_adapter])
+            props[:SQL] = payload[:sql]
+            props
+          end
+
+          def check_prepared_stmt(statement, payload)
+            if StackifyRubyAPM.agent.config.prefix_enabled
+              case get_profiler(payload[:db_adapter])
+              when 'generic', 'mysql', 'sqlite', 'oracle', 'db2'
+                # We check the placeholder of sequel mysql by ? and sometimes sequel sqlite is using : or ?
+                if check_prepared_stmt_by_placeholder(payload[:sql].include?('?'), statement, payload)
+                else check_prepared_stmt_by_placeholder(payload[:sql].include?(':'), statement, payload)
+                end
+              when 'postgresql'
+                check_prepared_stmt_by_placeholder(!!payload[:sql].match(/\$\d/), statement, payload)
+              end
+            end
+          end
         end
         # rubocop:enable Lint/UselessAssignment
       end