ruby-production-breakpoints 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 393332e205830e98423e4e80256b91d0a5619b2459dade719e22e9a90a507b34
-  data.tar.gz: 255897924c095642d81a0efbfb4cb98acf384f99bc37d3ccc6b699729682410a
+  metadata.gz: c667c558395ef7da2130c3085956a438366a9ae49c9531b97ab08f994a90e157
+  data.tar.gz: 946c38475edf95386ac832e82815e5a5cb0efeb1a7f1d9a05300939dbc6fab94
 SHA512:
-  metadata.gz: 65d5ef0836703f22a47344931525028b506d74f396d1185c7213e4db6d426cf3c33ba0c873474abd486bbb5e287976f4c7ec3a0006c22975ac93fe613e43be32
-  data.tar.gz: f37633bf6107dfac1eccfe872069012af57ab1c85ce05a4211aa22dfff5ec5d47333dae2d5327f6ab1f85291d06fb2284a4ae56a20aa7c47df08ccfdadea340b
+  metadata.gz: 0146b4b990c9a9ac018eb4b3dc365891cfb9b55b0b8b9fc902ebfb4bb9ab50eeb548e3536d9a02d5ffd5568eb5c47dfb2d735f5c6339ee0153ae1f3412cf54c8
+  data.tar.gz: 4ed8781d90ea4351d1ff980726aac868198e46bbadcb820c88de0b6057464d8a255f9ba9a010919049e6ab8c746e0274dfb5a85828d93f3c9f1d0100a9681c05

data/lib/ruby-production-breakpoints/breakpoints/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'unmixer'
+using Unmixer
+
+module ProductionBreakpoints
+  module Breakpoints
+    class Base
+      TRACEPOINT_TYPES = [].freeze
+
+      attr_reader :provider_name, :name, :tracepoint
+
+      def initialize(source_file, start_line, end_line, trace_id: 1)
+        @injector_module = nil
+        @source_file = source_file
+        @start_line = start_line
+        @end_line = end_line
+        @trace_id = trace_id
+        @method = self.class.name.split('::').last.downcase
+        @parser = ProductionBreakpoints::Parser.new(@source_file)
+        @node = @parser.find_definition_node(@start_line, @end_line)
+        @method_override = ProductionBreakpoints::MethodOverride.new(@parser, start_line, end_line)
+        @ns = Object.const_get(@parser.find_definition_namespace(@node)) # FIXME: error handling, if not found
+        @provider_name = File.basename(@source_file).gsub('.', '_')
+        @name = "#{@method}_#{@trace_id}"
+        @tracepoint = StaticTracing::Tracepoint.new(@provider_name, @name, *self.class.const_get('TRACEPOINT_TYPES'))
+      end
+
+      def install
+        @injector_module = build_redefined_definition_module(@node)
+        @ns.prepend(@injector_module)
+      end
+
+      # FIXME: saftey if already uninstalled
+      def uninstall
+        @ns.instance_eval { unprepend(@injector_module) }
+        @injector_module = nil
+      end
+
+      def load
+        @tracepoint.provider.enable
+      end
+
+      def unload
+        @tracepoint.provider.disable
+      end
+
+      # Allows for specific handling of the selected lines
+      def handle(caller_binding)
+        eval(@method_override.handler_src.join, caller_binding)
+      end
+
+      def resume(caller_binding)
+        eval(@method_override.resume_src.join, caller_binding) if @method_override.resume_src
+      end
+
+      private
+
+      # A custom module we'll prepend in order to override
+      # us to keep the expected binding for the wrapped code, and remainder of the method
+      def build_redefined_definition_module(node)
+        # This is the metaprogramming to inject our breakpoint handle
+        handler = "ProductionBreakpoints.installed_breakpoints[:#{@trace_id}].handle(Kernel.binding)"
+
+        # This injects our handler at the end of the original source code
+        injected = @parser.inject_metaprogramming_handlers(handler, node.first_lineno, node.last_lineno)
+        # ProductionBreakpoints.config.logger.debug(injected)
+        Module.new { module_eval { eval(injected); eval('def production_breakpoint_enabled?; true; end;') } }
+      end
+    end
+  end
+end

