stackify-ruby-apm 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37b3e9d03e3a48f658ac93e0c7fb2bde7ff1bbe4b477d8db6307288182da1218
-  data.tar.gz: d85d9a3ebefa5f9fa86b232887087634c7fa3a464b8a430da6f43ec1e2a76973
+  metadata.gz: 5644c5079318a7c3529770465f45372106c02a8334b4648880cee789495c9a17
+  data.tar.gz: 6309a247094d7795b7abf970bf7ca46c3ea6a499de6aa03cb8b92c22080ee191
 SHA512:
-  metadata.gz: 6d7ad0838dc3db4eedb0f1dd9dfdc7ad7987952fcbdb8a5b1e852ecd2451b4193cf6f7e3df70046db7b9766834a23313e059bb5ea9752b965bba79c5332330d0
-  data.tar.gz: e5bddb17c802ee238fb73ad50b4208ff91b5072b6057726977478d61189cab9812eaef7df8153688722118fb7fbd5e69869c963d35c17a4084a33e1f16e7420b
+  metadata.gz: b3ebbe0dc60d749aa5cffde012ac3f5fa815fd3b1a52c110fc9ff213ab7252a69a1d43dc951f3578c725cfdc32e29b3b1a1f59666293357c3f86deabefd6b5f5
+  data.tar.gz: 97a7f413c89124d246d4c499c8fada9e6c2373a21adc3e096fcce9c8dadd1cb0e32e55b300cbe1c4c3a633711444ef3822796596047cf2b25629f7fc00d1b0fa

data/README.md

@@ -25,6 +25,14 @@
     ```
 5. Build/Deploy your application
 
+###  Custom Instrumentation in Rails
+
+In the config/initializer folder of your Rails app create a file `config/initializer/stackify.rb` and then add this configuration
+
+    Rails.configuration.to_prepare do
+      StackifyRubyAPM.run_custom_instrument
+    end
+
 ### Non-Rails Guide 
 
 1. Install **Stackify Linux Agent**. 
@@ -47,9 +55,21 @@
 
 5. In the `config.ru` add the following lines:
 
-    ``` use StackifyRubyAPM::Middleware
+    ```
+        use StackifyRubyAPM::Middleware
         StackifyRubyAPM.start
         at_exit { StackifyRubyAPM.stop }
     ```
 
 6. Build/Deploy your application
+
+###  Custom Instrumentation in Non-Rails
+
+In `config.ru` file add this line: StackifyRubyAPM.run_custom_instrument
+
+Example:
+
+        use StackifyRubyAPM::Middleware
+        StackifyRubyAPM.start
+        StackifyRubyAPM.run_custom_instrument
+        at_exit { StackifyRubyAPM.stop }

data/lib/stackify_apm/config.rb

@@ -175,6 +175,7 @@ module StackifyRubyAPM
         curb
         curb/easy
         curb/multi
+        httparty
         stackify_logger
       ]
     end
@@ -312,21 +313,21 @@ module StackifyRubyAPM
       @device_id = nil
       @client_run_domain = nil
       begin
-        info 'Reading the Stackify props in Environment variables'
+        info '[Config] Reading the Stackify props in Environment variables'
         @client_run_domain = ENV['STACKIFY_RUM_DOMAIN'] || nil
         if ENV['STACKIFY_ENV']
           props = ENV['STACKIFY_ENV'].split('|')
           @client_id = props[0].to_s if props[0]
           @device_id = props[1].to_s if props[1]
-          info "stackify.properties: clientId=#{@client_id}, deviceId=#{@device_id}, client_rum_domain=#{@client_run_domain}"
+          info "[Config] stackify.properties: clientId=#{@client_id}, deviceId=#{@device_id}, client_rum_domain=#{@client_run_domain}"
         end
       rescue StandardError => e
-        info 'Error occured while reading the Stackify props in Environment variables.'
+        info '[Config] Error occured while reading the Stackify props in Environment variables.'
         info e.inspect
       end
