trace_viz 0.0.1 → 1.0.0

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

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

data/lib/trace_viz/collectors/steps.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "steps/**/*.rb")].each { |file| require_relative file }
+
+module TraceViz
+  module Collectors
+    module Steps
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_pipeline.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    class TracePipeline
+      def initialize
+        @steps = []
+      end
+
+      def add_step(step)
+        @steps << step
+      end
+
+      def process(trace_data)
+        @steps.each do |step|
+          trace_data = step.call(trace_data)
+          return nil unless trace_data
+        end
+        trace_data
+      rescue StandardError => e
+        TraceViz.logger.error("Pipeline processing failed for trace_data ID: #{trace_data.id} - #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_pipeline_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "trace_pipeline"
+require_relative "steps"
+
+module TraceViz
+  module Collectors
+    class TracePipelineBuilder
+      class << self
+        def build
+          TracePipeline.new.tap do |pipeline|
+            pipeline.add_step(Steps::ValidationStep.new)
+
+            #
+            # Those actions require access to the current call,
+            # so it needs to be run before current call is updated
+            #
+            pipeline.add_step(Steps::BuildHierarchyStep.new)
+            pipeline.add_step(Steps::LinkingStep.new)
+
+            pipeline.add_step(Steps::AssignDepthForCallStep.new)
+            pipeline.add_step(Steps::AssignDepthForReturnStep.new)
+            pipeline.add_step(Steps::HiddenStep.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_point_collector.rb

@@ -0,0 +1,41 @@
+# 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"
+
+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 can_collect?(trace_point)
+        within_depth? || match_action?(trace_point)
+      end
+
+      def build_trace(trace_point)
+        TraceData::TracePointBuilder.build(trace_point)
+      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
+    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

data/lib/trace_viz/config/copier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Config
+    class Copier
+      def initialize(configuration)
+        @origin_configuration = configuration
+        @settings = origin_configuration.settings
+      end
+
+      def copy
+        copied_settings = deep_copy(settings)
+        copy = origin_configuration.class.new
+        copied_settings.each { |key, value| copy.update(key, value) }
+        copy
+      end
+
+      private
+
+      attr_reader :origin_configuration, :settings
+
+      def deep_copy(value)
+        case value
+        when Hash
+          value.transform_values { |v| deep_copy(v) }
+        when Array
+          value.map { |v| deep_copy(v) }
+        else
+          begin
+            value.dup
+          rescue TypeError
+            value # Return immutable objects as-is
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/config/validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "trace_viz/collectors/filters/registry"
+
+module TraceViz
+  module Config
+    class Validator
+      FILTER_KEYS = Collectors::Filters::Registry::FILTERS.keys.freeze
+
+      def initialize
+        @validations = {
+          params: ->(value) { validate_params(value) },
+          result: ->(value) { validate_result(value) },
+          source_location: ->(value) { validate_source_location(value) },
+          filters: ->(value) { validate_filters(value) },
+          export: ->(value) { validate_export(value) },
+        }
+      end
+
+      def validate(group, value)
+        return unless @validations.key?(group)
+
+        @validations[group].call(value)
+      end
+
+      private
+
+      def validate_params(value)
+        mode = value[:mode]
+        unless Defaults::Config.valid_param_mode?(mode)
+          raise ArgumentError,
+            "Invalid param mode: #{mode}. Valid modes are #{Defaults::Config.valid_param_modes.join(", ")}."
+        end
+
+        if value[:truncate_values] && (!value[:truncate_values].is_a?(Integer) || value[:truncate_values] <= 0)
+          raise ArgumentError, "Truncate values must be a positive integer."
+        end
+      end
+
+      def validate_result(value)
+        if value[:truncate_length] && !value[:truncate_length].is_a?(Integer)
+          raise ArgumentError, "Truncate values must be a positive integer."
+        end
+      end
+
+      def validate_source_location(value)
+        if value[:truncate_length] && (!value[:truncate_length].is_a?(Integer) || value[:truncate_length] <= 0)
+          raise ArgumentError, "Truncate length for source_location must be a positive integer."
+        end
+
+        if value[:filter_paths] && !value[:filter_paths].all? { |path| path.is_a?(Regexp) }
+          raise ArgumentError, "All filter paths must be regular expressions."
+        end
+      end
+
+      def validate_filters(filters)
+        unless filters.is_a?(Array)
+          raise ArgumentError, "Filters must be an array. Received: #{filters.class.name}"
+        end
+      end
+
+      def validate_export(value)
+        unless value.is_a?(Hash)
+          raise ArgumentError, "Export configuration must be a hash."
+        end
+
+        format = value[:format]
+        unless Defaults::Config.valid_export_format?(format)
+          raise ArgumentError,
+            "Invalid export format: #{format}. Valid formats are #{Defaults::Config.valid_export_formats.join(", ")}."
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/configuration.rb

@@ -1,47 +1,53 @@
 # frozen_string_literal: true
 
 require "trace_viz/logger"
+require "trace_viz/config/validator"
+require "trace_viz/config/copier"
 
 module TraceViz
   class Configuration
-    attr_accessor :logger,
-      :tab_size,
-      :show_indent,
-      :show_depth,
-      :max_display_depth,
-      :show_method_name,
-      :show_source_location,
-      :show_params,
-      :show_return_value,
-      :show_execution_time,
-      :show_trace_events
+    attr_reader :logger, :settings
+    attr_reader(*Defaults::Config.fetch.keys)
 
     def initialize
       @logger = Logger.new
-      @tab_size = 2
-      @show_indent = true
-      @show_depth = true
-      @max_display_depth = 3 # Recommended to keep this value between 3 and 5
-      @show_method_name = true
-      @show_source_location = false
-      @show_params = true
-      @show_return_value = true
-      @show_execution_time = true
-      @show_trace_events = [:call, :return]
+      @validator = Config::Validator.new
+      @settings = Defaults::Config.fetch
+      define_dynamic_accessors
+    end
+
+    def [](key)
+      settings[key]
+    end
+
+    def update(group, values)
+      raise ArgumentError, "Invalid configuration group: #{group}" unless settings.key?(group)
+
+      @validator.validate(group, values)
+      if settings[group].is_a?(Hash)
+        settings[group].merge!(values)
+      else
+        settings[group] = values
+      end
+    end
+
+    def reset_defaults
+      @settings = Defaults::Config.fetch
     end
 
     def dup
-      copy = self.class.new
-      instance_variables.each do |var|
-        value = instance_variable_get(var)
-        copy_value = begin
-          value.dup
-        rescue TypeError
-          value
+      Config::Copier.new(self).copy
+    end
+
+    private
+
+    def define_dynamic_accessors
+      settings.each_key do |attr|
+        define_singleton_method(attr) { settings[attr] }
+        define_singleton_method("#{attr}=") do |value|
+          update(attr, value)
         end
-        copy.instance_variable_set(var, copy_value)
       end
-      copy
     end
   end
 

data/lib/trace_viz/context/config_context.rb

@@ -23,7 +23,7 @@ module TraceViz
           if temp_configuration.respond_to?("#{key}=")
             temp_configuration.send("#{key}=", value)
           else
-            warn("TraceViz: Unknown configuration option '#{key}'")
+            TraceViz.logger.warn("Unknown configuration option '#{key}'")
           end
         end
 

data/lib/trace_viz/context/manager.rb

@@ -1,37 +1,33 @@
 # frozen_string_literal: true
 
-require "trace_viz/context/manager/context_map"
-require "trace_viz/context/manager/context_validation"
-require "trace_viz/context/manager/context_registry"
-require "trace_viz/context/manager/context_operations"
-require "trace_viz/context/config_context"
-require "trace_viz/context/tracking_context"
+require "trace_viz/context/map"
+require "trace_viz/context/registry"
 
 module TraceViz
   module Context
     class Manager
+      @map = Map.new
+
       class << self
-        include ContextMap
-        include ContextValidation
-        include ContextRegistry
-        include ContextOperations
+        def enter_contexts(contexts)
+          @map.replace(Registry.build(contexts))
+        end
 
-        # Initialize class instance variables
-        def initialize_manager
-          @context_map = {}
-          @registered_contexts = {}
+        def exit_contexts(*keys)
+          @map.remove(*keys)
+        end
 
-          register_default_contexts
+        def with_contexts(contexts = {})
+          enter_contexts(contexts)
+          yield
+        ensure
+          exit_contexts(*contexts.keys)
         end
 
-        def register_default_contexts
-          Manager.register_context_type(:config, ConfigContext)
-          Manager.register_context_type(:tracking, TrackingContext)
+        def fetch_context(key)
+          @map.fetch(key)
         end
       end
-
-      # Ensure initialization upon loading
-      initialize_manager
     end
   end
 end

data/lib/trace_viz/context/map.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class Map
+      def initialize
+        @context_map = {}
+      end
+
+      def replace(new_map)
+        @context_map = new_map
+      end
+
+      def fetch(key)
+        @context_map.fetch(key)
+      rescue KeyError
+        raise ContextError, "Context for key '#{key}' not found"
+      end
+
+      def remove(*keys)
+        keys.each { |key| @context_map.delete(key) }
+      end
+
+      def reset
+        @context_map.clear
+      end
+    end
+  end
+end

data/lib/trace_viz/context/registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/config_context"
+require "trace_viz/context/tracking_context"
+
+module TraceViz
+  module Context
+    class Registry
+      CONTEXTS = {
+        config: ConfigContext,
+        tracking: TrackingContext,
+      }.freeze
+
+      class << self
+        # Builds a hash of context objects based on the provided contexts hash.
+        #
+        # @param [Hash] contexts A hash where the keys are context keys and the values are options for each context.
+        #   Example:
+        #     {
+        #       context_key1: { option1: 'value1', option2: 'value2' },
+        #       context_key2: { option1: 'value3', option2: 'value4' }
+        #     }
+        #
+        # @return [Hash] A hash where the keys are context keys and the values are instantiated context objects.
+        #
+        # @raise [ArgumentError] If a context key is not found in the CONTEXTS hash.
+        def build(contexts)
+          contexts.each_with_object({}) do |(context_key, options), result|
+            klass = CONTEXTS.fetch(context_key)
+
+            result[context_key] = klass.new(**(options || {}))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/tracking/active_calls.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    module Tracking
+      class ActiveCalls
+        def initialize
+          @stack = []
+        end
+
+        def push(trace_data)
+          @stack.push(trace_data)
+        end
+
+        def pop
+          @stack.pop
+        end
+
+        def current
+          @stack.last
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def size
+          @stack.size
+        end
+
+        def clear
+          @stack.clear
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/tracking_context.rb

@@ -2,16 +2,25 @@
 
 require "trace_viz/context/base_context"
 require "trace_viz/context/tracking/depth"
+require "trace_viz/context/tracking/active_calls"
 
 module TraceViz
   module Context
     class TrackingContext < BaseContext
-      attr_reader :depth
+      attr_reader :active_calls
 
       def initialize(**options)
         super
 
-        @depth = Tracking::Depth.new
+        @active_calls = Tracking::ActiveCalls.new
+      end
+
+      def current_call
+        active_calls.current
+      end
+
+      def current_depth
+        active_calls.size
       end
     end
   end

data/lib/trace_viz/context.rb

@@ -5,8 +5,8 @@ require "trace_viz/context/manager"
 module TraceViz
   module Context
     class << self
-      def for(type)
-        Manager.get_context(type)
+      def for(key)
+        Manager.fetch_context(key)
       end
     end
   end

data/lib/trace_viz/core/tracer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "trace_viz/defaults"
 require "trace_viz/logger"
 require "trace_viz/context"
 require "trace_viz/configuration"
@@ -9,6 +10,8 @@ module TraceViz
   module Core
     class Tracer
       def trace(**options, &block)
+        Defaults::Themes.apply_solarized_theme
+
         Context::Manager.with_contexts(config: options, tracking: {}) do
           adapter = Adapters::TracePointAdapter.new
           adapter.trace(&block)

data/lib/trace_viz/defaults/actions.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Actions
+      EMOJIS = {
+        default: "",
+        info: "ℹ️",
+        success: "✅",
+        error: "❌",
+        warn: "⚠️",
+        start: "🚀",
+        processing: "🔄",
+        finish: "🏁",
+        exported: "📤",
+        skipped: "⏩",
+        stats: "📊",
+      }.freeze
+
+      COLORS = {
+        # Default actions
+        default: :reset,
+        info: :cyan,
+        success: :green,
+        error: :bright_red,
+        warn: :yellow,
+
+        # Processing actions
+        start: :bright_cyan,
+        processing: [:dim, :bright_white],
+        finish: :bright_magenta,
+
+        # Export & stats actions
+        exported: :bright_green,
+        skipped: :bright_white,
+        stats: [:bold, :underline, :bright_white],
+
+        # Trace data actions
+        trace_indent: :dim,
+        trace_depth: :blue,
+        trace_depth_prefix: [:dim, :italic, :blue],
+        trace_depth_open: [:dim, :bright_blue],
+        trace_depth_value: :bright_red,
+        trace_depth_close: [:dim, :bright_blue],
+        trace_method_name: :bright_cyan,
+        trace_method_class: :bright_green,
+        trace_method_sign: :blue,
+        trace_method_action: [:bold, :bright_cyan],
+        trace_source_location: [:dim, :bright_white],
+        trace_params_key: :bright_yellow,
+        trace_params_value: [:dim, :bright_yellow],
+        trace_result_prefix: [:italic, :bright_blue],
+        trace_result_value: :bright_white,
+        trace_execution_time: [:dim, :bright_red],
+      }.freeze
+
+      class << self
+        def emojis
+          EMOJIS
+        end
+
+        def colors
+          COLORS
+        end
+
+        def keys
+          colors.keys
+        end
+
+        def emoji_for(action)
+          EMOJIS.fetch(action, EMOJIS[:default])
+        end
+
+        def source_colors
+          Defaults.action_colors || COLORS
+        end
+
+        def colors_for(action)
+          Array(source_colors.fetch(action, source_colors[:default]))
+        end
+      end
+    end
+  end
+end