trace_viz 0.0.1

data/lib/trace_viz/adapters/trace_point/trace_formatter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/colorize"
+
+module TraceViz
+  module Adapters
+    module TracePoint
+      class TraceFormatter
+        def initialize(trace_data)
+          @trace_data = trace_data
+          @config = @trace_data.config
+          @logger = TraceViz.logger
+        end
+
+        def format_call
+          return "" if trace_data.exceeded_max_depth?
+
+          [
+            indent_if_enabled,
+            colorize(depth_if_enabled, :blue),
+            colorize(method_name_if_enabled, :light_green),
+            colorize(source_location_if_enabled, :dark_gray),
+            colorize(params_if_enabled, :yellow),
+          ].compact.join(" ")
+        end
+
+        def format_return
+          return "" if trace_data.exceeded_max_depth?
+
+          [
+            indent_if_enabled,
+            colorize(depth_if_enabled, :blue),
+            colorize(method_name_if_enabled, :light_green),
+            colorize(result_if_enabled, :cyan),
+            colorize(source_location_if_enabled, :dark_gray),
+            colorize(execution_time_if_enabled, :red),
+          ].compact.join(" ")
+        end
+
+        private
+
+        attr_reader :trace_data, :config, :logger
+
+        def indent_if_enabled
+          return unless config.show_indent && config.show_depth
+
+          " " * (config.tab_size * trace_data.depth)
+        end
+
+        def depth_if_enabled
+          return unless config.show_depth
+
+          "#depth:#{trace_data.depth}"
+        end
+
+        def method_name_if_enabled
+          return unless config.show_method_name
+
+          "#{trace_data.klass}##{trace_data.id}"
+        end
+
+        def source_location_if_enabled
+          return unless config.show_source_location
+
+          "at #{trace_data.path}:#{trace_data.line_number}"
+        end
+
+        def params_if_enabled
+          return unless config.show_params
+
+          param_values = trace_data.params.map do |var|
+            trace_data.trace_point.binding.local_variable_get(var).inspect
+          end.join(", ")
+          "(#{param_values})"
+        end
+
+        def result_if_enabled
+          return unless config.show_return_value
+
+          "#=> #{trace_data.result.inspect}"
+        end
+
+        def execution_time_if_enabled
+          return unless config.show_execution_time && trace_data.duration
+
+          "in #{trace_data.duration}ms"
+        end
+
+        def colorize(text, color_key)
+          Utils::Colorize.colorize(text, color_key)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/adapters/trace_point/trace_logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Adapters
+    module TracePoint
+      class TraceLogger
+        def initialize(trace_data)
+          @trace_data = trace_data
+          @config = @trace_data.config
+          @formatter = TraceFormatter.new(@trace_data)
+        end
+
+        def log_trace
+          return unless should_log?
+
+          case trace_data.event
+          when :call
+            log_call
+          when :return
+            log_return
+          end
+        end
+
+        private
+
+        attr_reader :trace_data, :config, :formatter
+
+        def log_call
+          formatted_call = formatter.format_call
+          TraceViz.logger.start(formatted_call)
+        end
+
+        def log_return
+          formatted_return = formatter.format_return
+          TraceViz.logger.finish(formatted_return)
+        end
+
+        def should_log?
+          config.show_trace_events.include?(trace_data.event)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/adapters/trace_point_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "trace_viz/logger"
+require "trace_viz/adapters/base_adapter"
+require "trace_viz/adapters/trace_point/trace_formatter"
+require "trace_viz/adapters/trace_point/trace_logger"
+require "trace_viz/adapters/trace_point/trace_data"
+require "trace_viz/adapters/trace_point/event_handler"
+
+module TraceViz
+  module Adapters
+    class TracePointAdapter < BaseAdapter
+      def trace(&block)
+        ::TracePoint.new(:call, :return) do |tp|
+          trace_data = TracePoint::TraceData.new(tp)
+
+          next if trace_data.internal_call?
+          next if trace_data.exceeded_max_depth?
+
+          TracePoint::EventHandler.new(trace_data).handle
+        end.enable(&block)
+      end
+    end
+  end
+end