-      info 'No clientId found in environment variables.' if @client_id.nil?
-      info 'No deviceId found in environment variables.' if @device_id.nil?
-      info 'No client RUM domain found in environment variables.' if @client_run_domain.nil?
+      info '[Config] No clientId found in environment variables.' if @client_id.nil?
+      info '[Config] No deviceId found in environment variables.' if @device_id.nil?
+      info '[Config] No client RUM domain found in environment variables.' if @client_run_domain.nil?
     end
     # rubocop:enable Metrics/CyclomaticComplexity
     # rubocop:enable Metrics/PerceivedComplexity

data/lib/stackify_apm/instrumenter_helper.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# This class will custom instrument a class and method
+
+module StackifyRubyAPM
+  # @api private
+  class InstrumenterHelper
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Lint/UselessAssignment
+    # rubocop:disable Security/Eval
+    attr_accessor :custom_instrumented, :custom_class_info
+    @custom_instrumented = {}
+    @custom_class_info = {}
+
+    def self.custom_instrumented_reset
+      @custom_instrumented.each do |custom_instrument, values|
+        current_class = custom_instrument
+        module_consget = Module.const_get(current_class)
+        values.each_key do |current_method|
+          is_method_exists = StackifyRubyAPM::Spies.ismethod_exists(current_class, current_method)
+          if is_method_exists
+            @custom_instrumented[current_class.to_s][current_method.to_s] = false
+          end
+        end
+      end
+    end
+
+    def self.m_class(tracked_func, current_class, class_path, current_method, tracked_function_name)
+      module_consget = Module.const_get(current_class)
+      classspyitem = "#{current_class}Spy"
+      module_consget_spy = Module.const_get(current_class)
+      current_method_without = "_without_apm_#{current_method}"
+
+      unless @custom_instrumented[current_class.to_s]
+        @custom_instrumented[current_class.to_s] = {}
+      end
+
+      unless @custom_instrumented[current_class.to_s][current_method.to_s]
+        @custom_instrumented[current_class.to_s][current_method.to_s] = false
+      end
+
+      unless @custom_class_info[current_class.to_s]
+        @custom_class_info[current_class.to_s] = {}
+      end
+
+      unless @custom_class_info[current_class.to_s]['controller']
+        @custom_class_info[current_class.to_s]['controller'] = false
+      end
+
+      unless @custom_class_info[current_class.to_s]['model']
+        @custom_class_info[current_class.to_s]['model'] = false
+      end
+
+      return unless @custom_instrumented[current_class.to_s][current_method.to_s] == false
+
+      eval <<-RUBY
+        class #{classspyitem}
+          def install
+            #{current_class}.class_eval do
+              alias_method "#{current_method_without}", "#{current_method}"
+
+              def #{current_method}(*args, &block)
+                return #{current_method_without}(*args, &block) unless StackifyRubyAPM.current_transaction
+
+                name = "Custom Instrument"
+                type = "#{current_class}##{current_method}"
+                ctx = if "#{tracked_func}" == 'true'
+                        Span::Context.new(
+                          CATEGORY: 'Ruby',
+                          TRACKED_FUNC: "#{tracked_function_name}"
+                        )
+                      else
+                        Span::Context.new(
+                          CATEGORY: 'Ruby'
+                        )
+                      end
+
+                req = #{current_method_without}(*args, &block)
+                StackifyRubyAPM.span name, type, context: ctx do
+                    req
+                end
+              end
+            end
+          end
+        end
+        StackifyRubyAPM::Spies.register current_class.to_s, class_path.to_s, #{classspyitem}.new, true, "#{current_method}", "#{tracked_func}", "#{tracked_function_name}"
+      RUBY
+
+      @custom_instrumented[current_class.to_s][current_method.to_s] = true
+      @custom_class_info[current_class.to_s]['controller'] = true if class_path && class_path.include?('controllers')
+      @custom_class_info[current_class.to_s]['model'] = true if class_path && class_path.include?('models')
+    end
+
+    def self.m_singleton(tracked_func, current_class, class_path, current_method, tracked_function_name)
+      module_consget = Module.const_get(current_class)
+      classspyitem = "#{current_class}Spy"
+
+      unless @custom_instrumented[current_class.to_s]
+        @custom_instrumented[current_class.to_s] = {}
+      end
+
+      unless @custom_instrumented[current_class.to_s][current_method.to_s]
+        @custom_instrumented[current_class.to_s][current_method.to_s] = false
+      end
+
+      unless @custom_class_info[current_class.to_s]
+        @custom_class_info[current_class.to_s] = {}
+      end
+
+      unless @custom_class_info[current_class.to_s]['controller']
+        @custom_class_info[current_class.to_s]['controller'] = false
+      end
+
+      unless @custom_class_info[current_class.to_s]['model']
+        @custom_class_info[current_class.to_s]['model'] = false
+      end
+
+      return unless @custom_instrumented[current_class.to_s][current_method.to_s] == false
+
+      eval <<-RUBY
+        class #{classspyitem}
+          def install
+            #{current_class}.class_eval do
+              singleton_class.send(:alias_method, :"_self_without_apm_#{current_method}", :"#{current_method}")
+
+              def self.#{current_method}(*args, &block)
+                return _self_without_apm_#{current_method}(*args, &block) unless StackifyRubyAPM.current_transaction
+
+                name = "Custom Instrument"
+                type = "#{current_class}##{current_method}"
+                ctx = if "#{tracked_func}" == 'true'
+                        Span::Context.new(
+                          CATEGORY: 'Ruby',
+                          TRACKED_FUNC: "#{tracked_function_name}"
+                        )
+                      else
+                        Span::Context.new(
+                          CATEGORY: 'Ruby'
+                        )
+                      end
+                req = _self_without_apm_#{current_method}(*args, &block)
+                StackifyRubyAPM.span name, type, context: ctx do
+                  req
+                end
+              end
+
+              def self.get_class_name
+                return self.class.name
+              end
+            end
+          end
+        end
+        StackifyRubyAPM::Spies.register current_class.to_s, class_path.to_s, #{classspyitem}.new, true, "#{current_method}", "#{tracked_func}", "#{tracked_function_name}"
+      RUBY
+      @custom_instrumented[current_class.to_s][current_method.to_s] = true
+      @custom_class_info[current_class.to_s]['controller'] = true if class_path && class_path.include?('controllers')
+      @custom_class_info[current_class.to_s]['model'] = true if class_path && class_path.include?('models')
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Lint/UselessAssignment
+    # rubocop:enable Security/Eval
+  end
+end

