codebeacon-tracer 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc0306f363cf17c02cf4e0de4c37df04d52b22f7b992b047767a47e243341a9a
-  data.tar.gz: ba785f9723112678105d34030f1ea3f9960630d6701a3f14041e5d82d554c6c6
+  metadata.gz: 47ec3d248b6f0358c3c36310a7b39c506982695565e453d11580ae20b1f28582
+  data.tar.gz: 8f6da9ed15ca33105c73fead83856a014c718853cbf30db5641719e5d6fdfc36
 SHA512:
-  metadata.gz: c59c1bd83110e7e4214988ca69fa6f08d9533c096b98e4e555c28d2700ef35d05e3c1fd154804d156bc9b022656dbf3b3a6c17e2592df1cc0f67abe73f3aef15
-  data.tar.gz: 7d2ae9552ea537767cb5ef93409565243674a75b65f3b9810ca5f3c894845743aa775def5dd519c4ac99687b057ab157e7b4e2e5b57ea234afb7aaaa84f9c96c
+  metadata.gz: 69b782857204580baf4b8251f478d0e16652d015fcbf5f79c65a47f691f9623a52ee9271c973d5539ed4d680d4c37c21f9571299225ce16ecab446e9bbd43ffd
+  data.tar.gz: 27dd8bdcb652b7db338e0ac8aba0862b6cb3106c00a76524265cec238714849d046c416c43c62448aa3ca4ca84be19a3c0651b53b347cdd79b9561fd3b7dca99

data/bin/codebeacon

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+require_relative '../lib/codebeacon-tracer'
+
+script = ARGV.shift
+if script.nil?
+  Codebeacon::Tracer.logger.error("No script provided")
+  exit 1
+end
+
+at_exit do
+  Codebeacon::Tracer.stop
+end
+Codebeacon::Tracer.start(
+  name: File.basename(script),
+  trigger_type: "script"
+)
+
+load File.expand_path(script)

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

@@ -1,6 +1,12 @@
 require 'fileutils'
 require 'yaml'
 
+begin
+  require 'listen'
+rescue LoadError
+  # Listen gem not available, file watching will be disabled
+end
+
 module Codebeacon
   module Tracer
     class Configuration
@@ -8,6 +14,7 @@ module Codebeacon
       RETURN_VAL_MAX_LENGTH = 1000
       MAX_CALL_COUNT = 100000000
       MAX_DEPTH = 99999
+      SERIALIZATION_TIMEOUT_MS = 10
 
       def initialize()
         @query = ""
@@ -19,6 +26,7 @@ module Codebeacon
         exclude_paths << lib_root
         reload_paths_to_record
         load_main_config
+        start_config_file_watcher
       end
 
       def load_main_config
@@ -62,7 +70,7 @@ module Codebeacon
       end
 
       def data_dir
-        ".code-beacon"
+        File.join(root_path, ".code-beacon")
       end
 
       def db_path
@@ -85,6 +93,10 @@ module Codebeacon
         File.expand_path(File.join(lib_root, 'config.yml')) 
       end
 
+      def tracer_config_path
+        File.join(data_dir, "tracer_config.yml")
+      end
+
       def read_paths
         if File.exist?(paths_path)
           YAML.load_file(paths_path)
@@ -104,7 +116,7 @@ module Codebeacon
       end
 
       def root_path
-        @root_path ||= defined?(Rails) ? Rails.root.to_s : Dir.pwd
+        @root_path ||= @config_root_path || (defined?(Rails) ? Rails.root.to_s : Dir.pwd)
       end
 
       def rubylib_path
@@ -125,12 +137,52 @@ module Codebeacon
       end
 
       def trace_enabled?
-        # @trace_enabled
-        true
+        if @donotcache
+          load_tracer_config_enabled
+        else
+          @trace_enabled ||= load_tracer_config_enabled
+        end
+      end
+
+      def reload_tracer_config
+        @trace_enabled = load_tracer_config_enabled
+        @config_root_path = load_tracer_config_root_path
+        @recording_meta_exclude_patterns = nil  # Force reload of exclusion patterns
+      end
+
+      def reload_main_config
+        @root_path = nil  # Force reload of root_path
+        load_main_config
       end
 
