trace_viz 0.0.1 → 1.0.0

data/lib/trace_viz/logger.rb

@@ -1,73 +1,52 @@
 # frozen_string_literal: true
 
+require "trace_viz/utils/colorize"
+
 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
+    LEVELS = Defaults::Actions.keys.freeze
 
     def initialize(output: $stdout)
       @output = output
     end
 
-    def info(message)
-      log(:info, message)
+    LEVELS.each do |level|
+      define_method(level) do |message|
+        log(message, level)
+      end
     end
 
-    def success(message)
-      log(:success, message)
-    end
+    def log(message, level = :default)
+      validate_message!(message)
+      validate_level!(level)
 
-    def error(message)
-      log(:error, message)
-    end
+      colors = Defaults::Actions.colors_for(level)
+      emoji = Defaults::Actions.emoji_for(level)
 
-    def warn(message)
-      log(:warn, message)
-    end
+      raw_message = build_message(message, level, emoji)
+      formatted_message = apply_colors(raw_message, colors)
 
-    def start(message)
-      log(:start, message)
-    end
-
-    def finish(message)
-      log(:finish, message)
+      @output.puts(formatted_message)
     end
 
     private
 
-    def log(level, message)
-      return unless LEVELS.include?(level)
+    def validate_message!(message)
+      raise ArgumentError, "Message must be a String" unless message.is_a?(String)
+    end
 
-      color = COLORS[level] || COLORS[:info]
-      emoji = EMOJIS[level] || EMOJIS[:info]
+    def validate_level!(level)
+      raise ArgumentError, "Invalid log level: #{level}" unless LEVELS.include?(level)
+    end
 
-      # Align emoji and level using fixed-width columns
-      formatted_message = format(
-        "#{color}%-3s %-8s#{COLORS[:reset]} %s",
-        emoji,
-        "[#{level.to_s.upcase}]",
-        message,
-      )
+    def build_message(message, level, emoji)
+      level_str = level == :default ? "" : "[#{level.to_s.upcase}]"
+      merged_emoji_level = "#{emoji} #{level_str}".strip
+      format("%s%s", merged_emoji_level, message)
+    end
 
-      @output.puts(formatted_message)
+    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,39 @@
+# frozen_string_literal: true
+
+require "trace_viz/formatters/log/formatter_factory"
+require "trace_viz/shared"
+require_relative "base_logger"
+require_relative "log_level_resolver"
+
+module TraceViz
+  module Loggers
+    class PostCollectionLogger < BaseLogger
+      include Shared::RendererHelper
+
+      def initialize(collector)
+        super()
+
+        @collector = collector
+        @renderer = build_renderer(collector, Formatters::Log::FormatterFactory)
+      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[:trace_data]), line[:line])
+
+        process_lines(line[:nested_lines]) { |nested| log_line(nested) }
+      end
+
+      def resolve_log_level(trace_data)
+        LogLevelResolver.resolve(trace_data)
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/trace_logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base_logger"
+require_relative "log_level_resolver"
+require "trace_viz/formatters/log/formatter_factory"
+
+module TraceViz
+  module Loggers
+    class TraceLogger < BaseLogger
+      def initialize(trace_data)
+        super()
+
+        @trace_data = trace_data
+      end
+
+      def log
+        log_message(log_level, formatted_message)
+      end
+
+      private
+
+      attr_reader :trace_data
+
+      def log_level
+        LogLevelResolver.resolve(trace_data)
+      end
+
+      def formatted_message
+        fetch_formatter(trace_data).call(trace_data)
+      end
+
+      def fetch_formatter(trace_data)
+        Formatters::Log::FormatterFactory.fetch_formatter(trace_data.event)
+      end
+    end
+  end
+end

data/lib/trace_viz/loggers/trace_stats_logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base_logger"
+
+module TraceViz
+  module Loggers
+    class TraceStatsLogger < BaseLogger
+      def initialize(collector)
+        super()
+        @collector = collector
+        @stats = collector.stats
+      end
+
+      def log
+        logger.stats(format_stats)
+      end
+
+      private
+
+      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_event_counts
+        stats.event_counts.map { |event, count| "#{event.capitalize}: #{count}" }.join(", ")
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/base_renderer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Renderers
+    class BaseRenderer
+      def initialize(data, context:)
+        @data = data
+        @context = context
+      end
+
+      def render
+        to_lines.map { |line| line[:line] }.join("\n")
+      end
+
+      def to_lines
+        []
+      end
+
+      private
+
+      attr_reader :data, :context
+    end
+  end
+end

