trace-util-adv 0.1.1 → 0.2.0

data/lib/test_special_filters.rb

@@ -0,0 +1,78 @@
+require 'core_extensions'
+require 'filters/base_filters'
+require 'filters/message_filters'
+
+# Procs of this form can be used as filters inside include/exclude lists
+rest_view = Proc.new {|name| name == 'abc' }
+
+module Tracing  
+  # abstract context filter
+  class MsgContextFilter
+    attr_accessor :options    
+    
+    def initialize(options)
+      @options = options
+    end
+  
+    def allow?(msg, context)
+      true
+    end
+  end
+
+  # abstract name filter
+  class NameFilter 
+    attr_accessor :options
+
+    def initialize(options)
+      @options = options
+    end
+    
+    # return boolean
+    def allow?(name)
+      true
+    end
+  end
+
+  class CustomNameFilter < NameFilter 
+    def allow?(name)
+      name == options[:name]
+    end    
+  end
+end
+
+msg_filter = Tracing::MsgContextFilter.new '22'
+
+name_filter = Tracing::CustomNameFilter.new('rapid')
+
+var_rule_A = {
+  :name => 'var rule A',
+  :var_name => :template_path,
+  :var_rules => {
+    :include => [rest_view, name_filter], 
+    :exclude => [/.*\/rapid_.*/],
+    :default => false         
+  }
+}
+
+comp_var_rules_A = {
+  :name => 'test template_path',
+  :vars => [var_rule_A]
+}
+
+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.
+}
+
+var_filter = Tracing::InstanceVarFilter.new(var_rule_A)
+
+puts var_filter.allow?("hello", @context)

data/lib/test_xml_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::XmlAppender.new(:tracer => :xml, :to_file => 'log_files/xml/traced.xml')      
+  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
+

data/lib/test_xml_gen.rb