-      def trace_enabled=(value)
-        @trace_enabled = value
+      def recording_meta_exclude_patterns
+        if @donotcache
+          load_recording_meta_exclude_patterns
+        else
+          @recording_meta_exclude_patterns ||= load_recording_meta_exclude_patterns
+        end
+      end
+
+      def skip_tracing?(name, description)
+        return false unless recording_meta_exclude_patterns&.any?
+        
+        name_str = name.to_s
+        description_str = description.to_s
+        
+        excluded = recording_meta_exclude_patterns.any? do |pattern|
+          name_matches = File.fnmatch(pattern['name'], name_str, File::FNM_CASEFOLD)
+          description_matches = File.fnmatch(pattern['description'], description_str, File::FNM_CASEFOLD)
+          name_matches && description_matches
+        end
+        
+        if excluded && debug?
+          logger.debug("Skipping trace due to metadata exclusion - name: '#{name_str}', description: '#{description_str}'")
+        end
+        
+        excluded
+      rescue => e
+        logger.warn("Error checking skip_tracing patterns: #{e.message}")
+        false  # Default to not skipping on error
       end
 
       def debug?
@@ -184,6 +236,10 @@ module Codebeacon
         MAX_DEPTH
       end
 
+      def serialization_timeout_ms
+        SERIALIZATION_TIMEOUT_MS
+      end
+
       def logger
         @logger ||= Codebeacon::Tracer::Logger.new()
       end
@@ -194,6 +250,77 @@ module Codebeacon
         # Codebeacon::Tracer.logger.info("Call count: #{@return_count}")
         # Codebeacon::Tracer.logger.info("Return @depth: #{@depth}, method: #{tp.method_id}, line: #{tp.lineno}, path: #{tp.path}")
       end
+
+      def start_config_file_watcher
+        return unless defined?(Listen) && !@config_listener
+        return unless File.directory?(data_dir)
+        
+        begin
+          @config_listener = Listen.to(data_dir, only: /tracer_config\.yml$/) do |modified, added, removed|
+            if (modified + added + removed).any? { |path| File.basename(path) == 'tracer_config.yml' }
+              reload_tracer_config
+            end
+          end
+          @config_listener.start
+        rescue => e
+          @donotcache = true
+          logger.warn("Failed to start config file watcher: #{e.message}")
+        end
+      end
+
+      def stop_config_file_watcher
+        if @config_listener
+          @config_listener.stop
+          @config_listener = nil
+        end
+      end
+
+      private
+
+      def load_recording_meta_exclude_patterns
+        if File.exist?(tracer_config_path)
+          config_data = YAML.load_file(tracer_config_path)
+          patterns = config_data.dig('filters', 'recording_meta_exclude') || []
+          
+          # Validate patterns
+          valid_patterns = patterns.select do |pattern|
+            if pattern.is_a?(Hash) && pattern.key?('name') && pattern.key?('description')
+              true
+            else
+              logger.warn("Invalid recording_meta_exclude pattern: #{pattern.inspect}")
+              false
+            end
+          end
+          
+          valid_patterns
+        else
+          []
+        end
+      rescue => e
+        logger.warn("Error loading recording meta exclude patterns: #{e.message}")
+        []
+      end
+
+      def load_tracer_config_enabled
+        if File.exist?(tracer_config_path)
+          config_data = YAML.load_file(tracer_config_path)
+          config_data['tracing_enabled'] != false  # Default to true if not specified
+        else
+          true
+        end
+      rescue => e
+        logger.warn("Error loading tracer config: #{e.message}")
+        true
+      end
+
+      def load_tracer_config_root_path
+        if File.exist?(tracer_config_path)
+          config_data = YAML.load_file(tracer_config_path)
+          @config_root_path = config_data['root_path'] if config_data['root_path']
+        end
+      rescue => e
+        logger.warn("Error loading tracer config root_path: #{e.message}")
+      end
     end
   end
 end

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

@@ -10,7 +10,17 @@ module Codebeacon
           CREATE TABLE IF NOT EXISTS metadata (
             id INTEGER PRIMARY KEY,
             name TEXT,
-            description TEXT
+            description TEXT,
+            caller_file TEXT,
+            caller_method TEXT,
+            caller_line INTEGER,
+            caller_class TEXT,
+            caller_defined_class TEXT,
+            start_time TEXT,
+            end_time TEXT,
+            duration_ms REAL,
+            trigger_type TEXT,
+            language TEXT
           );
         SQL
       end
@@ -18,8 +28,31 @@ module Codebeacon
       def self.create_indexes(database)
       end
 