data/lib/trace_viz/renderers/render_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Renderers
+    class RenderContext
+      attr_reader :formatter_factory, :group_keys
+
+      def initialize(formatter_factory:, group_keys: [])
+        @formatter_factory = formatter_factory
+        @group_keys = group_keys
+      end
+
+      def fetch_formatter(key)
+        formatter_factory.fetch_formatter(key)
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/renderer_factory.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "verbose_renderer"
+require_relative "summary_renderer"
+
+module TraceViz
+  module Renderers
+    class RendererFactory
+      RENDERERS = {
+        verbose: VerboseRenderer,
+        summary: SummaryRenderer,
+      }.freeze
+
+      class << self
+        def build(mode, collector, context:)
+          renderer_class = fetch_renderer_class(mode)
+          renderer_class.new(determine_input(mode, collector), context: context)
+        end
+
+        private
+
+        def fetch_renderer_class(mode)
+          RENDERERS.fetch(mode) do
+            raise ArgumentError, "Unknown mode: #{mode}. Valid modes are: #{RENDERERS.keys.join(", ")}"
+          end
+        end
+
+        def determine_input(mode, collector)
+          case mode
+          when :verbose
+            collector.collection
+          when :summary
+            collector.hierarchy.root
+          else
+            raise ArgumentError, "Invalid mode for input determination: #{mode}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/summary/node_processor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "trace_viz/trace_data/summary_node"
+
+module TraceViz
+  module Renderers
+    class NodeProcessor
+      def initialize(nodes, context)
+        @nodes = nodes
+        @context = context
+      end
+
+      def process
+        grouped_nodes.flat_map { |key, group| render_node_or_group(key, group) }
+      end
+
+      private
+
+      attr_reader :nodes, :context
+
+      def grouped_nodes
+        nodes.group_by { |node| node_key(node) }
+      end
+
+      def group_keys
+        context.group_keys
+      end
+
+      def node_key(node)
+        group_keys.map { |key| fetch_node_attribute(node, key) }
+      end
+
+      def fetch_node_attribute(node, key)
+        node.respond_to?(key) ? node.public_send(key) : nil
+      end
+
+      def render_node_or_group(key, group)
+        if group.size > 1
+          render_group(key, group)
+        else
+          render_single_node(group.first)
+        end
+      end
+
+      def render_group(key, group)
+        representative_node = group.first
+        nested_lines = process_nested_nodes(representative_node)
+
+        [{
+          line: format_group_line(group),
+          trace_data: representative_node,
+          nested_lines: nested_lines,
+        }]
+      end
+
+      def render_single_node(node)
+        current_line = {
+          line: format_node(node),
+          trace_data: node,
+          nested_lines: process_nested_nodes(node),
+        }
+
+        [current_line]
+      end
+
+      def process_nested_nodes(node)
+        return [] unless node.respond_to?(:children) && node.children.any?
+
+        NodeProcessor.new(node.children, context).process
+      end
+
+      def format_node(node)
+        context.fetch_formatter(node.event).call(node)
+      end
+
+      def format_group_line(group)
+        node = TraceData::SummaryNode.new(group: group)
+        context.fetch_formatter(:summary_group).call(node)
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/summary_renderer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base_renderer"
+require_relative "summary/node_processor"
+
+module TraceViz
+  module Renderers
+    class SummaryRenderer < BaseRenderer
+      def to_lines
+        return [] unless valid_children?(data)
+
+        NodeProcessor.new(data.children, context).process
+      end
+
+      private
+
+      def valid_children?(node)
+        node.respond_to?(:children) && node.children.any?
+      end
+    end
+  end
+end

data/lib/trace_viz/renderers/verbose_renderer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_renderer"
+require "trace_viz/formatters/log/formatter_factory"
+
+module TraceViz
+  module Renderers
+    class VerboseRenderer < BaseRenderer
+      def to_lines
+        traverse_data(data)
+      end
+
+      private
+
+      def traverse_data(data)
+        data.map do |trace_data|
+          {
+            line: format_for(trace_data),
+            trace_data: trace_data,
+          }
+        end
+      end
+
+      def format_for(trace_data)
+        context.fetch_formatter(trace_data.event).call(trace_data)
+      end
+    end
+  end
+end

data/lib/trace_viz/shared/renderer_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "trace_viz/renderers/renderer_factory"
+require "trace_viz/renderers/render_context"
+require "trace_viz/formatters/export/formatter_factory"
+require "trace_viz/formatters/log/formatter_factory"
+
+module TraceViz
+  module Shared
+    module RendererHelper
+      def build_renderer(collector, formatter_factory)
+        raise ArgumentError, "Collector cannot be nil" unless collector
+        raise ArgumentError, "FormatterFactory cannot be nil" unless formatter_factory
+
+        mode = fetch_config(collector, :mode)
+        group_keys = fetch_config(collector, :group_keys)
+
+        context = Renderers::RenderContext.new(
+          formatter_factory: formatter_factory,
+          group_keys: group_keys,
+        )
+        Renderers::RendererFactory.build(mode, collector, context: context)
+      end
+
+      def process_lines(lines, &block)
+        return [] unless lines.is_a?(Array)
+
+        lines.map do |line|
+          validate_line_structure!(line)
+          block.call(line)
+        end.compact
+      end
+
+      private
+
+      def fetch_config(collector, key)
+        collector.config.general[key]
+      end
+
+      def validate_line_structure!(line)
+        raise ArgumentError, "Line must be a Hash" unless line.is_a?(Hash)
+        raise KeyError, "Line must include a :line key" unless line.key?(:line)
+      end
+    end
+  end
+end

data/lib/trace_viz/shared.rb

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

data/lib/trace_viz/trace_data/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "trace_viz/helpers"
+require "trace_viz/traits"
+
+module TraceViz
+  module TraceData
+    class Base
+      include Helpers::ConfigHelper
+      include Traits::DepthTrackable
+      include Traits::TimeTrackable
+
+      def initialize
+        assign_depth(0)
+        record_timestamp
+      end
+
+      def event
+        raise NotImplementedError
+      end
+
+      def klass
+        raise NotImplementedError
+      end
+
+      def action
+        raise NotImplementedError
+      end
+
+      def path
+        raise NotImplementedError
+      end
+
+      def line_number
+        raise NotImplementedError
+      end
+
+      def to_h
+        {
+          event: event,
+          klass: klass,
+          action: action,
+          path: path,
+          line_number: line_number,
+        }
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/node.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module TraceViz
+  module TraceData
+    class Node < Base
+      attr_accessor :parent
+      attr_reader :children
+
+      def initialize
+        super()
+
+        @parent = nil
+        @children = []
+      end
+
+      def add_child(child)
+        child.parent = self
+        @children << child
+      end
+
+      def to_h
+        super.merge(
+          {
+            parent: parent&.to_s,
+            children: children.map(&:to_h),
+          },
+        )
+      end
+    end
+  end
+end