data/lib/ruby-production-breakpoints/breakpoints/inspect.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  module Breakpoints
+    # Inspect result of the last evaluated expression
+    class Inspect < Base
+      TRACEPOINT_TYPES = [String].freeze
+
+      def handle(caller_binding, &block)
+        return super(caller_binding, &block) unless @tracepoint.enabled?
+
+        val = super(caller_binding, &block)
+        @tracepoint.fire(val.inspect)
+
+        resume(caller_binding, &block) || val
+      end
+    end
+  end
+end

data/lib/ruby-production-breakpoints/breakpoints/latency.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  module Breakpoints
+    # Exposes nanosecond the latency of executing the selected lines
+    class Latency < Base # FIXME: refactor a bunch of these idioms into Base
+      TRACEPOINT_TYPES = [Integer].freeze
+
+      def handle(caller_binding, &block)
+        return super(caller_binding, &block) unless @tracepoint.enabled?
+
+        start_time = StaticTracing.nsec
+        val = super(caller_binding, &block)
+        duration = StaticTracing.nsec - start_time
+        @tracepoint.fire(duration)
+        resume(caller_binding, &block) || val
+      end
+    end
+  end
+end

data/lib/ruby-production-breakpoints/breakpoints/locals.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  module Breakpoints
+    # Show local variables and their values
+    class Locals < Base # FIXME: refactor a bunch of these idioms into Base
+      TRACEPOINT_TYPES = [String].freeze
+
+      def handle(caller_binding, &block)
+        return super(caller_binding, &block) unless @tracepoint.enabled?
+
+        val = super(caller_binding, &block)
+        locals = caller_binding.local_variables
+        locals.delete(:local_bind)
+        vals = locals.map { |v| [v, caller_binding.local_variable_get(v)] }.to_h
+        @tracepoint.fire(vals.to_json)
+        resume(caller_binding, &block) || val
+      end
+    end
+  end
+end

data/lib/ruby-production-breakpoints/breakpoints/ustack.rb

