callstacking-rails 0.1.19 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 122755f46a3f89ee6c310aed0ede48453bf7ff7f92c50f9809fe7466ad49159b
-  data.tar.gz: adfdbd3892e3c6cc5b1e869ce8a1d63185610347b3079a1de8cf6ebb8009eff3
+  metadata.gz: 1da66ff58acecfefd9f52e259cb9d69eb54e8328a4fee36ed130e26f968d61a2
+  data.tar.gz: 2d8bc0b54633d9a17e607ee1c7006d7d728e999c5a5d5c6bfc93dd9090a1a19e
 SHA512:
-  metadata.gz: baa19130df5d47f45d0df4d2a0055edb1d5a2bbb74bdff1919a20de8bd6e6fa5fe6ad8224dddf8a6b973128301f007b76f094d076e0753c1b5257f3b5852c9ac
-  data.tar.gz: 22e7fc256542ea2f13de0f400b350a74a2e115c96610734f0db0e492d416b48d6dd19f26ea68b40a4ffac6ef3a515f27a21604b3a0fe0dca2e43f6017bf1693f
+  metadata.gz: 737cf8e5ddf9467a6ce6ca2ae1ebeee369f5e9200b7893440fb923ecbe21638ac0ec0430ab909cddd29910b5a4bc83d04436fd2cf304109b88d7d64768232789
+  data.tar.gz: 8f8afdfc52b192dd8e688e5f28dc8f93306241bc4347cc3c90144d7a6b7b9f210b0d9eb6037b288e6bbc4c68554e71456261fd736e5ea5e5fde6402c29051d53

data/README.md

@@ -1,4 +1,5 @@
 # Callstacking::Rails
