callstacking-rails 0.1.20 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf64a69817d5a94e205db95cd79dbff2c15d1190ed001bb49d1113aa0ada96b4
-  data.tar.gz: 4a37b31f1d9faac2de735ea799fd7fda9151ff2300de7401ad23d9dc8c21fd5e
+  metadata.gz: db3f273ed8ae89ee3727de24fa80f8a3621ebb9aa5997874cf8f8f2607f9595b
+  data.tar.gz: facd7b5f062db3b4e50ecdd78857b5b0635119a8aa07589bc1e9fa03583bf036
 SHA512:
-  metadata.gz: 2739c75f8347b76baa6f509f4f5c31c87e3de649490d3c1d3f4c9237062b44e90cb8a0cf47cf4d025b1e9b0539834b0e8641cd6ef6a2302854f0610bf0a3775e
-  data.tar.gz: acecb1df5835c9b3992501e506042c1693364c326545e36d6b0fd6549b48afba0af43808a4a730135ea988bbd4f6a38c14c361d4467361456f668e5bda7fba1e
+  metadata.gz: a74d58ed4f01a8a466ae81d763499d4a0004a97bdaee5cf8fe7aba47d97b367dbbc4ba7d2f1e8d2be0bff8d450b09a99b8de1fb4f738baa67664623583884660
+  data.tar.gz: 104df4887100b79f1d056fc24e7690dee30404a5c3827fd9d7fcce2c6c84e74124649a98e6c71c77cd62310d227b5987ee306d2f09f4816b3825adf32250aeb4

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

@@ -7,16 +7,18 @@ module Callstacking
         CREATE_URL = "/api/v1/traces.json"
         UPDATE_URL = "/api/v1/traces/:id.json"
 
-        def create(method_name, klass, action_name, format_name, root_path, url, request_id, headers, params)
+        def create(request_id, tuid, method_name, klass, action_name, format_name, root_path, url, headers, params)
           resp = post(CREATE_URL,
                       {},
-                      { method_name: method_name,
+                      {
+                        request_id: request_id,
+                        tuid: tuid,
+                        method_name: method_name,
                         klass: klass,
                         action_name: action_name,
                         format_name: format_name,
                         root_path: root_path,
                         url: url,
-                        request_id: request_id,
                         h: headers.to_h,
                         p: params.to_h,
                       })

data/lib/callstacking/rails/engine.rb

@@ -12,17 +12,21 @@ require "callstacking/rails/client/authenticate"
 require "callstacking/rails/client/trace"
 require "callstacking/rails/cli"
 require "callstacking/rails/traces_helper"
+require "callstacking/rails/time_based_uuid"
 
 module Callstacking
   module Rails
     class Engine < ::Rails::Engine
-      cattr_accessor :spans, :trace, :settings
+      EXCLUDED_TEST_CLASSES = ['test/dummy/app/models/salutation.rb'].freeze
+      
+      cattr_accessor :spans, :trace, :settings, :instrumenter, :loader
 
       isolate_namespace Callstacking::Rails
 
       @@settings||=Callstacking::Rails::Settings.new
       @@spans||=Spans.new
       @@trace||=Trace.new(@@spans)
+      @@instrumenter||=Instrument.new(@@spans)
 
       initializer "engine_name.assets.precompile" do |app|
         app.config.assets.precompile << "checkpoint_rails_manifest.js"
@@ -42,13 +46,29 @@ module Callstacking
             inject_hud(@@settings)
           end
 
-          Callstacking::Rails::Loader.new.on_load(@@spans)
+          @@loader = Callstacking::Rails::Loader.new(@@instrumenter,
+                                                     excluded: @@settings.excluded + EXCLUDED_TEST_CLASSES)
+          @@loader.on_load
 
-          @@trace.tracing
+          @@trace.request_tracing
         else
           puts "Call Stacking disabled (#{Callstacking::Rails::Env.environment})"
         end
       end
+
+      def self.start_tracing
+        return false if @@settings.disabled?
+
+        @@instrumenter.enable!(@@loader.klasses)
+        true
+      end
+
+      def self.stop_tracing
+        return false if @@settings.disabled?
+
+        @@instrumenter.disable!
+        true
+      end
     end
   end
 end

data/lib/callstacking/rails/instrument.rb

@@ -4,25 +4,26 @@ require 'rails'
 module Callstacking
   module Rails
     class Instrument
-      attr_accessor :spans, :klass
-      attr_reader :root
+      attr_accessor :spans
+      attr_reader :root, :settings, :span_modules
 
-      def initialize(spans, klass)
+      def initialize(spans)
         @spans = spans
-        @klass = klass
-        @root  = Regexp.new(::Rails.root.to_s)
+        @span_modules = Set.new
+        @settings = Callstacking::Rails::Settings.new
+        @root  = Regexp.new(::Rails.root.to_s) # <-------
       end
 
-      def instrument_method(method_name, application_level: true)
+      def instrument_method(klass, method_name, application_level: true)
         method_path = (klass.instance_method(method_name).source_location.first rescue nil) ||
           (klass.method(method_name).source_location.first rescue nil)
 
         # Application level method definitions
-        return unless method_path =~ root if application_level
+        return if method_path =~ /#{::Rails.root.to_s}/ && application_level
 
         return if method_path =~ /initializer/i
 
-        tmp_module = find_or_initialize_module
+        tmp_module = find_or_initialize_module(klass)
 
         return if tmp_module.nil? ||
                     tmp_module.instance_methods.include?(method_name) ||
@@ -76,31 +77,23 @@ module Callstacking
         new_method
       end
 
-      def find_or_initialize_module
-        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)
-
-        unless module_index
-          new_module = Object.const_set(module_name, Module.new)
-
-          new_module.instance_variable_set("@klass", klass)
-          new_module.instance_variable_set("@spans", spans)
-
-          klass.prepend new_module
-          klass.singleton_class.prepend new_module if klass.class == Module
-
-          return find_or_initialize_module
+      def enable!(klasses)
+        klasses.each do |klass|
+          instrument_klass(klass, application_level: true)
         end
