trace_viz 0.0.1 → 0.0.2

data/lib/trace_viz/config/copier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Config
+    class Copier
+      def initialize(configuration)
+        @origin_configuration = configuration
+        @settings = origin_configuration.settings
+      end
+
+      def copy
+        copied_settings = deep_copy(settings)
+        copy = origin_configuration.class.new
+        copied_settings.each { |key, value| copy.update(key, value) }
+        copy
+      end
+
+      private
+
+      attr_reader :origin_configuration, :settings
+
+      def deep_copy(value)
+        case value
+        when Hash
+          value.transform_values { |v| deep_copy(v) }
+        when Array
+          value.map { |v| deep_copy(v) }
+        else
+          begin
+            value.dup
+          rescue TypeError
+            value # Return immutable objects as-is
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/config/validator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "trace_viz/collectors/filters/registry"
+
+module TraceViz
+  module Config
+    class Validator
+      FILTER_KEYS = Collectors::Filters::Registry::FILTERS.keys.freeze
+
+      def initialize
+        @validations = {
+          params: ->(value) { validate_params(value) },
+          result: ->(value) { validate_result(value) },
+          source_location: ->(value) { validate_source_location(value) },
+          filters: ->(value) { validate_filters(value) },
+          export: ->(value) { validate_export(value) },
+        }
+      end
+
+      def validate(group, value)
+        return unless @validations.key?(group)
+
+        @validations[group].call(value)
+      end
+
+      private
+
+      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(", ")}."
+        end
+
+        if value[:truncate_values] && (!value[:truncate_values].is_a?(Integer) || value[:truncate_values] <= 0)
+          raise ArgumentError, "Truncate values must be a positive integer."
+        end
+      end
+
+      def validate_result(value)
+        if value[:truncate_length] && (!value[:truncate_length].is_a?(Integer) || value[:truncate_length] <= 0)
+          raise ArgumentError, "Truncate values must be a positive integer."
+        end
+      end
+
+      def validate_source_location(value)
+        if value[:truncate_length] && (!value[:truncate_length].is_a?(Integer) || value[:truncate_length] <= 0)
+          raise ArgumentError, "Truncate length for source_location must be a positive integer."
+        end
+
+        if value[:filter_paths] && !value[:filter_paths].all? { |path| path.is_a?(Regexp) }
+          raise ArgumentError, "All filter paths must be regular expressions."
+        end
+      end
+
+      def validate_filters(filters)
+        unless filters.is_a?(Array)
+          raise ArgumentError, "Filters must be an array. Received: #{filters.class.name}"
+        end
+      end
+
+      def validate_export(value)
+        unless value.is_a?(Hash)
+          raise ArgumentError, "Export configuration must be a hash."
+        end
+
+        format = value[:format]
+        unless Defaults.valid_export_formats.include?(format)
+          raise ArgumentError,
+            "Invalid export format: #{format}. Valid formats are #{Defaults.valid_export_formats.join(", ")}."
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/configuration.rb

@@ -1,47 +1,53 @@
 # frozen_string_literal: true
 
 require "trace_viz/logger"
+require "trace_viz/config/validator"
+require "trace_viz/config/copier"
 
 module TraceViz
   class Configuration
-    attr_accessor :logger,
-      :tab_size,
-      :show_indent,
-      :show_depth,
-      :max_display_depth,
-      :show_method_name,
-      :show_source_location,
-      :show_params,
-      :show_return_value,
-      :show_execution_time,
-      :show_trace_events
+    attr_reader :logger, :settings
+    attr_reader(*Defaults.fetch_defaults.keys)
 
     def initialize
       @logger = Logger.new
-      @tab_size = 2
-      @show_indent = true
-      @show_depth = true
-      @max_display_depth = 3 # Recommended to keep this value between 3 and 5
-      @show_method_name = true
-      @show_source_location = false
-      @show_params = true
-      @show_return_value = true
-      @show_execution_time = true
-      @show_trace_events = [:call, :return]
+      @validator = Config::Validator.new
+      @settings = Defaults.fetch_defaults
+      define_dynamic_accessors
+    end
+
+    def [](key)
+      settings[key]
+    end
+
+    def update(group, values)
+      raise ArgumentError, "Invalid configuration group: #{group}" unless settings.key?(group)
+
+      @validator.validate(group, values)
+      if settings[group].is_a?(Hash)
+        settings[group].merge!(values)
+      else
+        settings[group] = values
+      end
+    end
+
+    def reset_defaults
+      @settings = Defaults.fetch_defaults
     end
 
     def dup
-      copy = self.class.new
-      instance_variables.each do |var|
-        value = instance_variable_get(var)
-        copy_value = begin
-          value.dup
-        rescue TypeError
-          value
+      Config::Copier.new(self).copy
+    end
+
+    private
+
+    def define_dynamic_accessors
+      settings.each_key do |attr|
+        define_singleton_method(attr) { settings[attr] }
+        define_singleton_method("#{attr}=") do |value|
+          update(attr, value)
         end
-        copy.instance_variable_set(var, copy_value)
       end
