callstacking-rails 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4bc78186fe09232889a12dea985d128878de745f00a7f6761fd2d6bdc1bc6e0
+  data.tar.gz: 113fe92740e5260af527603445de8c0ec5ce49262a332dff1620382bb584dfa3
+SHA512:
+  metadata.gz: db7b809625176d70d726b202d11d26d55c73809281af0e569431f9c884ad81ce7868e29fa685a0527a48ffc0ba8fd52cf4e35b4ae0e83bd6cf64684663bc5e31
+  data.tar.gz: 74cf19f86b7ad4da4c67eb1a83af54f51e843d324e067b6d05cf81eede3a1bc14a05903e252ed73359c01d0cf58a35e98940e13688fa2423abd61616ca302c6a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Jim Jones
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# Checkpoint::Rails
+
+Callstacking 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).  
+
+You no longer need to debug with `binding.pry` or `puts` statements, as the entire callstack for a given request is captured.
+
+Demo video:
+[![Watch the video](https://user-images.githubusercontent.com/4600/190929740-fc68e18f-9572-41be-9719-cc6a8077e97f.png)](https://www.youtube.com/watch?v=NGqnwcNWv_k)
+
+Class method calls are labeled.  Return values for those calls are denoted with ↳
+
+Arguments for a method will be listed along with their calling values.
+
+For method returns ↳, the final values of the local variables will be listed when you hover over the entry.
+
+<img width="1695" alt="CleanShot 2022-09-17 at 21 10 32@2x" src="https://user-images.githubusercontent.com/4600/190882603-a99e9358-9754-4cbf-ac68-a41d53afe747.png">
+
+Subsequent calls within a method are visibly nested.
+
+Checkpoint is a Rails engine that you mount within your Rails app.
+
+Here's a sample debugging sessions recorded from a Jumpstart Rails based app I've been working on.  This is a request for the main page ( https://smartk.id/ ).
+
+![image](https://user-images.githubusercontent.com/4600/190882432-58092e38-7ee2-4138-b13a-f45ff2b09227.png)
+
+Checkpoint Rails records all of the critical method calls within your app, along with their important context (param/argument/return/local variable values).
+
+All in a rolling panel, so that you can debug your call chains from any point in the stack.
+
+You'll never have to debug with `puts` statements ever again.
+
+Calls are visibly nested so that it's easy to see which calls are issued from which parent methods.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "callstacking-rails"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Usage
+When you open a page for your app, once the page has rendered, you will see an arrow on the right hand side.
+
+Click the arrow, and observe the full callstack context.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/config/checkpoint_rails_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/checkpoint/rails .css

data/app/assets/stylesheets/checkpoint/rails/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/checkpoint/rails/application_controller.rb

@@ -0,0 +1,6 @@
+module Checkpoint
+  module Rails
+    class ApplicationController < ActionController::Base
+    end
+  end
+end

data/app/controllers/checkpoint/rails/traces_controller.rb

@@ -0,0 +1,6 @@
+module Checkpoint::Rails
+  class TracesController < ApplicationController
+    def index
+    end
+  end
+end

data/app/helpers/checkpoint/rails/application_helper.rb

@@ -0,0 +1,6 @@
+module Checkpoint
+  module Rails
+    module ApplicationHelper
+    end
+  end
+end

data/app/jobs/checkpoint/rails/application_job.rb

@@ -0,0 +1,6 @@
+module Checkpoint
+  module Rails
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/checkpoint/rails/application_mailer.rb

@@ -0,0 +1,8 @@
+module Checkpoint
+  module Rails
+    class ApplicationMailer < ActionMailer::Base
+      default from: "from@example.com"
+      layout "mailer"
+    end
+  end
+end

data/app/models/checkpoint/rails/application_record.rb

@@ -0,0 +1,7 @@
+module Checkpoint
+  module Rails
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+Checkpoint::Rails::Engine.routes.draw do
+  resources :traces
+  root to: "traces#index"
+end

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

@@ -0,0 +1,22 @@
+require 'json'
+
+module Checkpoint
+  module Rails
+    module Client
+      class Error < StandardError; end
+
+      class Authenticate < Base
+        URL = "/api/v1/auth.json"
+
+        def login(email, password)
+          resp = post(URL, email: email, password: password)
+
+          raise Faraday::UnauthorizedError if resp&.body.nil?
+
+          body = resp&.body || {}
+          body["token"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'faraday'
+require 'faraday/follow_redirects'
+require "checkpoint/rails/settings"
+
+module Checkpoint
+  module Rails
+    module Client
+      class Error < StandardError; end
+
+      class Base
+        include Checkpoint::Rails::Settings
+
+        def initialize
+          read_settings
+        end
+
+        def connection
+          # 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, nil, { headers: false, bodies: false }
+            c.response :follow_redirects
+            c.use Faraday::Response::RaiseError # raise exceptions on 40x, 50x responses
+            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?
+              c.request :authorization, :Bearer, auth_token
+            end
+          end
+        end
+
+        def get(url, params = {})
+          connection.get(url, params, headers)
+        end
+
+        def post(url, params = {}, body = {}, headers_ext = {})
+          r(:post, url, params, body, headers_ext)
+        end
+
+        def patch(url, params = {}, body = {}, headers_ext = {})
+          r(:patch, url, params, body, headers_ext)
+        end
+
+        def r(action, url, params = {}, body = {}, _headers_ext = {})
+          connection.send(action, url) do |req|
+            req.params.merge!(params)
+            req.body = body
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Checkpoint
+  module Rails
+    module Client
+      class Trace < Base
+        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)
+          resp = post(CREATE_URL,
+                      {},
+                      { 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,
+                      })
+
+          return resp.body["trace_id"], resp.body["pulse_interval"]
+        end
+
+        def upsert(trace_id, traces)
+          resp = patch(UPDATE_URL.gsub(':id', trace_id), {}, traces)
+
+          resp.status
+        end
+      end
+    end
+  end
+end

data/lib/checkpoint/rails/engine.rb

@@ -0,0 +1,34 @@
+require "checkpoint/rails/traceable"
+require "checkpoint/rails/setup"
+require "checkpoint/rails/settings"
+require "checkpoint/rails/client/base"
+require "checkpoint/rails/client/authenticate"
+require "checkpoint/rails/client/trace"
+require "checkpoint/rails/traces_helper"
+
+module Checkpoint
+  module Rails
+    class Engine < ::Rails::Engine
+      isolate_namespace Checkpoint::Rails
+
+      include ::Checkpoint::Rails::Traceable
+
+      initializer "engine_name.assets.precompile" do |app|
+        app.config.assets.precompile << "checkpoint_rails_manifest.js"
+      end
+
+      initializer 'local_helper.action_controller' do
+        ActiveSupport.on_load :action_controller do
+          helper Checkpoint::Rails::TracesHelper
+          include Checkpoint::Rails::TracesHelper
+        end
+      end
+
+      initializer :append_before_action do
+        ActionController::Base.send :after_action, :inject_hud
+      end
+
+      set_trace
+    end
+  end
+end

data/lib/checkpoint/rails/env.rb

@@ -0,0 +1,15 @@
+module Checkpoint
+  module Rails
+    class Env
+      DEFAULT_ENVIRONMENT = "development"
+
+      cattr_accessor :environment
+
+      @@environment = (ENV['RAILS_ENV'] || DEFAULT_ENVIRONMENT).parameterize(separator: '_').to_sym
+
+      def self.production?
+        @@environment == DEFAULT_ENVIRONMENT.parameterize(separator: '_').to_sym
+      end
+    end
+  end
+end

data/lib/checkpoint/rails/settings.rb

@@ -0,0 +1,46 @@
+require "active_support/concern"
+require "active_support/core_ext/class/attribute_accessors"
+require "checkpoint/rails/env"
+
+module Checkpoint
+  module Rails
+    module Settings
+      extend ActiveSupport::Concern
+
+      included do |base|
+        attr_accessor :settings
+      end
+
+      SETTINGS_FILE = "#{Dir.home}/.callstacking-rails"
+      PRODUCTION_URL = "https://callstacking.com"
+
+      def url
+        settings[:url]
+      end
+
+      def auth_token
+        settings[:auth_token]
+      end
+
+      def auth_token?
+        auth_token.present?
+      end
+
+      def write_settings(new_settings)
+        File.write(SETTINGS_FILE, new_settings.to_yaml)
+      end
+
+      def read_settings
+        @@settings = @settings = complete_settings.dig(::Checkpoint::Rails::Env.environment, :settings)
+      rescue StandardError => e
+        puts e.full_message
+        puts e.backtrace.join("\n")
+        return {}
+      end
+
+      def complete_settings
+        YAML.load(File.read(Checkpoint::Rails::Client::Base::SETTINGS_FILE)) rescue {}
+      end
+    end
+  end
+end

data/lib/checkpoint/rails/setup.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+require "checkpoint/rails/settings"
+
+module Checkpoint
+  module Rails
+    class Setup
+      include ::Checkpoint::Rails::Settings
+      extend ::Checkpoint::Rails::Settings
+
+      attr_accessor :client
+
+      def initialize
+        read_settings
+      end
+
+      def client
+        @client = Checkpoint::Rails::Client::Authenticate.new
+      end
+
+      def start
+        email      = prompt("Enter email:")
+        password   = prompt("Enter password:")
+
+        url = if Rails::Checkpoint::Env.production? && ENV['CHECKPOINT_RAILS_LOCAL_TEST'].nil?
+                PRODUCTION_URL
+              else
+                prompt("Enter URL for #{Checkpoint::Rails::Env.environment} API calls [#{PRODUCTION_URL}]:") || PRODUCTION_URL
+              end
+
+        save(email, password, url)
+
+        puts "Authentication successful."
+        puts "Settings saved to #{SETTINGS_FILE}"
+      rescue StandardError => e
+        puts "Problem authenticating: #{e.message}"
+      end
+
+      def prompt(label)
+        puts label
+        value = STDIN.gets.chomp
+        puts
+
+        return nil if value == ''
+        value
+      end
+
+      def token(email, password)
+        client.login(email, password)
+      end
+
+      def save(email, password, url)
+        props = { auth_token: '',
+                  url: url,
+        }
+
+        props = { Checkpoint::Rails::Env.environment => {
+          settings: props
+        } }
+
+        write_settings(complete_settings.merge(props))
+
+        props[Checkpoint::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 #{Checkpoint::Rails::Env.environment}"
+        puts
+        puts "Usage: "
+        puts
+        puts "  callstacking-rails register"
+        puts "    Opens a browser window to register as a Callstacking user."
+        puts
+        puts "  callstacking-rails setup"
+        puts "    Interactively prompts you for your Callstacking username/password, "
+        puts "    Stores auth details in #{SETTINGS_FILE} "
+        puts
+        puts " You can have multiple environments."
+        puts "    Default is #{Rails::Checkpoint::Env::DEFAULT_ENVIRONMENT}."
+        puts
+        puts " The #{Checkpoint::Rails::Env.environment}: section in the #{SETTINGS_FILE} contains your credentials."
+        puts " By setting the RAILS_ENV environment you can maintain"
+        puts " multiple settings."
+        puts
+        puts "Questions? Create an issue: https://github.com/callstacking/callstacking-rails/issues"
+      end
+    end
+  end
+end

data/lib/checkpoint/rails/traceable.rb

@@ -0,0 +1,210 @@
+require "active_support/concern"
+require "checkpoint/rails/client/base"
+require "checkpoint/rails/client/authenticate"
+require "checkpoint/rails/client/trace"
+require "checkpoint/rails/settings"
+
+module Checkpoint
+  module Rails
+    module Traceable
+      extend ActiveSupport::Concern
+      include Checkpoint::Rails::Settings
+
+      TARGET_DIV = 'traces'
+
+      mattr_accessor :current_request_id
+
+      def set_trace
+        read_settings
+        
+        client = Checkpoint::Rails::Client::Trace.new
+
+        trace_points = {}
+        params       = {}
+        prev_event   = ''
+        order_num    = 0
+        trace_id     = nil
+        traces       = []
+        lock         = Mutex.new
+        task         = nil
+
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+          next if payload[:controller] == 'Checkpoint::Rails::TracesController'
+
+          key = request_key(payload)
+          params[key] = payload[:params]
+
+          nesting_level = -1
+
+          request_id = payload[:request].request_id
+          Checkpoint::Rails::Traceable.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], params[key])
+
+
+          puts "#{settings[:url] || Checkpoint::Rails::Settings::PRODUCTION_URL}/traces/#{trace_id}"
+
+          task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 60) {
+            send_traces!(trace_id, traces, lock, client)
+          }
+
+          task.execute
+
+          create_message(start_request_message(payload), order_num, traces, lock)
+
+          trace_points[key]&.disable
+          trace_point = TracePoint.new(:call, :return) do |t|
+            trace = caller[0]
+
+            next unless trace.match?(Dir.pwd)
+
+            order_num += 1
+
+            if t.event == :call
+              nesting_level += 1
+
+              prev_event = previous_event(t)
+
+              create_call_entry(nesting_level, order_num, t, traces, lock)
+            elsif t.event == :return
+              coupled_callee = false
+              coupled_callee = true if prev_event == previous_event(t)
+
+              prev_event = previous_event(t)
+              return_value = t.return_value.inspect
+
+              create_call_return(coupled_callee, nesting_level, order_num, return_value, t, traces, lock)
+
+              nesting_level -= 1
+            end
+          end
+
+          trace_point.enable
+          trace_points[key] = trace_point
+        end
+
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |name, start, finish, id, payload|
+          trace_points[request_key(payload)]&.disable
+          task&.shutdown
+
+          create_message(completed_request_message(payload), order_num, traces, lock)
+          send_traces!(trace_id, traces, lock, client)
+        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)
+        puts "start request message - "
+        "Request: #{payload[:method]} #{payload[:controller]}##{payload[:action]} as #{payload[:format]}"
+      end
+
+      def create_call_return(coupled_callee, nesting_level, order_num, return_value, t, traces, lock)
+        lock.synchronize do
+          traces << { trace_entry: { trace_entryable_type: 'TraceCallReturn',
+                                     order_num: order_num,
+                                     nesting_level: nesting_level,
+                                     trace_entryable_attributes: {
+                                       local_variables: locals_for(t),
+                                       klass: t.binding.receiver.class.name.to_s,
+                                       line_number: t.lineno,
+                                       path: t.path,
+                                       method_name: t.method_id,
+                                       return_value: return_value,
+                                       coupled_callee: coupled_callee,
+                                     } } }
+        end
+      end
+
+      def create_call_entry(nesting_level, order_num, t, traces, lock)
+        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: t.binding.receiver.class.name.to_s,
+                                       line_number: t.lineno,
+                                       path: t.path,
+                                       method_name: t.method_id,
+                                     } } }
+        end
+      end
+
+      def create_message(message, order_num, traces, lock)
+        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, client)
+        lock.synchronize do
+          return if traces.empty?
+          
+          client.upsert(trace_id, { traces: traces })
+          traces.clear
+        end
+      end
+
+      def caller_key(t)
+        "#{t.binding.receiver.class.name.to_s}##{t.method_id}"
+      end
+
+      def request_key(payload)
+        "#{payload[:controller]}##{payload[:action]}"
+      end
+
+      def previous_event(t)
+        "#{t.binding.receiver.class.name.to_s}:#{t.method_id}"
+      end
+
+      def view_rendered?(t)
+        t.path.to_s =~ /view/
+      end
+
+      def partial_rendered?(t)
+        view_rendered?(t) && Pathname.new(t.path).basename.to_s =~ /^_/
+      end
+
+      def layout_rendered?(t)
+        view_rendered?(t) && t.path =~ /layouts/
+      end
+
+      def template_rendered?(t)
+        view_rendered?(t) && !partial_rendered?(t) && !layout_rendered?(t)
+      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
+    end
+  end
+end

