stackify-ruby-apm 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5644c5079318a7c3529770465f45372106c02a8334b4648880cee789495c9a17
-  data.tar.gz: 6309a247094d7795b7abf970bf7ca46c3ea6a499de6aa03cb8b92c22080ee191
+  metadata.gz: 9e21411e3d9be64aa1c8907e09552f6aac44ecf712e59065d1a1156381c9a278
+  data.tar.gz: a0b0aaa469349611840c4b222c920a87253678ab1d681969f4a5b5804cb40515
 SHA512:
-  metadata.gz: b3ebbe0dc60d749aa5cffde012ac3f5fa815fd3b1a52c110fc9ff213ab7252a69a1d43dc951f3578c725cfdc32e29b3b1a1f59666293357c3f86deabefd6b5f5
-  data.tar.gz: 97a7f413c89124d246d4c499c8fada9e6c2373a21adc3e096fcce9c8dadd1cb0e32e55b300cbe1c4c3a633711444ef3822796596047cf2b25629f7fc00d1b0fa
+  metadata.gz: 61300001e05eb6eb32b0adfb66eead66dac56eea502fb1f64da60cfcdc51c5d33bf96f284f433441adb2488779f709307d9c05d5fc97c8271114dbf155be5413
+  data.tar.gz: ebd7cc6ff9e131f89ff38152135fc82eb22b8955ec417959edb4bfa63843cfbc2fce4608e8241d14832b43dc88e24dbc1c096ea2789e1cfd7d7323ea0c8eb61b

data/README.md

@@ -26,8 +26,24 @@
 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
