trace-util-adv 0.2.3 → 0.2.4

data/lib/filters/composite/composite_class_filter.rb

@@ -0,0 +1,25 @@
+module Tracing
+  class CompositeClassFilter < BaseFilter
+    def initialize(options)
+      super(options)      
+      @rules = options || {}
+    end
+
+    # filter on class names and then methods within those classes
+    def allow_action(msg, context)
+      # class name of context
+      class_name = context[:class_name]
+      action = rules[:default] || :yield
+      rules[:classes].each do |clazz|
+        names=clazz[:names]
+        class_name_match = names.matches_any?(class_name)
+        next if !class_name_match
+        # if name matches rule
+        method_filter = MethodFilter.new(clazz)
+        action = method_filter.allow_action(msg, context)
+        return action if (action == :include || action == :exclude)
+      end
+      return action
+    end
+  end
+end

data/lib/filters/composite/composite_module_filter.rb

@@ -0,0 +1,53 @@
+module Tracing
+  class CompositeModuleFilter < BaseFilter
+    def initialize(options)
+      super(options)      
+      @rules = options || {}
+    end
+
+    # filter on module names and then on class names and methods within those modules
+    def allow_action(msg, context)
+      modules_name = context[:full_modules_name]
+      action = rules[:default] || :yield 
+      # puts "modules_name: #{modules_name}"     
+      rules[:modules].each do |_module|
+        # get names of modules to match
+        names         = _module[:names]
+        class_rules   = _module[:class_rules]
+        classes       = _module[:classes]
+        method_rules  =_module[:method_rules]
+        
+        class_name    = context[:class_name]
+        method_name    = context[:method_name]
+        
+        # puts "module names to match: #{names}"
+        # puts "context class_name: #{class_name}"
+        # puts "context method_name: #{method_name}"
+        
+        # test if current module name matches any of the module names for this rule
+        next if !names.matches_any?(modules_name)
+        # if name matches rule
+        if classes && !class_name.blank?
+          # puts "CC filter"
+          composite_class_filter = CompositeClassFilter.new(_module)
+          action = composite_class_filter.allow_action(msg, context)
+          return action if (action == :include || action == :exclude)          
+        end
+        if class_rules && !class_name.blank?
+          # puts "class filter"          
+          class_filter = ClassFilter.new(_module)
+          action = class_filter.allow_action(msg, context)
+          return action if (action == :include || action == :exclude)                    
+        end
+        if method_rules && !method_name.blank?
+          # puts "method filter"                    
+          method_filter = MethodFilter.new(_module)
+          action = method_filter.allow_action(msg, context)
+          return action if (action == :include || action == :exclude)
+        end
+      end
+      # puts "action: #{action}"
+      return action
+    end
+  end
+end

data/lib/filters/executor/filter_exec.rb

@@ -0,0 +1,74 @@
+module Tracing
+  module Filter            
+    # enable execution of filters
+    class Executor
+      attr_accessor :filters, :final_yield_action
+            
+      def initialize(options)
+        @final_yield_action = options[:final_yield_action] || :exclude
+        @filters ||= []
+        _filters = options.filters
+        # puts "filters exec: #{_filters.inspect}"
+        @filters.add(_filters)
+      end      
+      
+      # determine if message and context should pass through filter chain
+      # return: 
+      # - true to allow
+      # - false to disallow
+      def filters_allow?(msg, context)
+        # puts "method: filters_allow?"
+                        
+        # default allow return value
+        allow = (final_yield_action == :exclude ? false : true)               
+        
+        # puts "default allow: #{allow}"
+        # puts "filters: #{@filters}"  
+        
+        return allow if @filters.blank?        
+        
+        @filters.each do |_filter|
+          # apply filter
+          if _filter 
+            res = _filter.allow_action(msg, context)
+            # puts "res: #{res}"  
+
+            if (res == :include_and_yield)
+              allow = true
+            end
+
+            if (res == :exclude_and_yield)
+              allow = false
+            end
+
+            if (res == :include)
+              # puts "included - break"
+              allow = true
+              break
+            end
+            
+            if (res == :exclude) 
+              # puts "excluded - break"              
+              allow = false
+              break
+            end
+            # puts "yielding..."
+          end
+        end
+        # puts "filters_allow?: #{allow}"
+        return allow
+      end
+    end
+  end
+end
+
+
+module Tracing
+  module Filter            
+    module ExecUse
+      # set to instance of Tracing::Filter:Exec
+      attr_accessor :filter_executor
+    end
+  end
+end
+      

