trace_viz 0.0.1 → 1.0.0

data/lib/trace_viz/trace_data/root_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class RootNode < Node
+      def initialize
+        super()
+
+        # Explicitly ensure no parent for root
+        @parent = nil
+      end
+
+      def parent=(_parent)
+        raise NoMethodError, "RootNode cannot have a parent"
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/summary_node.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class SummaryNode < Node
+      attr_reader :group, :count, :representative_node, :event, :klass, :action, :path, :params, :result
+
+      def initialize(group:)
+        super()
+
+        @group = group
+        @count = group.size
+
+        @representative_node = group.first
+        @depth = representative_node.depth
+        @event = representative_node.event
+        @klass = representative_node.klass
+        @path = representative_node.path
+        @action = representative_node.action
+
+        # Representative node is the first node in the group belonging to MethodCall
+        @params = representative_node.params
+        @result = representative_node.method_return.result
+
+        add_children(representative_node.children)
+      end
+
+      def average_duration
+        return 0 if count.zero?
+
+        total_duration / count
+      end
+
+      def total_duration
+        children.map(&:duration).sum
+      end
+
+      private
+
+      def add_children(nodes)
+        nodes.each do |node|
+          add_child(node)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/trace_point/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "trace_viz/traits"
+require_relative "../node"
+
+module TraceViz
+  module TraceData
+    module TracePoint
+      class Base < TraceData::Node
+        include Traits::Identifiable
+
+        attr_reader :trace_point,
+          :memory_id,
+          :event,
+          :klass,
+          :action,
+          :path,
+          :line_number
+
+        def initialize(trace_point)
+          super()
+
+          @trace_point = trace_point
+          populate_attributes
+          assign_memory_id
+          assign_ids
+        end
+
+        def duration
+          0
+        end
+
+        def to_h
+          super.merge(
+            {
+              id: id,
+              action_id: action_id,
+              memory_id: memory_id,
+            },
+          )
+        end
+
+        private
+
+        def populate_attributes
+          @event = trace_point.event
+          @klass = trace_point.defined_class
+          @action = trace_point.callee_id
+          @path = trace_point.path
+          @line_number = trace_point.lineno
+        end
+
+        def assign_memory_id
+          @memory_id = trace_point.self.object_id
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/trace_point/method_call.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers/trace_point/param_helper"
+require_relative "base"
+
+module TraceViz
+  module TraceData
+    module TracePoint
+      class MethodCall < Base
+        include Helpers::TracePoint::ParamHelper
+
+        attr_reader :params, :method_return
+
+        def initialize(trace_point)
+          super(trace_point)
+
+          populate_params
+        end
+
+        def link(method_return)
+          @method_return = method_return
+        end
+
+        def duration
+          return 0 unless method_return
+
+          method_return.timestamp - timestamp
+        end
+
+        def to_h
+          super.merge(
+            {
+              params: params,
+              method_return_id: method_return&.id,
+            },
+          )
+        end
+
+        private
+
+        def populate_params
+          @params = extract_params(trace_point.binding, action)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/trace_point/method_return.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module TraceViz
+  module TraceData
+    module TracePoint
+      class MethodReturn < Base
+        attr_reader :result, :method_call
+
+        def initialize(trace_point)
+          super(trace_point)
+
+          populate_result
+        end
+
+        def link(method_call)
+          @method_call = method_call
+          method_call.link(self)
+        end
+
+        def duration
+          return 0 unless method_call
+
+          timestamp - method_call.timestamp
+        end
+
+        def to_h
+          super.merge(
+            {
+              result: result,
+              method_call_id: method_call&.id,
+            },
+          )
+        end
+
+        private
+
+        def populate_result
+          @result = @trace_point.return_value
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/trace_point_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "trace_point/method_call"
+require_relative "trace_point/method_return"
+
+module TraceViz
+  module TraceData
+    class TracePointBuilder
+      class << self
+        def build(tp)
+          case tp.event
+          when :call
+            TracePoint::MethodCall.new(tp)
+          when :return
+            TracePoint::MethodReturn.new(tp)
+          else
+            raise ArgumentError, "Unsupported TracePoint event: #{tp.event}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/traits/depth_trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Traits
+    module DepthTrackable
+      attr_reader :depth
+
+      def assign_depth(depth)
+        @depth = depth
+      end
+    end
+  end
+end

data/lib/trace_viz/traits/identifiable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/id_generator"
+
+module TraceViz
+  module Traits
+    module Identifiable
+      attr_reader :id, :action_id
+
+      def assign_ids
+        @id = Utils::IDGenerator.generate_unique_id(
+          memory_id: memory_id,
+          action: action,
+          path: path,
+          line_number: line_number,
+        )
+
+        @action_id = Utils::IDGenerator.generate_action_id(
+          memory_id: memory_id,
+          action: action,
+        )
+      end
+    end
+  end
+end

data/lib/trace_viz/traits/time_trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Traits
+    module TimeTrackable
+      attr_reader :timestamp
+
+      def record_timestamp
+        @timestamp = Time.now
+      end
+    end
+  end
+end

