trace_viz 0.0.2 → 1.0.1

data/lib/trace_viz/formatters/helpers/time_helper.rb

@@ -4,10 +4,10 @@ module TraceViz
   module Formatters
     module Helpers
       module TimeHelper
-        def execution_time_representation
+        def execution_time_representation(trace_data)
           return unless config.execution[:show_time] && trace_data.duration
 
-          "in #{trace_data.duration}ms"
+          format("in %.6fms", trace_data.duration)
         end
       end
     end

data/lib/trace_viz/formatters/helpers.rb

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

data/lib/trace_viz/formatters/log/base_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../trace_data_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class BaseFormatter < TraceDataFormatter
+        include Helpers::Log::ColorHelper
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/log/formatter_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../base_formatter_factory"
+require_relative "method_call_formatter"
+require_relative "method_return_formatter"
+require_relative "summary_group_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class FormatterFactory < BaseFormatterFactory
+        def initialize
+          super(
+            call: Log::MethodCallFormatter.new,
+            return: Log::MethodReturnFormatter.new,
+            summary_group: Log::SummaryGroupFormatter.new
+          )
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/log/method_call_formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "verbose_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class MethodCallFormatter < VerboseFormatter
+        include Helpers::Log::ParamsHelper
+        include Helpers::Log::ResultHelper
+
+        def call(trace_data)
+          [
+            indent_representation(trace_data),
+            format_depth(trace_data, config),
+            format_method_name(trace_data, config),
+            colorize_for(source_location_representation(trace_data), :trace_source_location),
+            format_params(trace_data, config),
+            format_result(trace_data, config),
+            colorize_for(execution_time_representation(trace_data), :trace_execution_time),
+          ].compact.join(" ")
+        end
+
+        private
+
+        def format_result(trace_data, config)
+          return unless trace_data.method_return
+
+          super(trace_data.method_return, config)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/log/method_return_formatter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "verbose_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class MethodReturnFormatter < VerboseFormatter
+        include Helpers::Log::ResultHelper
+
+        def call(trace_data)
+          [
+            indent_representation(trace_data),
+            format_depth(trace_data, config),
+            format_method_name(trace_data, config),
+            format_result(trace_data, config),
+            colorize_for(source_location_representation(trace_data), :trace_source_location),
+            colorize_for(execution_time_representation(trace_data), :trace_execution_time),
+          ].compact.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/log/summary_group_formatter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class SummaryGroupFormatter < BaseFormatter
+        include Helpers::Log::DepthHelper
+        include Helpers::Log::MethodNameHelper
+        include Helpers::Log::Summary::ParamsHelper
+
+        def call(trace_data)
+          [
+            indent_representation(trace_data),
+            format_depth(trace_data, config),
+            Defaults::Actions.emoji_for(:processing),
+            format_method_name(trace_data, config),
+            format_params_template(trace_data, config),
+            summary_info(trace_data),
+          ].compact.join(" ")
+        end
+
+        private
+
+        def summary_info(trace_data)
+          colorize(
+            "[Summary: #{trace_data.count} calls | Avg Time: #{format(
+              "in %.6fms",
+              trace_data.duration,
+            )}]",
+            :bold,
+            :italic,
+            :yellow,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/log/verbose_formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class VerboseFormatter < BaseFormatter
+        include Helpers::Log::DepthHelper
+        include Helpers::Log::MethodNameHelper
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/trace_data_formatter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+require_relative "helpers"
+
+module TraceViz
+  module Formatters
+    class TraceDataFormatter < BaseFormatter
+      #
+      # General formatting methods for TraceData::Base
+      # These methods are used to format the output of the trace data
+      # based on the configuration settings.
+      #
+
+      include Helpers::IndentHelper
+      include Helpers::DepthHelper
+      include Helpers::TimeHelper
+      include Helpers::ParamsHelper
+      include Helpers::SourceHelper
+      include Helpers::ResultHelper
+      include Helpers::MethodDetailsHelper
+    end
+  end
+end

data/lib/trace_viz/helpers/config_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+
+module TraceViz
+  module Helpers
+    module ConfigHelper
+      def config
+        Context.for(:config).configuration
+      end
+
+      def fetch_general_config(key)
+        config.general[key]
+      end
+    end
+  end
+end

