trace_viz 0.0.2 → 1.0.0

data/lib/trace_viz/formatters/helpers/log/summary/params_helper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/format_utils"
+
+module TraceViz
+  module Formatters
+    module Helpers
+      module Log
+        module Summary
+          module ParamsHelper
+            def format_params_template(trace_data, config)
+              return unless config.params[:show]
+
+              params = prepare_params(trace_data.params, config)
+              wrap_params(params, config)
+            end
+
+            private
+
+            def prepare_params(params, config)
+              params
+                .then { |p| truncate_values(p, config.params[:truncate_values]) }
+                .then { |p| colorize_keys_and_values(p) }
+                .then { |p| format_as_string(p, config.params[:mode]) }
+            end
+
+            def truncate_values(params, length)
+              return params unless length
+
+              params.transform_values { |value| Utils::FormatUtils.truncate_value(value, length) }
+            end
+
+            def colorize_keys_and_values(params)
+              params.transform_keys { |key| colorize_for(key.to_s, :trace_params_key) }
+                .transform_values { |value| colorize("<#{value.class}>", :yellow) }
+            end
+
+            def format_as_string(params, mode)
+              Utils::FormatUtils.format_key_value_pairs(params, mode)
+            end
+
+            def wrap_params(params_string, config)
+              return unless params_string
+
+              truncated = Utils::FormatUtils.truncate_value(params_string, config.params[:truncate_length])
+              "(#{truncated})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module TraceViz
   module Formatters
     module Helpers
       module MethodDetailsHelper
-        def method_name_representation
+        def method_name_representation(trace_data)
           return unless config.general[:show_method_name]
 
           "#{trace_data.klass}##{trace_data.action}"

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

@@ -6,19 +6,36 @@ module TraceViz
   module Formatters
     module Helpers
       module ParamsHelper
-        def params_representation
+        def params_representation(trace_data)
           return unless config.params[:show]
 
-          truncated_params = trace_data.params.transform_values do |value|
-            Utils::FormatUtils.truncate_value(value, config.params[:truncate_values])
-          end
+          params = process_params(trace_data.params, config)
+          wrap_params_string(params, config)
+        end
+
+        private
+
+        def process_params(params, config)
+          params
+            .then { |p| truncate_param_values(p, config.params[:truncate_values]) }
+            .then { |p| stringify_params(p, config.params[:mode]) }
+        end
+
+        def truncate_param_values(params, max_length)
+          return params unless max_length
+
+          params.transform_values { |value| Utils::FormatUtils.truncate_value(value, max_length) }
+        end
+
+        def stringify_params(params, mode)
+          Utils::FormatUtils.format_key_value_pairs(params, mode)
+        end
 
-          formatted_values = Utils::FormatUtils.format_key_value_pairs(
-            truncated_params,
-            config.params[:mode],
-          )
+        def wrap_params_string(params_string, config)
+          return unless params_string
 
-          "(#{formatted_values})"
+          truncated_string = Utils::FormatUtils.truncate_value(params_string, config.params[:truncate_length])
+          "(#{truncated_string})"
         end
       end
     end

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

@@ -6,7 +6,7 @@ module TraceViz
   module Formatters
     module Helpers
       module ResultHelper
-        def result_representation
+        def result_representation(trace_data)
           return unless config.result[:show]
 
           truncated_result = Utils::FormatUtils.truncate_value(

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

@@ -6,12 +6,13 @@ module TraceViz
   module Formatters
     module Helpers
       module SourceHelper
-        def source_location_representation
+        def source_location_representation(trace_data)
           return unless config.source_location[:show]
 
           truncated_path = Utils::FormatUtils.truncate_value(
             trace_data.path,
             config.source_location[:truncate_length],
+            direction: :start,
           )
           "at #{truncated_path}:#{trace_data.line_number}"
         end

data/lib/trace_viz/formatters/helpers/summary/params_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/format_utils"
+
+module TraceViz
+  module Formatters
+    module Helpers
+      module Summary
+        module ParamsHelper
+          def format_params_template(trace_data, config)
+            return unless config.params[:show]
+
+            params_template = build_params_template(trace_data.params, config)
+            wrap_params_template(params_template, config)
+          end
+
+          private
+
+          def build_params_template(params, config)
+            params.transform_values do |value|
+              "<#{value.class}>"
+            end.then do |formatted_params|
+              format_as_string(formatted_params, config.params[:mode])
+            end
+          end
+
+          def format_as_string(params, mode)
+            Utils::FormatUtils.format_key_value_pairs(params, mode)
+          end
+
+          def wrap_params_template(params_string, config)
+            return unless params_string
+
+            truncated = Utils::FormatUtils.truncate_value(params_string, config.params[:truncate_length])
+            "(#{truncated})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/formatters/helpers/summary/source_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "trace_viz/utils/format_utils"
+
+module TraceViz
+  module Formatters
+    module Helpers
+      module Summary
+        module SourceHelper
+          def source_location_representation(trace_data)
+            return unless config.source_location[:show]
+
+            truncated_path = Utils::FormatUtils.truncate_value(
+              trace_data.path,
+              config.source_location[:truncate_length],
+              direction: :start,
+            )
+            "at #{truncated_path}"
+          end
+        end
+      end
+    end
+  end
+end

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,27 @@
+# frozen_string_literal: true
+
+require_relative "method_call_formatter"
+require_relative "method_return_formatter"
+require_relative "summary_group_formatter"
+
+module TraceViz
+  module Formatters
+    module Log
+      class FormatterFactory
+        FORMATTERS = {
+          call: MethodCallFormatter.new,
+          return: MethodReturnFormatter.new,
+          summary_group: SummaryGroupFormatter.new,
+        }.freeze
+
+        class << self
+          def fetch_formatter(key)
+            FORMATTERS.fetch(key) do
+              raise ArgumentError, "Unsupported factory key: #{key}"
+            end
+          end
+        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.average_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,13 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+
+module TraceViz
+  module Helpers
+    module ConfigHelper
+      def config
+        Context.for(:config).configuration
+      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