data/lib/trace_viz/traits.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "traits/time_trackable"
+require_relative "traits/depth_trackable"
+require_relative "traits/identifiable"
+
+module TraceViz
+  module Traits
+  end
+end

data/lib/trace_viz/utils/colorize.rb

@@ -3,31 +3,20 @@
 module TraceViz
   module Utils
     module Colorize
-      ANSI_COLORS = {
-        reset: "\e[0m",
-        black: "\e[30m",
-        red: "\e[31m",
-        green: "\e[32m",
-        yellow: "\e[33m",
-        blue: "\e[34m",
-        magenta: "\e[35m",
-        cyan: "\e[36m",
-        light_gray: "\e[37m",
-        dark_gray: "\e[90m",
-        light_red: "\e[91m",
-        light_green: "\e[92m",
-        light_yellow: "\e[93m",
-        light_blue: "\e[94m",
-        light_magenta: "\e[95m",
-        light_cyan: "\e[96m",
-        white: "\e[97m",
-      }.freeze
-
       class << self
-        def colorize(text, color)
-          return text unless text
+        def colorize(text, *colors)
+          return text if text.nil? || colors.empty?
+
+          "#{build_color_sequence(colors)}#{text}#{Defaults::Colors.fetch(:default)}"
+        end
+
+        private
 
-          "#{ANSI_COLORS[color]}#{text}#{ANSI_COLORS[:reset]}"
+        def build_color_sequence(colors)
+          colors
+            .map { |color| Defaults::Colors.fetch(color) }
+            .compact
+            .join
         end
       end
     end

data/lib/trace_viz/utils/format_utils/key_value_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module FormatUtils
+      class KeyValueFormatter
+        DEFAULT_MODE = :name_and_value
+
+        def initialize(mode: DEFAULT_MODE)
+          @mode = mode
+          @formatter = build_formatter
+        end
+
+        def call(data)
+          validate_input(data)
+          data.map { |key, value| @formatter.call(key, value) }.join(", ")
+        end
+
+        private
+
+        def validate_input(data)
+          unless data.is_a?(Hash)
+            raise ArgumentError, "Expected a Hash for key-value formatting, got #{data.class}"
+          end
+        end
+
+        def build_formatter
+          {
+            name_and_value: ->(key, value) { "#{key}: #{value}" },
+            name_only: ->(key, _) { key.to_s },
+            value_only: ->(_, value) { value.to_s },
+          }.fetch(@mode) { raise ArgumentError, "Invalid mode: #{@mode}" }
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/format_utils/value_truncator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    module FormatUtils
+      class ValueTruncator
+        DEFAULT_LENGTH = -1
+        VALID_DIRECTIONS = [:start, :end].freeze
+
+        def initialize(length: DEFAULT_LENGTH, direction: :end)
+          @length = length
+          @direction = validate_direction(direction)
+        end
+
+        def truncate(value)
+          return value unless valid_length?
+
+          case value
+          when String then truncate_string(value)
+          when Array then truncate_array(value)
+          when Hash then truncate_hash(value)
+          else truncate_generic(value)
+          end
+        end
+
+        private
+
+        attr_reader :length, :direction
+
+        def validate_direction(direction)
+          return direction if VALID_DIRECTIONS.include?(direction)
+
+          raise ArgumentError, "Invalid direction: #{direction}. Valid options are :start or :end."
+        end
+
+        def valid_length?
+          length.is_a?(Integer) && length.positive?
+        end
+
+        def truncate_string(string)
+          return string if string.length <= length
+
+          case direction
+          when :start then "...#{string[-length..]}"
+          when :end then "#{string[0, length]}..."
+          end
+        end
+
+        def truncate_array(array)
+          truncated = array.take(length)
+          truncated << "..." if array.size > length
+          truncated
+        end
+
+        def truncate_hash(hash)
+          keys = hash.keys.take(length)
+          truncated_pairs = keys.map { |key| "#{key}: #{truncate(hash[key])}" }
+          truncated_pairs << "..." if hash.size > length
+          "{#{truncated_pairs.join(", ")}}"
+        end
+
+        def truncate_generic(object)
+          object_str = object.inspect
+          return object_str if object_str.length <= length
+
+          case direction
+          when :start then "#{object.class}(...#{object_str[-length..]})"
+          when :end then "#{object.class}(#{object_str[0, length]}...)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/format_utils.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "format_utils/key_value_formatter"
+require_relative "format_utils/value_truncator"
+
+module TraceViz
+  module Utils
+    module FormatUtils
+      class << self
+        # Formats key-value pairs based on the provided mode
+        def format_key_value_pairs(data, mode)
+          formatter = KeyValueFormatter.new(mode: mode)
+          formatter.call(data)
+        end
+
+        # Truncates a value to the specified length
+        def truncate_value(value, length, direction: :end)
+          truncator = ValueTruncator.new(length: length, direction: direction)
+          truncator.truncate(value)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/utils/id_generator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Utils
+    class IDGenerator
+      ID_DELIMITER = "|"
+      COMPONENT_DELIMITER = ":"
+
+      class << self
+        def generate_unique_id(memory_id:, action:, path:, line_number:)
+          join_with_delimiters(
+            memory: memory_id,
+            action: action,
+            path: path,
+            line: line_number,
+          )
+        end
+
+        def generate_action_id(memory_id:, action:)
+          join_with_delimiters(
+            memory: memory_id,
+            action: action,
+          )
+        end
+
+        private
+
+        def join_with_delimiters(**components)
+          components.map { |key, value| "#{key}#{COMPONENT_DELIMITER}#{value}" }
+            .join(ID_DELIMITER)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TraceViz
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/sig/adapters/base_adapter.rbs

