RubyGems - trace-util-adv - Versions diffs - 0.1.1 → 0.2.0 - Mend

trace-util-adv 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

data/CHANGELOG +7 -0
data/VERSION +1 -1
data/lib/README +87 -0
data/lib/TODO.txt +12 -0
data/lib/action_handler.rb +99 -0
data/lib/appenders/appender.rb +97 -0
data/lib/appenders/appender_registration.rb +16 -0
data/lib/appenders/base_appender.rb +82 -0
data/lib/appenders/file_appender.rb +72 -0
data/lib/appenders/html_appender.rb +94 -0
data/lib/appenders/logger_appender.rb +84 -0
data/lib/appenders/stream_appender.rb +37 -0
data/lib/appenders/template_log_appender.rb +28 -0
data/lib/appenders/xml_appender.rb +75 -0
data/lib/core_extensions.rb +101 -0
data/lib/filters/base_filters.rb +178 -0
data/lib/filters/composite_filters.rb +71 -0
data/lib/filters/filter_factory.rb +17 -0
data/lib/filters/message_filters.rb +35 -0
data/lib/filters/tracing_filter.rb +88 -0
data/lib/output_templates.rb +5 -0
data/lib/rule_match.rb +38 -0
data/lib/sample_filters.rb +95 -0
data/lib/templates/base_template.rb +21 -0
data/lib/templates/html_template.rb +48 -0
data/lib/templates/string_template.rb +30 -0
data/lib/templates/trace_output_handler.rb +47 -0
data/lib/templates/xml_template.rb +36 -0
data/lib/test_action_handler.rb +34 -0
data/lib/test_appender.rb +29 -0
data/lib/test_file_appender.rb +32 -0
data/lib/test_filters.rb +112 -0
data/lib/test_filters_chain.rb +100 -0
data/lib/test_filters_create.rb +28 -0
data/lib/test_html_appender.rb +66 -0
data/lib/test_special_filters.rb +78 -0
data/lib/test_xml_appender.rb +66 -0
data/lib/test_xml_gen.rb +46 -0
data/lib/trace_appenders.rb +9 -0
data/lib/trace_calls.rb +86 -0
data/lib/trace_ext.rb +57 -0
data/lib/trace_filters.rb +4 -0
data/trace-util-adv.gemspec +98 -0
metadata +44 -2

data/lib/appenders/html_appender.rb ADDED Viewed

@@ -0,0 +1,94 @@
+# surround html ouput with wrapper-html
+# include jquery and css
+# collapse non-important regions and expand important ones
+# TODO: how to ensure html ouput finishes
+# file.seek(-20, IO:SEEK_END)
+module Tracing
+  class HtmlAppender < FileAppender
+    attr_accessor :to_file, :html_output
+    class << self
+      def default_path
+        return if !@default_path
+        if !File.exists?(@default_path)
+          FileUtils.mkdir_p @default_path
+        end
+        @default_path
+      end
+      def default_path=(path)
+        @default_path = path
+      end
+    end
+    def initialize(init_options = nil)
+      @tracer = Tracing::OutputTemplate::HtmlTrace.new
+      super(init_options)
+      @html_output = html_begin
+      return if !init_options
+      # write to file
+      @to_file = init_options[:to_file]
+      if @to_file
+        write_wrap_file(to_file)
+      else
+        html_output << html_begin << html_end
+      end
+    end
+    def write_wrap_file(file)
+      file = file_path(file)
+      File.open(file, "w") do |file|
+        file.puts html_begin
+        file.puts html_end
+      end
+    end
+    def create_initial_file(file)
+      write_wrap_file(file)
+    end
+    def html_begin
+      %q{<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+  <title>Tracing :: abc</title>
+  <link rel="stylesheet" href="tracing.css" type="text/css" media="screen" title="tracing" charset="utf-8">
+  <script type="text/javascript" src="jquery-1.3.2.min.js"></script>
+  <script type="text/javascript" src="tracing.js"></script>
+</head>
+<body>}
+    end
+    def html_end
+      %q{
+</body>
+</html>
+      }
+    end
+    # perform append
+    # perform append
+    def allow_append(txt, context)
+      # check if BEGIN or END
+      if txt.include?('BEGIN')
+        txt = tracer.handle_before_call(context)
+      elsif txt.include?('END')
+        txt = tracer.handle_after_call(context)
+      end
+      if to_file
+        insert_into_file(to_file, txt, html_end)
+      else
+        # insert into string
+        html_output = txt[0..-html_end.length] + txt + html_end
+      end
+    end
+    # silently ignore
+    def not_allow_append(lines, context)
+    end
+  end
+end