+[![Build Status](https://github.com/callstacking/callstacking-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/callstacking/callstacking-rails/actions/workflows/ci.yml)
 
 Call Stacking is a rolling, checkpoint debugger for Rails.  It records all of the critical method calls within your app, along with their important context (param/argument/return/local variable values).  
 

data/exe/callstacking-rails

@@ -1,33 +1,15 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
-require "callstacking/rails/setup"
-require "callstacking/rails/settings"
+require "callstacking/rails"
 
-include Callstacking::Rails::Settings
-
-action = ARGV[0]&.downcase&.strip
+action = Callstacking::Rails::Cli.action(ARGV)
+settings = Callstacking::Rails::Settings.new
 
 if action.nil?
   Callstacking::Rails::Setup.instructions
   exit!(1)
 end
 
-read_settings
-
-case action
-  when 'register'
-    puts "Open the following URL to register:\n\n"
-    puts "  #{settings[:url]}/users/sign_up\n\n"
-
-  when 'setup'
-    Callstacking::Rails::Setup.new.start
-
-  when 'enable'
-    Callstacking::Rails::Setup.new.enable_disable
-    puts "Call Stacking tracing enabled (#{Callstacking::Rails::Env.environment})"
-
-  when 'disable'
-    Callstacking::Rails::Setup.new.enable_disable(enabled: false)
-    puts "Call Stacking tracing disabled (#{Callstacking::Rails::Env.environment})"
-end
+cli = Callstacking::Rails::Cli.new(action, settings)
+cli.run

data/lib/callstacking/rails/cli.rb

@@ -0,0 +1,50 @@
+module Callstacking
+  module Rails
+    class Cli
+      REGISTER = 'register'
+      SETUP = 'setup'
+      ENABLE = 'enable'
+      DISABLE = 'disable'
+
+      attr_reader :action, :settings
+
+      def initialize(action, settings)
+        @action = action
+        @settings = settings
+      end
+
+      def run
+        parse_options
+      end
+
+      def self.action(args)
+        args[0]&.downcase&.strip
+      end
+
+      private
+
+      def parse_options
+        case action
+        when REGISTER
+          puts "Open the following URL to register:\n\n"
+          puts "  #{settings.url}/users/sign_up\n\n"
+          REGISTER
+
+        when SETUP
+          Callstacking::Rails::Setup.new.start
+          SETUP
+
+        when ENABLE
+          settings.enable_disable
+          puts "Call Stacking tracing enabled (#{Callstacking::Rails::Env.environment})"
+          ENABLE
+
+        when DISABLE
+          settings.enable_disable(enabled: false)
+          puts "Call Stacking tracing disabled (#{Callstacking::Rails::Env.environment})"
+          DISABLE
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 require 'json'
-require "callstacking/rails/client/base"
 
 module Callstacking
   module Rails

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

@@ -1,6 +1,5 @@
 require 'faraday'
 require 'faraday/follow_redirects'
-require "callstacking/rails/settings"
 
 module Callstacking
   module Rails
@@ -8,12 +7,12 @@ module Callstacking
       class Error < StandardError; end
 
       class Base
-        include Callstacking::Rails::Settings
+        attr_reader :url, :auth_token
 
-        def initialize
-          read_settings
+        def initialize(url, auth_token)
+          @url = url
+          @auth_token = auth_token
         end
-
         def connection
           # https://github.com/lostisland/awesome-faraday
           @connection ||= Faraday.new(url) do |c|
@@ -25,7 +24,7 @@ module Callstacking
             c.request :json # This will set the "Content-Type" header to application/json and call .to_json on the body
             c.adapter Faraday.default_adapter
 
-            if auth_token?
+            if auth_token.present?
               c.request :authorization, :Bearer, auth_token
             end
           end

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

@@ -1,4 +1,6 @@
 require "rails"
+require "active_support/cache"
+require "callstacking/rails/env"
 require "callstacking/rails/trace"
 require "callstacking/rails/instrument"
 require 'callstacking/rails/spans'
@@ -8,20 +10,23 @@ require "callstacking/rails/loader"
 require "callstacking/rails/client/base"
 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
+      EXCLUDED_TEST_CLASSES = ['test/dummy/app/models/salutation.rb'].freeze
+      
+      cattr_accessor :spans, :trace, :settings, :instrumenter, :loader
 
-      include Settings
       isolate_namespace Callstacking::Rails
 
-      read_settings
-
+      @@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"
@@ -31,19 +36,38 @@ module Callstacking
         ActiveSupport.on_load :action_controller do
           include Callstacking::Rails::TracesHelper
         end
+      end
+
+      config.after_initialize do
+        if @@settings.enabled?
+          puts "Call Stacking enabled (#{Callstacking::Rails::Env.environment})"
+
+          ActionController::Base.send :after_action do
+            inject_hud(@@settings)
+          end
 
-        Callstacking::Rails::Loader.new.on_load(@@spans) if enabled?
+          @@loader = Callstacking::Rails::Loader.new(@@instrumenter,
+                                                     excluded: @@settings.excluded + EXCLUDED_TEST_CLASSES)
+          @@loader.on_load
+
+          @@trace.request_tracing
+        else
+          puts "Call Stacking disabled (#{Callstacking::Rails::Env.environment})"
+        end
       end
 
-      initializer :append_before_action do
-        ActionController::Base.send :after_action, :inject_hud
+      def self.start_tracing
+        return false if @@settings.disabled?
+
+        @@instrumenter.enable!(@@loader.klasses)
+        true
       end
 
-      if enabled?
-        puts "Call Stacking enabled (#{Callstacking::Rails::Env.environment})"
-        trace.tracing
-      else
-        puts "Call Stacking disabled (#{Callstacking::Rails::Env.environment})"
+      def self.stop_tracing
+        return false if @@settings.disabled?
+
+        @@instrumenter.disable!
+        true
       end
     end
   end

data/lib/callstacking/rails/instrument.rb

@@ -4,16 +4,17 @@ 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
+        @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)
 
@@ -22,7 +23,7 @@ module Callstacking
 
         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,22 @@ 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
+      def disable!
+        span_modules.each do |mod|
+          mod.instance_methods.each do |method_name|
+            mod.remove_method(method_name)
+          end
         end
-
-        klass.ancestors[module_index]
       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 = all_methods(klass) - filtered
+        relevant.each { |method| instrument_method(klass, method, application_level: application_level) }
       end
 
       def self.arguments_for(m, args)
@@ -118,9 +110,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,32 @@ require "rails"
 module Callstacking
   module Rails
     class Loader
-      attr_accessor :loader, :root, :once
-      def initialize
+      attr_accessor :root, :spans, :instrumenter, :klasses, :excluded
+      def initialize(instrumenter, excluded: [])
         @root = Regexp.new(::Rails.root.to_s)
+        @spans = spans
+        @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
+          exclude = excluded.any? { |ex| path =~ /#{ex}/ }
+
+          if path =~ root && !exclude
+            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

@@ -1,18 +1,22 @@
+require "active_support/cache"
 require "active_support/concern"
 require "active_support/core_ext/class/attribute_accessors"
-require "callstacking/rails/env"
 
 module Callstacking
   module Rails
-    module Settings
-      extend ActiveSupport::Concern
-
-      included do |base|
-        attr_accessor :settings
-      end
+    class Settings
+      attr_accessor :settings
+      attr_reader :client
 
       SETTINGS_FILE = "#{Dir.home}/.callstacking"
       PRODUCTION_URL = "https://callstacking.com"
+      ENV_KEY        = 'CALLSTACKING_ENABLED'
+      CACHE_KEY      = :callstacking_enabled
+
+      def initialize
+        read_settings
+        @client = Callstacking::Rails::Client::Authenticate.new(url, auth_token)
+      end
 
       def url
         settings[:url] || PRODUCTION_URL
@@ -30,18 +34,67 @@ module Callstacking
         File.write(SETTINGS_FILE, new_settings.to_yaml)
       end
 
+      def self.enable!
+        ::Rails.cache.write(CACHE_KEY, true)
+      end
+
+      def self.disable!
+        ::Rails.cache.write(CACHE_KEY, false)
+      end
+
       def enabled?
+        return ::Rails.cache.read(CACHE_KEY) unless ::Rails.cache.read(CACHE_KEY).nil?
+        return false if ENV[ENV_KEY] == 'false'
         return false if settings.nil?
-        return false if ENV['CALLSTACKING_ENABLED'] == 'false'
+        
         settings[:enabled]
       end
 
+      def excluded
+        settings[:excluded] || []
+      end
+
       def disabled?
         !enabled?
       end
 
+      def save(email, password, url)
+        props = { auth_token: '',
+                  url: url,
+                  enabled: true
+        }
+
+        props = { Callstacking::Rails::Env.environment => {
+          settings: props
+        } }
+
+        write_settings(complete_settings.merge(props))
+
+        props[Callstacking::Rails::Env.environment][:settings][:auth_token] = token(email, password)
+
+        write_settings(complete_settings.merge(props))
+
+        read_settings
+      end
+
+      def enable_disable(enabled: true)
+        settings[:enabled] = enabled
+
+        props = { Callstacking::Rails::Env.environment => {
+          settings: settings
+        } }
+
+        write_settings(complete_settings.merge(props))
+      end
+
+      private
+
+      def token(email, password)
+        client.login(email, password)
+      end
+
       def read_settings
-        @@settings = @settings = complete_settings.dig(::Callstacking::Rails::Env.environment, :settings) || {}
+        @settings = complete_settings.dig(::Callstacking::Rails::Env.environment, :settings) || {}
       rescue StandardError => e
         puts e.full_message
         puts e.backtrace.join("\n")

data/lib/callstacking/rails/setup.rb

@@ -1,53 +1,33 @@
 require 'yaml'
-require "callstacking/rails/settings"
-require "callstacking/rails/client/authenticate"
-require "callstacking/rails/env"
 require 'io/console'
 
 module Callstacking
   module Rails
     class Setup
-      include ::Callstacking::Rails::Settings
-      extend ::Callstacking::Rails::Settings
-
-      attr_accessor :client
+      attr_accessor :settings
 
       def initialize
-        read_settings
-      end
-
-      def client
-        @client = Callstacking::Rails::Client::Authenticate.new
+        @settings = Callstacking::Rails::Settings.new
       end
 
       def start
         puts "Login to callstacking.com"
         puts
         
-        email      = prompt("Enter email:")
+        email      = prompt("Enter email:", echo: true)
         password   = prompt("Enter password:", echo: false)
 
-        save(email, password, url)
+        settings.save(email, password, url)
 
         puts "Authentication successful."
-        puts "Settings saved to #{SETTINGS_FILE}"
+        puts "Settings saved to #{Callstacking::Rails::Settings::SETTINGS_FILE}"
         true
       rescue StandardError => e
-        puts "Problem authenticating: #{e.message}"
+        puts "Error authenticating: #{e.message}"
         puts e.backtrace.join("\n")
         false
       end
 
-      def enable_disable(enabled: true)
-        settings[:enabled] = enabled
-
-        props = { Callstacking::Rails::Env.environment => {
-          settings: settings
-        } }
-
-        write_settings(complete_settings.merge(props))
-      end
-
       def prompt(label, echo: true)
         puts label
 
@@ -58,31 +38,7 @@ module Callstacking
         value
       end
 
-      def token(email, password)
-        client.login(email, password)
-      end
-
-      def save(email, password, url)
-        props = { auth_token: '',
-                  url: url,
-                  enabled: true
-        }
-
-        props = { Callstacking::Rails::Env.environment => {
-          settings: props
-        } }
-
-        write_settings(complete_settings.merge(props))
-
-        props[Callstacking::Rails::Env.environment][:settings][:auth_token] = token(email, password)
-
-        write_settings(complete_settings.merge(props))
-
-        read_settings
-      end
-
       def self.instructions
-        read_settings
         puts "loading environment #{Callstacking::Rails::Env.environment}"
         puts
         puts "Usage: "
@@ -94,7 +50,7 @@ module Callstacking
         puts "  > callstacking-rails setup"
         puts
         puts "    Interactively prompts you for your callstacking.com username/password."
-        puts "    Stores auth details in #{SETTINGS_FILE}"
+        puts "    Stores auth details in #{Callstacking::Rails::Settings::SETTINGS_FILE}"
         puts
         puts "  > callstacking-rails enable"
         puts
@@ -107,19 +63,23 @@ module Callstacking
         puts " You can have multiple environments."
         puts " The default is #{Callstacking::Rails::Env::DEFAULT_ENVIRONMENT}."
         puts
-        puts " The #{Callstacking::Rails::Env.environment}: section in the #{SETTINGS_FILE} contains your credentials."
+        puts " The #{Callstacking::Rails::Env.environment}: section in the #{Callstacking::Rails::Settings::SETTINGS_FILE} contains your credentials."
         puts " By setting the RAILS_ENV environment you can maintain multiple settings."
         puts
         puts "Questions? Create an issue: https://github.com/callstacking/callstacking-rails/issues"
+        
+        :instructions
       end
 
       private
 
       def url
-        if Callstacking::Rails::Env.production? && ENV['CALLSTACKING_RAILS_LOCAL_TEST'].nil?
-          PRODUCTION_URL
+        if (Callstacking::Rails::Env.production? || ::Rails.env.test?) &&
+          ENV['CALLSTACKING_RAILS_LOCAL_TEST'].nil?
+          Callstacking::Rails::Settings::PRODUCTION_URL
         else
-          prompt("Enter URL for #{Callstacking::Rails::Env.environment} API calls [#{PRODUCTION_URL}]:") || PRODUCTION_URL
+          prompt("Enter URL for #{Callstacking::Rails::Env.environment} API calls [#{Callstacking::Rails::Settings::PRODUCTION_URL}]:") ||
+              Callstacking::Rails::Settings::PRODUCTION_URL
         end
       end
     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

@@ -1,57 +1,72 @@
 require "rails"
 require "active_support/concern"
-require "callstacking/rails/client/base"
-require "callstacking/rails/client/authenticate"
-require "callstacking/rails/client/trace"
-require "callstacking/rails/settings"
 
 module Callstacking
   module Rails
     class Trace
-      include Callstacking::Rails::Settings
-
       attr_accessor :spans, :client, :lock
-      cattr_accessor :current_request_id
+      attr_reader :settings
+      cattr_accessor :current_trace_id
+      cattr_accessor :current_tuid
+
+      ICON = '💥'
+      MAX_TRACE_ENTRIES = 3000
 
       def initialize(spans)
         @traces = []
         @spans  = spans
+        @settings = Callstacking::Rails::Settings.new
 
         @lock   = Mutex.new
-        @client = Callstacking::Rails::Client::Trace.new
-      end
+        @client = Callstacking::Rails::Client::Trace.new(settings.url, settings.auth_token)
 
-      def tracing
-        read_settings
+        init_uuids(nil, nil)
+        init_callbacks(nil)
+      end
 
+      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
@@ -60,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: {},
@@ -78,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,
@@ -96,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,
@@ -118,30 +136,28 @@ 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)
-        url = "#{settings[:url]}/traces/#{trace_id}"
+        url = "#{settings.url}/traces/#{trace_id}"
         
         puts "*" * url.size
         puts url
@@ -150,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

@@ -7,12 +7,9 @@ module Callstacking
       include ActionView::Helpers::TagHelper
       include ActionView::Helpers::JavaScriptHelper
       include ActionView::Context
-      include Callstacking::Rails::Settings
 
-      def hud
-        read_settings
-
-        frame_url = "#{url || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{Callstacking::Rails::Trace.current_request_id}/print"
+      def hud(url)
+        frame_url = "#{url || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{Callstacking::Rails::Trace.current_trace_id}/print"
 
         body = []
         body << (content_tag( :div, data: { turbo:false },
@@ -20,7 +17,7 @@ module Callstacking
                             padding: 0px; position: fixed; height: 50px; width: 40px; cursor: pointer;',
                     onclick: 'document.getElementById("callstacking-debugger").style.display = "unset";
                               document.getElementById("callstacking-close").style.display = "unset";') do
-          "<span title='ctrl-d'><center>💥</center></span>".html_safe
+          "<span title='ctrl-d'><center>#{Callstacking::Rails::Trace::ICON}</center></span>".html_safe
         end)
         
         body << (content_tag(:iframe, src: frame_url, id: 'callstacking-debugger', data: { turbo:false },
@@ -45,11 +42,8 @@ module Callstacking
         body.join
       end
 
-      def inject_hud
-        read_settings
-        return unless enabled?
-        
-        response.body = response.body.sub(/<\/body>/i, "#{hud}</body>")
+      def inject_hud(settings)
+        response.body = response.body.sub(/<\/body>/i, "#{hud(settings.url)}</body>")
       end
     end
   end

data/lib/callstacking/rails/version.rb

@@ -1,5 +1,5 @@
 module Callstacking
   module Rails
-    VERSION = "0.1.19"
+    VERSION = "0.1.21"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callstacking-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.21
 platform: ruby
 authors:
 - Jim Jones
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-09 00:00:00.000000000 Z
+date: 2023-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-silence
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Quickly visualize which methods call which, their parameters, and return
   values.
 email:
@@ -74,6 +102,7 @@ files:
 - config/routes.rb
 - exe/callstacking-rails
 - lib/callstacking/rails.rb
+- lib/callstacking/rails/cli.rb
 - lib/callstacking/rails/client/authenticate.rb
 - lib/callstacking/rails/client/base.rb
 - lib/callstacking/rails/client/trace.rb
@@ -84,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