trace_viz 0.0.2 → 1.0.0

data/lib/trace_viz/collectors/steps/linking_step.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "trace_viz/context"
+require_relative "base_step"
+
+module TraceViz
+  module Collectors
+    module Steps
+      class LinkingStep < BaseStep
+        def call(trace_data)
+          valid?(trace_data) ? linking_trace(trace_data) : trace_data
+        rescue StandardError => e
+          logger.error("Linking failed for trace_data ID: #{trace_data.id} - #{e.message}")
+          nil
+        end
+
+        private
+
+        def valid?(trace_data)
+          return false unless current_call
+
+          [
+            trace_data.event == :return,
+            current_call.event == :call,
+            trace_data.action_id == current_call.action_id,
+          ].all?
+        end
+
+        def linking_trace(trace_data)
+          trace_data.link(current_call)
+          trace_data
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/{evaluators/filter_evaluator.rb → steps/validation_step.rb}

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
 require "trace_viz/collectors/filters/registry"
-require_relative "base_evaluator"
+require_relative "base_step"
 
 module TraceViz
   module Collectors
-    module Evaluators
-      class FilterEvaluator < BaseEvaluator
+    module Steps
+      class ValidationStep < BaseStep
         def initialize
           super()
-
           @filters = build_filters.freeze
         end
 
-        def pass?(trace_data)
-          filters.all? { |filter| filter.apply?(trace_data) }
+        def call(trace_data)
+          trace_data if pass?(trace_data)
         end
 
         private
 
         attr_reader :filters
 
+        def pass?(trace_data)
+          filters.all? { |filter| filter.apply?(trace_data) }
+        end
+
         def build_filters
           Collectors::Filters::Registry.build(config.filters)
         end

data/lib/trace_viz/collectors/steps.rb

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

