trace-util-adv 0.1.1 → 0.2.0

data/lib/filters/composite_filters.rb

@@ -0,0 +1,71 @@
+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?(msg, context)
+      # class name of context
+      class_name = context[:class_name]
+      rules[:classes].each do |clazz|
+        names=clazz[:names]
+        next if !names.matches_any?(name)
+        # if name matches rule
+        method_filter = MethodFilter.new(clazz)
+        return false if !method_filter.allow?(msg, context)
+      end
+      return true
+    end
+  end
+
+  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?(msg, context)
+      modules_name = context[:full_module_name]
+      rules[:modules].each do |_module|
+        # get names of modules to match
+        names = _module[:names]
+        # 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 _module[:classes]
+          composite_class_filter = CompositeClassFilter.new(_module)
+          return false if !composite_class_filter.allow?(msg, context)
+        end
+        if _module[:class_rules]
+          class_filter = ClassFilter.new(_module)
+          return false if !class_filter.allow?(msg, context)
+        end
+        if _module[:method_rules]
+          method_filter = MethodFilter.new(_module)
+          return false if !method_filter.allow?(msg, context)
+        end
+      end
+      # log it!
+      true
+    end
+  end
+
+  class CompositeInstanceVarFilter < BaseFilter
+    def initialize(options)
+      super(options)      
+      @rules = options || {}
+    end
+
+    def allow?(msg, context)
+      rules[:vars].each do |var|
+        var_filter = InstanceVarFilter.new(var)
+        return false if !var_filter.allow?(msg, context)
+      end
+      true
+    end
+  end
+
+end

data/lib/filters/filter_factory.rb

@@ -0,0 +1,17 @@
+# convenience methods to create and operate on filters, fx merge filters into composites, extract filters from composites etc
+
+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|
+        # puts "symbol:" + symbol.to_s
+        res = name_hash.try_create_filter(symbol) 
+        # puts "Filter created:" + res.inspect     
+        return res if res
+      end
+      # puts "no filter could be created :("
+      nil
+  end
+      
+end

data/lib/filters/message_filters.rb

@@ -0,0 +1,35 @@
+# various alternative ways to provide include/exclude filters
+
+# interface class
+module Tracing
+  class MsgFilter
+    def initialize(options)
+      @options = options
+    end
+  
+    def allow?(msg, context)
+      true
+    end
+  end
+
+  # example of specific filter on instance variable
+  class RangeFilter < MsgFilter  
+    def allow?(msg, context)
+      obj = context[:self]    
+      var = obj.instance_variable_get @options[:var]
+      return @options[:range].include?(var)    
+    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})

data/lib/filters/tracing_filter.rb

@@ -0,0 +1,88 @@
+module Tracing
+  module Filter
+    # enable registration of filters
+    module Registration
+      attr_accessor :filters
+      
+      def create_filters(reg_filters)
+        if reg_filters.kind_of?(Array)
+          reg_filters.flatten!
+          new_filters = reg_filters.collect do |f|
+            if f.kind_of? Hash
+              Tracing::BaseFilter.create_filter(f)
+            elsif f.kind_of? Tracing::BaseFilter
+              f
+            end
+          end  
+          new_filters        
+        elsif filters.kind_of? Hash
+          Tracing::BaseFilter.create_filter(reg_filters)
+        else
+          reg_filters
+        end        
+      end
+      
+      def register_filters(reg_filters)
+        @filters ||= []      
+        
+        # puts "Register filters, using: #{reg_filters.inspect}"                  
+        new_filters = create_filters(reg_filters)
+        
+        # puts "New filters to register: #{new_filters.inspect}"          
+        return if !new_filters
+        if new_filters
+          new_filters.compact! 
+          return if !(new_filters.size > 0)
+          # puts "DO register filters: #{new_filters.inspect}"          
+          @filters << new_filters.flatten!
+          # puts "Filters after reg: " + @filters.inspect
+        end
+      end
+
+      def unregister_filters(filters)
+        filters.delete(filters)
+      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)
+              # 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
+

data/lib/output_templates.rb

@@ -0,0 +1,5 @@
+require 'erb'
+require 'templates/base_template'
+require 'templates/string_template'
+require 'templates/html_template'
+require 'templates/xml_template'

data/lib/rule_match.rb

@@ -0,0 +1,38 @@
+module Tracing
+  module RuleMatch
+    class RuleTypeError < RuntimeError; end  
+  
+    def matches_any?(name) 
+      # puts "matches any: #{name}"
+      self.any? do |rule| 
+        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
+        elsif rule.kind_of? String
+          match = (name == rule)
+          # puts "matches string #{rule}: #{match}"          
+          match
+        elsif rule.kind_of? Proc
+          rule.call(name)
+        elsif rule.kind_of? NameFilter
+          rule.allow?(name)
+        else
+          raise RuleTypeError, "Bad rule type: must be Regexp, String, Proc or NameFilter"
+        end
+      end
+    end
+  
+    def rules_allow_action(name)
+      self.each do |rule|
+        res = rule.rule_allow_action(name)
+        return :exclude if (res == :exclude)
+        return :include if (res == :include)
+      end
+      # default allow action
+      return :yield
+    end
+  end
+end