data/lib/stackify_apm/logger/logger_high_version.rb

@@ -5,6 +5,7 @@
 #
 # @param file
 # @removed the header of the generated log
+require 'logger'
 module StackifyRubyAPM
   # @api private
   class StackifyLogger < Logger

data/lib/stackify_apm/logger/logger_lower_version.rb

@@ -5,6 +5,7 @@
 #
 # @param file
 # @removed the header of the generated log
+require 'logger'
 module StackifyRubyAPM
   # @api private
   class StackifyLogger < Logger

data/lib/stackify_apm/serializers/transactions.rb

@@ -47,7 +47,12 @@ module StackifyRubyAPM
       end
 
       def build_span(span)
-        span_type = span.type
+        span_type = if span.name == 'Custom Instrument'
+                      "custom.#{span.type}"
+                    else
+                      span.type
+                    end
+
         span_context = span.context && span.context.to_h
 
         {

data/lib/stackify_apm/span/context.rb

@@ -28,6 +28,11 @@ module StackifyRubyAPM
                     :THREAD_ID,
                     :ID,
                     :TRACKED_FUNC
+      # rubocop:disable Style/VariableName
+      def update_status(status)
+        @STATUS = status
+      end
+      # rubocop:enable Style/VariableName
     end
   end
 end

data/lib/stackify_apm/spies.rb

@@ -13,14 +13,19 @@ module StackifyRubyAPM
     # @api private
     class Registration
       extend Forwardable
-
-      def initialize(const_name, require_paths, spy)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(const_name, require_paths, spy, custom_instrumented = false, custom_method = '', tracked_func = false, tracked_function_name = '')
         @const_name = const_name
         @require_paths = Array(require_paths)
         @spy = spy
+        @custom_instrumented = custom_instrumented
+        @custom_method = custom_method
+        @tracked_func = tracked_func
+        @tracked_function_name = tracked_function_name
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      attr_reader :const_name, :require_paths
+      attr_reader :const_name, :require_paths, :custom_instrumented, :custom_method, :tracked_func, :tracked_function_name
 
       def_delegator :@spy, :install
     end
@@ -71,7 +76,6 @@ module StackifyRubyAPM
       if ENV['STACKIFY_RUBY_ENV'] == 'rspec'
         file = 'spec/integration/stackify_spec.json'
       end
-
       return unless File.exist?(file)
 
       File.open(file) do |f|
@@ -86,6 +90,35 @@ module StackifyRubyAPM
     rescue NameError
       return false
     end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.ismethod_exists(class_name, current_method)
+      module_consget = Module.const_get(class_name)
+      current_method_without_apm = "_without_apm_#{current_method}"
+      self_current_method_without_apm = "_self_without_apm_#{current_method}"
+
+      with_flag = module_consget.instance_methods(false).include?(:"#{current_method_without_apm}")
+      self_with_flag = module_consget.instance_methods(false).include?(:"#{self_current_method_without_apm}")
+
+      current_method_exists = module_consget.instance_methods(false).include?(:"#{current_method}")
+      self_current_method_exists = module_consget.instance_methods(false).include?(:"self.#{current_method}")
+
+      exists = false
+      if (self_with_flag == false && with_flag == false) &&
+         (current_method_exists == true || self_current_method_exists == true)
+        exists = true
+      end
+
+      if (module_consget.methods.include?(:"#{current_method_without_apm}") == false &&
+         module_consget.methods.include?(:"#{self_current_method_without_apm}") == false) &&
+         (module_consget.methods.include?(:"#{current_method}") || module_consget.methods.include?(:"self.#{current_method}"))
+        exists = true
+      end
+      exists
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
   end
 end
 

data/lib/stackify_apm/spies/custom_instrumenter.rb

@@ -3,89 +3,31 @@
 # Monkey patch for the custom instrumentation any values from config/stackify.json will be loop and will
 # register as a spy.
 #
+require 'stackify_apm/instrumenter_helper.rb'
 require 'stackify_apm/config'
 require 'json'
-
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/PerceivedComplexity
 module StackifyRubyAPM
   # @api private
   module Spies
-    def self.m_class(tracked_func, current_class, current_method, tracked_function_name)
-      Module.const_get(current_class.to_s).class_eval <<-RUBY
-        alias :"__without_apm_#{current_method}" :"#{current_method}"
-
-        def #{current_method}(*args, &block)
-          return __without_apm_#{current_method}(*args, &block) unless StackifyRubyAPM.current_transaction
-          name = "Custom Instrument"
-          type = "#{current_class}##{current_method}"
-          ctx = if "#{tracked_func}" == 'true'
-                  Span::Context.new(
-                    CATEGORY: 'Ruby',
-                    TRACKED_FUNC: "#{tracked_function_name}"
-                  )
-                else
-                  Span::Context.new(
-                    CATEGORY: 'Ruby'
-                  )
-                end
-          req = __without_apm_#{current_method}(*args, &block)
-          StackifyRubyAPM.span name, type, context: ctx do
-            req
-          end
-        end
-
-        def get_class_name
-          return self.class.name
-        end
-      RUBY
-    end
-
-    def self.m_singleton(tracked_func, current_class, current_method, tracked_function_name)
-      Module.const_get(current_class.to_s).class_eval <<-RUBY
-        singleton_class.send(:alias_method, :"__self_without_apm_#{current_method}", :"#{current_method}")
-
-        def self.#{current_method}(*args, &block)
-          return __self_without_apm_#{current_method}(*args, &block) unless StackifyRubyAPM.current_transaction
+    def self.run_custom_instrumentation
+      config = Config.new
+      to_instrument = parse_json_config(config.json_config_file)
+      if config.logger.nil?
+        config.debug_logger
+        config.logger.send(:info, '[StackifyRubyAPM] Error: config/stackify.json does not exist which is required for custom instrumentation!') if to_instrument.nil?
+      end
 
-          name = "Custom Instrument"
-          type = "#{current_class}##{current_method}"
-          ctx = if "#{tracked_func}" == 'true'
-                  Span::Context.new(
-                    CATEGORY: 'Ruby',
-                    TRACKED_FUNC: "#{tracked_function_name}"
-                  )
-                else
-                  Span::Context.new(
-                    CATEGORY: 'Ruby'
-                  )
-                end
-          req = __self_without_apm_#{current_method}(*args, &block)
-          StackifyRubyAPM.span name, type, context: ctx do
-            req
-          end
-        end
+      return unless !to_instrument.nil? && !to_instrument.empty? && defined?(to_instrument['instrumentation']) && (to_instrument['instrumentation'].count > 0)
 
-        def self.get_class_name
-          return self.class.name
-        end
-      RUBY
-    end
-
-    config = Config.new
-    to_instrument = parse_json_config(config.json_config_file)
-    if defined?(to_instrument['instrumentation']) && (to_instrument['instrumentation'].count > 0)
       to_instrument['instrumentation'].each do |custom_spy|
         current_class = custom_spy['class']
         current_method = custom_spy['method']
         tracked_func = custom_spy['trackedFunction']
-        tracked_func_name = if defined?(custom_spy['trackedFunctionName'])
-                              custom_spy['trackedFunctionName']
-                            end
+        tracked_func_name = defined?(custom_spy['trackedFunctionName']) ? custom_spy['trackedFunctionName'] : ''
 
-        tracked_function_tpl = if tracked_func_name.nil?
-                                 '{{ClassName}}.{{MethodName}}'
-                               else
-                                 tracked_func_name
-                               end
+        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
@@ -95,10 +37,17 @@ module StackifyRubyAPM
           mod_constant = Module.const_get(current_class.to_s)
           klass_method_flag = mod_constant.method_defined?(current_method.to_s)
           singleton_method_flag = mod_constant.respond_to?(current_method.to_s)
+
+          class_location = mod_constant.instance_methods(false).map do |m|
+            mod_constant.instance_method(m).source_location.first
+          end.uniq
+
+          class_path = class_location.last
+
           if klass_method_flag
-            StackifyRubyAPM::Spies.m_class(tracked_func, current_class, current_method, tracked_function_name)
+            StackifyRubyAPM::InstrumenterHelper.m_class(tracked_func, current_class, class_path, current_method, tracked_function_name)
           elsif singleton_method_flag
-            StackifyRubyAPM::Spies.m_singleton(tracked_func, current_class, current_method, tracked_function_name)
+            StackifyRubyAPM::InstrumenterHelper.m_singleton(tracked_func, current_class, class_path, current_method, tracked_function_name)
           end
         end
         # rubocop:enable Style/Next
@@ -106,3 +55,5 @@ module StackifyRubyAPM
     end
   end
 end
+# rubocop:enable Metrics/CyclomaticComplexity
+# rubocop:enable Metrics/PerceivedComplexity

data/lib/stackify_apm/spies/httparty.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Monkey patch for the CurbSpy class for sending & receiving Curb responses.
+#
+require 'stackify_apm/config'
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class HTTPartySpy
+      def install
+        # puts HTTParty::ClassMethods.instance_methods(false).inspect
+        HTTParty::ClassMethods.module_eval do
+          alias_method 'perform_request_without_apm', 'perform_request'
+
+          # singleton_class.send(:alias_method, :perform_request_without_apm, :perform_request)
+
+          private :perform_request
+
+          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
+            )
+            # 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
+            end
+          end
+        end
+      end
+    end
+    # Registers CurbSpy spy, go to: /stackify/spies.rb
+    #
+    register 'HTTParty::ClassMethods', 'httparty', HTTPartySpy.new
+  end
+end

