callstacking-rails 0.1.29 → 0.1.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a645231d70a30c9296b1ffbd7f99ce8295f571bd7641b6389354f4fbd43ff153
-  data.tar.gz: 50d96385483deacfa0856b4af8cc8e59450d521d3237310735fa759de37f3bcb
+  metadata.gz: 26c64da0b1b2bb170e40ee319c04d9d8b090e4801d4aa61ecdb1728e4edb0a10
+  data.tar.gz: 619d6983c3aa94affb3d31c7c0e4a8532565c219bd9d14832a50b9fb46f813b7
 SHA512:
-  metadata.gz: 0f7dddf5d3c1f944ce982d2ce5a803cc984dbcf757b29856f289039df9aa09608749c7998f567ca3da6ce0b8edd32289894cc5edd2f1afd8090b6c3416cb4a79
-  data.tar.gz: 8c692f7133164c596e0a39550867a0ee882a882e719c449564c16619fb485a522fbd77150a74ec86ff00b04b3a2ed946f57dcdd7f6385abcb59840e229ecbf63
+  metadata.gz: fa3fc9c4d8e079df650a5efefe6704d6682f770ebd35516ff501ddd3c896f3df69e871f7d7908855d6074c0536cff05346d31a7c74024884633c685ad3bc6909
+  data.tar.gz: 0c253b57e8ff3044e17df80fc9bab0b3cc6cb49efc5aeba2d6900b8b27857fde19cb06fbdce5fae05da70371f6922ce7c6d4fc7419cc824c099f10df75aad7aa

data/README.md

@@ -45,25 +45,18 @@ $ bundle
 ```
 
 ## CLI Setup
-Register an account at callstacking.com:
 
-> callstacking-rails register
+*Step 1:*
+> bundle exec callstacking-rails register
+ 
+The above command will open a browser window and allow you to register an account at callstacking.com.
+       
+*Step 2:*
+> bundle exec callstacking-rails setup
 
-Opens a browser window to register as a callstacking.com user.
+This interactively prompts you for your callstacking.com username/password.
 
-> callstacking-rails setup
-
-Interactively prompts you for your callstacking.com username/password.
-Stores auth details in `~/.callstacking`.
-
-You can have multiple environments.
-The default is `development`.
-
-The `development:` section in the `~/.callstacking` config contains your credentials.
-
-By setting the RAILS_ENV environment you can maintain multiple settings.
-
-Questions? Create an issue: https://github.com/callstacking/callstacking-rails/issues
+The auth details are stored in `~/.callstacking`.
 
 ## Enabling Tracing
                                         
@@ -78,7 +71,7 @@ and for a `debug` param to be set to `1`:
 class ApplicationController < ActionController::Base
   include Callstacking::Rails::Helpers::InstrumentHelper
 
-  around_action :callstacking_setup, if: -> { current_user&.admin? && params[:debug] == '1' }
+  prepend_around_action :callstacking_setup, if: -> { current_user&.admin? && params[:debug] == '1' }
 ```
 
 For the above setup, you would you have to be authenticated as an admin and would append `?debug=1` 
@@ -91,6 +84,8 @@ e.g.
 
 The local Rails server log outputs the trace URL. 
 
+<img width="1141" alt="screenshot of trace url output in Rails logs" src="https://user-images.githubusercontent.com/4600/236599713-49a82a83-d8c0-4e51-9442-5da1fbca7f9c.png">
+
 ## Production Environment
 
 For production, you can provide the auth token via the `CALLSTACKING_API_TOKEN` environment variable.
@@ -103,14 +98,20 @@ The traces are recorded at https://callstacking.com/traces
 
 For local HTML requests, once your page has rendered, you will see a `💥` icon on the right hand side.
 
-Click the icon and observe the full callstack context.
+Click the icon and observe the trace.
+
+### Headless API requests
 
-For headless API requests, visit https://callstacking.com/traces to view your traces.
+The trace URL is output via the Rails logs.  https://callstacking.com/traces will updated with your latest trace.
 
 ## Tests
 ``
 rake app:test:all
 ``
 
