codebeacon-tracer 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc0306f363cf17c02cf4e0de4c37df04d52b22f7b992b047767a47e243341a9a
-  data.tar.gz: ba785f9723112678105d34030f1ea3f9960630d6701a3f14041e5d82d554c6c6
+  metadata.gz: 834e2095be6b5d5a919b96bbb1395dc33bfc569cfb189d67b7e95434574c8641
+  data.tar.gz: 1215e606cf263cc3cf77954e4f60e175bd8df43ad9adbe1ad17859bc03003c4b
 SHA512:
-  metadata.gz: c59c1bd83110e7e4214988ca69fa6f08d9533c096b98e4e555c28d2700ef35d05e3c1fd154804d156bc9b022656dbf3b3a6c17e2592df1cc0f67abe73f3aef15
-  data.tar.gz: 7d2ae9552ea537767cb5ef93409565243674a75b65f3b9810ca5f3c894845743aa775def5dd519c4ac99687b057ab157e7b4e2e5b57ea234afb7aaaa84f9c96c
+  metadata.gz: 7f7871f11660157413fecdb33a856d9f06465690570226b201e9c5ff2a31dd3a6dbea826b2c4a0d4729a15ebadfab4d07357e9ff8978f76314ed43ef63844471
+  data.tar.gz: c2d72f58559f32136268687dfaea900344a4141d6beb4f252821f9cb838e7e2b296cd304c0a9e51387589611068dff1e34f9a88139c56c5a85ebe2022389cb2a

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
@@ -19,6 +25,7 @@ module Codebeacon
         exclude_paths << lib_root
         reload_paths_to_record
         load_main_config
+        start_config_file_watcher
       end
 
       def load_main_config
@@ -85,6 +92,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)
@@ -125,12 +136,46 @@ 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
+        @recording_meta_exclude_patterns = nil  # Force reload of exclusion patterns
       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?
@@ -194,6 +239,68 @@ 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
     end
   end
 end

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

@@ -10,7 +10,16 @@ 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
           );
         SQL
       end
@@ -18,8 +27,30 @@ 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
+          ) 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]
+        )
       end
     end
   end

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

@@ -30,8 +30,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)

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

@@ -0,0 +1,76 @@
+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
+
+      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
+        
+        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
+        }
+      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/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()
@@ -95,6 +106,7 @@ module Codebeacon
           if [:call, :b_call, :return, :b_return].include?(type)
             paths << Kernel.caller(1..1)[0]
           end
+          paths.uniq!
           next if skip_methods?(paths)
           yield tp
         rescue => e

data/lib/codebeacon/tracer/version.rb

@@ -2,6 +2,6 @@
 
 module Codebeacon
   module Tracer
-    VERSION = "0.1.0"
+    VERSION = "0.3.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.3.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-16 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,16 +160,19 @@ 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/trace_metadata.rb
 - lib/codebeacon/tracer/src/data/tree_node_mapper.rb
 - lib/codebeacon/tracer/src/logger.rb
 - lib/codebeacon/tracer/src/models/call_tree.rb