@@ -0,0 +1,11 @@
+module TraceViz
+  module Adapters
+    class BaseAdapter
+      def initialize: () -> void
+      
+      def trace: () -> void
+
+      private attr_reader config: untyped
+    end
+  end
+end

data/sig/adapters/trace_point_adapter.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Adapters
+    class TracePointAdapter < BaseAdapter
+      def initialize: () -> void
+
+      def trace: () { () -> void } -> void
+
+      private attr_reader collector: TraceViz::Collectors::TracePointCollector
+
+      private def exporter: () -> untyped
+    end
+  end
+end

data/sig/collectors/filters/registry.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Collectors
+    module Filters
+      class Registry
+        FILTERS: Hash[Symbol, untyped]
+
+        def self.build: (Array[Symbol | Hash[Symbol, untyped]] filters) -> Array[untyped]
+
+        private def self.fetch_filter_class: (Symbol filter_key) -> untyped
+      end
+    end
+  end
+end

data/sig/collectors/trace_point_collector.rbs

@@ -0,0 +1,17 @@
+module TraceViz
+  module Collectors
+    class TracePointCollector
+      def initialize: () -> void
+
+      private attr_reader action_matcher: TraceViz::Matchers::TracePointActionMatcher
+      private attr_reader within_depth_matcher: TraceViz::Matchers::WithinDepthMatcher
+
+      private def collectible?: (untyped) -> bool
+      private def build_trace: (untyped) -> untyped
+      private def update_trace_depth: (untyped) -> void
+      private def match_action?: (untyped) -> bool
+      private def within_depth?: () -> bool
+      private def depth_manager: () -> TraceViz::Collectors::DepthManager
+    end
+  end
+end

data/sig/config/copier.rbs

@@ -0,0 +1,15 @@
+module TraceViz
+  module Config
+    class Copier
+      @origin_configuration: untyped
+      @settings: Hash[Symbol, untyped]
+
+      def initialize: (untyped configuration) -> void
+      def copy: () -> untyped
+
+      private def deep_copy: (untyped value) -> untyped
+      private attr_reader origin_configuration: untyped
+      private attr_reader settings: Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/config/validator.rbs

@@ -0,0 +1,18 @@
+module TraceViz
+  module Config
+    class Validator
+      FILTER_KEYS: Array[Symbol]
+
+      @validations: Hash[Symbol, ^(untyped) -> void]
+
+      def initialize: () -> void
+      def validate: (Symbol group, Symbol value) -> void
+
+      private def validate_params: (Hash[Symbol, untyped] value) -> void
+      private def validate_result: (Hash[Symbol, untyped] value) -> void
+      private def validate_source_location: (Hash[Symbol, untyped] value) -> void
+      private def validate_filters: (Array[untyped] filters) -> void
+      private def validate_export: (Hash[Symbol, untyped] value) -> void
+    end
+  end
+end

data/sig/configuration.rbs

@@ -0,0 +1,22 @@
+module TraceViz
+  class Configuration
+    @logger: TraceViz::Logger
+    @validator: TraceViz::Config::Validator
+    @settings: Hash[Symbol, untyped]
+
+    attr_reader logger: TraceViz::Logger
+    attr_reader settings: Hash[Symbol, untyped]
+
+    def initialize: () -> void
+    def []: (Symbol key) -> untyped
+    def update: (Symbol group, untyped values) -> void
+    def reset_defaults: () -> void
+    def dup: () -> TraceViz::Config::Copier
+
+    private def define_dynamic_accessors: () -> void
+  end
+
+  def self.configuration: () -> TraceViz::Configuration
+  def self.configure: () { (TraceViz::Configuration) -> void } -> void
+  def self.logger: () -> TraceViz::Logger
+end

data/sig/context/base_context.rbs

@@ -0,0 +1,9 @@
+module TraceViz
+  module Context
+    class BaseContext
+      attr_reader options: Hash[Symbol, untyped]
+
+      def initialize: (options: Hash[Symbol, untyped]) -> void
+    end
+  end
+end

data/sig/context/config_context.rbs

@@ -0,0 +1,13 @@
+module TraceViz
+  module Context
+    class ConfigContext
+      attr_reader configuration: untyped
+
+      def initialize: (options: Hash[Symbol, untyped]) -> void
+
+      def temp_configuration: () -> untyped
+
+      def apply_options: (Hash[Symbol, untyped]) -> untyped
+    end
+  end
+end