+## Questions/Bugs/Feature Requests
+
+Create an issue: https://github.com/callstacking/callstacking-rails/issues
+
 ## License
-The gem is available as open source under the terms of the [GPLv3 License](https://www.gnu.org/licenses/gpl-3.0.en.html).
+The license can be viewed at https://github.com/callstacking/callstacking-rails/blob/main/LICENSE

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

@@ -21,7 +21,7 @@ module Callstacking
           # https://github.com/lostisland/awesome-faraday
           @connection ||= Faraday.new(url) do |c|
             c.response :json
-            c.use Faraday::Response::Logger, Logger.new('/tmp/callstacking-rails.log')
+            c.use Faraday::Response::Logger
             # c.use Faraday::Response::Logger, nil, { headers: false, bodies: false }
             c.response :follow_redirects
             c.use Faraday::Response::RaiseError # raise exceptions on 40x, 50x responses
@@ -35,7 +35,7 @@ module Callstacking
           end
         end
 
-        def get(url, params = {})
+        def get(url, params = {}, headers = {})
           if async
             threads << Thread.new do
               connection.get(url, params, headers)

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

@@ -6,6 +6,7 @@ module Callstacking
       class Trace < Base
         CREATE_URL = "/api/v1/traces.json"
         UPDATE_URL = "/api/v1/traces/:id.json"
+        SHOW_URL = "/api/v1/traces/:id.json"
 
         def initialize(url, auth_token)
           super
@@ -37,6 +38,10 @@ module Callstacking
         def upsert(trace_id, traces)
           patch(UPDATE_URL.gsub(':id', trace_id), {}, traces)
         end
+
+        def show(trace_id, params = {})
+          get(SHOW_URL.gsub(':id', trace_id), params)
+        end
       end
     end
   end

data/lib/callstacking/rails/engine.rb

@@ -13,45 +13,83 @@ require "callstacking/rails/client/trace"
 require "callstacking/rails/cli"
 require "callstacking/rails/time_based_uuid"
 require "callstacking/rails/helpers/instrument_helper"
+require "callstacking/rails/logger"
 
 module Callstacking
   module Rails
     class Engine < ::Rails::Engine
-      EXCLUDED_TEST_CLASSES = %w[test/dummy/app/models/salutation.rb test/dummy/app/controllers/application_controller.rb].freeze
+      EXCLUDED_TEST_CLASSES = %w[test/dummy/app/models/salutation.rb 
+                                 test/dummy/app/controllers/application_controller.rb].freeze
       
-      cattr_accessor :spans, :trace, :settings, :instrumenter, :loader
+      cattr_accessor :spans, :traces, :settings, :instrumenter, :loader, :lock
 
       isolate_namespace Callstacking::Rails
 
+      @@spans||={}
+      @@traces||={}
+      @@lock||=Mutex.new
+      @@instrumenter||=Instrument.new
       @@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"
       end
 
       config.after_initialize do
-        puts "Call Stacking loading (#{Callstacking::Rails::Env.environment})"
-          
-        @@loader = Callstacking::Rails::Loader.new(@@instrumenter, excluded: @@settings.excluded + EXCLUDED_TEST_CLASSES)
-        @@loader.on_load
+        Logger.log "Call Stacking loading (#{Callstacking::Rails::Env.environment})"
+
+        spans[Thread.current.object_id]||=Spans.new
+        instrumenter.add_span(spans[Thread.current.object_id])
+
+        @@loader = Callstacking::Rails::Loader.new(instrumenter, excluded: settings.excluded + EXCLUDED_TEST_CLASSES)
+        @@loader.instrument_existing
+
+        loader.on_load
+        # loader.reset!
       end
 
+      # Serialize all tracing requests for now.
+      #  Can enable parallel tracing later.
       def self.start_tracing(controller)
-        @@settings.enable!
-        @@instrumenter.enable!(@@loader.klasses.to_a)
-        @@trace.begin_trace(controller)
+        Logger.log("Callstacking::Rails::Engine.start_tracing")
+        
+        settings.enable!
+
+        lock.synchronize do
+          spans[Thread.current.object_id]||=Spans.new
+          span = spans[Thread.current.object_id]
+
+          instrumenter.add_span(span)
+
+          if instrumenter.instrumentation_required?
+            loader.reset!
+            instrumenter.enable!(loader.klasses.to_a)
+          end
+
+          traces[Thread.current.object_id] = Trace.new(span)
+          trace = traces[Thread.current.object_id]
+
+          trace.begin_trace(controller)
+        end
 
         true
       end
 
       def self.stop_tracing(controller)
-        @@settings.disable!
-        @@instrumenter.disable!
-        @@trace.end_trace(controller)
+        Logger.log("Callstacking::Rails::Engine.stop_tracing")
+        
+        settings.disable!
+
+        trace = nil
+        lock.synchronize do
+          trace = traces.delete(Thread.current.object_id)
+          if traces.empty?
+            instrumenter.disable!
+          end
+        end
 
+        trace&.end_trace(controller)
+        
         true
       end
     end

data/lib/callstacking/rails/instrument.rb

@@ -7,8 +7,8 @@ module Callstacking
       attr_accessor :spans
       attr_reader :settings, :span_modules
 
-      def initialize(spans)
-        @spans = spans
+      def initialize
+        @spans = {}
         @span_modules = Set.new
         @settings = Callstacking::Rails::Settings.new
       end
@@ -34,6 +34,9 @@ module Callstacking
         new_method = nil
         if RUBY_VERSION < "2.7.8"
           new_method = tmp_module.define_method(method_name) do |*args, &block|
+            settings = tmp_module.instance_variable_get(:@settings)
+            return super(*args, &block) if settings.disabled?
+            
             method_name = __method__
 
             path = method(__method__).super_method.source_location.first
@@ -42,19 +45,23 @@ module Callstacking
             p, l = caller.find { |c| c.to_s =~ /#{::Rails.root.to_s}/}&.split(':')
 
             spans = tmp_module.instance_variable_get(:@spans)
+            span  = spans[Thread.current.object_id]
             klass = tmp_module.instance_variable_get(:@klass)
 
             arguments = Callstacking::Rails::Instrument.arguments_for(method(__method__).super_method, args)
 
-            spans.call_entry(klass, method_name, arguments, p || path, l || line_no)
+            span.call_entry(klass, method_name, arguments, p || path, l || line_no)
             return_val = super(*args, &block)
-            spans.call_return(klass, method_name, p || path, l || line_no, return_val)
+            span.call_return(klass, method_name, p || path, l || line_no, return_val)
 
             return_val
           end
           new_method.ruby2_keywords if new_method.respond_to?(:ruby2_keywords)
         else
           new_method = tmp_module.define_method(method_name) do |*args, **kwargs, &block|
+            settings = tmp_module.instance_variable_get(:@settings)
+            return super(*args, **kwargs, &block) if settings.disabled?
+
             method_name = __method__
 
             path = method(__method__).super_method.source_location.first
@@ -63,13 +70,14 @@ module Callstacking
             p, l = caller.find { |c| c.to_s =~ /#{::Rails.root.to_s}/}&.split(':')
 
             spans = tmp_module.instance_variable_get(:@spans)
+            span  = spans[Thread.current.object_id]
             klass = tmp_module.instance_variable_get(:@klass)
 
             arguments = Callstacking::Rails::Instrument.arguments_for(method(__method__).super_method, args)
 
-            spans.call_entry(klass, method_name, arguments, p || path, l || line_no)
+            span.call_entry(klass, method_name, arguments, p || path, l || line_no)
             return_val = super(*args, **kwargs, &block)
-            spans.call_return(klass, method_name, p || path, l || line_no, return_val)
+            span.call_return(klass, method_name, p || path, l || line_no, return_val)
 
             return_val
           end
@@ -95,6 +103,10 @@ module Callstacking
         reset!
       end
 
+      def instrumentation_required?
+        span_modules.empty?
+      end
+
       def reset!
         span_modules.clear
       end
@@ -118,6 +130,10 @@ module Callstacking
         f.filter h
       end
 
+      def add_span(span)
+        spans[Thread.current.object_id] ||= span
+      end
+
       private
       def find_or_initialize_module(klass)
         name = klass&.name rescue nil
@@ -127,11 +143,15 @@ module Callstacking
         module_index = klass.ancestors.map(&:to_s).index(module_name)
 
         unless module_index
-          new_module = Object.const_set(module_name, Module.new)
+          # Development class reload -
+          #   ancestors are reset but module definition remains
+          new_module = Object.const_get(module_name) rescue nil
+          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)
+          new_module.instance_variable_set("@settings", settings)
 
           klass.prepend new_module
           klass.singleton_class.prepend new_module if klass.class == Module

data/lib/callstacking/rails/loader.rb

@@ -1,4 +1,5 @@
 require "rails"
+require "callstacking/rails/logger"
 
 module Callstacking
   module Rails
@@ -10,25 +11,40 @@ module Callstacking
         @klasses = Set.new
       end
 
+      def instrument_existing
+        ObjectSpace.each_object(Module){|ob| filter_klass(ob, (Object.const_source_location(ob.to_s)&.first rescue nil))}
+      end
+
       def on_load
         trace = TracePoint.new(:end) do |tp|
           klass = tp.self
           path  = tp.path
 
-          excluded_klass = excluded.any? { |ex| path =~ /#{ex}/ }
-
-          if path =~ /#{::Rails.root.to_s}/ &&
-            !klasses.include?(klass) &&
-            !excluded_klass
-              klasses << klass
-          end
+          filter_klass(klass, path)
         end
 
         trace.enable
+      end
 
+      def reset!
         instrumenter.instrument_method(ActionView::PartialRenderer, :render, application_level: false)
         instrumenter.instrument_method(ActionView::TemplateRenderer, :render, application_level: false)
       end
+
+      private
+      def filter_klass(klass, path)
+        return if klass.nil? || path.nil?
+        return if path == false
+
+        excluded_klass = excluded.any? { |ex| path =~ /#{ex}/ }
+
+        if path =~ /#{::Rails.root.to_s}/ &&
+          !klasses.include?(klass) &&
+          !excluded_klass
+          instrumenter.instrument_klass(klass)
+          klasses << klass
+        end
+      end
     end
   end
 end

data/lib/callstacking/rails/logger.rb

@@ -0,0 +1,18 @@
+module Callstacking
+  module Rails
+    class Logger
+      def self.log(message)
+        puts message
+        
+        if ENV['GITHUB_OUTPUT'].present?
+          File.open(ENV['GITHUB_OUTPUT'], 'a') do |file|
+            # Write your progress output to the file
+            # This could be inside a loop or condition, depending on your needs
+            file.puts "::set-output name=progress_output::#{message}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/callstacking/rails/settings.rb

@@ -23,7 +23,9 @@ module Callstacking
       end
 
       def auth_token
-        ENV['CALLSTACKING_API_TOKEN'] || settings[:auth_token]
+        x = ENV['CALLSTACKING_API_TOKEN'] || settings[:auth_token]
+        raise "No auth token found. #{ENV['CALLSTACKING_API_TOKEN']} Please run `callstacking login` to get one." if x.nil?
+        x
       end
 
       def auth_token?
@@ -35,14 +37,14 @@ module Callstacking
       end
 
       def self.enable!
-        ::Rails.cache.write(CACHE_KEY, true)
+        Thread.current[CACHE_KEY] = true
       end
       def enable!
         self.class.enable!
       end
 
       def self.disable!
-        ::Rails.cache.write(CACHE_KEY, false)
+        Thread.current[CACHE_KEY] = false
       end
 
       def disable!
@@ -50,11 +52,9 @@ module Callstacking
       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?
-        
-        settings[:enabled]
+        return Thread.current[CACHE_KEY] if Thread.current[CACHE_KEY].present?
+        return ActiveRecord::Type::Boolean.new.cast(ENV[ENV_KEY]) if ENV[ENV_KEY].present?
+        false
       end
 
       def excluded

data/lib/callstacking/rails/trace.rb

@@ -7,18 +7,22 @@ module Callstacking
     class Trace
       include Callstacking::Rails::Helpers::HeadsUpDisplayHelper
       
-      attr_accessor :spans, :client, :lock
+      attr_accessor :spans, :client, :lock, :traces
       attr_reader :settings
       cattr_accessor :current_trace_id
       cattr_accessor :current_tuid
+      cattr_accessor :trace_log
 
       ICON = '💥'
       MAX_TRACE_ENTRIES = 3000
+      
+      @@trace_log||={}
 
       def initialize(spans)
-        @traces   = []
-        @spans    = spans
-        @settings = Callstacking::Rails::Settings.new
+
+        @traces    = []
+        @spans     = spans
+        @settings  = Callstacking::Rails::Settings.new
 
         @lock     = Mutex.new
         @client   = Callstacking::Rails::Client::Trace.new(settings.url, settings.auth_token)
@@ -29,16 +33,20 @@ module Callstacking
 
       def begin_trace(controller)
         @trace_id, @tuid = init_uuids(controller.request&.request_id || SecureRandom.uuid, TimeBasedUUID.generate)
+        trace_log[@trace_id] = controller.request&.original_url
+        
         init_callbacks(@tuid)
 
         start_request(@trace_id, @tuid,
                       controller.action_name, controller.controller_name,
                       controller.action_name, controller.request.format, ::Rails.root.to_s,
                       controller.request&.original_url,
-                      controller.request.headers, controller.request.params)
+                      controller.request.headers, controller.request.params, @traces)
       end
 
       def end_trace(controller)
+        return if @trace_id.nil? || @tuid.nil?
+        
         complete_request(@trace_id, @tuid,
                          controller.action_name, controller.controller_name,
                          controller.action_name, controller.request.format,
@@ -48,6 +56,10 @@ module Callstacking
         inject_hud(@settings, controller.request, controller.response)
       end
 
+      def self.trace_log_clear
+        trace_log.clear
+      end
+
       private
 
       def init_callbacks(tuid)
@@ -136,12 +148,18 @@ module Callstacking
         lock.synchronize do
           return if traces.empty?
 
+          STDERR.puts "Sending #{traces.size} traces to Callstacking.io -- enabled? - #{settings.enabled?} -- #{traces.inspect}"
+
           client.upsert(trace_id,
                         { trace_entries: traces.deep_dup })
           traces.clear
         end
       end
-      def start_request(trace_id, tuid, method, controller, action, format, path, original_url, headers, params)
+      def start_request(trace_id, tuid, method, controller, action, format, path, original_url, headers, params, traces)
+        lock.synchronize do
+          traces.clear
+        end
+
         return if do_not_track_request?(original_url, format)
 
         client.create(trace_id, tuid,
@@ -167,10 +185,7 @@ module Callstacking
       end
 
       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
+        return if do_not_track_request?(original_url, format)
 
         create_message(tuid, completed_request_message(method, controller, action, format),
                        spans.increment_order_num, traces)

data/lib/callstacking/rails/version.rb

@@ -1,5 +1,5 @@
 module Callstacking
   module Rails
-    VERSION = "0.1.29"
+    VERSION = "0.1.31"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callstacking-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.29
+  version: 0.1.31
 platform: ruby
 authors:
 - Jim Jones
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-06 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -112,6 +112,7 @@ files:
 - lib/callstacking/rails/helpers/instrument_helper.rb
 - lib/callstacking/rails/instrument.rb
 - lib/callstacking/rails/loader.rb
+- lib/callstacking/rails/logger.rb
 - lib/callstacking/rails/settings.rb
 - lib/callstacking/rails/setup.rb
 - lib/callstacking/rails/spans.rb