data/lib/trace_viz/collectors/trace_pipeline.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Collectors
+    class TracePipeline
+      def initialize
+        @steps = []
+      end
+
+      def add_step(step)
+        @steps << step
+      end
+
+      def process(trace_data)
+        @steps.each do |step|
+          trace_data = step.call(trace_data)
+          return nil unless trace_data
+        end
+        trace_data
+      rescue StandardError => e
+        TraceViz.logger.error("Pipeline processing failed for trace_data ID: #{trace_data.id} - #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_pipeline_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "trace_pipeline"
+require_relative "steps"
+
+module TraceViz
+  module Collectors
+    class TracePipelineBuilder
+      class << self
+        def build
+          TracePipeline.new.tap do |pipeline|
+            pipeline.add_step(Steps::ValidationStep.new)
+
+            #
+            # Those actions require access to the current call,
+            # so it needs to be run before current call is updated
+            #
+            pipeline.add_step(Steps::BuildHierarchyStep.new)
+            pipeline.add_step(Steps::LinkingStep.new)
+
+            pipeline.add_step(Steps::AssignDepthForCallStep.new)
+            pipeline.add_step(Steps::AssignDepthForReturnStep.new)
+            pipeline.add_step(Steps::HiddenStep.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/collectors/trace_point_collector.rb

@@ -4,8 +4,6 @@ require "trace_viz/trace_data/trace_point_builder"
 require_relative "base_collector"
 require_relative "matchers/trace_point_action_matcher"
 require_relative "matchers/within_depth_matcher"
-require_relative "depth_manager"
-require_relative "trace_stats"
 
 module TraceViz
   module Collectors
@@ -21,7 +19,7 @@ module TraceViz
 
       attr_reader :action_matcher, :within_depth_matcher
 
-      def collectible?(trace_point)
+      def can_collect?(trace_point)
         within_depth? || match_action?(trace_point)
       end
 
@@ -29,10 +27,6 @@ module TraceViz
         TraceData::TracePointBuilder.build(trace_point)
       end
 
-      def update_trace_depth(trace_data)
-        depth_manager.align(trace_data)
-      end
-
       def match_action?(trace_point)
         action_matcher.matches?(trace_point)
       end
@@ -42,10 +36,6 @@ module TraceViz
 
         within_depth_matcher.matches?(depth)
       end
-
-      def depth_manager
-        @depth_manager ||= DepthManager.new
-      end
     end
   end
 end

data/lib/trace_viz/config/validator.rb

@@ -27,8 +27,9 @@ module TraceViz
 
       def validate_params(value)
         mode = value[:mode]
-        unless Defaults.valid_param_modes.include?(mode)
-          raise ArgumentError, "Invalid param mode: #{mode}. Valid modes are #{Defaults.valid_param_modes.join(", ")}."
+        unless Defaults::Config.valid_param_mode?(mode)
+          raise ArgumentError,
+            "Invalid param mode: #{mode}. Valid modes are #{Defaults::Config.valid_param_modes.join(", ")}."
         end
 
         if value[:truncate_values] && (!value[:truncate_values].is_a?(Integer) || value[:truncate_values] <= 0)
@@ -37,7 +38,7 @@ module TraceViz
       end
 
       def validate_result(value)
-        if value[:truncate_length] && (!value[:truncate_length].is_a?(Integer) || value[:truncate_length] <= 0)
+        if value[:truncate_length] && !value[:truncate_length].is_a?(Integer)
           raise ArgumentError, "Truncate values must be a positive integer."
         end
       end
@@ -64,9 +65,9 @@ module TraceViz
         end
 
         format = value[:format]
-        unless Defaults.valid_export_formats.include?(format)
+        unless Defaults::Config.valid_export_format?(format)
           raise ArgumentError,
-            "Invalid export format: #{format}. Valid formats are #{Defaults.valid_export_formats.join(", ")}."
+            "Invalid export format: #{format}. Valid formats are #{Defaults::Config.valid_export_formats.join(", ")}."
         end
       end
     end

data/lib/trace_viz/configuration.rb

@@ -7,12 +7,12 @@ require "trace_viz/config/copier"
 module TraceViz
   class Configuration
     attr_reader :logger, :settings
-    attr_reader(*Defaults.fetch_defaults.keys)
+    attr_reader(*Defaults::Config.fetch.keys)
 
     def initialize
       @logger = Logger.new
       @validator = Config::Validator.new
-      @settings = Defaults.fetch_defaults
+      @settings = Defaults::Config.fetch
       define_dynamic_accessors
     end
 
@@ -32,7 +32,7 @@ module TraceViz
     end
 
     def reset_defaults
-      @settings = Defaults.fetch_defaults
+      @settings = Defaults::Config.fetch
     end
 
     def dup

data/lib/trace_viz/context/tracking_context.rb

@@ -15,6 +15,10 @@ module TraceViz
         @active_calls = Tracking::ActiveCalls.new
       end
 
+      def current_call
+        active_calls.current
+      end
+
       def current_depth
         active_calls.size
       end

data/lib/trace_viz/core/tracer.rb

@@ -10,6 +10,8 @@ module TraceViz
   module Core
     class Tracer
       def trace(**options, &block)
+        Defaults::Themes.apply_solarized_theme
+
         Context::Manager.with_contexts(config: options, tracking: {}) do
           adapter = Adapters::TracePointAdapter.new
           adapter.trace(&block)

data/lib/trace_viz/defaults/actions.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Actions
+      EMOJIS = {
+        default: "",
+        info: "ℹ️",
+        success: "✅",
+        error: "❌",
+        warn: "⚠️",
+        start: "🚀",
+        processing: "🔄",
+        finish: "🏁",
+        exported: "📤",
+        skipped: "⏩",
+        stats: "📊",
+      }.freeze
+
+      COLORS = {
+        # Default actions
+        default: :reset,
+        info: :cyan,
+        success: :green,
+        error: :bright_red,
+        warn: :yellow,
+
+        # Processing actions
+        start: :bright_cyan,
+        processing: [:dim, :bright_white],
+        finish: :bright_magenta,
+
+        # Export & stats actions
+        exported: :bright_green,
+        skipped: :bright_white,
+        stats: [:bold, :underline, :bright_white],
+
+        # Trace data actions
+        trace_indent: :dim,
+        trace_depth: :blue,
+        trace_depth_prefix: [:dim, :italic, :blue],
+        trace_depth_open: [:dim, :bright_blue],
+        trace_depth_value: :bright_red,
+        trace_depth_close: [:dim, :bright_blue],
+        trace_method_name: :bright_cyan,
+        trace_method_class: :bright_green,
+        trace_method_sign: :blue,
+        trace_method_action: [:bold, :bright_cyan],
+        trace_source_location: [:dim, :bright_white],
+        trace_params_key: :bright_yellow,
+        trace_params_value: [:dim, :bright_yellow],
+        trace_result_prefix: [:italic, :bright_blue],
+        trace_result_value: :bright_white,
+        trace_execution_time: [:dim, :bright_red],
+      }.freeze
+
+      class << self
+        def emojis
+          EMOJIS
+        end
+
+        def colors
+          COLORS
+        end
+
+        def keys
+          colors.keys
+        end
+
+        def emoji_for(action)
+          EMOJIS.fetch(action, EMOJIS[:default])
+        end
+
+        def source_colors
+          Defaults.action_colors || COLORS
+        end
+
+        def colors_for(action)
+          Array(source_colors.fetch(action, source_colors[:default]))
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/defaults/colors.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Colors
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        italic: "\e[3m",
+        underline: "\e[4m",
+        reverse: "\e[7m",
+        hidden: "\e[8m",
+        strikethrough: "\e[9m",
+      }
+
+      # Reference ASCII color codes
+      # https://talyian.github.io/ansicolors/
+
+      # Map 256-color ANSI codes
+      (0..255).each do |i|
+        COLORS["color_#{i}".to_sym] = "\e[38;5;#{i}m"
+      end
+
+      # To add background colors
+      (0..255).each do |i|
+        COLORS["bg_color_#{i}".to_sym] = "\e[48;5;#{i}m"
+      end
+
+      # Predefined names
+      COLORS.merge!({
+        black: "\e[30m",
+        red: "\e[31m",
+        green: "\e[32m",
+        yellow: "\e[33m",
+        blue: "\e[34m",
+        magenta: "\e[35m",
+        cyan: "\e[36m",
+        white: "\e[37m",
+        bright_black: "\e[90m",
+        bright_red: "\e[91m",
+        bright_green: "\e[92m",
+        bright_yellow: "\e[93m",
+        bright_blue: "\e[94m",
+        bright_magenta: "\e[95m",
+        bright_cyan: "\e[96m",
+        bright_white: "\e[97m",
+      })
+
+      class << self
+        def all
+          COLORS
+        end
+
+        def fetch(color)
+          COLORS.fetch(color, COLORS[:reset])
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/defaults/config.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Config
+      DEFAULTS = {
+        general: {
+          tab_size: 2,
+          mode: :summary, # :summary, :verbose
+          group_keys: [:event, :klass, :action],
+          show_indent: true,
+          show_depth: true,
+          max_display_depth: 3,
+          show_method_name: true,
+        },
+        source_location: {
+          show: false,
+          truncate_length: 100,
+        },
+        params: {
+          show: true,
+          mode: :name_and_value,
+          truncate_values: 10,
+        },
+        result: {
+          show: true,
+          truncate_length: 50,
+        },
+        execution: {
+          show_time: true,
+          show_trace_events: [:call, :return],
+        },
+        filters: [
+          :exclude_internal_call,
+          # :exclude_default_classes,
+          # :exclude_rails_framework,
+          # include_classes: {
+          #   classes: [],
+          # },
+          # exclude_classes: {
+          #   classes: [],
+          # },
+          # include_gems: {
+          #   app_running: true,
+          #   app_path: Dir.pwd,
+          #   gems: [],
+          # },
+          # exclude_gems: {
+          #   gems: [],
+          # },
+        ],
+        log: {
+          enabled: true,
+          runtime: false,
+          post_collection: true,
+          stats: true,
+        },
+        export: {
+          enabled: true,
+          path: "tmp",
+          format: :txt,
+          overwrite: false,
+        },
+      }.freeze
+
+      class << self
+        def fetch
+          DEFAULTS.dup
+        end
+
+        def valid_param_modes
+          [:name_and_value, :name_only, :value_only].freeze
+        end
+
+        def valid_param_mode?(mode)
+          valid_param_modes.include?(mode)
+        end
+
+        def valid_export_formats
+          [:txt, :json, :yaml].freeze
+        end
+
+        def valid_export_format?(format)
+          valid_export_formats.include?(format)
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/defaults/themes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Defaults
+    class Themes
+      SOLARIZED = {
+        base03: :color_234,
+        base02: :color_235,
+        base01: :color_240,
+        base00: :color_241,
+        base0: :color_244,
+        base1: :color_245,
+        base2: :color_254,
+        base3: :color_230,
+        yellow: :color_136,
+        orange: :color_166,
+        red: :color_160,
+        magenta: :color_125,
+        violet: :color_61,
+        blue: :color_33,
+        cyan: :color_37,
+        green: :color_64,
+      }.freeze
+
+      class << self
+        def solarized
+          SOLARIZED
+        end
+
+        def apply_solarized_theme
+          colors = {
+            default: SOLARIZED[:base0],
+            info: SOLARIZED[:blue],
+            success: SOLARIZED[:green],
+            error: SOLARIZED[:red],
+            warn: SOLARIZED[:yellow],
+            start: SOLARIZED[:blue],
+            processing: SOLARIZED[:base01],
+            finish: SOLARIZED[:magenta],
+            exported: SOLARIZED[:green],
+            skipped: SOLARIZED[:base01],
+            stats: [:bold, :underline, SOLARIZED[:base2]],
+            trace_indent: SOLARIZED[:base03],
+            trace_depth: SOLARIZED[:blue],
+            trace_depth_prefix: [:italic, SOLARIZED[:base02]],
+            trace_depth_open: SOLARIZED[:base02],
+            trace_depth_value: SOLARIZED[:red],
+            trace_depth_close: SOLARIZED[:base03],
+            trace_method_name: SOLARIZED[:cyan],
+            trace_method_class: [:bold, SOLARIZED[:green]],
+            trace_method_sign: SOLARIZED[:violet],
+            trace_method_action: [:bold, SOLARIZED[:blue]],
+            trace_source_location: SOLARIZED[:base01],
+            trace_params_key: SOLARIZED[:orange],
+            trace_params_value: SOLARIZED[:base00],
+            trace_result_prefix: SOLARIZED[:base1],
+            trace_result_value: SOLARIZED[:base3],
+            trace_execution_time: SOLARIZED[:cyan],
+          }
+
+          Defaults.action_colors = colors
+        end
+      end
+    end
+  end
+end