data/lib/stackify_apm/spies/net_http.rb

@@ -11,9 +11,8 @@ module StackifyRubyAPM
 
           def request(req, body = nil, &block)
             result = nil
-            unless StackifyRubyAPM.current_transaction
-              request_without_apm(req, body, &block)
-            end
+            return request_without_apm(req, body, &block) unless StackifyRubyAPM.current_transaction
+            return request_without_apm(req, body, &block) if started? && req['span']
 
             # Data configuration
             #
@@ -25,23 +24,25 @@ module StackifyRubyAPM
             name = "#{method} #{host}"
             type = "ext.net_http.#{method}"
 
-            # Submits HTTP request
-            #
-            result = request_without_apm(req, body, &block)
-
             # Builds span context
             #
             ctx = Span::Context.new(
               CATEGORY: 'Web External',
               SUBCATEGORY: 'Execute',
               URL: req.uri.nil? ? host : req.uri,
-              STATUS: result.code.to_i,
+              STATUS: '',
               METHOD: method
             )
 
             # Creates new span from HTTP result
             #
             StackifyRubyAPM.span name, type, context: ctx do
+              # Submits HTTP request
+              #
+              req['span'] = true
+              result = request_without_apm(req, body, &block)
+              status_code = result.code.to_i
+              ctx.update_status(status_code)
               return result
             end
           end