@@ -0,0 +1,74 @@
+# # frozen_string_literal: true
+
+# module ProductionBreakpoints
+#   module Breakpoints
+#     # Show local variables and their values
+#     class Ustack < Base
+#       TRACEPOINT_TYPES = [String, String, String,
+#                           String, String, String].freeze
+#       MAX_STACK_STR_SIZE = MAX_USDT_STR_SIZE * TRACEPOINT_TYPES.size
+
+#       def initialize(*args, &block)
+#         super(*args, &block)
+#         get_ruby_stack_str = <<-EOS
+#         caller.map { |l| l.split(":in ") }.to_h
+#         EOS
+#         @handler_iseq = RubyVM::InstructionSequence.compile(get_ruby_stack_str)
+#       end
+
+#       def handle(vm_tracepoint)
+#         return unless @tracepoint.enabled?
+
+#         stack_map = @handler_iseq.eval(vm_tracepoint.binding)
+
+#         shortened_map = {}
+#         stack_map.each do |k,v|
+#           newkey = k
+#           #if k.include?('gems')
+#           #  newkey = k[k.rindex('gems')..-1].split(File::SEPARATOR)[1..-1]
+#           #                                .join(File::SEPARATOR)
+#           #elsif k.include?('lib')
+#           #  newkey = k[k.rindex('lib')..-1].split(File::SEPARATOR)[1..-1]
+#           #                                .join(File::SEPARATOR)
+#           #end
+#           # FIXME lots of context is lost this way, as the above methods
+#           # consistently exceed the max size.
+#           # Need to find a more optimal way to shorten the stack here, to
+#           # pack it into the 1200 bytes available
+#           newkey = File.basename(k)
+#           shortened_map[newkey] = v
+#         end
+#         # ProductionBreakpoints.logger.debug(shortened_map.inspect)
+
+#         stack_str = shortened_map.to_json
+
+#         if stack_str.size > (MAX_STACK_STR_SIZE)
+#           ProductionBreakpoints.logger.error("Stack exceeds #{MAX_STACK_STR_SIZE}")
+#           # Truncate because i'm lazy
+#           stack_str = stack_str[0..MAX_STACK_STR_SIZE]
+#         end
+
+#         slices = stack_str.chars.each_slice(MAX_USDT_STR_SIZE).map(&:join)
+
+#         case slices.size
+
+#         when 1
+#           @tracepoint.fire(slices[0], "", "", "", "", "")
+#         when 2
+#           @tracepoint.fire(slices[0], slices[1], "", "", "", "")
+#         when 3
+#           @tracepoint.fire(slices[0], slices[1], slices[2], "", "", "")
+#         when 4
+#           @tracepoint.fire(slices[0], slices[1], slices[2], slices[3], "", "")
+#         when 5
+#           @tracepoint.fire(slices[0], slices[1], slices[2], slices[3],
+#                            slices[4], "")
+#         when 6
+#           @tracepoint.fire(slices[0], slices[1], slices[2], slices[3],
+#                            slices[4], slices[5])
+
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/ruby-production-breakpoints/breakpoints.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'ruby-production-breakpoints/breakpoints/base'
+require 'ruby-production-breakpoints/breakpoints/latency'
+require 'ruby-production-breakpoints/breakpoints/inspect'
+require 'ruby-production-breakpoints/breakpoints/locals'
+require 'ruby-production-breakpoints/breakpoints/ustack'

data/lib/ruby-production-breakpoints/configuration.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ProductionBreakpoints
+  class Configuration
+    # Modes of operation for tracers
+    module Modes
+      ON = 'ON'
+      OFF = 'OFF'
+      SIGNAL = 'SIGNAL'
+
+      module SIGNALS
+        SIGURG = 'URG'
+      end
+    end
+
+    attr_reader :mode, :signal, :configured_breakpoints, :logger
+    attr_accessor :path
+
+    # A new configuration instance
+    def initialize
+      @mode = Modes::SIGNAL
+      @signal = Modes::SIGNALS::SIGURG
+      @logger = Logger.new(STDERR)
+    end
+
+    def finish!
+      if File.exist?(path)
+        @configured_breakpoints = JSON.load(File.read(path))
+        enable_trap
+      else
+        logger.error("Config file #{path} not found")
+      end
+    end
+
+    private
+
+    # Disables trap handler
+    def disable_trap
+      Signal.trap(@signal, 'DEFAULT')
+    end
+
+    # Enables a new trap handler
+    def enable_trap
+      # ProductionBreakpoints.config.logger.debug("trap handler enabled for #{@signal}")
+      Signal.trap(@signal) { ProductionBreakpoints.sync! }
+    end
+  end
+end

data/lib/ruby-production-breakpoints/errors.rb

@@ -0,0 +1,5 @@
+
+# frozen_string_literal: true
+
+class NotConfiguredError < StandardError
+end

data/lib/ruby-production-breakpoints/method_override.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  # Extract valueable parts of the method
+  class MethodOverride
+    def initialize(parser, start_line, end_line)
+      @parser = parser
+      @source_lines = parser.source_lines
+      @node = parser.find_definition_node(start_line, end_line)
+      @start_line = start_line
+      @end_line = end_line
+    end
+
+     def unmodified_src
+      return if @start_line - @node.first_lineno <= 1 # if smaller or equal to one that means we are at the beginning of the method
+
+       @source_lines[(@node.first_lineno)..(@start_line - 2)]
+    end
+
+     def handler_src
+      @source_lines[@start_line - 1..@end_line - 1]
+    end
+
+     def resume_src
+      return if @node.last_lineno - @end_line <= 1 # if smaller or equal to one that means we are at the end of the method
+
+       @source_lines[@end_line..(@node.last_lineno - 2)]
+    end
+  end
+end

