codebeacon-tracer 0.1.0

data/lib/codebeacon/tracer/src/models/thread_local_call_tree_manager.rb

@@ -0,0 +1,35 @@
+require_relative 'call_tree'
+
+module Codebeacon
+  module Tracer
+    class ThreadLocalCallTreeManager
+      attr_reader :trees, :trace_id
+
+      def initialize(trace_id)
+        @trees = []
+        @trace_id = trace_id
+      end
+
+      def current()
+        Thread.current[thread_key] ||= begin
+          CallTree.new(Thread.current).tap do |tree|
+            Codebeacon::Tracer.logger.debug("Creating new call tree for thread: #{Thread.current} with trace_id: #{trace_id}")
+            @trees << tree
+          end
+        end
+      end
+
+      def cleanup()
+        Thread.list.each do |thread|
+          if thread[thread_key]
+            thread[thread_key] = nil
+          end
+        end
+      end
+
+      private def thread_key()
+        "call_tree_#{trace_id}".to_sym
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/src/models/tpklass.rb

@@ -0,0 +1,53 @@
+module Codebeacon
+  module Tracer
+    class TPKlass
+      def initialize(tp)
+        @tp = tp
+      end
+
+      def tp_class
+        klass = @tp.self.class
+        while klass && klass.to_s =~ /Class:0x/
+          klass = klass.superclass
+        end
+        klass
+      end
+
+      def defined_class
+        klass = @tp.defined_class.to_s.sub("#<", "").sub(">", "")
+        if klass.match(/^(Class|Module):/)
+          klass = klass.split(":")[1..].join(":")
+        elsif klass.match(/:0x[0-9a-f]+$/)
+          klass = klass.split(":")[0..-2].join(":")
+          klass += " Singleton"
+        end
+        klass
+      end
+
+      def tp_class_name
+        if @tp.self.is_a?(Module)
+          @tp.self.name
+        else
+          klass = @tp.self.class
+          while klass && klass.to_s =~ /Class:0x/
+            klass = klass.superclass
+          end
+          klass.name
+        end
+      end
+
+      def type
+        case @tp.self
+        when Class
+          :Class
+        when Module
+          :Module
+        when Object
+          :Object
+        else
+          :Unknown
+        end
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/src/models/tree_node.rb

