trace_viz 0.0.2 → 1.0.0

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

@@ -1,37 +1,36 @@
 # 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
       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
+
+      def log_level
+        LogLevelResolver.resolve(trace_data)
+      end
 
       def formatted_message
-        Loggers::TraceBuilder.new(trace_data).build
+        fetch_formatter(trace_data).call(trace_data)
+      end
+
+      def fetch_formatter(trace_data)
+        Formatters::Log::FormatterFactory.fetch_formatter(trace_data.event)
       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

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

@@ -1,28 +1,25 @@
 # frozen_string_literal: true
 
-require "trace_viz/context"
+require "trace_viz/helpers"
+require "trace_viz/traits"
 
 module TraceViz
   module TraceData
     class Base
-      attr_reader :config,
-        :timestamp
-      attr_accessor :depth
+      include Helpers::ConfigHelper
+      include Traits::DepthTrackable
+      include Traits::TimeTrackable
 
       def initialize
-        @config = Context.for(:config).configuration
-
-        @depth = 0
+        assign_depth(0)
         record_timestamp
       end
 
-      # Unique ID for each individual event
-      def id
+      def event
         raise NotImplementedError
       end
 
-      # Shared ID betweem events for the same method call
-      def action_id
+      def klass
         raise NotImplementedError
       end
 
@@ -30,10 +27,6 @@ module TraceViz
         raise NotImplementedError
       end
 
-      def event
-        raise NotImplementedError
-      end
-
       def path
         raise NotImplementedError
       end
@@ -42,14 +35,14 @@ module TraceViz
         raise NotImplementedError
       end
 
-      def klass
-        raise NotImplementedError
-      end
-
-      private
-
-      def record_timestamp
-        @timestamp = Time.now
+      def to_h
+        {
+          event: event,
+          klass: klass,
+          action: action,
+          path: path,
+          line_number: line_number,
+        }
       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

data/lib/trace_viz/trace_data/root_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class RootNode < Node
+      def initialize
+        super()
+
+        # Explicitly ensure no parent for root
+        @parent = nil
+      end
+
+      def parent=(_parent)
+        raise NoMethodError, "RootNode cannot have a parent"
+      end
+    end
+  end
+end

data/lib/trace_viz/trace_data/summary_node.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module TraceViz
+  module TraceData
+    class SummaryNode < Node
+      attr_reader :group, :count, :representative_node, :event, :klass, :action, :path, :params, :result
+
+      def initialize(group:)
+        super()
+
+        @group = group
+        @count = group.size
+
+        @representative_node = group.first
+        @depth = representative_node.depth
+        @event = representative_node.event
+        @klass = representative_node.klass
+        @path = representative_node.path
+        @action = representative_node.action
+
+        # Representative node is the first node in the group belonging to MethodCall
+        @params = representative_node.params
+        @result = representative_node.method_return.result
+
+        add_children(representative_node.children)
+      end
+
+      def average_duration
+        return 0 if count.zero?
+
+        total_duration / count
+      end
+
+      def total_duration
+        children.map(&:duration).sum
+      end
+
+      private
+
+      def add_children(nodes)
+        nodes.each do |node|
+          add_child(node)
+        end
+      end
+    end
+  end
+end