trace-util-adv 0.1.1 → 0.2.0

data/lib/templates/trace_output_handler.rb

@@ -0,0 +1,47 @@
+module Tracing
+  module OutputHandler   
+
+    # TODO: refactor (duplicate of appender method)
+    def method_stack
+      @method_stack ||= []
+    end
+    
+    # override to increase # of spaces for each indenation level!
+    def space_count
+      1
+    end
+
+    # calculate indentation level, based on method stack level (# of nested method calls)
+    def indentation
+      s = ""
+      lv = method_stack.empty? ? 0 : method_stack.size-1 
+      lv.times { s << (" " * space_count) }
+      s
+    end
+
+    def output(template, context)
+      # get spaces to indent each line
+      spaces = indentation
+
+      # modify template, inserting indentation
+      lines = template.split("\n")
+      lines.map!{|line| spaces + line + "\n"}
+      template = lines.join
+
+      # send modified template to output handler with context
+      output_handler(template, context)
+    end
+
+    # default output action: put string to STDOUT
+    # override this to customize trace handling
+    def output_handler(template, context)
+      # create new erb template
+      erb_template = ERB.new template
+      
+      # evaluate erb template for output using context
+      str_res = erb_template.result(binding)
+      # send final output to action handlers for further processing...
+      # action_handlers(str_res, context)
+    end
+  end 
+end

data/lib/templates/xml_template.rb

@@ -0,0 +1,36 @@
+module Tracing 
+  module OutputTemplate
+    class XmlTrace < BaseTrace
+      def before_template(context)
+        template = <<-EOF
+      <method name="<%= context[:method_full_name] %>">
+        <modules><%= context[:full_module_name] %></modules>
+        <class><%= context[:class_name].join(',') %></class>
+        <args><%= context[:args].inspect %></args>
+        #block#
+      EOF
+      end
+
+      def before_block_template 
+        template = <<-EOF
+      <block-arg>true</block-arg>
+      EOF
+      end
+
+      def end_template(context) 
+        template = <<-EOF
+        <result><%= context[:result] %></result>
+      </method>
+      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/test_action_handler.rb

@@ -0,0 +1,34 @@
+require "core_extensions"
+require "trace_calls"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    # tla1 = Tracing::TemplateLogAppender.new(:options => {:overwrite => false, :time_limit => 2.minutes}, :tracer => :string)      
+    # action handler is configured with a set of filters and a set of appenders
+    # the appenders are called in turn if log statement passes all filters!
+    # @ah1 = Tracing::ActionHandler.new(:filters => @filters = Module_filter_A)  
+
+    appender_options = {:options => {:overwrite => false, :time_limit => 2.minutes}, :type => :logger, :tracer => :string}
+    # @ah2 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => appender_options)    
+
+    @ah3 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => :logger)        
+  end
+
+  def teardown
+    ## Nothing really
+  end
+    
+  def test_filter
+    puts "ActionHandler:" + @ah3.inspect
+  end
+  
+  
+end
+

data/lib/test_appender.rb

@@ -0,0 +1,29 @@
+require "core_extensions"
+require "trace_calls"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    # Tracing::Appender.register_default_mappings    
+    
+    # test all the ways an appender can be initialized!
+    @ah1 = Tracing::LoggerAppender.new(:tracer => :html)      
+  end
+
+  def teardown
+    ## Nothing really
+  end
+    
+  def test_filter
+    puts @ah1.inspect
+  end
+  
+  
+end
+

data/lib/test_file_appender.rb

@@ -0,0 +1,32 @@
+require "core_extensions"
+require "trace_calls"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    # Tracing::Appender.register_default_mappings    
+    @file = 'test.txt'
+    
+    # test all the ways an appender can be initialized!
+    @file_appender = Tracing::FileAppender.new({:overwrite => true, :to_file => @file})
+  end
+
+  def teardown
+    ## Nothing really
+  end
+    
+  def test_filter
+    @file_appender.write_file(@file, "Hello World")
+    marker_txt = 'World'
+    @file_appender.insert_into_file(@file, 'My old ', marker_txt)
+  end
+  
+  
+end
+