-      def insert(name, description)
-        @db.execute("INSERT INTO metadata (name, description) VALUES (?, ?)", [name, description])
+      def insert(metadata)
+        metadata_hash = metadata.to_hash
+        
+        @db.execute(<<-SQL, 
+          INSERT INTO metadata (
+            name, description, caller_file, caller_method, caller_line,
+            caller_class, caller_defined_class, start_time, end_time,
+            duration_ms, trigger_type, language
+          ) VALUES (
+            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+          )
+        SQL
+          metadata_hash[:name],
+          metadata_hash[:description],
+          metadata_hash[:caller_file],
+          metadata_hash[:caller_method],
+          metadata_hash[:caller_line],
+          metadata_hash[:caller_class],
+          metadata_hash[:caller_defined_class],
+          metadata_hash[:start_time]&.iso8601,
+          metadata_hash[:end_time]&.iso8601,
+          metadata_hash[:duration_ms],
+          metadata_hash[:trigger_type],
+          metadata_hash[:language]
+        )
       end
     end
   end

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

@@ -1,27 +1,13 @@
 require_relative 'tree_node_mapper'
 require_relative 'node_source_mapper'
 require_relative 'metadata_mapper'
+require_relative 'type_detector'
+require_relative 'safe_serializer'
 
 module Codebeacon
   module Tracer
     class PersistenceManager
 
-      def self.marshal(name, value, tree_node)
-        begin
-          return value.inspect[0..Codebeacon::Tracer.config.max_value_length]
-        rescue => e
-          begin
-            if Codebeacon::Tracer.config.debug?
-              Codebeacon::Tracer.logger.warn "Marshal inspect failure - attempting to_s fallback for: \"#{name}\", located at: \"#{tree_node.file}:#{tree_node.line}\"\nerror message: \"#{e.message}\", error_location: \"#{e.backtrace[0]}\""
-            end
-            return value.to_s[0..Codebeacon::Tracer.config.max_value_length]
-          rescue => e
-            Codebeacon::Tracer.logger.error "Marshal failure for: \"#{name}\", located at: \"#{tree_node.file}:#{tree_node.line}\"\nerror message: \"#{e.message}\", error_location: \"#{e.backtrace[0]}\""
-            return "--Codebeacon::Tracer ERROR-- could not marshall value. See logs."
-          end
-        end
-      end
-
       def initialize(database)
         @database = database
         @tree_node_mapper = TreeNodeMapper.new(database)
@@ -30,8 +16,8 @@ module Codebeacon
         @progress_logger = Codebeacon::Tracer.logger.newProgressLogger("nodes persisted")
       end
 
-      def save_metadata(name, description)
-        @metadata_mapper.insert(name, description)
+      def save_metadata(metadata)
+        @metadata_mapper.insert(metadata)
       end
 
       def save_node_sources(node_sources)
@@ -69,6 +55,7 @@ module Codebeacon
           node_id = @tree_node_mapper.insert(
             tree_node.file,
             tree_node.line,
+            tree_node.called_method&.to_s, # Convert symbols to strings, keep nil as nil
             tree_node.method.to_s,
             tree_node.tp_class.to_s,
             tree_node.tp_defined_class.to_s,
@@ -80,7 +67,8 @@ module Codebeacon
             parent_id,
             tree_node.block,
             tree_node.node_source&.id,
-            _return_value(tree_node)
+            return_type(tree_node),
+            return_value(tree_node)
           )
 
           unless tree_node.depth_truncated?
@@ -95,12 +83,14 @@ module Codebeacon
         end
       end
 
-      def _return_value(node)
-        if node.method == :initialize
-          return nil
-        else
-          PersistenceManager.marshal(node.method, node.return_value, node)
-        end
+      private def return_type(node)
+        return nil if node.method == :initialize
+        node.return_value.class.name
+      end
+
+      private def return_value(node)
+        return nil if node.method == :initialize
+        SafeSerializer.serialize(node.return_value, Codebeacon::Tracer.config.max_value_length)
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'type_detector'
+require 'timeout'
+
+module Codebeacon
+  module Tracer
+    class SafeSerializer
+      def self.serialize(value, max_length)
+        return nil unless TypeDetector.serializable_type?(value)
+        return "..." if max_length <= 0
+        
+        timeout_ms = Codebeacon::Tracer.config.serialization_timeout_ms
+        
+        begin
+          Timeout.timeout(timeout_ms / 1000.0) do
+            serialized = case value
+            when String
+              value
+            when Integer, Float
+              value.to_s
+            when Symbol, TrueClass, FalseClass
+              value.to_s
+            when NilClass
+              "nil"
+            else
+              nil
+            end
+
+            return nil if serialized.nil?
+
+            serialized.length <= max_length ? serialized : serialized[0...max_length] + "..."
+          end
+        rescue Timeout::Error
+          return "(serialization timeout)"
+        end
+      end
+    end
+  end
+end 

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

