stackify-ruby-apm 1.10.0 → 1.12.3

data/lib/stackify_apm/spies/curb/multi.rb

@@ -14,19 +14,33 @@ module StackifyRubyAPM
           def self.http(urls_with_config, _multi_options = {}, &blk)
             return http_without_apm(urls_with_config, _multi_options = {}, &blk) unless StackifyRubyAPM.current_transaction
             http_without_apm(urls_with_config, _multi_options = {}) do |c, code, method|
-              status_code = code.zero? ? 404 : code
-              method = method.upcase
-              uri = c.url.to_s.strip
-              name = "#{method} #{uri}"
-              type = "ext.Curb.Multi.#{method}"
+              begin
+                status_code = code.zero? ? 404 : code
+                method = method.upcase
+                uri = c.url.to_s.strip
+                name = "#{method} #{uri}"
+                type = "ext.Curb.Multi.#{method}"
+
+                ctx = Span::Context.new(
+                  CATEGORY: 'Web External',
+                  SUBCATEGORY: 'Execute',
+                  URL: uri,
+                  STATUS: status_code,
+                  METHOD: method
+                )
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(c.post_body || "")
+                  ctx.update_request_headers(c.headers || Hash.new)
+                  ctx.update_response_body(c.body || "")
+                  ctx.update_response_headers(c.proxy_headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error "[CurbMultiSpy] Error: creating span context."
+                StackifyRubyAPM.agent.error "[CurbMultiSpy] #{e.inspect}"
+                return blk.call(c, code, method)
+              end
 
-              ctx = Span::Context.new(
-                CATEGORY: 'Web External',
-                SUBCATEGORY: 'Execute',
-                URL: uri,
-                STATUS: status_code,
-                METHOD: method
-              )
               # Creates new span from HTTP result
               StackifyRubyAPM.span name, type, context: ctx do
                 blk.call(c, code, method)

data/lib/stackify_apm/spies/custom_instrumenter.rb

@@ -24,16 +24,37 @@ module StackifyRubyAPM
       return unless !to_instrument.nil? && !to_instrument.empty? && defined?(to_instrument['instrumentation']) && (to_instrument['instrumentation'].count > 0)
 
       to_instrument['instrumentation'].each do |custom_spy|
-        current_class = custom_spy['class']
+        current_class = defined?(custom_spy['class']) ? custom_spy['class'] : nil
+        current_module = defined?(custom_spy['module']) ? custom_spy['module'] : nil
         current_method = custom_spy['method']
         tracked_func = custom_spy['trackedFunction']
         tracked_func_name = defined?(custom_spy['trackedFunctionName']) ? custom_spy['trackedFunctionName'] : ''
         transaction = defined?(custom_spy['transaction']) ? custom_spy['transaction'] : nil
         file_path = defined?(custom_spy['file_path']) ? custom_spy['file_path'] : nil
 
-        tracked_function_tpl = tracked_func_name.nil? ? '{{ClassName}}.{{MethodName}}' : tracked_func_name
-        tracked_function_name = tracked_function_tpl.sub '{{ClassName}}', current_class
-        tracked_function_name = tracked_function_name.sub '{{MethodName}}', current_method
+        if current_class
+          tracked_function_tpl = tracked_func_name.nil? ? '{{ClassName}}.{{MethodName}}' : tracked_func_name
+          tracked_function_name = tracked_function_tpl.to_s.sub '{{ClassName}}', current_class
+          tracked_function_name = tracked_function_name.to_s.sub '{{MethodName}}', current_method
+        elsif current_module
+          tracked_function_tpl = tracked_func_name.nil? ? '{{ModuleName}}.{{MethodName}}' : tracked_func_name
+          tracked_function_name = tracked_function_tpl.to_s.sub '{{ModuleName}}', current_module
+          tracked_function_name = tracked_function_name.to_s.sub '{{MethodName}}', current_method
+        end
+
+        begin
+          if current_module
+            if file_path.nil?
+              config.logger.send(:info, "[StackifyRubyAPM] Error: Missing file_path in module which is required in custom instrumentation.")
+            else
+              require file_path
+              StackifyRubyAPM::InstrumenterHelper.patched_module(tracked_func, current_module, file_path,
+                current_method: current_method, tracked_function_name: tracked_function_name, is_transaction: transaction)
+            end
+          end
+        rescue => e
+          throw e
+        end
 
         if !class_exists?(current_class) && !file_path.nil?
           begin

data/lib/stackify_apm/spies/delayed_job.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Monkey patch for the delayed_job class for running async tasks.
+#
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class DelayedJobSpy
+      def install
+        Delayed::Backend::Base.class_eval do
+          alias_method 'invoke_job_without_apm', 'invoke_job'
+
+          def invoke_job(*args, &block)
+            ret = nil
+            begin
+              name = nil
+              if payload_object.is_a?(::Delayed::PerformableMethod)
+                object = payload_object.object
+                klass = object.is_a?(Class) ? object : object.class
+                class_name = klass.name
+                separator = payload_object.object.is_a?(Class) ? '.' : '#'
+                method_name = payload_object.method_name
+                name = "#{class_name}#{separator}#{method_name}"
+              else
+                name = payload_object.class.name
+              end
+              ctx = StackifyRubyAPM::Context.new
+              ctx.category = 'Delayed::Job'
+              transaction = StackifyRubyAPM.transaction name, 'TASK', context: ctx
+              ret = invoke_job_without_apm(*args, &block)
+            rescue StackifyRubyAPM::InternalError
+              raise # Don't report StackifyRubyAPM errors
+            rescue StandardError => e
+              StackifyRubyAPM.report e
+              raise e
+            ensure
+              transaction.submit()
+            end
+            ret
+          end
+        end
+      end
+    end
+
+    register 'Delayed::Backend::Base', 'delayed/backend/base', DelayedJobSpy.new
+  end
+end

data/lib/stackify_apm/spies/httparty.rb

@@ -21,34 +21,55 @@ module StackifyRubyAPM
           def perform_request(http_method, path, options, &block)
             req = nil
             return perform_request_without_apm(http_method, path, options, &block) unless StackifyRubyAPM.current_transaction
-            # Data configuration
-            #
-            method = http_method.to_s.gsub('Net::HTTP::', '').upcase
-            uri = path.strip
-            name = "#{method} #{uri}"
-            type = "ext.HTTParty.#{method}"
-            # Submits HTTP request
-            #
-            # req = perform_request_without_apm(http_method, path, options, &block)
-            # Builds span context
-            #
-            # status_code = req.code
-
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: '',
-              METHOD: method
-            )
+
+            begin
+              # Data configuration
+              #
+              method = http_method.to_s.gsub('Net::HTTP::', '').upcase
+              uri = path.strip
+              name = "#{method} #{uri}"
+              type = "ext.HTTParty.#{method}"
+              # Submits HTTP request
+              #
+              # req = perform_request_without_apm(http_method, path, options, &block)
+              # Builds span context
+              #
+              # status_code = req.code
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[HTTPartySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[HTTPartySpy] #{e.inspect}"
+              return perform_request_without_apm(http_method, path, options, &block)
+            end
+
             # Creates new span from HTTP result
             #
             # class_info = { 'classname' => 'httparty', 'hostname' => URI.parse(uri).host }
             StackifyRubyAPM.span name, type, context: ctx do
-              req = perform_request_without_apm(http_method, path, options, &block)
-              status_code = req.code
-              ctx.update_status(status_code)
-              req
+              res = perform_request_without_apm(http_method, path, options, &block)
+
+              begin
+                status_code = res.code
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(options[:body] || "")
+                  ctx.update_request_headers(options[:headers] || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.each_header || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[HTTPartySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[HTTPartySpy] #{e.inspect}"
+              end
+              res
             end
           end
         end

data/lib/stackify_apm/spies/httpclient.rb

@@ -16,31 +16,52 @@ module StackifyRubyAPM
             req = nil
             return request_without_apm(method, uri, *args, &block) unless StackifyRubyAPM.current_transaction
 
-            # Data configuration
-            #
-            method = method.upcase
-            uri = uri.strip
-            name = "#{method} #{uri}"
-            type = "ext.httpclient.#{method}"
-
-            # Submits HTTP request
-            #
-            req = request_without_apm(method, uri, *args, &block)
+            begin
+              # Data configuration
+              #
+              method = method.upcase
+              uri = uri.strip
+              name = "#{method} #{uri}"
+              type = "ext.httpclient.#{method}"
 
-            # Builds span context
-            #
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: req.status_code,
-              METHOD: method
-            )
+              # Builds span context
+              #
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[HTTPClientSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[HTTPClientSpy] #{e.inspect}"
+              return request_without_apm(method, uri, *args, &block)
+            end
 
             # Creates new span from HTTP result
             #
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              # Submits HTTP request
+              #
+              res = request_without_apm(method, uri, *args, &block)
+
+              begin
+                ctx.update_status(res.status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  options = args && args[0] || Hash.new
+                  ctx.update_request_body(options[:body] || "")
+                  ctx.update_request_headers(options[:header] || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[HTTPClientSpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[HTTPClientSpy] #{e.inspect}"
+              end
+
+              res
             end
           end
         end

data/lib/stackify_apm/spies/httprb.rb

@@ -10,28 +10,49 @@ module StackifyRubyAPM
     class HTTPRbSpy
       def install
         HTTP::Client.class_eval do
-          alias_method 'request_without_apm', 'request'
+          alias_method 'perform_without_apm', 'perform'
 
           # Make HTTP request
-          def request(verb, uri, _opts = {})
-            return request_without_apm(verb, uri, _opts = {}) unless StackifyRubyAPM.current_transaction
-
-            method = verb.upcase
-            uri = uri.strip
-            name = "#{method} #{uri}"
-            type = "ext.httprb.#{method}"
-
-            req = request_without_apm(verb, uri, _opts = {})
-            ctx = Span::Context.new(
-              CATEGORY: 'Web External',
-              SUBCATEGORY: 'Execute',
-              URL: uri,
-              STATUS: req.code,
-              METHOD: method
-            )
+          def perform(req, options)
+            return perform_without_apm(req, options) unless StackifyRubyAPM.current_transaction
+
+            begin
+              method = req.verb.upcase
+              uri = req.uri.to_s.strip
+              name = "#{method} #{uri}"
+              type = "ext.httprb.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[HTTPRbSpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[HTTPRbSpy] #{e.inspect}"
+              return perform_without_apm(req, options)
+            end
 
             StackifyRubyAPM.span name, type, context: ctx do
-              req
+              res = perform_without_apm(req, options)
+
+              begin
+                ctx.update_status(res.code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(req.body.source || "")
+                  ctx.update_request_headers(req.headers || Hash.new)
+                  ctx.update_response_body(res.body || "")
+                  ctx.update_response_headers(res.headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[HTTPRbSpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[HTTPRbSpy] #{e.inspect}"
+              end
+
+              res
             end
           end
         end

data/lib/stackify_apm/spies/log4r.rb

@@ -0,0 +1,59 @@
+# 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
+              )
+
+              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,116 @@
+# 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
+          )
+
+          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