trace_viz 0.0.1 → 0.0.2

data/lib/trace_viz/collectors/base_collector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+require "trace_viz/loggers/trace_logger"
+require_relative "evaluators/filter_evaluator"
+require_relative "evaluators/hidden_evaluator"
+
+module TraceViz
+  module Collectors
+    class BaseCollector
+      attr_reader :collection, :stats
+
+      # To implement collect trace data from the given event,
+      # you need to enter the `config` context to perform the evaluation.
+      def initialize
+        @tracker = Context.for(:tracking)
+        @stats = TraceStats.new
+
+        @collection = []
+
+        @filter_evaluator = Evaluators::FilterEvaluator.new
+        @hidden_evaluator = Evaluators::HiddenEvaluator.new
+      end
+
+      def collect(event)
+        return unless collectible?(event)
+
+        trace_data = build_trace(event)
+        return unless valid?(trace_data)
+
+        trace_data = update_trace_depth(trace_data)
+        return if hidden?(trace_data)
+
+        log_trace(trace_data)
+        store_trace(trace_data)
+      end
+
+      def clear
+        @collection = []
+      end
+
+      private
+
+      attr_reader :tracker,
+        :filter_evaluator,
+        :hidden_evaluator
+
+      # Checks if trace data is collectible.
+      def collectible?(event)
+        raise NotImplementedError
+      end
+
+      # Validates trace data against filters.
+      def valid?(trace_data)
+        filter_evaluator.pass?(trace_data)
+      end
+
+      # Checks if trace data should be hidden.
+      def hidden?(trace_data)
+        hidden_evaluator.pass?(trace_data)
+      end
+
+      # Builds trace data from the given data.
+      def build_trace(event)
+        raise NotImplementedError
+      end
+
+      def update_trace_depth(trace_data)
+        raise NotImplementedError
+      end
+
+      def log_trace(trace_data)
+        Loggers::TraceLogger.log(trace_data)
+      end
+
+      def store_trace(trace_data)
+        stats.update(trace_data)
+
+        @collection << trace_data
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/depth_manager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    class DepthManager
+      def initialize
+        @tracker = Context.for(:tracking)
+      end
+
+      def align(trace_data)
+        case trace_data.event
+        when :call
+          push_to_call_stack(trace_data)
+        when :return
+          pop_from_call_stack(trace_data)
+        end
+        trace_data
+      end
+
+      private
+
+      attr_reader :tracker
+
+      # Increment the depth
+      def push_to_call_stack(trace_data)
+        trace_data.depth = tracker.current_depth
+        tracker.active_calls.push(trace_data)
+      end
+
+      # Decrement the depth
+      def pop_from_call_stack(trace_data)
+        tracker.active_calls.pop
+        trace_data.depth = tracker.current_depth
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/evaluators/base_evaluator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+
+module TraceViz
+  module Collectors
+    module Evaluators
+      class BaseEvaluator
+        def initialize
+          @config = Context.for(:config).configuration
+        end
+
+        def pass?(trace_data)
+          raise NotImplementedError
+        end
+
+        private
+
+        attr_reader :config
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/evaluators/filter_evaluator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "trace_viz/collectors/filters/registry"
+require_relative "base_evaluator"
+
+module TraceViz
+  module Collectors
+    module Evaluators
+      class FilterEvaluator < BaseEvaluator
+        def initialize
+          super()
+
+          @filters = build_filters.freeze
+        end
+
+        def pass?(trace_data)
+          filters.all? { |filter| filter.apply?(trace_data) }
+        end
+
+        private
+
+        attr_reader :filters
+
+        def build_filters
+          Collectors::Filters::Registry.build(config.filters)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/evaluators/hidden_evaluator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_evaluator"
+
+module TraceViz
+  module Collectors
+    module Evaluators
+      class HiddenEvaluator < BaseEvaluator
+        def pass?(trace_data)
+          !allowed_events.include?(trace_data.event)
+        end
+
+        private
+
+        def allowed_events
+          config.execution[:show_trace_events]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class BaseFilter
+        def initialize
+          @config = Context.for(:config).configuration
+        end
+
+        def apply?(trace_data)
+          raise NotImplementedError
+        end
+
+        private
+
+        attr_reader :config
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeClassesFilter < BaseFilter
+        def initialize(**options)
+          super()
+          @excluded_classes = options[:classes].map(&:to_s).freeze
+        end
+
+        def apply?(trace_data)
+          !exclude_class?(trace_data.klass)
+        end
+
+        private
+
+        attr_reader :excluded_classes
+
+        def exclude_class?(klass)
+          excluded_classes.include?(klass.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class ExcludeDefaultClassesFilter < BaseFilter
+        RUBY_CORE_CLASSES = Set.new([
+          Object,
+          String,
+          Array,
+          Hash,
+          Numeric,
+          Integer,
+          Float,
+          Symbol,
+          Kernel,
+          Module,
+          Class,
+          Range,
+          Regexp,
+        ].map(&:to_s).freeze)
+
+        def apply?(trace_data)
+          !excluded_class?(trace_data.klass)
+        end
+
+        private
+
+        def excluded_class?(klass)
+          RUBY_CORE_CLASSES.include?(klass.to_s)
+        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,28 @@
+# frozen_string_literal: true
+
+require_relative "base_filter"
+
+module TraceViz
+  module Collectors
+    module Filters
+      class IncludeClassesFilter < BaseFilter
+        def initialize(**options)
+          super()
+          @allowed_classes = options[:classes].map(&:to_s).freeze
+        end
+
+        def apply?(trace_data)
+          include_class?(trace_data.klass)
+        end
+
+        private
+
+        attr_reader :allowed_classes
+
+        def include_class?(klass)
+          allowed_classes.include?(klass.to_s)
+        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/matchers/trace_point_action_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    module Matchers
+      class TracePointActionMatcher
+        def initialize
+          @tracker = Context.for(:tracking)
+        end
+
+        def matches?(trace_point)
+          current_action_id == build_action_id(trace_point)
+        end
+
+        private
+
+        attr_reader :tracker
+
+        def current_action
+          tracker.active_calls.current
+        end
+
+        def current_action_id
+          current_action&.action_id
+        end
+
+        def build_action_id(trace_point)
+          [
+            trace_point.self.object_id,
+            trace_point.callee_id,
+          ].join("_")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    module Matchers
+      class WithinDepthMatcher
+        def initialize
+          @config = Context.for(:config).configuration
+        end
+
+        def matches?(depth)
+          depth <= max_depth
+        end
+
+        private
+
+        attr_reader :config
+
+        def max_depth
+          config.general[:max_display_depth]
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_point_collector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "trace_viz/trace_data/trace_point_builder"
+require_relative "base_collector"
+require_relative "matchers/trace_point_action_matcher"
+require_relative "matchers/within_depth_matcher"
+require_relative "depth_manager"
+require_relative "trace_stats"
+
+module TraceViz
+  module Collectors
+    class TracePointCollector < BaseCollector
+      def initialize
+        super()
+
+        @action_matcher = Matchers::TracePointActionMatcher.new
+        @within_depth_matcher = Matchers::WithinDepthMatcher.new
+      end
+
+      private
+
+      attr_reader :action_matcher, :within_depth_matcher
+
+      def collectible?(trace_point)
+        within_depth? || match_action?(trace_point)
+      end
+
+      def build_trace(trace_point)
+        TraceData::TracePointBuilder.build(trace_point)
+      end
+
+      def update_trace_depth(trace_data)
+        depth_manager.align(trace_data)
+      end
+
+      def match_action?(trace_point)
+        action_matcher.matches?(trace_point)
+      end
+
+      def within_depth?
+        depth = tracker.current_depth
+
+        within_depth_matcher.matches?(depth)
+      end
+
+      def depth_manager
+        @depth_manager ||= DepthManager.new
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_stats.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    class TraceStats
+      attr_reader :total_traces, :max_depth, :event_counts
+
+      def initialize
+        @total_traces = 0
+        @max_depth = 0
+        @event_counts = Hash.new(0)
+      end
+
+      def update(trace_data)
+        @total_traces += 1
+        @max_depth = [@max_depth, trace_data.depth].max
+        @event_counts[trace_data.event] += 1
+      end
+    end
+  end
+end