data/lib/checkpoint/rails/traces_helper.rb

@@ -0,0 +1,39 @@
+require "action_view/helpers/tag_helper.rb"
+require "action_view/context.rb"
+
+module Checkpoint
+  module Rails
+    module TracesHelper
+      include ActionView::Helpers::TagHelper
+      include ActionView::Context
+      include Checkpoint::Rails::Settings
+
+      def hud
+        read_settings
+
+        frame_url = "#{url || Checkpoint::Rails::Settings::PRODUCTION_URL}/traces/#{Checkpoint::Rails::Traceable.current_request_id}/print"
+
+        body = []
+        body << (content_tag( :div, data: { turbo:false },
+                    style: 'background-color: #FFF; color: #0000FF; font-size: 20pt; top: 50%; right: 20px;
+                            padding: 30px 10px 0px 10px; position: fixed; height: 100px; 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/checkpoint/rails/version.rb

@@ -0,0 +1,5 @@
+module Checkpoint
+  module Rails
+    VERSION = "0.1.2"
+  end
+end

data/lib/checkpoint/rails.rb

@@ -0,0 +1,7 @@
+require "checkpoint/rails/version"
+require "checkpoint/rails/engine"
+
+module Checkpoint
+  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,125 @@
+--- !ruby/object:Gem::Specification
+name: callstacking-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Jim Jones
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-11-21 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'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/checkpoint_rails_manifest.js
+- app/assets/stylesheets/checkpoint/rails/application.css
+- app/controllers/checkpoint/rails/application_controller.rb
+- app/controllers/checkpoint/rails/traces_controller.rb
+- app/helpers/checkpoint/rails/application_helper.rb
+- app/jobs/checkpoint/rails/application_job.rb
+- app/mailers/checkpoint/rails/application_mailer.rb
+- app/models/checkpoint/rails/application_record.rb
+- config/routes.rb
+- lib/checkpoint/rails.rb
+- lib/checkpoint/rails/client/authenticate.rb
+- lib/checkpoint/rails/client/base.rb
+- lib/checkpoint/rails/client/trace.rb
+- lib/checkpoint/rails/engine.rb
+- lib/checkpoint/rails/env.rb
+- lib/checkpoint/rails/settings.rb
+- lib/checkpoint/rails/setup.rb
+- lib/checkpoint/rails/traceable.rb
+- lib/checkpoint/rails/traces_helper.rb
+- lib/checkpoint/rails/version.rb
+- lib/tasks/checkpoint/rails_tasks.rake
+homepage: https://github.com/callstacking/callstacking-rails
+licenses:
+- MIT
+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: []