data/lib/appenders/logger_appender.rb ADDED Viewed

@@ -0,0 +1,84 @@
+require 'logger'
+# append log to STDOUT Logger
+module Tracing
+  class LoggerAppender < BaseAppender
+    attr_reader :logger
+    def stream(options)
+      if options
+        case options[:stream]
+          when :error
+            STDERR
+          else
+            STDOUT
+        end
+      else
+        STDOUT
+      end
+    end
+    def log_lv(options)
+      if options
+        case options[:log_level]
+          when :info
+            Logger::INFO
+          when :warning
+            Logger::WARNING
+          when :fatal
+            Logger::FATAL
+          else
+            Logger::DEBUG
+        end
+      else
+        Logger::DEBUG
+      end
+    end
+    def initialize(init_options)
+      @tracer = Tracing::OutputTemplate::StringTrace.new
+      super(init_options)
+      if init_options.kind_of? Hash
+        logger_options = init_options[:logger] if init_options
+      end
+      log_stream = stream(logger_options)
+      log_level = log_lv(logger_options)
+      @logger ||= Logger.new(log_stream)
+      @logger.level ||= log_level
+    end
+    def log_debug(txt)
+      logger.debug txt
+    end
+    def log_info(txt)
+      logger.info txt
+    end
+    # perform append
+    def allow_append(txt, context)
+      # check if BEGIN or END
+      if txt.include?('BEGIN')
+        txt = tracer.handle_before_call(context)
+      elsif txt.include?('END')
+        txt = tracer.handle_after_call(context)
+      end
+      if txt.include?('INFO')
+        log_info txt
+      elsif txt.include?('WARNING')
+          log_warning txt
+      elsif txt.include?('ERROR')
+          log_error txt
+      else
+        log_debug txt
+      end
+    end
+    # silently ignore
+    def not_allow_append(lines, context)
+    end
+  end
+end

data/lib/appenders/stream_appender.rb ADDED Viewed

@@ -0,0 +1,37 @@
+module Tracing
+  class StreamAppender < BaseAppender
+    attr_accessor :stream
+    def configure_stream(options)
+      @stream = $stdout
+      if options
+        case options[:stream]
+          when :error
+            @stream = $stderr
+        end
+      end
+    end
+    def initialize(init_options)
+      @tracer = Tracing::OutputTemplate::StringTrace.new
+      super(init_options)
+      configure_stream(init_options)
+    end
+    # perform append
+    def allow_append(txt, context)
+      # check if BEGIN or END
+      if txt.include?('BEGIN')
+        txt = tracer.handle_before_call(context)
+      elsif txt.include?('END')
+        txt = tracer.handle_after_call(context)
+      end
+      stream.puts txt
+    end
+    # silently ignore
+    def not_allow_append(lines, context)
+    end
+  end
+end

data/lib/appenders/template_log_appender.rb ADDED Viewed

@@ -0,0 +1,28 @@
+module Tracing
+  class TemplateLogAppender < FileAppender
+    def initialize(init_options)
+      @tracer = Tracing::OutputTemplate::StringTrace.new
+      super(init_options)
+    end
+    # get template path
+    def template_path(context)
+      obj = context[:self]
+      template_path = obj.instance_variable_get :@template_path
+    end
+    # perform append
+    def allow_append(lines, context)
+      path = template_path(context)
+      if path
+        log_file =  + '.log'
+        write_file(log_file)
+      end
+    end
+    # silently ignore
+    def not_allow_append(lines, context)
+    end
+  end
+end

data/lib/appenders/xml_appender.rb ADDED Viewed