data/lib/trace_viz/configuration.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "trace_viz/logger"
+
+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
+
+    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]
+    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
+        end
+        copy.instance_variable_set(var, copy_value)
+      end
+      copy
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def logger
+      configuration.logger
+    end
+  end
+end

data/lib/trace_viz/context/base_context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class BaseContext
+      attr_reader :options
+
+      def initialize(**options)
+        @options = options
+      end
+    end
+  end
+end

data/lib/trace_viz/context/config_context.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/base_context"
+
+module TraceViz
+  module Context
+    class ConfigContext < BaseContext
+      attr_reader :configuration
+
+      def initialize(**options)
+        super
+
+        @configuration = apply_options(options)
+      end
+
+      def temp_configuration
+        @temp_configuration ||= TraceViz.configuration.dup
+      end
+
+      # Apply the overrides from options
+      def apply_options(options)
+        options.each do |key, value|
+          if temp_configuration.respond_to?("#{key}=")
+            temp_configuration.send("#{key}=", value)
+          else
+            warn("TraceViz: Unknown configuration option '#{key}'")
+          end
+        end
+
+        temp_configuration
+      end
+    end
+  end
+end

data/lib/trace_viz/context/manager/context_map.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class Manager
+      module ContextMap
+        def get_context(key)
+          validate_key!(key)
+          @context_map[key]
+        end
+
+        def clear
+          @context_map.clear
+        end
+
+        def empty?
+          @context_map.empty?
+        end
+
+        def all_contexts
+          @context_map.map do |key, context|
+            {
+              key: key,
+              context: context,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/manager/context_operations.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/base_context"
+
+module TraceViz
+  module Context
+    class Manager
+      module ContextOperations
+        def create_context(key = nil, **options)
+          if key
+            validate_key!(key)
+            ensure_unique_key!(key)
+          end
+
+          context_class = @registered_contexts[key] || BaseContext
+          context = context_class.new(**options)
+          @context_map[key] = context if key
+          context
+        end
+
+        def enter_context(key = nil, **options)
+          create_context(key, **options)
+        end
+
+        def enter_multiple_contexts(contexts_with_options = {})
+          unless contexts_with_options.is_a?(Hash)
+            raise ContextError, "Expected a Hash of contexts and options, got #{contexts_with_options.class}"
+          end
+
+          contexts_with_options.each do |key, options|
+            enter_context(key, **options)
+          end
+        end
+
+        def exit_context(key)
+          validate_key!(key)
+          context = @context_map.delete(key)
+          raise ContextError, "No context found with key '#{key}' to exit" unless context
+
+          context
+        end
+
+        def exit_multiple_contexts(*keys)
+          keys.each do |key|
+            validate_key!(key)
+            exit_context(key)
+          end
+        end
+
+        # Execute a block within the context(s) specified
+        def with_contexts(contexts_with_options = {})
+          enter_multiple_contexts(contexts_with_options)
+          yield
+        ensure
+          exit_multiple_contexts(*contexts_with_options.keys)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/manager/context_registry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class Manager
+      module ContextRegistry
+        def register_context_type(key, context_class)
+          validate_key!(key)
+          validate_context_class!(context_class)
+
+          if @registered_contexts.key?(key)
+            raise ContextError, "Context type for key '#{key}' is already registered"
+          end
+
+          @registered_contexts[key] = context_class
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/manager/context_validation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class Manager
+      module ContextValidation
+        private
+
+        # Validate that the key is either a Symbol or String
+        def validate_key!(key)
+          return unless key
+
+          unless key.is_a?(Symbol) || key.is_a?(String)
+            raise ContextError, "Key must be a Symbol or String, got #{key.class}"
+          end
+        end
+
+        # Ensure that the key is unique (no existing context with the same key)
+        def ensure_unique_key!(key)
+          if @context_map.key?(key)
+            raise ContextError, "Context with key '#{key}' already exists"
+          end
+        end
+
+        # Validate that the context_class inherits from BaseContext
+        def validate_context_class!(context_class)
+          unless context_class < BaseContext
+            raise ContextError, "Context class must inherit from BaseContext"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/manager.rb

@@ -0,0 +1,37 @@
+# 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"
+
+module TraceViz
+  module Context
+    class Manager
+      class << self
+        include ContextMap
+        include ContextValidation
+        include ContextRegistry
+        include ContextOperations
+
+        # Initialize class instance variables
+        def initialize_manager
+          @context_map = {}
+          @registered_contexts = {}
+
+          register_default_contexts
+        end
+
+        def register_default_contexts
+          Manager.register_context_type(:config, ConfigContext)
+          Manager.register_context_type(:tracking, TrackingContext)
+        end
+      end
+
+      # Ensure initialization upon loading
+      initialize_manager
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    module Tracking
+      class Depth
+        attr_reader :current
+
+        def initialize(current = 0)
+          @current = current
+        end
+
+        def increment
+          @current += 1
+        end
+
+        def decrement
+          @current -= 1 if @current.positive?
+        end
+
+        def reset
+          @current = 0
+        end
+
+        def zero?
+          @current.zero?
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/tracking_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/base_context"
+require "trace_viz/context/tracking/depth"
+
+module TraceViz
+  module Context
+    class TrackingContext < BaseContext
+      attr_reader :depth
+
+      def initialize(**options)
+        super
+
+        @depth = Tracking::Depth.new
+      end
+    end
+  end
+end

data/lib/trace_viz/context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/manager"
+
+module TraceViz
+  module Context
+    class << self
+      def for(type)
+        Manager.get_context(type)
+      end
+    end
+  end
+end

data/lib/trace_viz/core/tracer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "trace_viz/logger"
+require "trace_viz/context"
+require "trace_viz/configuration"
+require "trace_viz/adapters/trace_point_adapter"
+
+module TraceViz
+  module Core
+    class Tracer
+      def trace(**options, &block)
+        Context::Manager.with_contexts(config: options, tracking: {}) do
+          adapter = Adapters::TracePointAdapter.new
+          adapter.trace(&block)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/core.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "trace_viz/core/tracer"
+
+module TraceViz
+  module Core
+  end
+end

data/lib/trace_viz/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module TraceViz
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class AdapterError < Error; end
+  class ContextError < Error; end
+end

data/lib/trace_viz/logger.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module TraceViz
+  class Logger
+    COLORS = {
+      reset: "\e[0m",
+      info: "\e[34m",
+      success: "\e[32m",
+      error: "\e[31m",
+      warn: "\e[33m",
+      start: "\e[36m",
+      finish: "\e[35m",
+    }.freeze
+
+    EMOJIS = {
+      info: "ℹ️",
+      success: "✅",
+      error: "❌",
+      warn: "⚠️",
+      start: "🚀",
+      finish: "🏁",
+    }.freeze
+
+    LEVELS = [:info, :success, :error, :warn, :start, :finish].freeze
+
+    def initialize(output: $stdout)
+      @output = output
+    end
+
+    def info(message)
+      log(:info, message)
+    end
+
+    def success(message)
+      log(:success, message)
+    end
+
+    def error(message)
+      log(:error, message)
+    end
+
+    def warn(message)
+      log(:warn, message)
+    end
+
+    def start(message)
+      log(:start, message)
+    end
+
+    def finish(message)
+      log(:finish, message)
+    end
+
+    private
+
+    def log(level, message)
+      return unless LEVELS.include?(level)
+
+      color = COLORS[level] || COLORS[:info]
+      emoji = EMOJIS[level] || EMOJIS[:info]
+
+      # Align emoji and level using fixed-width columns
+      formatted_message = format(
+        "#{color}%-3s %-8s#{COLORS[:reset]} %s",
+        emoji,
+        "[#{level.to_s.upcase}]",
+        message,
+      )
+
+      @output.puts(formatted_message)
+    end
+  end
+end

data/lib/trace_viz/utils/colorize.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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
+
+          "#{ANSI_COLORS[color]}#{text}#{ANSI_COLORS[:reset]}"
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/version.rb

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

data/lib/trace_viz.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "trace_viz/version"
+require "trace_viz/errors"
+require "trace_viz/core"
+
+module TraceViz
+  class << self
+    def trace(**options, &block)
+      Core::Tracer.new.trace(**options, &block)
+    end
+  end
+end