@@ -0,0 +1,78 @@
+module Codebeacon
+  module Tracer
+    class TraceMetadata
+      attr_reader :name, :description, :caller_file, :caller_method, :caller_line, 
+                  :caller_class, :caller_defined_class, :start_time, 
+                  :end_time, :duration_ms, :trigger_type, :language
+
+      def initialize(name: nil, description: nil, caller_location: nil, trigger_type: nil)
+        @name = name
+        @description = description
+        @start_time = Time.now
+        @end_time = nil
+        @duration_ms = nil
+        @trigger_type = trigger_type
+        @language = "ruby"
+        
+        if caller_location
+          capture_caller_info_from_location(caller_location)
+        end
+      end
+
+      def finish_trace
+        @end_time = Time.now
+        @duration_ms = ((@end_time - @start_time) * 1000).round(2)
+      end
+
+      def to_hash
+        {
+          name: @name,
+          description: @description,
+          caller_file: @caller_file,
+          caller_method: @caller_method,
+          caller_line: @caller_line,
+          caller_class: @caller_class,
+          caller_defined_class: @caller_defined_class,
+          start_time: @start_time,
+          end_time: @end_time,
+          duration_ms: @duration_ms,
+          trigger_type: @trigger_type,
+          language: @language
+        }
+      end
+
+      private
+
+      def capture_caller_info_from_location(location)
+        begin
+          @caller_file = location.absolute_path || location.path
+          @caller_line = location.lineno
+          @caller_method = location.label
+          
+          # Try to determine the calling class/module from the location
+          @caller_class, @caller_defined_class = determine_caller_class_from_location(location)
+        rescue => e
+          Codebeacon::Tracer.logger.warn("Failed to capture caller info from location: #{e.message}") if Codebeacon::Tracer.config.debug?
+        end
+      end
+
+      def determine_caller_class_from_location(location)
+        caller_class = ""
+        caller_defined_class = ""
+
+        # Extract class information from the location label if possible
+        if location.label && location.label.include?('#')
+          # Instance method call - extract class name
+          class_method = location.label.split('#')
+          caller_class = class_method[0] if class_method.length > 1
+        elsif location.label && location.label.include?('.')
+          # Class method call - extract class name
+          class_method = location.label.split('.')
+          caller_class = class_method[0] if class_method.length > 1
+        end
+
+        [caller_class, caller_defined_class]
+      end
+    end
+  end
+end 

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

@@ -8,20 +8,20 @@ module Codebeacon
         @db = database
       end
 
-      def insert(file, line, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, gem_entry, parent_id, block, node_source_id, return_value)
+      def insert(file, line, called_method, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, gem_entry, parent_id, block, node_source_id, return_type, return_value)
         @db.execute(<<-SQL, 
           INSERT INTO treenodes 
           (
-              file, line, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, 
-              gemEntry, parent_id, block, node_source_id, return_value
+              file, line, called_method, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, 
+              gemEntry, parent_id, block, node_source_id, return_type, return_value
           )
           VALUES 
           (
-              ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+              ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
           )
         SQL
-        file, line, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, 
-        gem_entry ? 1 : 0, parent_id, block ? 1 : 0, node_source_id, return_value)
+        file, line, called_method, method, tp_class, tp_defined_class, tp_class_name, self_type, depth, caller, 
+        gem_entry ? 1 : 0, parent_id, block ? 1 : 0, node_source_id, return_type, return_value)
         
         @db.last_insert_row_id
       end
@@ -32,6 +32,7 @@ module Codebeacon
             id INTEGER PRIMARY KEY,
             file TEXT,
             line INTEGER,
+            called_method TEXT,
             method TEXT,
             tp_class TEXT,
             tp_defined_class TEXT,
@@ -43,6 +44,7 @@ module Codebeacon
             parent_id INTEGER,
             block INTEGER,
             node_source_id INTEGER,