data/lib/test_filters.rb

@@ -0,0 +1,112 @@
+require "core_extensions"
+require "trace_calls"
+require "output_templates"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+
+# configure use of TraceExt
+module Me
+  class My     
+
+    def hello
+      puts "Hello cruel World!"
+    end   
+
+    def hi_there
+      puts "Hello cruel World!"
+    end   
+
+    def blip
+      puts "Blip!"
+    end   
+
+    def blap
+      puts "Blap!"
+    end   
+
+  end    
+end
+
+Method_filter_hello = {
+  :name => 'my methods',  
+  :method_rules => [{
+    # id of method rule set
+    :name => 'my_methods',
+    :include => [/hi.*/, 'blip', 'blap'],
+    :exclude => ['hello'],
+    :default => false
+  }]
+}    
+ 
+  
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    # module filter is created (see sample filters)
+    # @module_filter = Tracing::ModuleFilter.new(Module_filter_A)        
+
+    # Appender is configured with some appender options and a Tracer
+    # string_tracer = Tracing::OutputTemplate::StringTrace.new        
+    # template_log_options = {:options => {:overwrite => false, :time_limit => 2.minutes}, :tracer => string_tracer}
+    # tla1 = Tracing::TemplateLogAppender.new(:options => {:overwrite => false, :time_limit => 2.minutes}, :tracer => :string)  
+    
+    # action handler is configured with a set of filters and a set of appenders
+    # the appenders are called in turn if log statement passes all filters!
+    @ah1 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => :logger)    
+
+    appender_options = {:options => {:overwrite => false, :time_limit => 2.minutes}, :type => :logger, :tracer => :string}
+
+    # @ah2 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => appender_options)    
+
+    # TraceExt is configured with a set of action handlers
+    # on any method call the set of action handlers are called if all initial filters are passed 
+    # Tracing::TraceExt.register_action_handlers([ah1])
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  def test_filter
+    # module_filter = Tracing::ModuleFilter.new(Module_filter_A)   
+    
+    # TraceExt can be configured with a set of 'initial' filters, that determine if the method should have theaspects applied at all     
+    # Tracing::TraceExt.register_filters([module_filter])
+    # , :filters => Class_filter_A     
+    # Tracing::TraceExt.configure(:action_handlers => [ah1])
+    # Tracing::TraceExt.configure(:appenders => :logger)
+    
+    dryml_classes_to_trace = [ 'My']
+
+    dryml_classes_to_trace.each do |cls|
+      str = "Me::#{cls}.class_eval { include Tracing::TraceCalls }"
+      puts str
+      eval str
+    end    
+    
+    # Me::My.class_eval { include Tracing::TraceCalls }
+        
+    Tracing::HtmlAppender.default_path = 'log_files/html'
+        
+    # Tracing::TraceExt.configure(:appenders => {:type => :html, :to_file => 'log_files/html/traced.html'})    
+    Tracing::TraceExt.configure(:type => :html, :to_file => 'traced4.html', :filters => Method_filter_hello)        
+        
+    # Tracing::TraceExt.configure(:filters => Class_filter_A)
+    # 
+    my = Me::My.new
+    my.hello
+    my.hi_there
+    my.blip
+    my.blap
+
+    
+    # my.action_handlers(['a', 'b'], context)           
+  end
+  
+  
+end
+

data/lib/test_filters_chain.rb