data/lib/trace_viz/helpers/trace_point/param_helper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Helpers
+    module TracePoint
+      module ParamHelper
+        IGNORED_VARIABLES = [
+          "__ENCODING__", "__LINE__", "__FILE__",
+        ].freeze
+
+        IGNORED_METHODS = [
+          "initialize",
+          "inspect",
+          "object_id",
+          "to_s",
+          "class",
+          "method",
+          "instance_variable_get",
+          "instance_variable_set",
+          "instance_variables",
+          "public_methods",
+          "private_methods",
+          "protected_methods",
+          "respond_to?",
+          "send",
+        ].freeze
+
+        def extract_params(binding, method_name)
+          method = fetch_method_via_instance_method(binding, method_name)
+          return {} unless method
+
+          extract_parameters_from_signature(method.parameters, binding)
+        end
+
+        def fetch_method_via_instance_method(binding, method_name)
+          klass_instance = safe_eval(binding, "self")
+          return unless klass_instance
+
+          klass = klass_instance.class
+          klass.instance_method(method_name)
+        rescue StandardError
+          # TraceViz.logger.error("Failed to fetch method #{method_name}: #{e.message}")
+          nil
+        end
+
+        def extract_parameters_from_signature(parameters, binding)
+          parameters.each_with_object({}) do |(_, name), hash|
+            next unless name
+            next if should_ignore_parameter?(name)
+
+            hash[name] = safe_local_variable_get(binding, name)
+          end
+        end
+
+        def safe_local_variable_get(binding, name)
+          binding.local_variable_get(name)
+        rescue NameError
+          # class_name = safe_eval(binding, "self.class") || "unknown class"
+          # TraceViz.logger.error("Failed to get local variable '#{name}' in #{class_name}: #{e.message}")
+          nil
+        end
+
+        def safe_eval(binding, expression)
+          binding.eval(expression)
+        rescue StandardError => e
+          TraceViz.logger.error("Failed to eval expression #{expression}: #{e.message}")
+          nil
+        end
+
+        def should_ignore_parameter?(parameter_name)
+          parameter_name_str = parameter_name.to_s
+          return true if should_ignore_variable?(parameter_name_str)
+          return true if should_ignore_method?(parameter_name_str)
+          return true if splat_parameter?(parameter_name_str)
+          return true if placeholder_parameter?(parameter_name_str)
+
+          false
+        end
+
+        def should_ignore_variable?(variable_name_str)
+          IGNORED_VARIABLES.include?(variable_name_str)
+        end
+
+        def should_ignore_method?(method_name_str)
+          IGNORED_METHODS.include?(method_name_str)
+        end
+
+        def splat_parameter?(parameter_name_str)
+          parameter_name_str.include?("*")
+        end
+
+        def placeholder_parameter?(parameter_name_str)
+          parameter_name_str.start_with?("_")
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/helpers/tracking_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+
+module TraceViz
+  module Helpers
+    module TrackingHelper
+      def tracker
+        Context.for(:tracking)
+      end
+
+      # Helper methods to access tracker attributes
+      def active_call_stack
+        tracker.active_calls
+      end
+
+      def current_call
+        tracker.current_call
+      end
+
+      def current_depth
+        tracker.current_depth
+      end
+    end
+  end
+end

data/lib/trace_viz/helpers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "helpers/config_helper"
+require_relative "helpers/tracking_helper"
+
+module TraceViz
+  module Helpers
+  end
+end

data/lib/trace_viz/logger.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "trace_viz/utils/colorize"
+
 module TraceViz
   class Logger
-    LEVELS = Defaults.action_colors.keys.freeze
+    LEVELS = Defaults::Actions.keys.freeze
 
     def initialize(output: $stdout)
       @output = output
@@ -18,11 +20,11 @@ module TraceViz
       validate_message!(message)
       validate_level!(level)
 
-      color = color_for(level)
-      emoji = emoji_for(level)
+      colors = Defaults::Actions.colors_for(level)
+      emoji = Defaults::Actions.emoji_for(level)
 
       raw_message = build_message(message, level, emoji)
-      formatted_message = wrap_in_color(raw_message, color)
+      formatted_message = apply_colors(raw_message, colors)
 
       @output.puts(formatted_message)
     end
@@ -37,27 +39,14 @@ module TraceViz
       raise ArgumentError, "Invalid log level: #{level}" unless LEVELS.include?(level)
     end
 
-    def color_for(level)
-      color_key = Defaults.action_colors.fetch(level)
-      Defaults.colors.fetch(color_key)
-    end
-
-    def default_color
-      color_for(:default)
-    end
-
-    def emoji_for(level)
-      Defaults.action_emojis.fetch(level, "")
-    end
-
     def build_message(message, level, emoji)
       level_str = level == :default ? "" : "[#{level.to_s.upcase}]"
       merged_emoji_level = "#{emoji} #{level_str}".strip
-      format("%-12s %s", merged_emoji_level, message)
+      format("%s%s", merged_emoji_level, message)
     end
 
-    def wrap_in_color(message, color)
-      "#{color}#{message}#{default_color}"
+    def apply_colors(message, colors)
+      Utils::Colorize.colorize(message, *colors)
     end
   end
 end