@@ -0,0 +1,75 @@
+# append log to xml-stream or file
+module Tracing
+  class XmlAppender < FileAppender
+    attr_accessor :xml_output, :to_file
+    class << self
+      def default_path
+        return if !@default_path
+        if !File.exists?(@default_path)
+          FileUtils.mkdir_p @default_path
+        end
+        @default_path
+      end
+      def default_path=(path)
+        @default_path = path
+      end
+    end
+    def initialize(init_options)
+      @tracer = Tracing::OutputTemplate::XmlTrace.new
+      super(init_options)
+      @xml_output = xml_begin
+      return if !init_options
+      # write to file
+      @to_file = init_options[:to_file]
+      if @to_file
+        write_wrap_file(to_file)
+      else
+        xml_output << xml_begin << xml_end
+      end
+    end
+    def create_initial_file(file)
+      write_wrap_file(file)
+    end
+    def write_wrap_file(file)
+      File.open(file, "w") do |file|
+        file.puts xml_begin
+        file.puts xml_end
+      end
+    end
+    def xml_begin
+      "<?xml version='1.0' encoding='UTF-8'?>\n<tracing>\n"
+    end
+    def xml_end
+      "</tracing>"
+    end
+    # perform append
+    def allow_append(txt, context)
+      # check if BEGIN or END
+      if txt.include?('BEGIN')
+        txt = tracer.handle_before_call(context)
+      elsif txt.include?('END')
+        txt = tracer.handle_after_call(context)
+      end
+      if to_file
+        insert_into_file(to_file, txt, xml_end)
+      else
+        # insert into string
+        xml_output = xml_output[0..-xml_end.length] + txt + xml_end
+      end
+    end
+    # silently ignore
+    def not_allow_append(lines, context)
+    end
+  end
+end

data/lib/core_extensions.rb ADDED Viewed

@@ -0,0 +1,101 @@
+require 'rule_match'
+class String
+  def modules
+    self.split("::")[0..-2]
+  end
+  def class_name
+    self.split("::")[-1..-1]
+  end
+  def in_module?(module_name)
+    modules = self.modules
+    modules.include?(module_name)
+  end
+  def split_names
+    self.split(/\s|,/)
+  end
+end
+class Array
+  include Tracing::RuleMatch
+  def add(obj)
+    self << obj
+    self.flatten!
+  end
+end
+class Symbol
+  def prefix(pre)
+    (pre.to_s + self.to_s).to_sym
+  end
+end
+class Hash
+  include Tracing::RuleMatch
+  def try_create_filter(symbol)
+    isymbol = has_i(symbol) || has_x(symbol)
+    # puts "try_create_filter: " + isymbol.inspect
+    if isymbol
+      filter_names = self[isymbol]
+      # puts "filter_names:" + filter_names.inspect
+      {symbol => {:include => filter_names}}
+    end
+  end
+  def rules_allow_action(name)
+    rule_allow_action(name)
+  end
+  def rule_list(rules)
+    if rules.kind_of? String
+      rules.split_names
+    else
+      rules
+    end
+  end
+  # return a symbol, either - :include, :exclude or :yield (let next filter decide)
+  def rule_allow_action(name)
+    include_rules = rule_list(self[:include])
+    if include_rules && include_rules.size > 0
+      # puts "Rule include"
+      res = include_rules.matches_any?(name)
+      return :include if res
+    end
+    exclude_rules = rule_list(self[:exclude])
+    if exclude_rules
+      # puts "Rule exclude"
+      return :exclude if exclude_rules.matches_any?(name)
+    end
+    # puts "Not included or excluded"
+    if !self[:default].nil?
+      # puts "Return default: #{self[:default]}"
+      return self[:default]
+    end
+    # puts "Rule yields"
+    return :yield
+  rescue RuleTypeError
+    # puts "error"
+    return :exclude
+  end
+protected
+  def has_i(symbol)
+    isym = symbol.prefix('i')
+    self.has_key?(isym) ? isym : false
+  end
+  def has_x(symbol)
+    self.has_key?(symbol.prefix('i'))
+  end
+end

data/lib/filters/base_filters.rb ADDED Viewed

