callstacking-rails 0.1.0

data/lib/callstacking/rails/spans.rb

@@ -0,0 +1,72 @@
+module Callstacking
+  module Rails
+    class Spans
+      attr_accessor :order_num, :nesting_level, :previous_entry
+      attr_accessor :call_entry_callback, :call_return_callback
+
+      def initialize
+        @nesting_level = -1
+        @order_num = -1
+        @previous_entry = nil
+      end
+
+      def increment_order_num
+        @order_num+=1
+        @order_num
+      end
+
+      def increment_nesting_level
+        @nesting_level+=1
+        @nesting_level
+      end
+
+      def call_entry(klass, method_name, path, line_no)
+        @nesting_level+=1
+        @previous_entry = previous_event(klass, method_name)
+        @call_entry_callback.call(@nesting_level, increment_order_num, klass, method_name, path, line_no)
+      end
+
+      def call_return(klass, method_name, path, line_no, return_val)
+        @call_return_callback.call(coupled_callee(klass, method_name), @nesting_level,
+                                   increment_order_num, klass, method_name, path, line_no, return_val)
+        @nesting_level-=1
+      end
+
+      def on_call_entry(&block)
+        @call_entry_callback = block
+      end
+
+      def on_call_return(&block)
+        @call_return_callback = block
+      end
+
+      def arguments_for(trace)
+        param_names = trace&.parameters&.map(&:last)
+        return {} if param_names.nil?
+
+        param_names.map do |param|
+          next if [:&, :*, :**].include?(param)
+          [param, trace.binding.local_variable_get(param.to_s)]
+        end.compact.to_h
+      end
+
+      def locals_for(trace)
+        local_names = trace&.binding&.local_variables
+        return {} if local_names.nil?
+
+        local_names.map do |local|
+          [local, trace.binding.local_variable_get(local)]
+        end.to_h
+      end
+
+      private
+      def previous_event(klass, method_name)
+        "#{klass}:#{method_name}"
+      end
+
+      def coupled_callee(klass, method_name)
+        previous_entry == previous_event(klass, method_name)
+      end
+    end
+  end
+end

data/lib/callstacking/rails/trace.rb

@@ -0,0 +1,126 @@
+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
+
+      def initialize(spans)
+        @traces = []
+        @spans  = spans
+
+        @lock   = Mutex.new
+        @client = Callstacking::Rails::Client::Trace.new
+      end
+
+      def tracing
+        read_settings
+
+        trace_id = nil
+
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+          request_id = payload[:request].request_id
+          Callstacking::Rails::Trace.current_request_id = request_id
+
+          trace_id, _interval = client.create(payload[:method], payload[:controller],
+                                              payload[:action], payload[:format],
+                                              ::Rails.root, payload[:request].original_url,
+                                              request_id, payload[:headers],
+                                              payload[:params])
+
+          puts "#{settings[:url] || Callstacking::Rails::Settings::PRODUCTION_URL}/traces/#{trace_id}"
+          
+          create_message(start_request_message(payload), spans.increment_order_num, @traces)
+        end
+
+        @spans.on_call_entry do |nesting_level, order_num, klass, method_name, path, line_no|
+          create_call_entry(nesting_level, order_num, klass, method_name, 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(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|
+          create_message(completed_request_message(payload), spans.increment_order_num, @traces)
+          send_traces!(trace_id, @traces)
+        end
+      end
+
+      private
+
+      def completed_request_message(payload)
+        "Completed request: #{payload[:method]} #{payload[:controller]}##{payload[:action]} as #{payload[:format]}"
+      end
+
+      def start_request_message(payload)
+        "Started request: #{payload[:method]} #{payload[:controller]}##{payload[:action]} as #{payload[:format]}"
+      end
+
+      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,
+                                     } } }
+        end
+      end
+
+      def create_call_entry(nesting_level, order_num, klass, method_name, 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_for(t),
+                                       klass: klass_name(klass),
+                                       line_number: line_no,
+                                       path: path,
+                                       method_name: method_name,
+                                     } } }
+        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
+                                     } } }
+        end
+      end
+
+      def send_traces!(trace_id, traces)
+        lock.synchronize do
+          return if traces.empty?
+
+          client.upsert(trace_id, { traces: traces })
+          traces.clear
+        end
+      end
+
+      private
+      def klass_name(klass)
+        (klass.is_a?(Class) ? klass.name : klass.class.name)
+      end
+    end
+  end
+end

data/lib/callstacking/rails/traces_helper.rb

@@ -0,0 +1,39 @@
+require "action_view/helpers/tag_helper"
+require "action_view/context.rb"
+
+module Callstacking
+  module Rails
+    module TracesHelper
+      include ActionView::Helpers::TagHelper
+      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"
+
+        body = []
+        body << (content_tag( :div, data: { turbo:false },
+                    style: 'background-color: #FFF; font-size: 20pt; top: 50%; right: 10px; font-size: 36pt;
+                            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
+          "<<"
+        end)
+        
+        body << (content_tag(:iframe, src: frame_url, id: 'callstacking-debugger', data: { turbo:false },
+                    style: "width: 50%; height: 100%; overflow: scroll; top: 20px; right: 20px; position: fixed;
+                            z-index: 99; opacity: 1.0; background-color: #FFF; color: #000; border: 1px solid;
+                            margin: 0; padding: 0; box-shadow: 5px 5px; display: none;") do
+        end)
+        
+        body.join
+      end
+
+      def inject_hud
+        response.body = response.body.sub(/<\/body>/i, "#{hud}</body>")
+      end
+    end
+  end
+end

data/lib/callstacking/rails/version.rb

@@ -0,0 +1,5 @@
+module Callstacking
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/callstacking/rails.rb

@@ -0,0 +1,7 @@
+require "callstacking/rails/version"
+require "callstacking/rails/engine"
+
+module Callstacking
+  module Rails
+  end
+end

data/lib/tasks/checkpoint/rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :checkpoint_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: callstacking-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jim Jones
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rolling debugger that shows the full state of each call.
+email:
+- jim.jones1@gmail.com
+executables:
+- callstacking-rails
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/config/callstacking_rails_manifest.js
+- app/assets/stylesheets/callstacking/rails/application.css
+- app/controllers/callstacking/rails/application_controller.rb
+- app/helpers/callstacking/rails/application_helper.rb
+- app/jobs/callstacking/rails/application_job.rb
+- app/mailers/callstacking/rails/application_mailer.rb
+- app/models/callstacking/rails/application_record.rb
+- config/routes.rb
+- exe/callstacking-rails
+- lib/callstacking/rails.rb
+- lib/callstacking/rails/client/authenticate.rb
+- lib/callstacking/rails/client/base.rb
+- lib/callstacking/rails/client/trace.rb
+- lib/callstacking/rails/engine.rb
+- lib/callstacking/rails/env.rb
+- lib/callstacking/rails/instrument.rb
+- lib/callstacking/rails/loader.rb
+- lib/callstacking/rails/settings.rb
+- lib/callstacking/rails/setup.rb
+- lib/callstacking/rails/spans.rb
+- lib/callstacking/rails/trace.rb
+- lib/callstacking/rails/traces_helper.rb
+- lib/callstacking/rails/version.rb
+- lib/tasks/checkpoint/rails_tasks.rake
+homepage: https://github.com/callstacking/callstacking-rails
+licenses:
+- GPL-3.0-or-later
+metadata:
+  homepage_uri: https://github.com/callstacking/callstacking-rails
+  source_code_uri: https://github.com/callstacking/callstacking-rails
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Rolling debugger that shows the full state of each call per request.
+test_files: []