-      copy
     end
   end
 

data/lib/trace_viz/context/config_context.rb

@@ -23,7 +23,7 @@ module TraceViz
           if temp_configuration.respond_to?("#{key}=")
             temp_configuration.send("#{key}=", value)
           else
-            warn("TraceViz: Unknown configuration option '#{key}'")
+            TraceViz.logger.warn("Unknown configuration option '#{key}'")
           end
         end
 

data/lib/trace_viz/context/manager.rb

@@ -1,37 +1,33 @@
 # frozen_string_literal: true
 
-require "trace_viz/context/manager/context_map"
-require "trace_viz/context/manager/context_validation"
-require "trace_viz/context/manager/context_registry"
-require "trace_viz/context/manager/context_operations"
-require "trace_viz/context/config_context"
-require "trace_viz/context/tracking_context"
+require "trace_viz/context/map"
+require "trace_viz/context/registry"
 
 module TraceViz
   module Context
     class Manager
+      @map = Map.new
+
       class << self
-        include ContextMap
-        include ContextValidation
-        include ContextRegistry
-        include ContextOperations
+        def enter_contexts(contexts)
+          @map.replace(Registry.build(contexts))
+        end
 
-        # Initialize class instance variables
-        def initialize_manager
-          @context_map = {}
-          @registered_contexts = {}
+        def exit_contexts(*keys)
+          @map.remove(*keys)
+        end
 
-          register_default_contexts
+        def with_contexts(contexts = {})
+          enter_contexts(contexts)
+          yield
+        ensure
+          exit_contexts(*contexts.keys)
         end
 
-        def register_default_contexts
-          Manager.register_context_type(:config, ConfigContext)
-          Manager.register_context_type(:tracking, TrackingContext)
+        def fetch_context(key)
+          @map.fetch(key)
         end
       end
-
-      # Ensure initialization upon loading
-      initialize_manager
     end
   end
 end

data/lib/trace_viz/context/map.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    class Map
+      def initialize
+        @context_map = {}
+      end
+
+      def replace(new_map)
+        @context_map = new_map
+      end
+
+      def fetch(key)
+        @context_map.fetch(key)
+      rescue KeyError
+        raise ContextError, "Context for key '#{key}' not found"
+      end
+
+      def remove(*keys)
+        keys.each { |key| @context_map.delete(key) }
+      end
+
+      def reset
+        @context_map.clear
+      end
+    end
+  end
+end

data/lib/trace_viz/context/registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "trace_viz/context/config_context"
+require "trace_viz/context/tracking_context"
+
+module TraceViz
+  module Context
+    class Registry
+      CONTEXTS = {
+        config: ConfigContext,
+        tracking: TrackingContext,
+      }.freeze
+
+      class << self
+        # Builds a hash of context objects based on the provided contexts hash.
+        #
+        # @param [Hash] contexts A hash where the keys are context keys and the values are options for each context.
+        #   Example:
+        #     {
+        #       context_key1: { option1: 'value1', option2: 'value2' },
+        #       context_key2: { option1: 'value3', option2: 'value4' }
+        #     }
+        #
+        # @return [Hash] A hash where the keys are context keys and the values are instantiated context objects.
+        #
+        # @raise [ArgumentError] If a context key is not found in the CONTEXTS hash.
+        def build(contexts)
+          contexts.each_with_object({}) do |(context_key, options), result|
+            klass = CONTEXTS.fetch(context_key)
+
+            result[context_key] = klass.new(**(options || {}))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/tracking/active_calls.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TraceViz
+  module Context
+    module Tracking
+      class ActiveCalls
+        def initialize
+          @stack = []
+        end
+
+        def push(trace_data)
+          @stack.push(trace_data)
+        end
+
+        def pop
+          @stack.pop
+        end
+
+        def current
+          @stack.last
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def size
+          @stack.size
+        end
+
+        def clear
+          @stack.clear
+        end
+      end
+    end
+  end
+end

data/lib/trace_viz/context/tracking_context.rb

@@ -2,16 +2,21 @@
 
 require "trace_viz/context/base_context"
 require "trace_viz/context/tracking/depth"
+require "trace_viz/context/tracking/active_calls"
 
 module TraceViz
   module Context
     class TrackingContext < BaseContext
-      attr_reader :depth
+      attr_reader :active_calls
 
       def initialize(**options)
         super
 
-        @depth = Tracking::Depth.new
+        @active_calls = Tracking::ActiveCalls.new
+      end
+
+      def current_depth
+        active_calls.size
       end
     end
   end

data/lib/trace_viz/context.rb

@@ -5,8 +5,8 @@ require "trace_viz/context/manager"
 module TraceViz
   module Context
     class << self
-      def for(type)
-        Manager.get_context(type)
+      def for(key)
+        Manager.fetch_context(key)
       end
     end
   end

data/lib/trace_viz/core/tracer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "trace_viz/defaults"
 require "trace_viz/logger"
 require "trace_viz/context"
 require "trace_viz/configuration"