data/lib/ruby-production-breakpoints/parser.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  # FIXME: this class is a mess, figure out interface and properly separate private / public
+  class Parser
+    attr_reader :root_node, :source_lines
+
+    def initialize(source_file)
+      @root_node = RubyVM::AbstractSyntaxTree.parse_file(source_file)
+      @source_lines = File.read(source_file).lines
+      @logger = ProductionBreakpoints.config.logger
+    end
+
+    # FIXME: set a max depth here to pretent unbounded recursion? probably should
+    def find_node(node, type, first, last, depth: 0)
+      child_nodes = node.children.select { |c| c.is_a?(RubyVM::AbstractSyntaxTree::Node) }
+      # @logger.debug("D: #{depth} #{node.type} has #{child_nodes.size} children and spans #{node.first_lineno}:#{node.first_column} to #{node.last_lineno}:#{node.last_column}")
+
+      if node.type == type && first >= node.first_lineno && last <= node.last_lineno
+        return node
+      end
+
+      child_nodes.map { |n| find_node(n, type, first, last, depth: depth + 1) }.flatten
+    end
+
+    def find_lineage(target)
+      lineage = _find_lineage(@root_node, target)
+      lineage.pop # FIXME: verify leafy node is equal to target or throw an error?
+      lineage
+    end
+
+    def find_definition_namespace(target)
+      lineage = find_lineage(target)
+
+      namespaces = []
+      lineage.each do |n|
+        next unless n.type == :MODULE || n.type == :CLASS
+
+        symbols = n.children.select { |c| c.is_a?(RubyVM::AbstractSyntaxTree::Node) && c.type == :COLON2 }
+        if symbols.size != 1
+          @logger.error("Couldn't determine symbol location for parent namespace")
+        end
+        symbol = symbols.first
+
+        symstr = @source_lines[symbol.first_lineno - 1][symbol.first_column..symbol.last_column].strip
+        namespaces << symstr
+      end
+
+      namespaces.join('::')
+    end
+
+    def find_definition_symbol(start_line, end_line)
+      def_node = _find_definition_node(@root_node, start_line, end_line)
+      def_column_start = def_node.first_column
+      def_column_end = _find_args_start(def_node).first_column
+      @source_lines[def_node.first_lineno - 1][(def_column_start + 3 + 1)..def_column_end].strip.to_sym
+    end
+
+    def find_definition_node(start_line, end_line)
+      _find_definition_node(@root_node, start_line, end_line)
+    end
+
+    # This method is a litle weird and pretty deep into metaprogramming, so i'll try to explain it
+    #
+    # Given the source method some_method, and a range of lines to apply the breakpoint to, we will inject
+    # calls two breakpoint methods. We will pass these calls the string representation of the original source code.
+    # If the string of original source is part of the "handle" block, it will run withing the binding
+    # of the method up to that point, and allow for us to run our custom handler method to apply our debugging automation.
+    #
+    # Any remaining code in the method also needs to be eval'd, as we want it to be recognized in the original binding,
+    # and the same binding as we've used for evaluating our handler. This allows us to keep local variables persisted
+    # "between blocks", as we want our breakpoint code to have no impact to the original bindings and source code.
+    #
+    # A generated breakpoint is shown below, the resulting string. is what will be evaluated on the method
+    # that we will prepend to the original parent in order to initiate our override.
+    #
+    # def some_method
+    #  a = 1
+    #  sleep 0.5
+    #  b = a + 1
+    #  ProductionBreakpoints.installed_breakpoints[:test_breakpoint_install].handle(Kernel.binding)
+    # end
+    #
+    def inject_metaprogramming_handlers(handler, def_start, def_end)
+      source = @source_lines.dup
+
+      source.insert(def_end - 1, "#{handler}\n") # FIXME: columns? and indenting?
+      source[(def_start - 1)..(def_end)].join
+    end
+
+    def ruby_source(start_line, end_line)
+      @source_lines[(start_line - 1)..(end_line - 1)].join
+    end
+
+    private
+
+    def _find_lineage(node, target, depth: 0)
+      child_nodes = node.children.select { |c| c.is_a?(RubyVM::AbstractSyntaxTree::Node) }
+      # @logger.debug("D: #{depth} #{node.type} has #{child_nodes.size} children and spans #{node.first_lineno}:#{node.first_column} to #{node.last_lineno}:#{node.last_column}")
+
+      if node.type == target.type &&
+
+         target.first_lineno >= node.first_lineno &&
+         target.last_lineno <= node.last_lineno
+        return [node]
+      end
+
+      parents = []
+      child_nodes.each do |n|
+        res = _find_lineage(n, target, depth: depth + 1)
+        unless res.empty?
+          res.unshift(n)
+          parents = res
+        end
+      end
+
+      parents.flatten
+    end
+
+    # FIXME: better error handling
+    def _find_definition_node(node, start_line, end_line)
+      defs = find_node(node, :DEFN, start_line, end_line)
+
+      if defs.size > 1
+        @logger.error('WHaaat? Multiple definitions found?! Bugs will probably follow')
+      end
+      defs.first
+    end
+
+    # FIXME: better error handling
+    def _find_args_start(def_node)
+      args = find_node(def_node, :ARGS, def_node.first_lineno, def_node.first_lineno)
+
+      if args.size > 1
+        @logger.error("I didn't think this was possible, I must have been wrong")
+      end
+      args.first
+    end
+  end
+end

