callstacking-rails 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba4839162aee95292d54812c4c9f86be937f9ff13a5765197c34a371c21940a7
-  data.tar.gz: 56518b971c4fac333b0c2c5e645bdc92c580ff426fb62f4f72460bc2e3a95cd7
+  metadata.gz: 87abdbb303ead93a3e9675bb51a39d42141b5a9d4a27237a254e9e670171f399
+  data.tar.gz: 8d6aef27102d88c0b847c14616390dbb61ac8da2fd90af506e8a5cd0de12c6f1
 SHA512:
-  metadata.gz: 276072fc8c408926760d2cae1949ec24ce0ebcd0b4afda094a0132761db1b127dfae00900e9c50de1a0a1af697068effe1b84b922336a2de9f25a15db5753785
-  data.tar.gz: 53ab41b4aae0ce86466561a3381746b8853697f7927398e938604e95e4e17297ebbce6958e3e7f4be965a79c9ad488a89c7f18e21482511d2350d399a0394a9a
+  metadata.gz: 64489808b6674f2651f5a0abea52cf7c0e9053b1d3e47b1504febda71f21b29363152cfc3751fb65a31f3c61700e428ec1aedf2b7efbd6d41d0aa7efd4294ae3
+  data.tar.gz: 256bc96c37f4761e4bf03edfaa222dd044e38d589f518b844c1509fe9dce70bd5551b2e312d767a6e3eca60f65bbe862226d516bbf00e09d036b9b83b1d7cc6c

data/lib/callstacking/rails/client/trace.rb

@@ -21,7 +21,11 @@ module Callstacking
                         p: params.to_h,
                       })
 
-          return resp.body["trace_id"], resp.body["pulse_interval"]
+          if resp.status == 200
+            return resp.body["trace_id"], resp.body["pulse_interval"], resp.body["max_trace_entries"]
+          end
+
+          nil
         end
 
         def upsert(trace_id, traces)

data/lib/callstacking/rails/instrument.rb

@@ -20,6 +20,8 @@ module Callstacking
         # Application level method definitions
         return unless method_path =~ root if application_level
 
+        return if method_path =~ /initializer/i
+
         tmp_module = find_or_initialize_module
 
         return if tmp_module.nil? ||
@@ -48,7 +50,8 @@ module Callstacking
       end
 
       def find_or_initialize_module
-        return if klass&.name == nil
+        name = klass&.name rescue nil
+        return if name.nil?
 
         module_name = "#{klass.name.gsub('::', '')}Span"
         module_index = klass.ancestors.map(&:to_s).index(module_name)

data/lib/callstacking/rails/trace.rb

@@ -25,11 +25,13 @@ module Callstacking
         read_settings
 
         trace_id = nil
+        max_trace_entries = nil
 
         ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
-          trace_id = start_request(payload[:request]&.request_id, payload[:method], payload[:controller],
-                                   payload[:action], payload[:format], ::Rails.root,
-                                   payload[:original_url], payload[:headers], payload[:params])
+          trace_id, max_trace_entries = start_request(payload[:request]&.request_id, payload[:method], payload[:controller],
+                                                      payload[:action], payload[:format], ::Rails.root,
+                                                      payload[:request]&.original_url,
+                                                      payload[:headers], payload[:params])
         end
 
         @spans.on_call_entry do |nesting_level, order_num, klass, method_name, arguments, path, line_no|
@@ -41,7 +43,10 @@ module Callstacking
         end
 
         ActiveSupport::Notifications.subscribe("process_action.action_controller") do |name, start, finish, id, payload|
-          complete_request(payload[:method], payload[:controller], payload[:action], payload[:format], trace_id)
+          complete_request(payload[:method], payload[:controller],
+                           payload[:action], payload[:format],
+                           payload[:request]&.original_url,
+                           trace_id, max_trace_entries)
         end
       end
 
@@ -57,43 +62,55 @@ module Callstacking
 
       def create_call_return(coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val, traces)
         lock.synchronize do
-          traces << { trace_entry: { trace_entryable_type: 'TraceCallReturn',
-                                     order_num: order_num,
-                                     nesting_level: nesting_level,
-                                     trace_entryable_attributes: {
-                                       local_variables: {},
-                                       klass: klass_name(klass),
-                                       line_number: line_no,
-                                       path: path,
-                                       method_name: method_name,
-                                       return_value: return_val.inspect,
-                                       coupled_callee: coupled_callee,
-                                     } } }
+          traces << { type: 'TraceCallReturn',
+                      order_num: order_num,
+                      nesting_level: nesting_level,
+                      local_variables: {},
+                      args: {},
+                      klass: klass_name(klass),
+                      line_number: line_no,
+                      path: path,
+                      method_name: method_name,
+                      return_value: return_value(return_val),
+                      coupled_callee: coupled_callee,
+                      message: nil,
+          }
         end
       end