data/lib/sample_filters.rb

@@ -0,0 +1,95 @@
+# my_instance_variables = {:template_path => 'taglibs/rapid_core.dryml'}
+# args = {:a => 7}
+# context = {
+#   :modules => cls_name.modules,
+#   :class_name => cls_name.class_name,
+#   :full_class_name => cls_name,
+#   :method_name => name,
+#   :args => args,
+#   :block => false,
+#   :vars => my_instance_variables # to carry @template_path etc.
+# } 
+
+Module_filter_A = {
+  :name => 'my modules',
+  :module_rules => [{
+    # id of modules rule set
+    :name => ['my_modules'],
+    :include => [/Al/],
+    :exclude => [/Be/],
+    :default => true
+  }
+]}
+
+Class_filter_A = {
+  :name => 'my classes',  
+  :class_rules => [{
+    # id of class rule set
+    :name => 'my_classes',
+    :include => [/MyCl/],
+    :exclude => [/NotMy/],
+    :default => false
+  }]
+}
+
+Method_filter_A = {
+  :name => 'my methods',  
+  :method_rules => [{
+    # id of method rule set
+    :name => 'my_methods',
+    :include => [/by.*/, 'compile', 'do_it'],
+    :exclude => ['my.*'],
+    :default => false
+  }]
+}
+
+Class_composite_filter_A = {
+  # id of composite rule set  
+  :name => 'Template stuff',
+  :classes => [{
+    :names => ['My', /My/],
+    :method_rules => {
+      :include => [/by.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => false
+    }
+  }]
+}
+
+Module_composite_filter_A = {
+  # id of composite rule set    
+  :name => 'dryml_filter',
+  :modules => [{
+    :names => ['Hobo:Dryml', /Dryml/],
+    :class_rules => {
+      :include => [/Template.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => true
+    },
+    :method_rules => {
+      :include => [/Template.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => true
+    }
+  }]
+}
+
+
+# for specific instance_vars, match on values (after .to_s on var)  
+Var_composite_filter_A = {
+  :name => 'template_path',
+  :vars => [{
+    :name => 'template_path', :type => :string,
+    :var_rules => {
+      :include => [/.*\/taglib\/.*/], 
+      :exclude => [/.*\/rapid_.*/]         
+    } 
+    },
+    {
+      :name => 'template_path', 
+      :var_rules => {
+        :exclude => [/.*\/rapid_.*/],         
+        :default => true
+      } 
+    }]
+}

data/lib/templates/base_template.rb

@@ -0,0 +1,21 @@
+module Tracing 
+  module OutputTemplate
+    class BaseTrace
+      include Tracing::OutputHandler
+      
+      def handle_after_call(context)
+        template = end_template(context)
+        output(template, context)              
+      end
+  
+      def handle_before_call(context)
+        template = before_template(context)
+        if context[:block]       
+          template << before_block_template
+        end
+        output(template, context)
+      end  
+    end  
+  end
+end
+

data/lib/templates/html_template.rb

@@ -0,0 +1,48 @@
+module Tracing 
+  module OutputTemplate
+    class HtmlTrace < BaseTrace
+      
+      def before_template(context)
+        # method_name = context[:method_full_name]
+        # args = context[:args].inspect
+        template = <<-EOF
+        <div class="method-title"><%= context[:method_full_name] %></div>
+        <div class="method-body">
+          <div class="begin">
+            <div class="method-name"><%= context[:method_full_name] %> :: BEGIN</div>
+            <div class="args">
+              <div class="method-args"><%= context[:args] %> </div>
+              #block#
+            </div>
+          </div>
+      EOF
+      end
+
+      def before_block_template 
+        template = <<-EOF
+      <div class="method block-arg">(and a block)</div>
+      EOF
+      end
+
+      def end_template(context) 
+        # method_name = context[:method_full_name]
+        # result = context[:result].inspect
+        template = <<-EOF
+          <div class="end">
+            <div class="method-name"><%= context[:method_full_name] %> :: END</div>
+            <div class="method-result"><%= context[:result] %></div>
+          </div>
+        </div>
+      EOF
+      end
+
+      # override
+      def handle_before_call(context)
+        template = before_template(context)
+        block_replace = context[:block] ? before_block_template : ""
+        template.gsub!(/#block#/, block_replace)
+        output(template, context)
+      end
+    end
+  end
+end

data/lib/templates/string_template.rb

@@ -0,0 +1,30 @@
+module Tracing 
+  module OutputTemplate
+    class StringTrace < BaseTrace
+      def before_template(context)
+        template = <<-EOF
+      <<= <%= context[:method_full_name] %> : BEGIN
+      -----------------------------------------------
+      <%= context[:args].inspect %>
+      ===============================================
+      EOF
+      end
+
+      def before_block_template 
+        template = <<-EOF
+      (and a block)
+      -----------------------------------------------
+      EOF
+      end
+  
+      def end_template(context) 
+        template = <<-EOF
+      <<= <%= context[:method_full_name] %> : END
+      -----------------------------------------------
+      <%= context[:result] %>
+      ===============================================
+      EOF
+      end  
+    end
+  end
+end