+            return_type TEXT,
             return_value TEXT,
             FOREIGN KEY (parent_id) REFERENCES treenodes(id),
             FOREIGN KEY (node_source_id) REFERENCES node_sources(id)
@@ -54,6 +56,7 @@ module Codebeacon
         database.execute("CREATE INDEX IF NOT EXISTS IDX_treenode_parent_id ON treenodes(parent_id)")
         database.execute("CREATE INDEX IF NOT EXISTS IDX_treenode_node_source_id ON treenodes(node_source_id)")
         database.execute("CREATE INDEX IF NOT EXISTS IDX_treenode_file ON treenodes(file)")
+        database.execute("CREATE INDEX IF NOT EXISTS IDX_treenode_called_method ON treenodes(called_method)")
       end
     end
   end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Codebeacon
+  module Tracer
+    class TypeDetector
+      BASIC_TYPES = [
+        String, Integer, Float, Symbol, TrueClass, FalseClass, NilClass
+      ].freeze
+
+      def self.basic_type?(value)
+        return true if value.nil?
+        BASIC_TYPES.any? { |type| value.is_a?(type) }
+      end
+
+      def self.serializable_type?(value)
+        basic_type?(value)
+      end
+    end
+  end
+end 

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

@@ -37,6 +37,10 @@ module Codebeacon
           current_context.line = tp.lineno
           current_context.object_id = tp.self.object_id
           current_context.method = tp.method_id
+          if tp.callee_id != tp.method_id
+            current_context.called_method = tp.callee_id
+          end
+
           klass = TPKlass.new(tp)
 
           current_context.tp_class = klass.tp_class.to_s

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

@@ -31,9 +31,9 @@ module Codebeacon
       #   @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
+      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, :called_method
 
-      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)
+      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, called_method: nil)
         @file = file
         @line = line
         @method = method
@@ -58,6 +58,7 @@ module Codebeacon
         @backtrace_location = nil
         @script_binding = nil
         @script_self = nil
+        @called_method = called_method
       end
 
       def add_line(lineno, variables)

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

@@ -12,7 +12,8 @@ module Codebeacon
         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|
+            # For middleware, the caller is this method itself
+            Codebeacon::Tracer.trace(trigger_type: "middleware") 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 |_|
@@ -22,6 +23,9 @@ module Codebeacon
                 params = env['action_dispatch.request.parameters'].dup
                 tracer.name = "#{params.delete('controller')}##{params.delete('action')}"
                 tracer.description = params.to_json
+                # Update the metadata with the Rails-specific information
+                tracer.metadata.instance_variable_set(:@name, tracer.name)
+                tracer.metadata.instance_variable_set(:@description, tracer.description)
               rescue => e
                 Codebeacon::Tracer.logger.error("Error setting tracer metadata: #{e.message}")
               end

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

@@ -4,16 +4,26 @@ require_relative 'models/thread_local_call_tree_manager'
 module Codebeacon
   module Tracer
     class Tracer
-      attr_reader :id, :tree_manager
-      attr_accessor :name, :description
+      attr_reader :id, :tree_manager, :metadata, :name, :description
 
-      def initialize(name = nil, description = nil)
+      def initialize(name: nil, description: nil, caller_location: nil, trigger_type: 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)
+        @metadata = TraceMetadata.new(name:, description:, caller_location:, trigger_type:)
+      end
+
+      def name=(new_name)
+        @name = new_name
+        @metadata.instance_variable_set(:@name, new_name)
+      end
+
+      def description=(new_description)
+        @description = new_description
+        @metadata.instance_variable_set(:@description, new_description)
       end
 
       def id()
@@ -32,6 +42,7 @@ module Codebeacon
       def stop()
         stop_traces
         @progress_logger.finish()
+        @metadata.finish_trace
       end
 
       def cleanup()
@@ -62,7 +73,7 @@ module Codebeacon
 
       def trace_call
         trace(:call) do |tp|
-          NodeBuilder.trace_method_call(call_tree, tp, Kernel.caller[2..])
+          NodeBuilder.trace_method_call(call_tree, tp, "")
         ensure
           @progress_logger.increment()
         end
@@ -70,7 +81,7 @@ module Codebeacon
 
       def trace_b_call
         trace(:b_call) do |tp|
-          NodeBuilder.trace_block_call(call_tree, tp, Kernel.caller[2..])
+          NodeBuilder.trace_block_call(call_tree, tp, "")
         ensure
           @progress_logger.increment()
         end