+
       def create_call_entry(nesting_level, order_num, klass, method_name, arguments, path, line_no, traces)
         lock.synchronize do
-          traces << { trace_entry: { trace_entryable_type: 'TraceCallEntry',
-                                     order_num: order_num,
-                                     nesting_level: nesting_level,
-                                     trace_entryable_attributes: {
-                                       args: arguments,
-                                       klass: klass_name(klass),
-                                       line_number: line_no,
-                                       path: path,
-                                       method_name: method_name,
-                                     } } }
+          traces << { type: 'TraceCallEntry',
+                      order_num: order_num,
+                      nesting_level: nesting_level,
+                      args: arguments,
+                      klass: klass_name(klass),
+                      line_number: line_no,
+                      path: path,
+                      method_name: method_name,
+                      return_value: nil,
+                      coupled_callee: nil,
+                      local_variables: {},
+                      message: nil,
+          }
         end
       end
 
       def create_message(message, order_num, traces)
         lock.synchronize do
-          traces << { trace_entry: { trace_entryable_type: 'TraceMessage',
-                                     order_num: order_num,
-                                     nesting_level: 0,
-                                     trace_entryable_attributes: {
-                                       message: message
-                                     } } }
+          traces << { type: 'TraceMessage',
+                      order_num: order_num,
+                      nesting_level: 0,
+                      message: message,
+                      args: {},
+                      klass: nil,
+                      line_number: nil,
+                      path: nil,
+                      method_name: nil,
+                      return_value: nil,
+                      coupled_callee: false,
+                      local_variables: {},
+          }
         end
       end
 
@@ -101,30 +118,55 @@ module Callstacking
         lock.synchronize do
           return if traces.empty?
 
-          client.upsert(trace_id, { traces: traces })
+          client.upsert(trace_id, { trace_entries: traces })
           traces.clear
         end
       end
       def start_request(request_id, method, controller, action, format, path, original_url, headers, params)
+        return if do_not_track_request?(original_url)
+        
         request_id = request_id || SecureRandom.uuid
         Callstacking::Rails::Trace.current_request_id = request_id
 
-        trace_id, _interval = client.create(method, controller, action, format,
-                                            path, original_url, request_id, headers,
-                                            params)
+        trace_id, _interval, max_trace_entries = client.create(method, controller, action, format,
+                                                               path, original_url, request_id, headers,
+                                                               params)
 
         puts "#{settings[:url] || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{trace_id}"
 
         create_message(start_request_message(method, controller, action, format),
                        spans.increment_order_num, @traces)
 
-        trace_id
+        return trace_id, max_trace_entries
       end
 
-      def complete_request(method, controller, action, format, trace_id)
+      def complete_request(method, controller, action, format, original_url, trace_id, max_trace_entries)
+        return if do_not_track_request?(original_url)
+
         create_message(completed_request_message(method, controller, action, format),
                        spans.increment_order_num, @traces)
-        send_traces!(trace_id, @traces)
+
+        send_traces!(trace_id, @traces[0..max_trace_entries])
+      end
+
+      def track_request?(url)
+        !(track_request?(url))
+      end
+
+      def do_not_track_request?(url)
+        url =~ /(\/stylesheets\/|\/javascripts\/|\/css\/|\/js\/|\.js|\.css)/i
+      end
+
+      def return_value(return_val)
+        return_val.inspect
+      rescue ThreadError
+        # deadlock; recursive locking (ThreadError)
+        # Discourse overrides ActiveSupport::Inflector methods via lib/freedom_patches/inflector_backport.rb
+        # when return_value.inspect is called, it triggers a subsequent call
+        # to the instrumented inflector method, causing another call to mutex#synchronize
+        # from the block of the first synchronize call
+
+        return_val.to_s rescue "****"  # Can't evaluate
       end
 
       def klass_name(klass)

data/lib/callstacking/rails/version.rb

@@ -1,5 +1,5 @@
 module Callstacking
   module Rails
-    VERSION = "0.1.8"
+    VERSION = "0.1.10"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callstacking-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Jim Jones
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -28,22 +28,16 @@ dependencies:
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: faraday-follow_redirects
   requirement: !ruby/object:Gem::Requirement