data/lib/trace_viz/defaults.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module TraceViz
+  class Defaults
+    COLORS = {
+      reset: "\e[0m",
+      bold: "\e[1m",
+      dim: "\e[2m",
+      underline: "\e[4m",
+      reverse: "\e[7m",
+      black: "\e[30m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      magenta: "\e[35m",
+      cyan: "\e[36m",
+      light_gray: "\e[37m",
+      dark_gray: "\e[90m",
+      light_red: "\e[91m",
+      light_green: "\e[92m",
+      light_yellow: "\e[93m",
+      light_blue: "\e[94m",
+      light_magenta: "\e[95m",
+      light_cyan: "\e[96m",
+      white: "\e[97m",
+      dim_light_gray: "\e[2;37m",
+    }.freeze
+
+    ACTION_EMOJIS = {
+      default: "",
+      info: "ℹ️",
+      success: "✅",
+      error: "❌",
+      warn: "⚠️",
+      start: "🚀",
+      processing: "🔄",
+      finish: "🏁",
+      exported: "📤",
+      skipped: "⏩",
+      stats: "📊",
+    }.freeze
+
+    ACTION_COLORS = {
+      default: :reset,
+      info: :cyan,
+      success: :green,
+      error: :light_red,
+      warn: :yellow,
+      start: :light_cyan,
+      processing: :dim_light_gray,
+      finish: :light_magenta,
+      exported: :light_green,
+      skipped: :dark_gray,
+      stats: :underline,
+    }.freeze
+
+    CONFIG = {
+      general: {
+        tab_size: 2,
+        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: 50,
+      },
+      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: [],
+        # },
+      ],
+      export: {
+        enabled: true,
+        path: "tmp",
+        format: :txt,
+        overwrite: false,
+      },
+    }.freeze
+
+    VALID_PARAM_MODES = [:name_and_value, :name_only, :value_only].freeze
+    VALID_EXPORT_FORMATS = [:txt, :json, :yml].freeze
+
+    class << self
+      def colors
+        COLORS
+      end
+
+      def action_colors
+        ACTION_COLORS
+      end
+
+      def action_emojis
+        ACTION_EMOJIS
+      end
+
+      def fetch_defaults
+        CONFIG.dup
+      end
+
+      def valid_param_modes
+        VALID_PARAM_MODES
+      end
+
+      def valid_export_formats
+        VALID_EXPORT_FORMATS
+      end
+    end
+  end
+end

data/lib/trace_viz/exporters/base_exporter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require "trace_viz/context"
+require_relative "transformers/text_transformer"
+
+module TraceViz
+  module Exporters
+    class BaseExporter
+      def initialize(collector)
+        @config = Context.for(:config).configuration
+        @export_config = config.export
+        @logger = config.logger
+        @data = transform_collector_data(collector)
+      end
+
+      def export
+        unless export_enabled?
+          logger.warn("Export is disabled in configuration. Skipping export process.")
+          return
+        end
+
+        ensure_directory_exists
+        return if handle_empty_content == :skip
+        return if handle_existing_file == :skip
+
+        write_file(content)
+
+        logger.exported("Data successfully exported to #{file_path}")
+      end
+
+      private
+
+      attr_reader :config, :export_config, :logger, :data
+
+      def transform_collector_data(collector)
+        transformer = Transformers::TextTransformer.new(collector)
+        transformer.transform
+      end
+
+      def content
+        raise NotImplementedError
+      end
+
+      def export_enabled?
+        export_config[:enabled]
+      end
+
+      def ensure_directory_exists
+        FileUtils.mkdir_p(File.dirname(file_path))
+      end
+
+      def handle_existing_file
+        return unless File.exist?(file_path)
+
+        if export_config[:overwrite]
+          logger.processing("Overwriting existing file: #{file_path}")
+        else
+          logger.skipped("File already exists and overwrite is disabled: #{file_path}. Export skipped.")
+          :skip
+        end
+      end
+
+      def handle_empty_content
+        if content.nil? || content.strip.empty?
+          logger.skipped("Export content is empty. Export skipped.")
+          :skip
+        end
+      end
+
+      def file_path
+        format = export_config[:format]
+        path = export_config[:path]
+
+        "#{path}/trace_output.#{format}"
+      end
+
+      def write_file(data)
+        File.write(file_path, data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "trace_viz/formatters/base_formatter"
+
+module TraceViz
+  module Exporters
+    module Formatters
+      class BaseFormatter < TraceViz::Formatters::BaseFormatter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module TraceViz
+  module Exporters
+    module Formatters
+      class MethodCallFormatter < BaseFormatter
+        def format
+          [
+            indent_representation,
+            depth_representation,
+            method_name_representation,
+            source_location_representation,
+            params_representation,
+          ].compact.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module TraceViz
+  module Exporters
+    module Formatters
+      class MethodReturnFormatter < BaseFormatter
+        def format
+          [
+            indent_representation,
+            depth_representation,
+            method_name_representation,
+            result_representation,
+            source_location_representation,
+            execution_time_representation,
+          ].compact.join(" ")
+        end
+      end
+    end
+  end
+end