stackify-ruby-apm 1.10.2 → 1.13.2

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/dynamo_db.rb

@@ -0,0 +1,50 @@
+# Monkey patch for the Aws::DynamoDB::Client class
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class DynamoDBSpy
+      TYPE = 'db.dynamo.aws'.freeze
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def install
+        Aws::DynamoDB::Client.class_eval do
+          # Alias all available operations
+          api.operation_names.each do |operation_name|
+            alias_method "#{operation_name}_without_apm", "#{operation_name}"
+
+            define_method(operation_name) do |params = {}, options = {}|
+              original_method = method("#{operation_name}_without_apm")
+              return original_method.call(params, options) unless StackifyRubyAPM.current_transaction
+
+              result = nil
+
+              begin
+                name = operation_name
+                ctx = Span::Context.new(
+                  CATEGORY: 'Database',
+                  SUBCATEGORY: 'DynamoDB',
+                  ACTION: operation_name,
+                )
+              rescue Exception => e
+                StackifyRubyAPM.agent.error "[DynamoDBSpy] Error: creating span context."
+                StackifyRubyAPM.agent.error "[DynamoDBSpy] #{e.inspect}"
+                return original_method.call(params, options)
+              end
+
+              StackifyRubyAPM.span name, TYPE, context: ctx do
+                result = original_method.call(params, options)
+                return result
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    # Registers Aws::DynamoDB::Client spy, go to: /stackify_apm/spies.rb
+    #
+    register 'Aws::DynamoDB::Client', 'aws-sdk-dynamodb', DynamoDBSpy.new
+  end
+end

data/lib/stackify_apm/spies/faraday.rb

@@ -0,0 +1,87 @@
+# Monkey patch for the Faraday class
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class FaradaySpy
+      def install
+        Faraday::Connection.class_eval do
+          alias_method 'run_request_without_apm', 'run_request'
+
+          def run_request(method, url, body, headers, &block)
+            result = nil
+            return run_request_without_apm(method, url, body, headers, &block) unless StackifyRubyAPM.current_transaction
+
+            begin
+              uri = URI(build_url(url))
+
+              # url is not available yet if it is set inside block
+              # we need to build temporary request as of now
+              # NOTE: this could have a side effect doing yeild twice
+              unless uri.host
+                tmp_request = build_request(method) do |req|
+                  yield(req) if block_given?
+                end
+                uri = URI(tmp_request.path)
+              end
+
+              host = uri.host
+              method_upcase = method.to_s.upcase
+              name = "#{method_upcase} #{host}"
+              type = "ext.faraday.#{method_upcase}"
+
+              # Builds span context
+              #
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: '',
+                METHOD: method_upcase
+              )
+            rescue Exception => e
+              StackifyRubyAPM.agent.error "[FaradaySpy] Error: creating span context."
+              StackifyRubyAPM.agent.error "[FaradaySpy] #{e.inspect}"
+              return run_request_without_apm(method, url, body, headers, &block)
+            end
+
+            # Creates new span from HTTP result
+            #
+            StackifyRubyAPM.span name, type, context: ctx do
+              # Submits HTTP request
+              #
+              result = run_request_without_apm(method, url, body, headers) do |req|
+                yield req if block_given?
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_request_body(req.body || body || "")
+                  ctx.update_request_headers(req.headers || headers || Hash.new)
+                end
+              end
+
+              begin
+                status_code = result.status.to_s
+                ctx.update_status(status_code)
+
+                if StackifyRubyAPM.agent.config.prefix_enabled
+                  ctx.update_response_body(result.body || "")
+                  ctx.update_response_headers(result.headers || Hash.new)
+                end
+              rescue Exception => e
+                StackifyRubyAPM.agent.error '[FaradaySpy] Error: getting status code or updating request/response context.'
+                StackifyRubyAPM.agent.error "[FaradaySpy] #{e.inspect}"
+              end
+              return result
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    # Registers Faraday spy, go to: /stackify_apm/spies.rb
+    #
+    register 'Faraday', 'faraday', FaradaySpy.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