callstacking-rails 0.1.1 → 0.1.2

data/lib/callstacking/rails/engine.rb

@@ -1,49 +0,0 @@
-require "rails"
-require "callstacking/rails/trace"
-require "callstacking/rails/instrument"
-require 'callstacking/rails/spans'
-require "callstacking/rails/setup"
-require "callstacking/rails/settings"
-require "callstacking/rails/loader"
-require "callstacking/rails/client/base"
-require "callstacking/rails/client/authenticate"
-require "callstacking/rails/client/trace"
-require "callstacking/rails/traces_helper"
-
-module Callstacking
-  module Rails
-    class Engine < ::Rails::Engine
-      include Settings
-      isolate_namespace Callstacking::Rails
-
-      read_settings
-
-      spans = Spans.new
-      trace = Trace.new(spans)
-
-      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 Callstacking::Rails::TracesHelper
-          include Callstacking::Rails::TracesHelper
-        end
-
-        Callstacking::Rails::Loader.new.on_load(spans) if enabled?
-      end
-
-      initializer :append_before_action do
-        ActionController::Base.send :after_action, :inject_hud
-      end
-
-      if enabled?
-        puts "Callstacking enabled (#{Callstacking::Rails::Env.environment})"
-        trace.tracing
-      else
-        puts "Callstacking disabled (#{Callstacking::Rails::Env.environment})"
-      end
-    end
-  end
-end

data/lib/callstacking/rails/instrument.rb

@@ -1,100 +0,0 @@
-require 'rails'
-
-# https://stackoverflow.com/q/52932516
-module Callstacking
-  module Rails
-    class Instrument
-      attr_accessor :spans, :klass
-      attr_reader :root
-
-      def initialize(spans, klass)
-        @spans = spans
-        @klass = klass
-        @root  = Regexp.new(::Rails.root.to_s)
-      end
-
-      def instrument_method(method_name, application_level: true)
-        method_path = (klass.instance_method(method_name).source_location.first rescue nil) ||
-          (klass.method(method_name).source_location.first rescue nil)
-
-        # Application level method definitions
-        return unless method_path =~ root if application_level
-
-        tmp_module = find_or_initialize_module
-
-        return if tmp_module.instance_methods.include?(method_name) ||
-                    tmp_module.singleton_methods.include?(method_name)
-
-        tmp_module.define_method(method_name) do |*args, &block|
-          method_name = __method__
-
-          path = method(__method__).super_method.source_location.first
-          line_no = method(__method__).super_method.source_location.last
-
-          p, l = caller.find { |c| c.to_s =~ /#{::Rails.root.to_s}/}&.split(':')
-
-          spans = tmp_module.instance_variable_get(:@spans)
-          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)
-          return_val = super(*args, &block)
-          spans.call_return(klass, method_name, p || path, l || line_no, return_val)
-
-          return_val
-        end
-      end
-
-      def find_or_initialize_module
-        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
-        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) }
-      end
-
-      def self.arguments_for(m, args)
-        param_names = m.parameters&.map(&:last)
-        return {} if param_names.nil?
-
-        param_names.map.with_index do |param, index|
-          next if [:&, :*, :**].include?(param)
-          [param, args[index]]
-        end.compact.to_h
-      end
-
-      private
-
-      def all_methods
-        @all_methods ||= (klass.instance_methods +
-          klass.private_instance_methods(false) +
-          klass.protected_instance_methods(false) +
-          klass.methods +
-          klass.singleton_methods).uniq
-      end
-
-      def filtered
-        @filtered ||= (Object.instance_methods + Object.private_instance_methods +
-          Object.protected_instance_methods + Object.methods(false)).uniq
-      end
-
-    end
-  end
-end

data/lib/callstacking/rails/loader.rb

@@ -1,29 +0,0 @@
-require "rails"
-
-module Callstacking
-  module Rails
-    class Loader
-      attr_accessor :loader, :root, :once
-      def initialize
-        @root = Regexp.new(::Rails.root.to_s)
-      end
-
-      def on_load(spans)
-        trace = TracePoint.new(:end) do |tp|
-          klass = tp.self
-          path  = tp.path
-
-          Instrument.new(spans, klass).instrument_klass if path =~ root
-        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)
-      end
-    end
-  end
-end

data/lib/callstacking/rails/setup.rb

@@ -1,115 +0,0 @@
-require 'yaml'
-require "callstacking/rails/settings"
-require "callstacking/rails/client/authenticate"
-require "callstacking/rails/env"
-
-module Callstacking
-  module Rails
-    class Setup
-      include ::Callstacking::Rails::Settings
-      extend ::Callstacking::Rails::Settings
-
-      attr_accessor :client
-
-      def initialize
-        read_settings
-      end
-
-      def client
-        @client = Callstacking::Rails::Client::Authenticate.new
-      end
-
-      def start
-        email      = prompt("Enter email:")
-        password   = prompt("Enter password:")
-
-        url = if Callstacking::Rails::Env.production? && ENV['CHECKPOINT_RAILS_LOCAL_TEST'].nil?
-                PRODUCTION_URL
-              else
-                prompt("Enter URL for #{Callstacking::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 enable_disable(enabled: true)
-        settings[:enabled] = enabled
-
-        props = { Callstacking::Rails::Env.environment => {
-          settings: settings
-        } }
-
-        write_settings(complete_settings.merge(props))
-      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,
-                  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: "
-        puts
-        puts "  > callstacking-rails enable"
-        puts
-        puts "    Enables the callstacking tracing."
-        puts
-        puts "  > callstacking-rails disable"
-        puts
-        puts "    Disables the callstacking tracing."
-        puts
-        puts "  > callstacking-rails register"
-        puts
-        puts "    Opens a browser window to register as a callstacking.com user."
-        puts
-        puts "  > callstacking-rails setup"
-        puts
-        puts "    Interactively prompts you for your callstacking.com username/password."
-        puts "    Stores auth details in #{SETTINGS_FILE}"
-        puts
-        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 " By setting the RAILS_ENV environment you can maintain multiple settings."
-        puts
-        puts "Questions? Create an issue: https://github.com/callstacking/callstacking-rails/issues"
-      end
-    end
-  end
-end

data/lib/callstacking/rails/spans.rb

@@ -1,53 +0,0 @@
-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, arguments, 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, arguments, 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
-
-      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

@@ -1,126 +0,0 @@
-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, arguments, path, line_no|
-          create_call_entry(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(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, arguments, 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,
-                                       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/version.rb

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

data/lib/callstacking/rails.rb

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