+1. Create `config/stackify.json` file from the root of your app and place the class name and method name in which you want to instrument.
+
+Example stackify.json:
+```
+{
+  "instrumentation": [
+  {
+    "class": "<class name>",
+    "method": "<method name>",
+    "trackedFunctionName": "{{ClassName}}#{{MethodName}}",
+    "trackedFunction": <true or false>,
+    "transaction": <true or false>
+  }
+  ]
+}
+```
+
+2. 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
@@ -64,8 +80,24 @@ In the config/initializer folder of your Rails app create a file `config/initial
 6. Build/Deploy your application
 
 ###  Custom Instrumentation in Non-Rails
-
-In `config.ru` file add this line: StackifyRubyAPM.run_custom_instrument
+1. Create `config/stackify.json` file from the root of your app and place the class name and method name in which you want to instrument.
+
+Example stackify.json:
+```
+{
+  "instrumentation": [
+  {
+    "class": "<class name>",
+    "method": "<method name>",
+    "trackedFunctionName": "{{ClassName}}#{{MethodName}}",
+    "trackedFunction": <true or false>,
+    "transaction": <true or false>
+  }
+  ]
+}
+```
+
+2. In `config.ru` file add this line: StackifyRubyAPM.run_custom_instrument
 
 Example:
 

data/lib/stackify_apm/instrumenter_helper.rb

@@ -12,6 +12,7 @@ module StackifyRubyAPM
     attr_accessor :custom_instrumented, :custom_class_info
     @custom_instrumented = {}
     @custom_class_info = {}
+    TRACETYPE = 'TASK'.freeze
 
     def self.custom_instrumented_reset
       @custom_instrumented.each do |custom_instrument, values|
@@ -26,7 +27,10 @@ module StackifyRubyAPM
       end
     end
 
-    def self.m_class(tracked_func, current_class, class_path, current_method, tracked_function_name)
+    def self.m_class(tracked_func, current_class, class_path, **options)
+      current_method = options[:current_method] || nil
+      tracked_function_name = options[:tracked_function_name] || nil
+      transaction = options[:is_transaction] || nil
       module_consget = Module.const_get(current_class)
       classspyitem = "#{current_class}Spy"
       module_consget_spy = Module.const_get(current_class)
@@ -61,24 +65,37 @@ module StackifyRubyAPM
               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
+                if StackifyRubyAPM.current_transaction.nil? && #{!transaction.nil?}
+                  t = StackifyRubyAPM.transaction("custom.#{current_class}.#{current_method}", TRACETYPE)
+                  begin
+                    req = #{current_method_without}(*args, &block)
+                  rescue Exception => e
+                    StackifyRubyAPM.report(e)
+                    raise e
+                  ensure
+                    t.submit
+                  end
+                  return req
+                elsif 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
+                else
+                  return #{current_method_without}(*args, &block)
                 end
               end
             end
@@ -92,7 +109,10 @@ module StackifyRubyAPM
       @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)
+    def self.m_singleton(tracked_func, current_class, class_path, **options)
+      current_method = options[:current_method] || nil
+      tracked_function_name = options[:tracked_function_name] || nil
+      transaction = options[:is_transaction] || nil
       module_consget = Module.const_get(current_class)
       classspyitem = "#{current_class}Spy"
 
@@ -125,23 +145,36 @@ module StackifyRubyAPM
               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
+                if StackifyRubyAPM.current_transaction.nil? && #{!transaction.nil?}
+                  t = StackifyRubyAPM.transaction("custom.#{current_class}.#{current_method}", TRACETYPE)
+                  begin
+                    req = _self_without_apm_#{current_method}(*args, &block)
+                  rescue Exception => e
+                    StackifyRubyAPM.report(e)
+                    raise e
+                  ensure
+                    t.submit
+                  end
+                  return req
+                elsif 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
+                else
+                  return _self_without_apm_#{current_method}(*args, &block)
                 end
               end
 

data/lib/stackify_apm/middleware.rb

@@ -90,7 +90,7 @@ module StackifyRubyAPM
     # Start of transaction building with params: name, type, context
     #
     def build_transaction(env)
-      StackifyRubyAPM.transaction 'Rack', 'request', context: StackifyRubyAPM.build_context(env)
+      StackifyRubyAPM.transaction 'Rack', 'WEBAPP', context: StackifyRubyAPM.build_context(env)
     end
 
     def running?

data/lib/stackify_apm/root_info.rb

@@ -10,21 +10,18 @@ module StackifyRubyAPM
       @config = config
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def build
       # get process id
       pid = $PID || Process.pid
-
-      {
+      hash = {
         CATEGORY: 'Ruby',
         APPLICATION_PATH: '/',
         APPLICATION_FILESYSTEM_PATH: @config.root_path,
         APPLICATION_NAME: @config.application_name,
-        APPLICATION_ENV: @config.environment_name,
+        APPLICATION_ENV: @config.environment_name || 'Development',
         REPORTING_URL: @transaction.name,
-        METHOD: @transaction.context.request.method,
-        STATUS: @transaction.context.response.status_code,
-        URL: @transaction.context.request.url[:full],
-        TRACETYPE: 'WEBAPP',
         TRACE_ID: @transaction.id,
         THREAD_ID: Thread.current.object_id,
         TRACE_SOURCE: 'RUBY',
@@ -32,9 +29,16 @@ module StackifyRubyAPM
         HOST_NAME: @config.hostname || `hostname`,
         OS_TYPE: StackifyRubyAPM::Util.host_os,
         PROCESS_ID: pid,
-        TRACE_VERSION: '2.0'
+        TRACE_VERSION: '2.0',
+        TRACETYPE: @transaction.type || 'WEBAPP'
       }
+      hash[:METHOD] = @transaction.context.request.method if @transaction.context && @transaction.context.request && @transaction.context.request.method
+      hash[:STATUS] = @transaction.context.response.status_code if @transaction.context && @transaction.context.response && @transaction.context.response.status_code
+      hash[:URL] = @transaction.context.request.url[:full] if @transaction.context && @transaction.context.request && @transaction.context.request.url[:full]
+      hash
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def self.build(config, transaction)
       new(config, transaction).build

data/lib/stackify_apm/serializers/errors.rb

@@ -9,15 +9,13 @@ module StackifyRubyAPM
       def build(error)
         if (exception = error.exception)
           current_timestamp = error.timestamp
-
           base = {
-            CaughtBy: exception.module,
+            CaughtBy: exception.module != '' ? exception.module : exception.type,
             Exception: exception.type,
             Message: exception.message,
             Timestamp: current_timestamp.round.to_s,
             Frames: exception.stacktrace.to_a
           }
-
         end
 
         base

data/lib/stackify_apm/spies/custom_instrumenter.rb

@@ -26,9 +26,9 @@ module StackifyRubyAPM
         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
 
         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
 
@@ -45,9 +45,9 @@ module StackifyRubyAPM
           class_path = class_location.last
 
           if klass_method_flag
-            StackifyRubyAPM::InstrumenterHelper.m_class(tracked_func, current_class, class_path, current_method, tracked_function_name)
+            StackifyRubyAPM::InstrumenterHelper.m_class(tracked_func, current_class, class_path, current_method: current_method, tracked_function_name: tracked_function_name, is_transaction: transaction)
           elsif singleton_method_flag
-            StackifyRubyAPM::InstrumenterHelper.m_singleton(tracked_func, current_class, class_path, current_method, tracked_function_name)
+            StackifyRubyAPM::InstrumenterHelper.m_singleton(tracked_func, current_class, class_path, current_method: current_method, tracked_function_name: tracked_function_name, is_transaction: transaction)
           end
         end
         # rubocop:enable Style/Next

data/lib/stackify_apm/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackify-ruby-apm
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Stackify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-25 00:00:00.000000000 Z
+date: 2019-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler