trace_viz 0.0.2 → 1.0.1

data/lib/trace_viz/adapters/base_adapter.rb

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
+require "trace_viz/helpers"
+require "trace_viz/loggers/logging_manager"
+require "trace_viz/exporters/export_manager"
+
 module TraceViz
   module Adapters
     class BaseAdapter
-      def trace
+      include Helpers::ConfigHelper
+
+      def initialize
+        @logger = Loggers::LoggingManager.new
+        @exporter = Exporters::ExportManager.new
+      end
+
+      def trace(&block)
+        execute_trace(&block)
+      ensure
+        logger.log_post_collection(collector)
+        logger.log_stats(collector)
+        exporter.export(collector)
+      end
+
+      private
+
+      attr_reader :logger, :exporter, :collector
+
+      def execute_trace
         raise NotImplementedError
       end
     end

data/lib/trace_viz/adapters/trace_point_adapter.rb

@@ -2,8 +2,6 @@
 
 require "trace_viz/adapters/base_adapter"
 require "trace_viz/collectors/trace_point_collector"
-require "trace_viz/exporters/text_exporter"
-require "trace_viz/loggers/trace_stats_logger"
 
 module TraceViz
   module Adapters
@@ -14,18 +12,13 @@ module TraceViz
         @collector = Collectors::TracePointCollector.new
       end
 
-      def trace(&block)
+      private
+
+      def execute_trace(&block)
         ::TracePoint.new(:call, :return) do |tp|
           collector.collect(tp)
         end.enable(&block)
-      ensure
-        Loggers::TraceStatsLogger.log(collector)
-        Exporters::TextExporter.new(collector).export
       end
-
-      private
-
-      attr_reader :collector
     end
   end
 end

data/lib/trace_viz/builders/base_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Builders
+    class BaseBuilder
+      def build
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/trace_viz/builders/diagram/base_builder.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Builders
+    module Diagram
+      class BaseBuilder
+      end
+    end
+  end
+end

data/lib/trace_viz/builders/diagram/message_builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "trace_viz/managers/diagram/participant_manager"
+require "trace_viz/models"
+require_relative "base_builder"
+
+module TraceViz
+  module Builders
+    module Diagram
+      class MessageBuilder < BaseBuilder
+        def initialize(formatter, participants)
+          super()
+          @formatter = formatter
+          @participants_manager = Managers::Diagram::ParticipantsManager.new(participants)
+        end
+
+        def build_call_message(from_trace, to_trace)
+          return if same_class?(from_trace, to_trace)
+
+          build(
+            :call,
+            from: participant_for(from_trace),
+            to: participant_for(to_trace),
+            content: formatter.format_call,
+          )
+        end
+
+        def build_return_message(from_trace, to_trace)
+          return if same_class?(from_trace, to_trace)
+
+          build(
+            :return,
+            from: participant_for(from_trace),
+            to: participant_for(to_trace),
+            content: formatter.format_return,
+          )
+        end
+
+        def build_loop_start_message(trace)
+          build(:loop_start, content: "#{trace.count} calls")
+        end
+
+        def build_loop_end_message
+          build(:loop_end)
+        end
+
+        def build_activate_message(trace)
+          build(:activate, to: participant_for(trace))
+        end
+
+        def build_deactivate_message(trace)
+          build(:deactivate, to: participant_for(trace))
+        end
+
+        def build_internal_message(trace)
+          build(
+            :call,
+            from: participant_for(trace),
+            to: participant_for(trace),
+            content: formatter.format_internal_message(trace),
+          )
+        end
+
+        def build_note(trace)
+          build(
+            :note,
+            from: participant_for(trace),
+            to: participant_for(trace),
+            content: formatter.format_result(trace),
+          )
+        end
+
+        private
+
+        attr_reader :formatter, :participants_manager
+
+        def build(type, from: nil, to: nil, content: "")
+          Models::Message.new(
+            type: type,
+            from: from,
+            to: to,
+            content: content,
+          )
+        end
+
+        def same_class?(from_trace, to_trace)
+          from_trace.klass == to_trace.klass
+        end
+
+        def participant_for(trace)
+          participants_manager.find(trace.klass)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/builders/diagram/sequence_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "trace_viz/models/diagram"
+require "trace_viz/extractors/diagram/box_extractor"
+require "trace_viz/extractors/diagram/message_extractor"
+require_relative "base_builder"
+
+module TraceViz
+  module Builders
+    module Diagram
+      class SequenceBuilder < BaseBuilder
+        def initialize(collector)
+          super()
+          @collector = collector
+        end
+
+        def build
+          Models::Diagram.new.tap do |diagram|
+            add_boxes_to(diagram)
+            add_messages_to(diagram)
+          end
+        end
+
+        private
+
+        attr_reader :collector
+
+        def add_boxes_to(diagram)
+          boxes.each { |box| diagram.add_box(box) }
+        end
+
+        def add_messages_to(diagram)
+          messages.each { |message| diagram.add_message(message) }
+        end
+
+        def boxes
+          @boxes ||= Extractors::Diagram::BoxExtractor.new(collector).extract
+        end
+
+        def participants
+          @participants ||= boxes.flat_map(&:participants)
+        end
+
+        def messages
+          @messages ||= Extractors::Diagram::MessageExtractor.new(collector, participants).extract
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/base_collector.rb