@@ -0,0 +1,178 @@
+module Tracing
+  # abstract filter
+  class BaseFilter
+    attr_reader :name
+    attr_accessor :rules
+    class << self
+      attr_accessor :filters
+      # register symbol => filter mappings
+      def register_filters(hash)
+        filters.merge!(hash)
+      end
+      # array of symbols
+      # [:special_filter, :stream_filter]
+      def unregister_filters(hash)
+        filters.reject!{|key, value| hash.include? key}
+      end
+      def filter_rule_mappings
+        {
+          :module_rules => :module_filter,
+          :class_rules => :class_filter,
+          :method_rules => :method_filter,
+          :var_rules => :vars_filter,
+          :modules => :composite_module_filter,
+          :classes => :composite_class_filter,
+          :vars => :composite_vars_filter
+        }
+      end
+      def convenience_map
+        {
+         :module => :module_filter,
+         :class => :class_filter,
+         :method => :method_filter,
+         :vars => :vars_filter,
+        }
+      end
+      def default_filters
+        {
+         :module_filter => Tracing::ModuleFilter,
+         :class_filter  => Tracing::ClassFilter,
+         :method_filter => Tracing::MethodFilter,
+         :vars_filter => Tracing::InstanceVarFilter,
+         :composite_module_filter => Tracing::CompositeModuleFilter,
+         :composite_class_filter => Tracing::CompositeClassFilter,
+         :composite_vars_filter => Tracing::CompositeInstanceVarFilter
+        }
+      end
+      def get_filter(options)
+        convenience_map.select do |key, _filter|
+          return _filter if options.has_key?(key) || options.has_key?(_filter)
+        end
+        filter_rule_mappings.select do |key, _filter|
+          return _filter if options.has_key? key
+        end
+        return options
+      end
+      # Example:
+      # {:method, :include => 'hello,way'}
+      # {:class, :include => 'A,B', :exclude => 'C'}
+      def filter_by_hash(options)
+        filters ||= default_filters
+        # try by factory
+        new_filter = Tracing::Filter.create_filter(options)
+        # puts "New filter: #{new_filter.inspect}"
+        options = new_filter if new_filter
+        # try by other means
+        type = get_filter(options)
+        if type && type.kind_of?(Symbol)
+          filter_class = filters[type]
+          # puts "filter class: #{filter_class}"
+          # ensure options has rules
+          if filter_class
+            filter_class.new(options)
+          else
+            raise Exception, "Filterclass not found"
+          end
+        end
+      end
+      # TODO: Refactor using symbol map!
+      def create_filter(options)
+        if options.kind_of? Hash
+          _filter = filter_by_hash(options)
+        elsif options.kind_of? BaseFilter
+          options
+        else
+          nil
+        end
+      end
+    end
+    def initialize(options)
+      @name = options[:name] || "Unknown filter"
+    end
+    def name_allow_action(name)
+      res = rules.rules_allow_action(name)
+    end
+  end
+  # filter on module
+  class ModuleFilter < BaseFilter
+    def initialize(options)
+      super(options)
+      @rules = options[:module_rules] || {}
+    end
+    def allow_action(msg, context)
+      name = context[:full_module_name]
+      allow = name_allow_action(name)
+    end
+  end
+  # filter on class name
+  class ClassFilter < BaseFilter
+    def initialize(options)
+      super(options)
+      @rules = options[:class_rules] || {}
+    end
+    def allow_action(msg, context)
+      name = context[:class_name]
+      allow = name_allow_action(name)
+    end
+  end
+  # filter on method
+  class MethodFilter < BaseFilter
+    def initialize(options)
+      super(options)
+      @rules = options[:method_rules] || options[:method_filter] || {}
+    end
+    def allow_action(msg, context)
+      name = context[:method_name]
+      @encountered ||= []
+      name_allow_action(name)
+    end
+  end
+  # filter on instance variables
+  class InstanceVarFilter < BaseFilter
+    attr_accessor :var_name
+    def initialize(options)
+      super(options)
+      @rules = options[:var_rules] || {}
+      var_name = options[:var_name]
+    end
+    def allow_action(msg, context)
+      obj = context[:self]
+      if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
+        value = obj.instance_variable_get(var_name)
+        return name_allow_action(value)
+      end
+      :yield
+    end
+  end
+end