@@ -0,0 +1,113 @@
+require 'set'
+
+  # store node memory in a format that can be directly loaded 1:1 into sqlite3
+  # could use rocksdb or something else
+  # could use lmdb
+  # could use leveldb
+  # actually log if this speeds up developer time - would be really cool to show!
+module Codebeacon
+  module Tracer
+    class TreeNode
+      class TraceStatus < Struct.new(:previous_line)
+        def any_lines_traced?
+          !previous_line.nil?
+        end
+      end
+      # attr_accessor :file, :line, :method, :depth, :caller, :gem_entry, :children, :parent, :block, :locals, :ast, :return_value, :linevars
+
+      # def initialize(file: nil, line: nil, method: nil, depth: 0, caller: "", gem_entry: false, parent: nil, block: false, locals: [], ast: nil, return_value: "")
+      #   @file = file
+      #   @line = line
+      #   @method = method
+      #   @depth = depth
+      #   @caller = caller
+      #   @gem_entry = gem_entry
+      #   @parent = parent
+      #   @block = block
+      #   @locals = locals
+      #   @ast = ast
+      #   @return_value = return_value
+      #   @linevars = {}
+      #   @children = []
+      # end
+
+      attr_accessor :file, :line, :method, :object_id, :tp_class, :tp_defined_class, :tp_class_name, :self_type, :depth, :caller, :gem_entry, :children, :parent, :block, :locals, :return_value, :linevars, :node_source, :trace_status, :script, :backtrace_count, :backtrace_location, :script_binding, :script_self
+
+      def initialize(file: nil, line: nil, object_id: nil, method: nil, tp_class: nil, tp_defined_class: nil, tp_class_name: nil, self_type: nil, depth: 0, caller: "", gem_entry: false, parent: nil, block: false, locals: [], return_value: nil, node_source: nil, script: false)
+        @file = file
+        @line = line
+        @method = method
+        @object_id = object_id
+        @tp_class = tp_class
+        @tp_defined_class = tp_defined_class
+        @tp_class_name = tp_class_name
+        @self_type = self_type
+        @children = []
+        @depth = depth
+        @gem_entry = gem_entry
+        @caller = caller
+        @parent = parent
+        @block = block
+        @locals = locals
+        @return_value = return_value
+        @linevars = Hash.new { |h, k| h[k] = {} }
+        @node_source = node_source
+        @trace_status = TraceStatus.new(nil)
+        @script = script
+        @backtrace_count = 0
+        @backtrace_location = nil
+        @script_binding = nil
+        @script_self = nil
+      end
+
+      def add_line(lineno, variables)
+        @linevars[lineno] = @linevars[lineno].merge(variables)
+      end
+
+      def set_args(lineno, variables)
+        @linevars[lineno] = @linevars[lineno].merge(variables)
+      end
+
+      def inspect
+        ivar_inspect = instance_variables.reject { |ivar| [:@children].include?(ivar) }.map do |ivar|
+          "#{ivar.to_s}=#{instance_variable_get(ivar).inspect}"
+        end
+        ivar_inspect << "@children=#<#{@children.map(&:to_s)}>"
+        "#<#{self.class.name}:0x#{self.object_id.to_s} #{ivar_inspect.join(', ')}>"
+      end
+
+      def inspect_tree(attrs = [], depth = 0)
+        str = file.split("/").last + ":#{script ? "script" : method}"
+        if !attrs.empty?
+          attr_values = attrs.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
+          str += " " + attrs
+        end
+        str += children.map { |c| "\n" + " " * (depth + 1) * 2 + c.inspect_tree(attrs, depth + 1) }.join()
+        return str
+      end
+
+      def to_h
+        children = depth > Codebeacon::Tracer.config.max_depth ? nil : @children.map(&:to_h)
+        is_truncated = depth > Codebeacon::Tracer.config.max_depth ? true : false
+        {
+          file: @file,
+          line: @line,
+          method: @method,
+          class: @tp_class,
+          tp_defined_class: @tp_defined_class,
+          tp_class_name: @tp_class_name,
+          class_name: @class_name,
+          self_type: @self_type,
+          gemEntry: @gem_entry,
+          caller: @caller,
+          isDepthTruncated: is_truncated,
+          children: children
+        }
+      end
+
+      def depth_truncated?
+        @depth > Codebeacon::Tracer.config.max_depth && @children.count > 0
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/src/rails/middleware.rb

@@ -0,0 +1,47 @@
+module Codebeacon
+  module Tracer
+    class Middleware
+      def initialize(app)
+        @app = app
+        @first_run = true
+      end
+
+      def call(env)
+        response = nil
+        # tracer = Tracer.news
+        begin
+          Codebeacon::Tracer.config.set_query_config(env['QUERY_STRING'])
+          if !@first_run #Codebeacon::Tracer.config.trace_enabled? && !@first_run
+            Codebeacon::Tracer.trace do |tracer|
+              dry_run_log = Codebeacon::Tracer.config.dry_run? ? "--DRY RUN-- " : ""
+              Codebeacon::Tracer.logger.info(dry_run_log + "Tracing enabled for URI=#{env['REQUEST_URI']}")
+              response = @app.call(env).tap do |_|
+                Codebeacon::Tracer.logger.info("Tracing disabled for URI=#{env['REQUEST_URI']}")
+              end
+              begin
+                params = env['action_dispatch.request.parameters'].dup
+                tracer.name = "#{params.delete('controller')}##{params.delete('action')}"
+                tracer.description = params.to_json
+              rescue => e
+                Codebeacon::Tracer.logger.error("Error setting tracer metadata: #{e.message}")
+              end
+              response
+            end
+          else
+            if Codebeacon::Tracer.config.trace_enabled? && @first_run
+              Codebeacon::Tracer.logger.info("Bypassing first request for performance.")
+            end
+            @first_run = false if @first_run
+            response = @app.call(env)
+          end
+        rescue => e
+          Codebeacon::Tracer.logger.error("Error in middleware: #{e.message}")
+          Codebeacon::Tracer.logger.error(e.backtrace.join("\n")) if Codebeacon::Tracer.config.debug?
+          # Ensure the request is processed even if tracing fails
+          response = @app.call(env) if response.nil?
+        end
+        response
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/src/rails/railtie.rb