data/lib/stackify_apm/version.rb

@@ -2,5 +2,5 @@
 
 # Sets the version of the APM
 module StackifyRubyAPM
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.5.0'.freeze
 end

data/lib/stackify_ruby_apm.rb

@@ -16,9 +16,9 @@
 require 'stackify_apm/log'
 require 'stackify_apm/version'
 require 'stackify_apm/util/dig'
-require 'stackify_apm/agent'
 # Checks ruby version
 require RUBY_VERSION.to_f >= 2.4 ? 'stackify_apm/logger/logger_high_version' : 'stackify_apm/logger/logger_lower_version'
+require 'stackify_apm/agent'
 require 'stackify_apm/helper/database_helper'
 require 'stackify_apm/util'
 require 'stackify_apm/config'
@@ -27,6 +27,7 @@ require 'stackify_apm/instrumenter'
 require 'stackify_apm/internal_error'
 # require 'stackify_apm/util'
 require 'stackify_apm/middleware'
+require 'stackify_apm/instrumenter_helper'
 
 # Checks if the framework using is Rails
 require 'stackify_apm/railtie' if defined?(::Rails::Railtie)
@@ -65,6 +66,13 @@ module StackifyRubyAPM
     data-a=\"#{config.application_name}\" data-e=\"#{config.environment_name}\" data-enableInternalLogging=\"#{config.debug_logging}\" type=\"text/javascript\" async></script>"
   end
 
