trace_viz 0.0.1 → 1.0.0

data/lib/trace_viz/collectors/filters/base_class_filter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class BaseClassFilter < BaseFilter
+        def initialize(classes:)
+          super()
+          @classes_and_modules = classes.map(&:to_s).freeze
+        end
+
+        protected
+
+        attr_reader :classes_and_modules
+
+        def normalize_class_name(klass)
+          # Normalize class/module names to handle dynamic/nested representations
+          klass.to_s.gsub(/^#<Class:/, "").gsub(/>$/, "").strip
+        end
+
+        def matches_hierarchy?(klass_name, target_name)
+          klass_name == target_name || klass_name.start_with?("#{target_name}::")
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/base_exclude_filter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_class_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class BaseExcludeFilter < BaseClassFilter
+        def apply?(trace_data)
+          klass_name = normalize_class_name(trace_data.klass)
+          !classes_and_modules.any? { |excluded| matches_hierarchy?(klass_name, excluded) }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/base_filter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class BaseFilter
+        include Helpers::ConfigHelper
+
+        def apply?(trace_data)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/base_include_filter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_class_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class BaseIncludeFilter < BaseClassFilter
+        def apply?(trace_data)
+          klass_name = normalize_class_name(trace_data.klass)
+          classes_and_modules.any? { |allowed| matches_hierarchy?(klass_name, allowed) }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/exclude_classes_filter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base_exclude_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeClassesFilter < BaseExcludeFilter
+        def initialize(classes:)
+          super(classes: classes)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/exclude_default_classes_filter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base_exclude_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeDefaultClassesFilter < BaseExcludeFilter
+        DEFAULT_CLASSES_AND_MODULES = [
+          "Object",
+          "String",
+          "Array",
+          "Hash",
+          "Numeric",
+          "Integer",
+          "Float",
+          "Symbol",
+          "Kernel",
+          "Module",
+          "Class",
+          "Range",
+          "Regexp",
+          "BigDecimal",
+          "Set",
+          "Gem",
+        ].freeze
+
+        def initialize
+          super(classes: DEFAULT_CLASSES_AND_MODULES)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/exclude_gems_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeGemsFilter < BaseFilter
+        def initialize(**options)
+          super()
+          @excluded_gems = options[:gems].map do |gem_name|
+            ::Gem.loaded_specs[gem_name]&.full_gem_path
+          end.compact.freeze
+        end
+
+        def apply?(trace_data)
+          !excluded_gem?(trace_data.path)
+        end
+
+        private
+
+        attr_reader :excluded_gems
+
+        def excluded_gem?(path)
+          excluded_gems.any? { |gem_path| path.start_with?(gem_path) }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/exclude_internal_call_filter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeInternalCallFilter < BaseFilter
+        INTERNAL_PATH_IDENTIFIER = "<internal:"
+        INTERNAL_CLASS_PREFIX = "TracePoint"
+
+        def apply?(trace_data)
+          [
+            internal_path?(trace_data.path),
+            internal_class?(trace_data.klass),
+          ].none?
+        end
+
+        private
+
+        def internal_path?(path)
+          path.include?(INTERNAL_PATH_IDENTIFIER)
+        end
+
+        def internal_class?(klass)
+          klass.to_s.start_with?(INTERNAL_CLASS_PREFIX)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/exclude_rails_framework_filter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeRailsFrameworkFilter < BaseFilter
+        RAILS_MODULES = [
+          "ActiveSupport",
+          "ActiveModel",
+          "ActiveRecord",
+          "ActionPack",
+          "ActionController",
+          "ActionView",
+          "ActionMailer",
+          "ActiveJob",
+          "ActionCable",
+          "ActionDispatch",
+          "ActiveStorage",
+          "ActionMailbox",
+          "ActionText",
+          "Rails",
+        ].freeze
+
+        def apply?(trace_data)
+          !rails_related?(trace_data.klass)
+        end
+
+        private
+
+        def rails_related?(klass)
+          RAILS_MODULES.any? { |mod| klass.to_s.start_with?(mod) }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/include_classes_filter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base_include_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class IncludeClassesFilter < BaseIncludeFilter
+        def initialize(classes:)
+          super(classes: classes)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/include_gems_filter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class IncludeGemsFilter < BaseFilter
+        DEFAULT_OPTIONS = {
+          app_running: true,
+          gems: [],
+        }.freeze
+
+        def initialize(**options)
+          super()
+          @include_app = options.fetch(:app_running, DEFAULT_OPTIONS[:app_running])
+          @app_path = options[:app_path] || detect_app_path
+          @app_path.freeze
+          @included_gems = options.fetch(:gems, DEFAULT_OPTIONS[:gems]).map do |gem_name|
+            ::Gem.loaded_specs[gem_name]&.full_gem_path
+          end.compact.freeze
+        end
+
+        def apply?(trace_data)
+          app_path_included?(trace_data.path) || included_gem?(trace_data.path)
+        end
+
+        private
+
+        attr_reader :include_app, :app_path, :included_gems
+
+        def included_gem?(path)
+          included_gems.any? { |gem_path| path.start_with?(gem_path) }
+        end
+
+        def app_path_included?(path)
+          include_app && path.start_with?(app_path)
+        end
+
+        def detect_app_path
+          if defined?(Bundler)
+            Bundler.root.to_s
+          else
+            # Use the directory of the currently running script
+            File.expand_path("..", $PROGRAM_NAME)
+          end
+        rescue StandardError
+          # Fallback to current working directory
+          Dir.pwd
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/filters/registry.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "include_classes_filter"
+require_relative "include_gems_filter"
+require_relative "exclude_internal_call_filter"
+require_relative "exclude_gems_filter"
+require_relative "exclude_rails_framework_filter"
+require_relative "exclude_default_classes_filter"
+require_relative "exclude_classes_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class Registry
+        FILTERS = {
+          include_classes: IncludeClassesFilter,
+          include_gems: IncludeGemsFilter,
+          exclude_internal_call: ExcludeInternalCallFilter,
+          exclude_gems: ExcludeGemsFilter,
+          exclude_rails_framework: ExcludeRailsFrameworkFilter,
+          exclude_default_classes: ExcludeDefaultClassesFilter,
+          exclude_classes: ExcludeClassesFilter,
+        }.freeze
+
+        class << self
+          def build(filters)
+            filters.each_with_object([]) do |filter, result|
+              case filter
+              when Symbol
+                # Handle simple filters
+                # (e.g., :depth, :exclude_internal_call)
+                klass = fetch_filter_class(filter)
+                result << klass.new
+              when Hash
+                # Handle complex filters with options
+                # (e.g., { include_classes: { classes: [Example] } })
+                filter.each do |filter_key, options|
+                  klass = fetch_filter_class(filter_key)
+                  result << klass.new(**options)
+                end
+              else
+                raise ArgumentError, "Invalid filter format: #{filter.inspect}"
+              end
+            end
+          end
+
+          private
+
+          def fetch_filter_class(filter_key)
+            FILTERS.fetch(filter_key) do
+              available_keys = FILTERS.keys.join(", ")
+              raise ArgumentError, "Unknown filter: #{filter_key}. Available filters are: #{available_keys}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/hierarchy_linker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "trace_viz/trace_data/root_node"
+
+module TraceViz
+  module TraceData
+    class HierarchyLinker
+      attr_reader :root
+
+      def initialize
+        @root = RootNode.new
+      end
+
+      def link(trace_data)
+        return unless valid?(trace_data)
+
+        root.add_child(trace_data)
+      end
+
+      private
+
+      def valid?(trace_data)
+        [
+          trace_data.event == :call,
+          trace_data.parent.nil?,
+        ].all?
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/matchers/base_matcher.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    module Matchers
+      class BaseMatcher
+        def matches?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/matchers/trace_point_action_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/id_generator"
+require "trace_viz/helpers/tracking_helper"
+require_relative "base_matcher"
+
+module TraceViz
+  module Collectors
+    module Matchers
+      class TracePointActionMatcher < BaseMatcher
+        include Helpers::TrackingHelper
+
+        def matches?(trace_point)
+          current_action_id == build_action_id(trace_point)
+        end
+
+        private
+
+        def current_action
+          tracker.active_calls.current
+        end
+
+        def current_action_id
+          current_action&.action_id
+        end
+
+        def build_action_id(trace_point)
+          Utils::IDGenerator.generate_action_id(
+            memory_id: trace_point.self.object_id,
+            action: trace_point.callee_id,
+          )
+        end
+
+        private :tracker, :active_call_stack, :current_call, :current_depth
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/matchers/within_depth_matcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers/config_helper"
+require_relative "base_matcher"
+
+module TraceViz
+  module Collectors
+    module Matchers
+      class WithinDepthMatcher
+        include Helpers::ConfigHelper
+
+        def matches?(depth)
+          depth <= max_depth
+        end
+
+        private
+
+        def max_depth
+          config.general[:max_display_depth]
+        end
+
+        private :config
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/assign_depth_for_call_step.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class AssignDepthForCallStep < BaseStep
+        def call(trace_data)
+          assign_depth(trace_data) if valid?(trace_data)
+          trace_data
+        rescue StandardError => e
+          logger.error("Depth assignment failed for trace_data ID: #{trace_data.id} - #{e.message}")
+          nil
+        end
+
+        private
+
+        def valid?(trace_data)
+          trace_data.event == :call
+        end
+
+        def assign_depth(trace_data)
+          trace_data.assign_depth(current_depth)
+          active_call_stack.push(trace_data)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/assign_depth_for_return_step.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class AssignDepthForReturnStep < BaseStep
+        def call(trace_data)
+          assign_depth(trace_data) if valid?(trace_data)
+          trace_data
+        rescue StandardError => e
+          logger.error("Depth assignment failed for trace_data ID: #{trace_data.id} - #{e.message}")
+          nil
+        end
+
+        private
+
+        def valid?(trace_data)
+          trace_data.event == :return
+        end
+
+        def call_matches?(trace_data)
+          trace_data.action_id == current_call&.action_id
+        end
+
+        def assign_depth(trace_data)
+          if call_matches?(trace_data)
+            active_call_stack.pop
+          else
+            logger.warn("Unmatched return event for trace_data ID #{trace_data.id}")
+          end
+
+          trace_data.assign_depth(current_depth)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/base_step.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers/tracking_helper"
+require "trace_viz/helpers/config_helper"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class BaseStep
+        include Helpers::TrackingHelper
+        include Helpers::ConfigHelper
+
+        def initialize
+          @logger = TraceViz.logger
+        end
+
+        def call
+          raise NotImplementedError
+        end
+
+        private
+
+        attr_reader :logger
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/build_hierarchy_step.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class BuildHierarchyStep < BaseStep
+        def call(trace_data)
+          link_to_parent(trace_data) if valid?(trace_data)
+
+          trace_data
+        rescue StandardError => e
+          logger.error("Hierarchy building failed for trace_data ID: #{trace_data.id} - #{e.message}")
+          nil
+        end
+
+        private
+
+        def valid?(trace_data)
+          trace_data.event == :call
+        end
+
+        def link_to_parent(trace_data)
+          return unless current_call
+
+          current_call.add_child(trace_data)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/hidden_step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class HiddenStep < BaseStep
+        def call(trace_data)
+          trace_data unless pass?(trace_data)
+        end
+
+        private
+
+        def pass?(trace_data)
+          !allowed_events.include?(trace_data.event)
+        end
+
+        def allowed_events
+          config.execution[:show_trace_events]
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/steps/linking_step.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class LinkingStep < BaseStep
+        def call(trace_data)
+          valid?(trace_data) ? linking_trace(trace_data) : trace_data
+        rescue StandardError => e
+          logger.error("Linking failed for trace_data ID: #{trace_data.id} - #{e.message}")
+          nil
+        end
+
+        private
+
+        def valid?(trace_data)
+          return false unless current_call
+
+          [
+            trace_data.event == :return,
+            current_call.event == :call,
+            trace_data.action_id == current_call.action_id,
+          ].all?
+        end
+
+        def linking_trace(trace_data)
+          trace_data.link(current_call)
+          trace_data
+        end
+      end
+    end
+  end
+end