data/lib/filters/filter.rb

@@ -0,0 +1,43 @@
+module Tracing
+
+  # interface (abstract class)
+  # instances of this form can be used as filters inside include/exclude lists
+  class NameFilter 
+    # return boolean
+    def allow?(name)
+      true
+    end
+  end
+
+
+  # abstract filter  
+  class BaseFilter
+    attr_reader :name
+    attr_accessor :rules
+
+    class << self
+      attr_accessor :filters
+    
+      # register symbol => filter mappings
+      def register_filters(hash)
+        @filters ||= {}
+        filters.merge!(hash)
+      end
+
+      # array of symbols
+      # [:special_filter, :stream_filter]
+      def unregister_filters(hash)
+        @filters ||= {}
+        filters.reject!{|key, value| hash.include? key}
+      end    
+    end
+  
+    def initialize(options = {})
+      @name = options[:name] || "Unknown filter"      
+    end
+    
+    def name_allow_action(name)
+      res = rules.rules_allow_action(name)
+    end
+  end  
+end

data/lib/filters/filter_factory.rb

@@ -4,7 +4,7 @@ module Tracing::Filter
   
   def self.create_filter(name_hash)
     # puts "TRY create_filter: " + name_hash.inspect
-      [:module_filter, :class_filter, :method_filter].each do |symbol|
+      [:module_filter, :class_filter, :method_filter, :vars_filter].each do |symbol|
         # puts "symbol:" + symbol.to_s
         res = name_hash.try_create_filter(symbol) 
         # puts "Filter created:" + res.inspect     

data/lib/filters/filter_mappings.rb