+      end
 
-        klass.ancestors[module_index]
+      def disable!
+        span_modules.each do |mod|
+          mod.instance_methods.each do |method_name|
+            mod.remove_method(method_name)
+          end
+        end
       end
 
-      def instrument_klass(application_level: true)
-        relevant = all_methods - filtered
-        relevant.each { |method| instrument_method(method, application_level: application_level) }
+      def instrument_klass(klass, application_level: true)
+        relevant_methods = all_methods(klass) - filtered
+        relevant_methods.each { |method| instrument_method(klass, method, application_level: application_level) }
       end
 
       def self.arguments_for(m, args)
@@ -118,9 +111,31 @@ module Callstacking
       end
 
       private
+      def find_or_initialize_module(klass)
+        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)
+
+        unless module_index
+          new_module = Object.const_set(module_name, Module.new)
+          span_modules << new_module
+
+          new_module.instance_variable_set("@klass", klass)
+          new_module.instance_variable_set("@spans", spans)
+
+          klass.prepend new_module
+          klass.singleton_class.prepend new_module if klass.class == Module
+
+          return find_or_initialize_module(klass)
+        end
+
+        klass.ancestors[module_index]
+      end
 
-      def all_methods
-        @all_methods ||= (klass.instance_methods +
+      def all_methods(klass)
+        (klass.instance_methods +
           klass.private_instance_methods(false) +
           klass.protected_instance_methods(false) +
           klass.methods +

data/lib/callstacking/rails/loader.rb

@@ -3,26 +3,33 @@ require "rails"
 module Callstacking
   module Rails
     class Loader
-      attr_accessor :loader, :root, :once
-      def initialize
+      attr_accessor :root, :instrumenter, :klasses, :excluded
+      def initialize(instrumenter, excluded: [])
         @root = Regexp.new(::Rails.root.to_s)
+        @excluded = excluded
+        @instrumenter = instrumenter
+        @klasses = Set.new
       end
 
-      def on_load(spans)
+      def on_load
         trace = TracePoint.new(:end) do |tp|
           klass = tp.self
           path  = tp.path
 
-          Instrument.new(spans, klass).instrument_klass if path =~ root
+          excluded_klass = excluded.any? { |ex| path =~ /#{ex}/ }
+
+          if path =~ root &&
+            !klasses.include?(klass) &&
+            !excluded_klass
+              instrumenter.instrument_klass(klass)
+              klasses << klass
+          end
         end
 
         trace.enable
 
-        Instrument.new(spans, ActionView::PartialRenderer).instrument_method(:render,
-                                                                             application_level: false)
-        
-        Instrument.new(spans, ActionView::TemplateRenderer).instrument_method( :render,
-                                                                               application_level: false)
+        instrumenter.instrument_method(ActionView::PartialRenderer, :render, application_level: false)
+        instrumenter.instrument_method(ActionView::TemplateRenderer, :render, application_level: false)
       end
     end
   end

data/lib/callstacking/rails/settings.rb

@@ -34,11 +34,11 @@ module Callstacking
         File.write(SETTINGS_FILE, new_settings.to_yaml)
       end
 
-      def enable!
+      def self.enable!
         ::Rails.cache.write(CACHE_KEY, true)
       end
 
-      def disable!
+      def self.disable!
         ::Rails.cache.write(CACHE_KEY, false)
       end
 
@@ -50,6 +50,10 @@ module Callstacking
         settings[:enabled]
       end
 
+      def excluded
+        settings[:excluded] || []
+      end
+
       def disabled?
         !enabled?
       end

data/lib/callstacking/rails/time_based_uuid.rb

@@ -0,0 +1,25 @@
+require 'securerandom'
+
+class TimeBasedUUID
+  EPOCH_OFFSET = 1468418800000  # A custom epoch, it could be the UNIX timestamp when the application was created (in milliseconds)
+  MAX_INT8_VALUE = 9223372036854775807
+
+  def self.generate
+    # Get the current time in milliseconds
+    current_time = (Time.now.to_f * 1000).to_i
+
+    # Subtract the custom epoch to reduce the timestamp size
+    timestamp = current_time - EPOCH_OFFSET
+
+    # Generate a random 64-bit number using SecureRandom
+    random_bits = SecureRandom.random_number(1 << 64)
+
+    # Combine the timestamp and the random bits
+    uuid = (timestamp << 64) | random_bits
+
+    # Ensure the UUID fits into a PostgreSQL int8 column
+    uuid = uuid % MAX_INT8_VALUE if uuid > MAX_INT8_VALUE
+
+    uuid
+  end
+end

data/lib/callstacking/rails/trace.rb

@@ -6,9 +6,11 @@ module Callstacking
     class Trace
       attr_accessor :spans, :client, :lock
       attr_reader :settings
-      cattr_accessor :current_request_id
+      cattr_accessor :current_trace_id
+      cattr_accessor :current_tuid
 
       ICON = '💥'
+      MAX_TRACE_ENTRIES = 3000
 
       def initialize(spans)
         @traces = []
@@ -17,37 +19,54 @@ module Callstacking
 
         @lock   = Mutex.new
         @client = Callstacking::Rails::Client::Trace.new(settings.url, settings.auth_token)
+
+        init_uuids(nil, nil)
+        init_callbacks(nil)
       end
 
-      def tracing
+      def request_tracing
+        tuid     = nil
         trace_id = nil
-        max_trace_entries = nil
 
-        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
-          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[:path],
-                                                      payload[:headers], payload[:params])
-        end
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |_name, _start, _finish, _id, payload|
+          trace_id, tuid = init_uuids(payload[:request]&.request_id || SecureRandom.uuid, TimeBasedUUID.generate)
+          init_callbacks(tuid)
 
-        @spans.on_call_entry do |nesting_level, order_num, klass, method_name, arguments, path, line_no|
-          create_call_entry(nesting_level, order_num, klass, method_name, arguments, path, line_no, @traces)
+          start_request(trace_id, tuid,
+                        payload[:method], payload[:controller],
+                        payload[:action], payload[:format], ::Rails.root,
+                        payload[:request]&.original_url || payload[:path],
+                        payload[:headers], payload[:params])
         end
 
-        @spans.on_call_return do |coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val|
-          create_call_return(coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val, @traces)
-        end
-
-        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |name, start, finish, id, payload|
-          complete_request(payload[:method], payload[:controller],
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |_name, _start, _finish, _id, payload|
+          complete_request(trace_id, tuid,
+                           payload[:method], payload[:controller],
                            payload[:action], payload[:format],
                            payload[:request]&.original_url || payload[:path],
-                           trace_id, @traces, max_trace_entries)
+                           @traces, MAX_TRACE_ENTRIES)
         end
       end
 
       private
 
+      def init_callbacks(tuid)
+        @spans.on_call_entry do |nesting_level, order_num, klass, method_name, arguments, path, line_no|
+          create_call_entry(tuid, nesting_level, order_num, klass, method_name, arguments, path, line_no, @traces)
+        end
+
+        @spans.on_call_return do |coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val|
+          create_call_return(tuid, coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val, @traces)
+        end
+      end
+
+      def init_uuids(trace_id, tuid)
+        Callstacking::Rails::Trace.current_trace_id = trace_id
+        Callstacking::Rails::Trace.current_tuid = tuid
+        
+        return trace_id, tuid
+      end
+
       def completed_request_message(method, controller, action, format)
         "Completed request: #{method} #{controller}##{action} as #{format}"
       end
@@ -56,9 +75,10 @@ module Callstacking
         "Started request: #{method} #{controller}##{action} as #{format}"
       end
 
-      def create_call_return(coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val, traces)
+      def create_call_return(tuid, coupled_callee, nesting_level, order_num, klass, method_name, path, line_no, return_val, traces)
         lock.synchronize do
-          traces << { type: 'TraceCallReturn',
+          traces << { tuid: tuid,
+                      type: 'TraceCallReturn',
                       order_num: order_num,
                       nesting_level: nesting_level,
                       local_variables: {},
@@ -74,9 +94,10 @@ module Callstacking
         end
       end
 
-      def create_call_entry(nesting_level, order_num, klass, method_name, arguments, path, line_no, traces)
+      def create_call_entry(tuid, nesting_level, order_num, klass, method_name, arguments, path, line_no, traces)
         lock.synchronize do
-          traces << { type: 'TraceCallEntry',
+          traces << { tuid: tuid,
+                      type: 'TraceCallEntry',
                       order_num: order_num,
                       nesting_level: nesting_level,
                       args: arguments,
@@ -92,9 +113,10 @@ module Callstacking
         end
       end
 
-      def create_message(message, order_num, traces)
+      def create_message(tuid, message, order_num, traces)
         lock.synchronize do
-          traces << { type: 'TraceMessage',
+          traces << { tuid: tuid,
+                      type: 'TraceMessage',
                       order_num: order_num,
                       nesting_level: 0,
                       message: message,
@@ -114,26 +136,24 @@ module Callstacking
         lock.synchronize do
           return if traces.empty?
 
-          client.upsert(trace_id, { trace_entries: 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)
+      def start_request(trace_id, tuid, method, controller, action, format, path, original_url, headers, params)
         return if do_not_track_request?(original_url, format)
-        
-        request_id = request_id || SecureRandom.uuid
-        Callstacking::Rails::Trace.current_request_id = request_id
 
-        trace_id, _interval, max_trace_entries = client.create(method, controller, action, format,
-                                                               path, original_url, request_id, headers,
-                                                               params)
+        client.create(trace_id, tuid,
+                      method, controller,
+                      action, format,
+                      path, original_url,
+                      headers, params)
 
         print_trace_url(trace_id)
 
-        create_message(start_request_message(method, controller, action, format),
+        create_message(tuid, start_request_message(method, controller, action, format),
                        spans.increment_order_num, @traces)
-
-        return trace_id, max_trace_entries
       end
 
       def print_trace_url(trace_id)
@@ -146,13 +166,13 @@ module Callstacking
         url
       end
 
-      def complete_request(method, controller, action, format, original_url, trace_id, traces, max_trace_entries)
+      def complete_request(trace_id, tuid, method, controller, action, format, original_url, traces, max_trace_entries)
         if do_not_track_request?(original_url, format)
           traces.clear
           return
         end
 
-        create_message(completed_request_message(method, controller, action, format),
+        create_message(tuid, completed_request_message(method, controller, action, format),
                        spans.increment_order_num, traces)
 
         send_traces!(trace_id, traces[0..max_trace_entries])

data/lib/callstacking/rails/traces_helper.rb

@@ -9,7 +9,7 @@ module Callstacking
       include ActionView::Context
 
       def hud(url)
-        frame_url = "#{url || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{Callstacking::Rails::Trace.current_request_id}/print"
+        frame_url = "#{url || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{Callstacking::Rails::Trace.current_trace_id}/print"
 
         body = []
         body << (content_tag( :div, data: { turbo:false },

data/lib/callstacking/rails/version.rb

@@ -1,5 +1,5 @@
 module Callstacking
   module Rails
-    VERSION = "0.1.20"
+    VERSION = "0.1.22"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callstacking-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.22
 platform: ruby
 authors:
 - Jim Jones
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-12 00:00:00.000000000 Z
+date: 2023-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -113,6 +113,7 @@ files:
 - lib/callstacking/rails/settings.rb
 - lib/callstacking/rails/setup.rb
 - lib/callstacking/rails/spans.rb
+- lib/callstacking/rails/time_based_uuid.rb
 - lib/callstacking/rails/trace.rb
 - lib/callstacking/rails/traces_helper.rb
 - lib/callstacking/rails/version.rb