+  # Run the custom instrument
+  def self.run_custom_instrument
+    return unless running?
+    StackifyRubyAPM::InstrumenterHelper.custom_instrumented_reset
+    StackifyRubyAPM::Spies.run_custom_instrumentation
+  end
+
   # Stops the StackifyRubyAPM Agent
   def self.stop
     Agent.stop

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackify-ruby-apm
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Stackify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-18 00:00:00.000000000 Z
+date: 2019-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,6 +127,7 @@ files:
 - lib/stackify_apm/error_builder.rb
 - lib/stackify_apm/helper/database_helper.rb
 - lib/stackify_apm/instrumenter.rb
+- lib/stackify_apm/instrumenter_helper.rb
 - lib/stackify_apm/internal_error.rb
 - lib/stackify_apm/log.rb
 - lib/stackify_apm/logger/log_device.rb
@@ -153,6 +154,7 @@ files:
 - lib/stackify_apm/spies/curb/easy.rb
 - lib/stackify_apm/spies/curb/multi.rb
 - lib/stackify_apm/spies/custom_instrumenter.rb
+- lib/stackify_apm/spies/httparty.rb
 - lib/stackify_apm/spies/httpclient.rb
 - lib/stackify_apm/spies/httprb.rb
 - lib/stackify_apm/spies/mongo.rb