@@ -90,23 +101,16 @@ module Codebeacon
 
       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)
+          next if skip_methods?(tp.path)
           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
+      def skip_methods?(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

data/lib/codebeacon/tracer/version.rb

@@ -2,6 +2,6 @@
 
 module Codebeacon
   module Tracer
-    VERSION = "0.1.0"
+    VERSION = "0.4.0"
   end
 end 

data/lib/codebeacon-tracer.rb

@@ -48,17 +48,30 @@ module Codebeacon
       #
       # @param name [String, nil] Optional name for the trace
       # @param description [String, nil] Optional description for the trace
+      # @param trigger_type [String] The type of trigger that initiated the trace (default: "manual")
       # @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)
+      def trace(name: nil, description: nil, trigger_type: "manual")
+        # Capture caller information immediately at entry point
+        caller_location = caller_locations(1, 1).first
+
+        unless config.trace_enabled?
+          logger.info("Tracing is disabled. Skipping trace: #{name} - #{description}")
+          return yield(nil)
+        end
+        if config.skip_tracing?(name, description)
+          logger.info("Exclusion rules matched. Skipping trace: #{name} - #{description}")
+          return yield(nil)
+        end
+
         begin
           setup
-          @tracer = Tracer.new(name, description)
+          @tracer = Tracer.new(name:, description:, caller_location:, trigger_type:)
           result = @tracer.enable_traces do
             yield @tracer
           end
-          persist(@tracer.name, @tracer.description)
+          persist(@tracer.metadata)
           cleanup
           result
         rescue => e
@@ -70,18 +83,28 @@ module Codebeacon
       end
 
       # Starts tracing without a block
+      # @param name [String, nil] Optional name for the trace
+      # @param description [String, nil] Optional description for the trace
+      # @param trigger_type [String] The type of trigger that initiated the trace (default: "manual")
       # @return [void]
-      def start
+      def start(name: nil, description: nil, trigger_type: "manual")
+        # Capture caller information immediately at entry point
+        caller_location = caller_locations(1, 1).first
+        
+        return unless config.trace_enabled?
+        
         setup
-        @tracer = Tracer.new()
+        @tracer = Tracer.new(name:, description:, caller_location:, trigger_type:)
         @tracer.start
       end
 
       # Stops tracing and persists the results
       # @return [void]
       def stop
+        return unless @tracer # checks whether trace_enabled? was false when start was called or if it was called
+
         @tracer.stop
-        persist
+        persist(@tracer.metadata)
         cleanup
       end
 
@@ -92,25 +115,35 @@ module Codebeacon
         @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
+      private def persist(metadata)
+        name = metadata.name || ""
+        description = metadata.description || ""
+        
+        if config.skip_tracing?(name, description)
+          config.logger.debug("Skipping persistence due to metadata exclusion - name: '#{name}', description: '#{description}'") if config.debug?
+          return
+        end
+        
+        if Codebeacon::Tracer.config.dry_run?
+          config.logger.debug("Dry run - skipping persistence") if config.debug?
+          return
+        end
+
+        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(metadata)
+          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?
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codebeacon-tracer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jonathan Conley
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2025-03-25 00:00:00.000000000 Z
+date: 2025-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -38,6 +38,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -140,17 +160,22 @@ description: Codebeacon::Tracer provides tools to trace and capture call graphs
   execution paths.
 email:
 - conley.jj@gmail.com
-executables: []
+executables:
+- codebeacon
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/codebeacon
 - lib/codebeacon-tracer.rb
 - lib/codebeacon/tracer/src/configuration.rb
 - lib/codebeacon/tracer/src/data/database.rb
 - lib/codebeacon/tracer/src/data/metadata_mapper.rb
 - lib/codebeacon/tracer/src/data/node_source_mapper.rb
 - lib/codebeacon/tracer/src/data/persistence_manager.rb
+- lib/codebeacon/tracer/src/data/safe_serializer.rb
+- lib/codebeacon/tracer/src/data/trace_metadata.rb
 - lib/codebeacon/tracer/src/data/tree_node_mapper.rb
+- lib/codebeacon/tracer/src/data/type_detector.rb
 - lib/codebeacon/tracer/src/logger.rb
 - lib/codebeacon/tracer/src/models/call_tree.rb
 - lib/codebeacon/tracer/src/models/node_builder.rb