@@ -0,0 +1,10 @@
+$first_run = true
+module Codebeacon
+  module Tracer
+    class Railtie < Rails::Railtie
+      initializer "codebeacon_tracer.middleware" do |app|
+        app.middleware.use Codebeacon::Tracer::Middleware
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/src/tracer.rb

@@ -0,0 +1,113 @@
+require_relative 'models/node_builder'
+require_relative 'models/thread_local_call_tree_manager'
+
+module Codebeacon
+  module Tracer
+    class Tracer
+      attr_reader :id, :tree_manager
+      attr_accessor :name, :description
+
+      def initialize(name = nil, description = nil)
+        @progress_logger = Codebeacon::Tracer.logger.newProgressLogger("calls traced")
+        @traces = [trace_call, trace_b_call, trace_return, trace_b_return]
+        @name = name
+        @description = description
+        @trace_id = SecureRandom.uuid
+        @tree_manager = ThreadLocalCallTreeManager.new(@trace_id)
+      end
+
+      def id()
+        @trace_id
+      end
+
+      def call_tree()
+        @tree_manager.current()
+      end
+
+      def start()
+        @progress_logger = Codebeacon::Tracer.logger.newProgressLogger("calls traced")
+        start_traces
+      end
+
+      def stop()
+        stop_traces
+        @progress_logger.finish()
+      end
+
+      def cleanup()
+        @tree_manager.cleanup
+      end
+
+      def start_traces
+        dry_run_log = Codebeacon::Tracer.config.dry_run? ? "--DRY RUN-- " : ""
+        Codebeacon::Tracer.logger.info("#{dry_run_log}Starting trace: #{id}")
+        @traces.each do |trace|
+          trace.enable
+        end
+      end
+
+      def stop_traces
+        @traces.each do |trace|
+          trace.disable
+        end
+        Codebeacon::Tracer.logger.info("END tracing")
+      end
+
+      def enable_traces
+        start
+        return yield
+      ensure
+        stop
+      end
+
+      def trace_call
+        trace(:call) do |tp|
+          NodeBuilder.trace_method_call(call_tree, tp, Kernel.caller[2..])
+        ensure
+          @progress_logger.increment()
+        end
+      end
+
+      def trace_b_call
+        trace(:b_call) do |tp|
+          NodeBuilder.trace_block_call(call_tree, tp, Kernel.caller[2..])
+        ensure
+          @progress_logger.increment()
+        end
+      end
+
+      def trace_return
+        trace(:return) do |tp|
+          NodeBuilder.trace_return(call_tree, tp)
+        end
+      end
+
+      def trace_b_return
+        trace(:b_return) do |tp|
+          NodeBuilder.trace_return(call_tree, tp)
+        end
+      end
+
+      def trace(type)
+        TracePoint.new(type) do |tp|
+          paths = [tp.path]
+          # capture calls and returns to skipped paths from non skipped paths. All I need is the return value to display in recorded files, but the code doesn't yet support this without tracing the entire call and return.
+          if [:call, :b_call, :return, :b_return].include?(type)
+            paths << Kernel.caller(1..1)[0]
+          end
+          next if skip_methods?(paths)
+          yield tp
+        rescue => e
+          Codebeacon::Tracer.logger.error("TracePoint(#{type}) #{tp.path} #{e.message}")
+        end
+      end
+
+      def skip_methods?(paths)
+        paths.all? do |path|
+          path.nil? || Codebeacon::Tracer.config.exclude_paths.any?{ |exclude_path| path.start_with?(exclude_path) } ||
+            Codebeacon::Tracer.config.local_methods_only? && !path.start_with?(Codebeacon::Tracer.config.root_path)
+        end
+      end
+    end
+  end
+end

data/lib/codebeacon/tracer/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Codebeacon
+  module Tracer
+    VERSION = "0.1.0"
+  end
+end 