@@ -0,0 +1,46 @@
+require 'ftools'
+
+
+@begin = "<?xml version='1.0' encoding='UTF-8'?>\n<tracing>\n"
+@end = "</tracing>"
+
+File.open('text.xml', "w") do |file|
+  file.puts @begin
+  file.puts @end
+end
+# 
+# File.open('text.xml', "a+") do |file|
+#   file.seek(-@end.length, IO:SEEK_END)
+#   file.puts "hello world"
+# end
+
+
+# # # Create a new file and write to it  
+# File.open('test.rb', 'w+') do |f2|  
+#   # use "\n" for two lines of text  
+#   f2.puts "Created by Satish\nThank God!"  
+# end
+# 
+# f = File.new("test.rb", "a+")  
+# #   
+# # # SEEK_CUR - Seeks to first integer number parameter plus current position  
+# # # SEEK_END - Seeks to first integer number parameter plus end of stream  
+# # #   (you probably want a negative value for first integer number parameter)  
+# # # SEEK_SET - Seeks to the absolute location given by first integer number parameter  
+# # # :: is the scope operator - more on this later  
+# # f.seek(12, IO::SEEK_SET)  
+# # print f.readline  
+# str = "hello world</end>"
+# f.seek(-6, IO::SEEK_END)
+# f.puts str
+# f.close
+
+def gsub_file(path, regexp, *args, &block)
+  content = File.read(path).gsub(regexp, *args, &block)
+  File.open(path, 'wb') { |file| file.write(content) }
+end
+
+line = '</tracing>'
+gsub_file 'text.xml', /(#{Regexp.escape(line)})/mi do |match|
+  "<line>hello</line>\n#{match}"
+end

data/lib/trace_appenders.rb

@@ -0,0 +1,9 @@
+require 'appenders/appender_registration'
+require 'appenders/appender'
+require 'appenders/base_appender'
+require 'appenders/file_appender'
+require 'appenders/logger_appender'
+require 'appenders/stream_appender'
+require 'appenders/xml_appender'
+require 'appenders/html_appender'
+require 'appenders/template_log_appender'

data/lib/trace_calls.rb

@@ -0,0 +1,86 @@
+require 'trace_ext'
+
+module Tracing
+  module TraceCalls
+    
+    def self.included(klass)
+      suppress_tracing do
+        klass.instance_methods(false).each do |existing_method|
+          wrap(klass, existing_method)
+        end
+      end
+      def klass.method_added(method)  # note: nested definition
+        unless @trace_calls_internal
+          @trace_calls_internal = true
+          TraceCalls.wrap(self, method)
+          @trace_calls_internal = false
+        end
+      end
+    end
+    
+    def self.suppress_tracing
+      Thread.current[:'suppress tracing'] = true
+      yield
+    ensure
+      Thread.current[:'suppress tracing'] = false
+    end
+
+    def self.ok_to_trace?(name)
+      !Thread.current[:'suppress tracing']
+    end      
+
+    def self.wrap(klass, method) 
+      klass.class_eval do
+        name = method.to_s
+        original_method = instance_method(name)
+
+        define_method(name) do |*args, &block|        
+          cls_name = self.class.to_s
+          context = {                  
+                     :modules => cls_name.modules,
+                     :full_module_name => cls_name.modules.join("::"),
+                     :class_name => cls_name.class_name,
+                     :full_class_name => cls_name, 
+                     :method_name => name, 
+                     :args => args, 
+                     :block => block_given?,
+                     :self => self,
+                     :vars => self.instance_variables} # to carry @template_path etc.
+          context[:method_full_name] = method_full_name(context)
+
+          if TraceCalls.ok_to_trace?(name)
+            TraceCalls.suppress_tracing do
+              if trace_method?(context) 
+                # puts "tracing before:" + context[:method_full_name]
+                handle_before_call(context)
+              end
+            end
+          end
+          result = original_method.bind(self).call(*args, &block)
+          if TraceCalls.ok_to_trace?(name)
+            TraceCalls.suppress_tracing do          
+              if trace_method?(context)  
+                # puts "tracing after:" + context[:method_full_name]                
+                context[:result] = result
+                handle_after_call(context)   
+              end
+            end
+          end
+          res = result
+          # if TraceCalls.ok_to_trace?(name)
+          #   TraceCalls.suppress_tracing do          
+          #     if trace_method?(name)                        
+          #       # method_stack.pop      
+          #     end
+          #   end
+          # end 
+          res         
+        end
+      end
+    end
+  
+    suppress_tracing do
+      include Tracing::TraceExt
+    end  
+  end
+end

data/lib/trace_ext.rb

@@ -0,0 +1,57 @@
+require 'templates/trace_output_handler'
+require 'trace_filters'
+require 'action_handler'
+require 'trace_appenders'
+
+module Tracing
+  module TraceExt
+    # include Tracing::Filter::Registration
+    include Tracing::Filter::Exec
+
+    class << self
+      include Tracing::Filter::Registration
+      include Tracing::ActionHandler::Registration
+
+      attr_accessor :final_yield_action
+
+      def configure(options)
+        # puts "Filters before config: " + Tracing::TraceExt.filters.inspect        
+        
+        register_filters(options[:filters])
+        
+        # puts "Filters after config: " + Tracing::TraceExt.filters.inspect        
+        
+        register_action_handlers(options[:action_handlers] || options)
+        @final_yield_action = options[:final_yield] || :include
+      end
+
+    end
+
+    def method_full_name(context)
+      "#{context[:class_name]}.#{context[:method_name]}"
+    end
+
+    def trace_method?(context)
+      filters_allow?('', context)
+    end
+
+    def handle_before_call(context)
+      exec_action_handlers('BEGIN' , context)
+    end
+
+    def handle_after_call(context)
+      exec_action_handlers('END' , context)      
+    end
+
+    def exec_action_handlers(txt, context)
+      _handlers = Tracing::TraceExt.action_handlers
+      
+      # puts "exec_action_handlers:" + _handlers.inspect       
+      return if !_handlers || !_handlers.kind_of?(Array)
+      # puts "each handler..."
+      _handlers.each do |handler|
+        handler.handle(txt, context)
+      end
+    end
+  end
+end

data/lib/trace_filters.rb

@@ -0,0 +1,4 @@
+require 'filters/tracing_filter'
+require 'filters/base_filters'
+require 'filters/composite_filters'
+require 'filters/filter_factory'

data/trace-util-adv.gemspec

@@ -0,0 +1,98 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{trace-util-adv}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kristian Mandrup"]
+  s.date = %q{2009-10-28}
+  s.description = %q{
+      Configure tracing using context sensitive filters, appenders, output templates in a completely non-intrusive fashion. 
+      Tracing can even be applied runtime as a response when certain conditions occur}
+  s.email = %q{kmandrup@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/README",
+     "lib/TODO.txt",
+     "lib/action_handler.rb",
+     "lib/appenders/appender.rb",
+     "lib/appenders/appender_registration.rb",
+     "lib/appenders/base_appender.rb",
+     "lib/appenders/file_appender.rb",
+     "lib/appenders/html_appender.rb",
+     "lib/appenders/logger_appender.rb",
+     "lib/appenders/stream_appender.rb",
+     "lib/appenders/template_log_appender.rb",
+     "lib/appenders/xml_appender.rb",
+     "lib/core_extensions.rb",
+     "lib/filters/base_filters.rb",
+     "lib/filters/composite_filters.rb",
+     "lib/filters/filter_factory.rb",
+     "lib/filters/message_filters.rb",
+     "lib/filters/tracing_filter.rb",
+     "lib/output_templates.rb",
+     "lib/rule_match.rb",
+     "lib/sample_filters.rb",
+     "lib/templates/base_template.rb",
+     "lib/templates/html_template.rb",
+     "lib/templates/string_template.rb",
+     "lib/templates/trace_output_handler.rb",
+     "lib/templates/xml_template.rb",
+     "lib/test_action_handler.rb",
+     "lib/test_appender.rb",
+     "lib/test_file_appender.rb",
+     "lib/test_filters.rb",
+     "lib/test_filters_chain.rb",
+     "lib/test_filters_create.rb",
+     "lib/test_html_appender.rb",
+     "lib/test_special_filters.rb",
+     "lib/test_xml_appender.rb",
+     "lib/test_xml_gen.rb",
+     "lib/trace-util-adv.rb",
+     "lib/trace_appenders.rb",
+     "lib/trace_calls.rb",
+     "lib/trace_ext.rb",
+     "lib/trace_filters.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/trace-util-adv_spec.rb",
+     "trace-util-adv.gemspec"
+  ]
+  s.homepage = %q{http://github.com/kristianmandrup/trace-util-adv}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{adds advancing tracing capability to your ruby code}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/trace-util-adv_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+