@@ -0,0 +1,100 @@
+require "core_extensions"
+require "trace_calls"
+require "output_templates"
+require "rubygems"
+require "duration"
+require "test/unit"
+
+# configure use of TraceExt
+module Me
+  class My     
+
+    def hello
+      puts "Hello World!"
+    end   
+
+    def hi_there
+      puts "Hi there!"
+    end   
+
+    def blip
+      puts "Blip!"
+    end   
+
+    def blap
+      puts "Blap!"
+    end   
+
+  end    
+end
+
+Method_filter_A = {
+  :name => 'my methods',  
+  :method_rules => [{
+    # id of method rule set
+    :name => 'my_methods',
+    :include => [/hi.*/],
+    :exclude => ['hello'],
+    :default => :yield
+  }]
+}    
+ 
+# Method_filter_B = {
+#   :name => 'my methods',  
+#   :method_rules => [{
+#     # id of method rule set
+#     :name => 'my_methods',
+#     :include => ['blip', 'blop'],
+#     :default => :yield
+#   }]
+# }
+
+  
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  def test_filter
+    # Tracing::TraceExt.configure(:appenders => :logger, :filters => [Method_filter_A, Method_filter_B])            
+    Me::My.class_eval { include Tracing::TraceCalls }
+        
+    Tracing::HtmlAppender.default_path = 'log_files/html'
+
+    names_A = %w{blip blop}
+    names_B = "blip blop"
+    names_C = "blip, blop"
+
+    bfil = {:xmethod_filter => names_B}
+
+    # method_filter_A = Tracing::Filter.create_filter({:imethod_filter =>  names_A})        
+    method_filter_B = Tracing::Filter.create_filter(bfil)        
+    # method_filter_C = Tracing::Filter.create_filter({:imethod_filter =>  names_C})        
+        
+    # Tracing::TraceExt.configure(:appenders => {:type => :html, :to_file => 'log_files/html/traced.html'})    
+    meth_filter_A = {:imethod_filter =>  names_A}
+        
+    puts "mf B: " + method_filter_B.inspect    
+        
+    Tracing::TraceExt.configure(:appenders => {:type => :html, :to_file => 'traced4.html'}, :filters => [meth_filter_A], :final_yield => :exclude)        
+    
+    puts "Handlers configured:" + Tracing::TraceExt.action_handlers.inspect    
+            
+    # 
+    my = Me::My.new
+    my.hello
+    my.hi_there
+    my.blip
+    my.blap
+    
+  end
+  
+  
+end
+

data/lib/test_filters_create.rb

@@ -0,0 +1,28 @@
+require "core_extensions"
+require "trace_calls"
+require "output_templates"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestFilter < Test::Unit::TestCase
+
+  def teardown
+    ## Nothing really
+  end
+    
+  def test_filter_create
+
+    names = %w{blip blop}
+    puts "create include method filter, names: #{names}" 
+    method_filter_B = Tracing::Filter.create_filter({:imethod_filter =>  names})
+    
+    f = Tracing::BaseFilter.create_filter(method_filter_B)
+    
+    puts method_filter_B.inspect
+    puts f.inspect
+  end
+  
+  
+end
+

data/lib/test_html_appender.rb

@@ -0,0 +1,66 @@
+require "core_extensions"
+require "trace_calls"
+require "output_templates"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestFilter < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    # Tracing::Appender.register_default_mappings    
+    
+    # test all the ways an appender can be initialized!
+    @ah1 = Tracing::HtmlAppender.new(:tracer => :html, :to_file => 'log_files/html/traced.html')      
+  end
+
+  def teardown
+    ## Nothing really
+  end
+    
+  def method_full_name(context)
+    "#{context[:class_name]}.#{context[:method_name]}"
+  end
+    
+  def test_filter
+    cls_name = "Alpha::Beta::Gamma"
+    name = "my_method"
+    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.
+    }    
+    @context[:method_full_name] = method_full_name(@context)
+    
+    @ah1.allow_append("BEGIN #{name}", @context)
+
+    name = "my_other_method"
+
+    @context[:method_name] = name
+    @context[:method_full_name] = method_full_name(@context)
+
+    @ah1.allow_append("BEGIN #{name}", @context)        
+    
+    @context[:result] = "32"
+    @ah1.allow_append("END #{name}", @context)    
+
+    name = "my_method"
+    @context[:method_name] = name    
+    @context[:method_full_name] = method_full_name(@context)    
+    
+    @context[:result] = "27"
+    @ah1.allow_append("END #{name}", @context)    
+  end
+  
+  
+end
+