data/lib/codebeacon-tracer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+require_relative "codebeacon/tracer/version"
+require 'securerandom'
+
+# Load all the source files
+Dir[File.join(File.dirname(__FILE__), 'codebeacon', 'tracer', 'src', '*.rb')].each { |file| require file }
+Dir[File.join(File.dirname(__FILE__), 'codebeacon', 'tracer', 'src', 'models', '*.rb')].each { |file| require file }
+Dir[File.join(File.dirname(__FILE__), 'codebeacon', 'tracer', 'src', 'data', '*.rb')].each { |file| require file }
+Dir[File.join(File.dirname(__FILE__), 'codebeacon', 'tracer', 'src', 'rails', '*.rb')].each { |file| require file } if defined?(Rails::Railtie)
+
+module Codebeacon
+  # The Tracer module provides tools to trace and analyze the runtime performance
+  # of your Ruby applications. It captures method calls, execution times, and generates
+  # reports to help identify bottlenecks.
+  #
+  # @example Tracing a block of code
+  #   Codebeacon::Tracer.trace("My Trace", "Description of what I'm tracing") do |tracer|
+  #     # Your code to analyze goes here
+  #     some_method_to_analyze
+  #   end
+  #
+  module Tracer
+    class << self
+      # @return [ThreadLocalCallTreeManager] The current tree manager
+      attr_reader :tree_manager
+
+      # Returns the configuration object for Codebeacon::Tracer
+      # @return [Configuration] The configuration object
+      def config 
+        @config ||= Configuration.new
+      end
+
+      # Returns the current call tree
+      # @return [CallTree] The current call tree
+      def current_tree
+        @tracer&.tree_manager&.current()
+      end
+
+      # Returns the logger instance
+      # @return [Logger] The logger instance
+      def logger
+        config.logger
+      end
+
+      # Traces a block of code and collects runtime information
+      #
+      # @param name [String, nil] Optional name for the trace
+      # @param description [String, nil] Optional description for the trace
+      # @yield [tracer] Yields the tracer object to the block
+      # @yieldparam tracer [Tracer] The tracer object
+      # @return [Object] The result of the block
+      def trace(name = nil, description = nil)
+        begin
+          setup
+          @tracer = Tracer.new(name, description)
+          result = @tracer.enable_traces do
+            yield @tracer
+          end
+          persist(@tracer.name, @tracer.description)
+          cleanup
+          result
+        rescue => e
+          Codebeacon::Tracer.logger.error("Error during tracing: #{e.message}")
+          Codebeacon::Tracer.logger.error(e.backtrace.join("\n")) if Codebeacon::Tracer.config.debug?
+          # Continue execution without crashing the application
+          yield nil if block_given?
+        end
+      end
+
+      # Starts tracing without a block
+      # @return [void]
+      def start
+        setup
+        @tracer = Tracer.new()
+        @tracer.start
+      end
+
+      # Stops tracing and persists the results
+      # @return [void]
+      def stop
+        @tracer.stop
+        persist
+        cleanup
+      end
+
+      private def setup
+        Codebeacon::Tracer.config.setup
+        @app_node = NodeSource.new('app', Codebeacon::Tracer.config.root_path)
+        @gem_node = NodeSource.new('gem', Codebeacon::Tracer.config.gem_path)
+        @rubylib_node = NodeSource.new('rubylib', Codebeacon::Tracer.config.rubylib_path)
+      end
+
+      private def persist(name = "", description = "")
+        unless Codebeacon::Tracer.config.dry_run?
+          begin
+            schema = DatabaseSchema.new
+            schema.create_tables
+            DatabaseSchema.trim_db_files
+            pm = PersistenceManager.new(schema.db)
+            ordered_sources = [ @app_node, @gem_node, @rubylib_node ]
+            pm.save_metadata(name, description)
+            pm.save_node_sources(ordered_sources)
+            pm.save_trees(@tracer.tree_manager.trees)
+            schema.create_indexes
+            schema.db.close
+            touch_refresh
+          rescue => e
+            Codebeacon::Tracer.logger.error("Error during persistence: #{e.message}")
+            Codebeacon::Tracer.logger.error(e.backtrace.join("\n")) if Codebeacon::Tracer.config.debug?
+            # Continue execution without crashing the application
+          end
+        end
+      end
+
+      private def cleanup
+        NodeSource.clear
+        @tracer.cleanup
+      end
+
+      private def touch_refresh
+        FileUtils.mkdir_p(Codebeacon::Tracer.config.tmp_dir) unless File.exist?(Codebeacon::Tracer.config.tmp_dir)
+        if File.exist?(Codebeacon::Tracer.config.refresh_path)
+          File.utime(Time.now, Time.now, Codebeacon::Tracer.config.refresh_path)
+        else
+          File.open(Codebeacon::Tracer.config.refresh_path, 'w') {}
+        end
+      end
+    end
+  end
+end