data/lib/trace_viz/loggers/base_logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Loggers
+    class BaseLogger
+      def initialize
+        @logger = TraceViz.logger
+      end
+
+      class << self
+        def log(*args)
+          new(*args).log
+        end
+      end
+
+      def log
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :logger
+
+      def log_message(level, message)
+        logger.send(level, message)
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/log_level_resolver.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Loggers
+    class LogLevelResolver
+      LOG_LEVELS = {
+        call: :start,
+        return: :finish,
+      }.freeze
+
+      class << self
+        def resolve(trace_data)
+          LOG_LEVELS[trace_data.event] || :info
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/logging_manager.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers"
+require_relative "trace_logger"
+require_relative "post_collection_logger"
+require_relative "trace_stats_logger"
+
+module TraceViz
+  module Loggers
+    class LoggingManager
+      include Helpers::ConfigHelper
+
+      def log_runtime_trace(trace_data)
+        return unless runtime_logging_enabled?
+
+        TraceLogger.log(trace_data)
+      end
+
+      def log_stats(collector)
+        return unless stats_logging_enabled?
+
+        TraceStatsLogger.log(collector)
+      end
+
+      def log_post_collection(collector)
+        return unless post_collection_logging_enabled?
+
+        PostCollectionLogger.log(collector)
+      end
+
+      private
+
+      def runtime_logging_enabled?
+        config.log[:enabled] && config.log[:runtime]
+      end
+
+      def post_collection_logging_enabled?
+        config.log[:enabled] && config.log[:post_collection]
+      end
+
+      def stats_logging_enabled?
+        config.log[:enabled] && config.log[:stats]
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/post_collection_logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "trace_viz/formatters/log/formatter_factory"
+require "trace_viz/renderers/renderer_builder"
+require "trace_viz/shared"
+require_relative "base_logger"
+require_relative "log_level_resolver"
+
+module TraceViz
+  module Loggers
+    class PostCollectionLogger < BaseLogger
+      include Helpers::ConfigHelper
+      include Shared::RendererHelper
+
+      def initialize(collector)
+        super()
+
+        @collector = collector
+
+        @renderer = Renderers::RendererBuilder.build(
+          collector,
+          key: fetch_general_config(:mode),
+          formatter_factory: Formatters::Log::FormatterFactory.new,
+        )
+      end
+
+      def log
+        process_lines(renderer.to_lines) { |line| log_line(line) }
+      end
+
+      private
+
+      attr_reader :collector, :renderer
+
+      def log_line(line)
+        log_message(resolve_log_level(line[:data]), line[:line])
+      end
+
+      def resolve_log_level(trace_data)
+        LogLevelResolver.resolve(trace_data)
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/trace_logger.rb

@@ -1,37 +1,33 @@
 # frozen_string_literal: true
 
-require_relative "trace_builder"
+require_relative "base_logger"
+require_relative "log_level_resolver"
+require "trace_viz/formatters/log/formatter_factory"
 
 module TraceViz
   module Loggers
-    class TraceLogger
-      LOG_LEVELS = {
-        call: :start,
-        return: :finish,
-      }.freeze
-
-      class << self
-        def log(trace_data)
-          new(trace_data).log
-        end
-      end
-
+    class TraceLogger < BaseLogger
       def initialize(trace_data)
-        @logger = TraceViz.logger
+        super()
+
         @trace_data = trace_data
+        @formatter_factory = Formatters::Log::FormatterFactory.new
       end
 
       def log
-        log_level = LOG_LEVELS[trace_data.event] || :info
-        logger.send(log_level, formatted_message)
+        log_message(log_level, formatted_message)
       end
 
       private
 
-      attr_reader :logger, :trace_data
+      attr_reader :trace_data, :formatter_factory
+
+      def log_level
+        LogLevelResolver.resolve(trace_data)
+      end
 
       def formatted_message
-        Loggers::TraceBuilder.new(trace_data).build
+        formatter_factory.fetch_formatter(trace_data.key).call(trace_data)
       end
     end
   end

data/lib/trace_viz/loggers/trace_stats_logger.rb

@@ -1,32 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "trace_builder"
+require_relative "base_logger"
 
 module TraceViz
   module Loggers
-    class TraceStatsLogger
-      class << self
-        def log(collector)
-          new(collector).log
-        end
-      end
-
+    class TraceStatsLogger < BaseLogger
       def initialize(collector)
-        @logger = TraceViz.logger
+        super()
+        @collector = collector
         @stats = collector.stats
       end
 
       def log
-        logger.stats(formatted_stats)
+        logger.stats(format_stats)
       end
 
       private
 
-      attr_reader :logger, :stats
+      attr_reader :stats
+
+      def format_stats
+        [
+          total_traces_info,
+          max_depth_info,
+          event_counts_info,
+        ].join(" | ")
+      end
+
+      def total_traces_info
+        "Total Traces: #{stats.total_traces}"
+      end
+
+      def max_depth_info
+        "Max Depth: #{stats.max_depth}"
+      end
+
+      def event_counts_info
+        "Event Counts: [#{formatted_event_counts}]"
+      end
 
-      def formatted_stats
-        event_counts = stats.event_counts.map { |event, count| "#{event.capitalize}: #{count}" }.join(", ")
-        "Total Traces: #{stats.total_traces} | Max Depth: #{stats.max_depth} | Event Counts: [#{event_counts}]"
+      def formatted_event_counts
+        stats.event_counts.map { |event, count| "#{event.capitalize}: #{count}" }.join(", ")
       end
     end
   end