@@ -0,0 +1,36 @@
+module FilterMappings
+  
+  def self.rules_map
+    {
+      :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 self.convenience_map
+    {
+     :module => :module_filter,
+     :class => :class_filter,
+     :method => :method_filter,
+     :variable => :vars_filter,
+    }
+  end
+
+
+  def self.defaults
+    {
+     :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  
+end

data/lib/filters/{tracing_filter.rb → filter_registration.rb}

@@ -24,6 +24,11 @@ module Tracing
       
       def register_filters(reg_filters)
         @filters ||= []      
+        @filters.add(reg_filters.filters)
+      end
+      
+      def _register_filters(reg_filters)
+        @filters ||= []      
         
         # puts "Register filters, using: #{reg_filters.inspect}"                  
         new_filters = create_filters(reg_filters)
@@ -44,53 +49,5 @@ module Tracing
       end
 
     end
-    
-    # enable execution of filters
-    module Exec
-      def filters_allow?(msg, context)
-        # puts "method: filters_allow?"
-        
-        @filters ||= Tracing::TraceExt.filters
-        return true if !@filters && !@filters.kind_of?(Array)
-        
-        # default allow return value
-        allow = true           
-        allow = false if (Tracing::TraceExt.final_yield_action == :exclude)                
-        
-        @filters.each do |_filter|
-          # apply filter
-          if _filter 
-            res = _filter.allow_action(msg, context)
-            # puts "res: #{res}"  
-
-            if (res == :include_and_yield)
-              allow = true
-            end
-
-            if (res == :exclude_and_yield)
-              allow = false
-            end
-
-            if (res == :include)
-              # puts "included - break"
-              allow = true
-              break
-            end
-            
-            if (res == :exclude) 
-              # puts "excluded - break"              
-              allow = false
-              break
-            end
-
-            # puts "yielding..."
-
-          end
-        end
-        # puts "filters_allow?: #{allow}"
-        return allow
-      end
-    end
   end
-end
-
+end

data/lib/filters/filter_use.rb

@@ -0,0 +1,10 @@
+# include this on any class that should have filter functionality available
+# for tracing, this is used on TraceExt, ActionHandler, Appender
+module Tracing
+  module FilterUse
+    include Tracing::Filter::Registration    
+    include Tracing::Filter::ExecUse
+  
+    attr_accessor :filters     
+  end
+end

data/lib/filters/include.rb

@@ -0,0 +1,8 @@
+dir = 'filters/'
+require dir + 'filter'
+include_folder_rec(dir + 'simple')
+include_folder_rec(dir + 'composite')
+include_folder_rec(dir + 'list')
+include_folder_rec(dir + 'msg_context')
+include_folder_rec(dir + 'executor')
+include_folder(dir)

data/lib/filters/list/README-NOTE.txt

@@ -0,0 +1 @@
+Not sure how useful specific list filters (limited to a single kind of filter) are, since you can always just create a list of various kinds of filters.

data/lib/filters/list/list_instance_var_filter.rb

@@ -0,0 +1,27 @@
+module Tracing
+  class ListInstanceVarFilter < BaseFilter
+    def initialize(options)
+      super(options)      
+      @rules = options || {}
+    end
+
+    def allow_action(msg, context)
+      action = rules[:default] || :yield      
+      var_rules = rules[:vars]
+      # puts "var rules: #{var_rules.inspect}"
+      # puts "var_rules size: #{var_rules.size}"
+      # puts "context: #{context.inspect}"
+      var_rules.each do |var_rule|
+        # puts "var rule: #{var_rule.inspect}"
+        options = {}
+        options[:var_rules] = var_rule[:var_rules]
+        options[:var_name]  = var_rule[:name]      
+        
+        var_filter = InstanceVarFilter.new(options)
+        action = var_filter.allow_action(msg, context)
+        return action if (action == :include || action == :exclude)        
+      end
+      return action
+    end
+  end
+end

data/lib/filters/{message_filters.rb → msg_context/message_context_filters.rb}

@@ -2,7 +2,7 @@
 
 # interface class
 module Tracing
-  class MsgFilter
+  class MsgContextFilter
     def initialize(options)
       @options = options
     end
@@ -13,7 +13,7 @@ module Tracing
   end
 
   # example of specific filter on instance variable
-  class RangeFilter < MsgFilter  
+  class InstanceVarRangeFilter < MsgContextFilter  
     def name_allow_action(msg, context)
       obj = context[:self]    
       var = obj.instance_variable_get @options[:var]
@@ -21,16 +21,7 @@ module Tracing
       return :yield
     end
   end
-
-  # interface (abstract class)
-  # instances of this form can be used as filters inside include/exclude lists
-  class NameFilter 
-    # return boolean
-    def allow?(name)
-      true
-    end
-  end
 end
   
 # custom filter
-my_msg_filter = Tracing::RangeFilter.new({:range => 0..10, :var => :rating})
+my_msg_filter = Tracing::InstanceVarRangeFilter.new({:range => 0..10, :var => :rating})

data/lib/filters/simple/argument_filter.rb

@@ -0,0 +1,24 @@
+module Tracing
+  # filter on instance variables
+  class ArgumentFilter < BaseFilter
+    attr_accessor :var_name
+        
+    def initialize(options)
+      super(options)    
+      @rules = options[:arg_rules] || {}
+      @var_name = options[:arg_name]
+    end
+
+    def allow_action(msg, context)
+      obj = context[:args]
+      if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
+        key = var_name.to_sym
+        if obj.has_key? key
+          value = obj[key]      
+          return name_allow_action(value)
+        end
+      end
+      :yield
+    end    
+  end  
+end

data/lib/filters/simple/class_filter.rb

@@ -0,0 +1,15 @@
+module Tracing
+  # 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]
+      # puts "class_name: #{name}"
+      allow = name_allow_action(name)
+    end
+  end
+end  

data/lib/filters/simple/instance_var_filter.rb

@@ -0,0 +1,25 @@
+module Tracing
+  # filter on instance variables
+  class InstanceVarFilter < BaseFilter
+    attr_accessor :var_name
+        
+    def initialize(options)
+      super(options)    
+      # puts "create inst.var filter: #{options.inspect}"  
+      @rules = options[:var_rules] || {}
+      @var_name = options[:var_name]
+    end
+
+    def allow_action(msg, context)
+      # puts "InstanceVarFilter.allow_action"
+      obj = context[:self]
+      # puts "var_name: #{var_name}"
+      if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
+        value = obj.instance_variable_get("@#{var_name}")      
+        # puts "value: #{value}"
+        return name_allow_action(value)
+      end
+      :yield
+    end    
+  end  
+end  

data/lib/filters/simple/method_filter.rb

@@ -0,0 +1,17 @@
+module Tracing
+  # filter on method
+  class MethodFilter < BaseFilter
+    def initialize(options)
+      super(options)   
+      # puts "Method filter options: #{options.inspect}" 
+      # puts "use :method_rules or :method_filter"  
+      @rules = options[:method_rules] || options[:method_filter] || {}
+    end
+
+    def allow_action(msg, context)
+      name = context[:method_name]
+      # puts "allow name?: #{name}"
+      allow = name_allow_action(name)
+    end
+  end
+end

data/lib/filters/simple/module_filter.rb

@@ -0,0 +1,14 @@
+module Tracing
+  # filter on module
+  class ModuleFilter < BaseFilter
+    def initialize(options)
+      super(options)
+      @rules = options[:module_rules] || {}
+    end
+
+    def allow_action(msg, context)
+      name = context[:full_modules_name]
+      allow = name_allow_action(name)
+    end
+  end
+end  

data/lib/rules/rule_mappings.rb

@@ -0,0 +1,10 @@
+module RuleMappings  
+  def self.prefix_map
+    {
+      :i => :include,
+      :x => :exclude,
+      :iy => :include_and_yield,
+      :xy => :exclude_and_yield      
+    }
+  end  
+end

data/lib/{rule_match.rb → rules/rule_match.rb}

@@ -3,13 +3,15 @@ module Tracing
     class RuleTypeError < RuntimeError; end  
   
     def matches_any?(name) 
-      # puts "matches any: #{name}"
+      puts "matches any: #{name.inspect}"
       self.any? do |rule| 
+        puts "rule:" + rule.inspect
+        puts "against:" + name.inspect
         if rule.kind_of? Regexp
           # match return position of match, or nil if no match
           # here converted into boolean result
-          match = (name =~ rule) 
-          # puts "matches regexp #{rule}: #{match}"
+          match = !(name =~ rule).nil? 
+          puts "match: #{match}"
           match
         elsif rule.kind_of? String
           match = (name == rule)

data/lib/targets/README-NOTE.txt

@@ -0,0 +1,2 @@
+Each Appender should be set up with a target.
+A Html appender shouldn't have to output to a file fx.

data/lib/targets/file_target.rb

@@ -0,0 +1,65 @@
+module Tracing
+  class FileTarget
+    include Tracing::DefaultPath
+    class << self
+      include Tracing::DefaultPath
+    end    
+
+    def append(txt, context)
+      file = get_file(context)
+      write_file(file, txt)
+    end
+
+    # file
+    def write_file(file, txt)
+      file = file_path(file)      
+      
+      write_mode = mode(file) 
+      File.open(file, write_mode) do |f|
+        f.puts txt
+      end   
+    end
+
+    def create_initial_file(file)
+    end
+
+    def insert_into_file(file, txt, marker_txt)
+      line = marker_txt
+
+      file = file_path(file)
+
+      if !File.exist?(file)
+        create_initial_file(file)
+      end  
+      
+      gsub_file file, /(#{Regexp.escape(line)})/mi do |match|
+        "#{txt}\n#{match}"
+      end
+    end
+
+    # helper for deciding file "write mode"
+    def is_old_file?(file)
+      File.new(file).mtime < (Time.now - time_limit)
+    end
+
+    def file_path(file)
+      def_path = default_path || self.class.default_path
+      file = File.join(def_path, file) if self.class.default_path      
+    end
+
+protected
+    def gsub_file(path, regexp, *args, &block)
+      content = File.read(path).gsub(regexp, *args, &block)
+      File.open(path, 'wb') { |file| file.write(content) }
+    end
+
+    # default file "write mode"
+    def mode(file)
+      if !options[:overwrite] && File.exist?(file) && !is_old_file?(file)
+        "a+"
+      else
+        "w+"
+      end
+    end
+  end
+end

data/lib/targets/stream_target.rb

@@ -0,0 +1,9 @@
+module Tracing
+  class StreamTarget
+    attr_accessor :stream
+    
+    def append(txt, context)
+      @stream << txt
+    end
+  end
+end

data/lib/targets/string_target.rb

@@ -0,0 +1,9 @@
+module Tracing
+  class StringTarget
+    attr_accessor :text
+    
+    def append(txt, context)
+      @text << txt
+    end
+  end
+end

data/lib/templates/base_template.rb

@@ -1,6 +1,7 @@
+require 'templates/trace_output_handler'
+
 module Tracing 
-  module OutputTemplate
-    class BaseTrace
+  class BaseTemplate
       include Tracing::OutputHandler
       
       def handle_after_call(context)

data/lib/templates/html_template.rb

@@ -1,6 +1,5 @@
 module Tracing 
-  module OutputTemplate
-    class HtmlTrace < BaseTrace
+  class HtmlTemplate < BaseTemplate
       
       def before_template(context)
         # method_name = context[:method_full_name]

data/lib/templates/include.rb

@@ -0,0 +1,2 @@
+require 'erb'
+Dir.glob(File.join(File.dirname(__FILE__), '**/*.rb')).each {|f| require f }