data/lib/ruby-production-breakpoints/platform.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  # Platform detection for ruby-static-tracing
+  module Platform
+    module_function
+
+     # Returns true if platform is linux
+    def linux?
+      /linux/.match(RUBY_PLATFORM)
+    end
+
+     # Returns true if platform is darwin
+    def darwin?
+      /darwin/.match(RUBY_PLATFORM)
+    end
+
+     # Returns true if platform is known to be supported
+    def supported_platform?
+      linux? || darwin?
+    end
+  end
+end

data/lib/ruby-production-breakpoints/start_end_line_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  # Validate that start line and end line point to code into the file
+  # At the momemt it will be valid if both start and end line points to valid ruby code
+  module StartEndLineValidator
+    module_function
+
+     def call(source_file, start_line, end_line)
+      source_lines = File.read(source_file).lines
+
+      !source_lines[start_line - 1].strip.empty? && !source_lines[end_line - 1].strip.empty?
+    end
+  end
+end

data/lib/ruby-production-breakpoints/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ProductionBreakpoints
+  # The current version of this gem
+  VERSION = '0.0.6'
+end

data/lib/ruby-production-breakpoints.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'ruby-static-tracing'
+
+require 'ruby-production-breakpoints/version'
+require 'ruby-production-breakpoints/platform'
+require 'ruby-production-breakpoints/errors'
+require 'ruby-production-breakpoints/breakpoints'
+require 'ruby-production-breakpoints/configuration'
+require 'ruby-production-breakpoints/parser'
+require 'ruby-production-breakpoints/method_override'
+require 'ruby-production-breakpoints/start_end_line_validator'
+
+module ProductionBreakpoints
+  extend self
+
+  attr_accessor :installed_breakpoints
+
+  self.installed_breakpoints = {} # FIXME: namespace by provider, to allow multiple BP per file
+
+  def configure
+    @configuration = Configuration.new
+    yield @configuration
+    @configuration.finish!
+  end
+
+  def config
+    unless defined?(@configuration)
+      raise NotConfiguredError
+    end
+
+    @configuration
+  end
+
+  # For now add new types here
+  def install_breakpoint(type, source_file, start_line, end_line, trace_id: 1)
+    # Hack to check if there is a supported breakpoint of this type for now
+    case type.name
+    when 'ProductionBreakpoints::Breakpoints::Latency'
+    when 'ProductionBreakpoints::Breakpoints::Inspect'
+    when 'ProductionBreakpoints::Breakpoints::Locals'
+      # logger.debug("Creating latency tracer")
+      # now rewrite source to call this created breakpoint through parser
+    else
+      config.logger.error("Unsupported breakpoint type #{type}")
+    end
+
+    breakpoint = type.new(source_file, start_line, end_line, trace_id: trace_id)
+    installed_breakpoints[trace_id.to_sym] = breakpoint
+    breakpoint.install
+    breakpoint.load
+  end
+
+  def disable_breakpoint(trace_id)
+    breakpoint = installed_breakpoints.delete(trace_id)
+    breakpoint.unload
+    breakpoint.uninstall
+  end
+
+  def disable!
+    installed_breakpoints.each do |trace_id, _bp|
+      disable_breakpoint(trace_id)
+    end
+  end
+
+  def sync!
+    # FIXME: don't just install, also remove - want to 'resync'
+    # logger.debug("Resync initiated")
+    desired = config.configured_breakpoints['breakpoints']
+
+    desired_trace_ids = desired.map { |bp| bp['trace_id'] }
+    installed_trace_ids = installed_breakpoints.keys
+
+    to_install_tids = desired_trace_ids - installed_trace_ids
+    to_remove_tids = installed_trace_ids - desired_trace_ids
+    to_install = desired.select { |bp| to_install_tids.include?(bp['trace_id']) }
+    # logger.debug("Will install #{to_install.size} breakpoints")
+    # logger.debug("Will remove #{to_remove_tids.size} breakpoints")
+    to_install.each do |bp|
+      handler = breakpoint_constant_for_type(bp)
+      unless valid_start_line_end_line?(bp['source_file'], bp['start_line'], bp['end_line'])
+        msg = <<~MSG
+          Skipping #{handler} for #{bp['source_file']}. start line and end line do not point to any code on the file.
+        MSG
+        config.logger.warn(msg)
+        next
+      end
+      install_breakpoint(handler, bp['source_file'], bp['start_line'], bp['end_line'], trace_id: bp['trace_id'])
+    end
+
+    to_remove_tids.each do |trace_id|
+      disable_breakpoint(trace_id)
+    end
+  end
+
+  private
+
+  def valid_start_line_end_line?(source_file, start_line, end_line)
+    StartEndLineValidator.call(source_file, start_line, end_line)
+  end
+
+  def breakpoint_constant_for_type(bp)
+    symstr = "ProductionBreakpoints::Breakpoints::#{bp['type'].capitalize}"
+    Object.const_get(symstr)
+  rescue NameError
+    config.logger.error("Could not find breakpoint handler for #{symstr}")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-production-breakpoints
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Dale Hamel
@@ -143,7 +143,21 @@ email: dale.hamel@srvthe.net
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/ruby-production-breakpoints.rb
+- lib/ruby-production-breakpoints/breakpoints.rb
+- lib/ruby-production-breakpoints/breakpoints/base.rb
+- lib/ruby-production-breakpoints/breakpoints/inspect.rb
+- lib/ruby-production-breakpoints/breakpoints/latency.rb
+- lib/ruby-production-breakpoints/breakpoints/locals.rb
+- lib/ruby-production-breakpoints/breakpoints/ustack.rb
+- lib/ruby-production-breakpoints/configuration.rb
+- lib/ruby-production-breakpoints/errors.rb
+- lib/ruby-production-breakpoints/method_override.rb
+- lib/ruby-production-breakpoints/parser.rb
+- lib/ruby-production-breakpoints/platform.rb
+- lib/ruby-production-breakpoints/start_end_line_validator.rb
+- lib/ruby-production-breakpoints/version.rb
 homepage: https://github.com/dalehamel/ruby-production-breakpoints
 licenses:
 - MIT