@@ -1,38 +1,40 @@
 # frozen_string_literal: true
 
-require "trace_viz/context"
-require "trace_viz/loggers/trace_logger"
-require_relative "evaluators/filter_evaluator"
-require_relative "evaluators/hidden_evaluator"
+require "trace_viz/helpers"
+require "trace_viz/loggers/logging_manager"
+require_relative "hierarchy_linker"
+require_relative "trace_stats"
+require_relative "trace_pipeline_builder"
 
 module TraceViz
   module Collectors
     class BaseCollector
-      attr_reader :collection, :stats
+      include Helpers::ConfigHelper
+      include Helpers::TrackingHelper
+
+      attr_reader :collection, :hierarchy, :stats, :renderer
 
       # 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 = []
+        setup_logger
+        setup_stats
+        setup_pipeline
+        setup_hierarchy
 
-        @filter_evaluator = Evaluators::FilterEvaluator.new
-        @hidden_evaluator = Evaluators::HiddenEvaluator.new
+        clear
       end
 
       def collect(event)
-        return unless collectible?(event)
+        return unless can_collect?(event)
 
         trace_data = build_trace(event)
-        return unless valid?(trace_data)
+        processed_data = process_trace(trace_data)
 
-        trace_data = update_trace_depth(trace_data)
-        return if hidden?(trace_data)
+        return unless processed_data
 
-        log_trace(trace_data)
-        store_trace(trace_data)
+        store_trace(processed_data)
+        link_to_hierarchy(processed_data)
       end
 
       def clear
@@ -41,43 +43,48 @@ module TraceViz
 
       private
 
-      attr_reader :tracker,
-        :filter_evaluator,
-        :hidden_evaluator
+      attr_reader :logger, :pipeline
 
-      # Checks if trace data is collectible.
-      def collectible?(event)
-        raise NotImplementedError
+      def setup_logger
+        @logger = Loggers::LoggingManager.new
       end
 
-      # Validates trace data against filters.
-      def valid?(trace_data)
-        filter_evaluator.pass?(trace_data)
+      def setup_stats
+        @stats = TraceStats.new
       end
 
-      # Checks if trace data should be hidden.
-      def hidden?(trace_data)
-        hidden_evaluator.pass?(trace_data)
+      def setup_pipeline
+        @pipeline = TracePipelineBuilder.build
       end
 
-      # Builds trace data from the given data.
-      def build_trace(event)
-        raise NotImplementedError
+      def setup_hierarchy
+        @hierarchy = TraceData::HierarchyLinker.new
+      end
+
+      def process_trace(trace_data)
+        pipeline.process(trace_data)
       end
 
-      def update_trace_depth(trace_data)
+      # Base on trace-event for specific adapter
+      def can_collect?(event)
         raise NotImplementedError
       end
 
-      def log_trace(trace_data)
-        Loggers::TraceLogger.log(trace_data)
+      # Builds trace data from the trace-event for specific adapter
+      def build_trace(event)
+        raise NotImplementedError
       end
 
       def store_trace(trace_data)
+        logger.log_runtime_trace(trace_data)
         stats.update(trace_data)
 
         @collection << trace_data
       end
+
+      def link_to_hierarchy(trace_data)
+        hierarchy.link(trace_data)
+      end
     end
   end
 end

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

@@ -0,0 +1,31 @@
+# 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/, "<Class")
+            .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

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 
-require "trace_viz/context"
+require "trace_viz/helpers"
 
 module TraceViz
   module Collectors
     module Filters
       class BaseFilter
-        def initialize
-          @config = Context.for(:config).configuration
-        end
+        include Helpers::ConfigHelper
 
         def apply?(trace_data)
           raise NotImplementedError
         end
-
-        private
-
-        attr_reader :config
       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

@@ -1,26 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "base_filter"
+require_relative "base_exclude_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)
+      class ExcludeClassesFilter < BaseExcludeFilter
+        def initialize(classes:)
+          super(classes: classes)
         end
       end
     end

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

@@ -1,36 +1,32 @@
 # frozen_string_literal: true
 
-require "set"
-require_relative "base_filter"
+require_relative "base_exclude_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)
+      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 apply?(trace_data)
-          !excluded_class?(trace_data.klass)
-        end
-
-        private
-
-        def excluded_class?(klass)
-          RUBY_CORE_CLASSES.include?(klass.to_s)
+        def initialize
+          super(classes: DEFAULT_CLASSES_AND_MODULES)
         end
       end
     end

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

@@ -1,26 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "base_filter"
+require_relative "base_include_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)
+      class IncludeClassesFilter < BaseIncludeFilter
+        def initialize(classes:)
+          super(classes: classes)
         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

@@ -1,12 +1,14 @@
 # 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
-        def initialize
-          @tracker = Context.for(:tracking)
-        end
+      class TracePointActionMatcher < BaseMatcher
+        include Helpers::TrackingHelper
 
         def matches?(trace_point)
           current_action_id == build_action_id(trace_point)
@@ -14,8 +16,6 @@ module TraceViz
 
         private
 
-        attr_reader :tracker
-
         def current_action
           tracker.active_calls.current
         end
@@ -25,11 +25,13 @@ module TraceViz
         end
 
         def build_action_id(trace_point)
-          [
-            trace_point.self.object_id,
-            trace_point.callee_id,
-          ].join("_")
+          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