rack-insight 0.5.0

data/lib/rack/insight/filtered_backtrace.rb

@@ -0,0 +1,45 @@
+module Rack::Insight
+  module FilteredBacktrace
+
+    def backtrace
+      @backtrace
+    end
+
+    def has_backtrace?
+      filtered_backtrace.any?
+    end
+
+    def filtered_backtrace
+      @filtered_backtrace ||= @backtrace.grep(FilteredBacktrace.backtrace_regexp)
+    end
+
+    def self.backtrace_regexp
+      @backtrace_regexp ||=
+        begin
+          if true or (app_root = root_for_backtrace_filtering).nil?
+            /.*/
+          else
+            excludes = %w{vendor}
+            %r{^#{app_root}(?:#{::File::Separator}(?!#{excludes.join("|")}).+)$}
+          end
+        end
+    end
+
+    def self.root_for_backtrace_filtering(sub_path = nil)
+      if defined?(Rails) && Rails.respond_to?(:root)
+        sub_path ? Rails.root.join(sub_path) : Rails.root
+      else
+        root = if defined?(RAILS_ROOT)
+                 RAILS_ROOT
+               elsif defined?(ROOT)
+                 ROOT
+               elsif defined?(Sinatra::Application)
+                 Sinatra::Application.root
+               else
+                 nil
+               end
+        sub_path ? ::File.join(root, sub_path) : root
+      end
+    end
+  end
+end

data/lib/rack/insight/instrumentation.rb

@@ -0,0 +1,9 @@
+module Rack::Insight
+  module Instrumentation; end
+end
+require 'rack/insight/instrumentation/instrument'
+require 'rack/insight/instrumentation/probe'
+require 'rack/insight/instrumentation/client'
+require 'rack/insight/instrumentation/setup'
+require 'rack/insight/instrumentation/package-definition'
+require 'rack/insight/instrumentation/probe-definition'

data/lib/rack/insight/instrumentation/backstage.rb

@@ -0,0 +1,10 @@
+module Rack::Insight::Instrumentation
+  module Backstage
+    def backstage
+      Thread.current["instrumented_backstage"] = true
+      yield
+    ensure
+      Thread.current["instrumented_backstage"] = false
+    end
+  end
+end

data/lib/rack/insight/instrumentation/client.rb

@@ -0,0 +1,20 @@
+require 'rack/insight/instrumentation/package-definition'
+module Rack::Insight::Instrumentation
+  module Client
+    def probe(collector, &block)
+      ::Rack::Insight::Instrumentation::PackageDefinition::probe(collector, &block)
+    end
+
+    def request_start(env, start)
+    end
+
+    def before_detect(method_call, arguments)
+    end
+
+    def after_detect(method_call, timing, arguments, result)
+    end
+
+    def request_finish(env, status, headers, body, timing)
+    end
+  end
+end

data/lib/rack/insight/instrumentation/instrument.rb

@@ -0,0 +1,109 @@
+require 'rack/insight/instrumentation/backstage'
+require 'rack/insight/logger'
+
+module Rack::Insight
+  module Instrumentation
+    class Instrument
+      MethodCall = Struct.new(:call_number, :backtrace, :file, :line, :object, :context, :kind, :method, :thread)
+      class Timing
+        def initialize(request_start, start, finish)
+          @request_start, @start, @finish = request_start, start, finish
+        end
+
+        attr_reader :request_start, :start, :finish
+
+        def duration
+          @duration ||= ((@finish - @start) * 1000).to_i
+        end
+
+        def delta_t
+          @delta_t ||= ((@start - @request_start) * 1000).to_i
+        end
+      end
+
+      @@call_seq = 0
+
+      def self.seq_number
+        Thread.exclusive do
+          return @@call_seq += 1
+        end
+      end
+
+      def initialize()
+        @start = Time.now
+        @collectors = nil
+      end
+
+      include Backstage
+
+      include Logging
+
+      def run(object, context="::", kind=:instance, called_at = caller[0], method = "<unknown>", args=[], &blk)
+        file, line, rest = called_at.split(':')
+        call_number = backstage{ self.class.seq_number }
+        method_call = backstage{ MethodCall.new(call_number, caller(1), file, line, object, context, kind, method, Thread::current) }
+        #$stderr.puts [method_call.context, method_call.method].inspect
+        start_time = Time.now
+        backstage do
+          start_event(method_call, args)
+        end
+        result = blk.call      # execute the provided code block
+        backstage do
+          finish_event(method_call, args, start_time, result)
+        end
+      end
+
+      def collectors_for(method_call)
+        probe_chain = if method_call.kind == :instance
+                        InstanceProbe.get_probe_chain(method_call.context)
+                      else
+                        ClassProbe.get_probe_chain(method_call.context)
+                      end
+        collectors = probe_chain.inject([]) do |list, probe|
+          probe.collectors(method_call.method)
+        end
+        logger.debug do
+          "Probe chain for: #{method_call.context} #{method_call.kind} #{method_call.method}:\n  #{collectors.map{|col| col.class.name}.join(", ")}"
+        end
+        collectors
+      end
+
+      def start_event(method_call, arguments)
+        logger.debug{ "Starting event: #{method_call.context} #{method_call.kind} #{method_call.method}" }
+
+        collectors_for(method_call).each do |collector|
+          collector.before_detect(method_call, arguments)
+        end
+      end
+
+      def finish_event(method_call, arguments, start_time, result)
+        timing = Timing.new(@start, start_time, Time.now)
+        logger.debug{ "Finishing event: #{method_call.context} #{method_call.kind} #{method_call.method}" }
+        collectors_for(method_call).each do |collector|
+          collector.after_detect(method_call, timing, arguments, result)
+        end
+      end
+
+      def all_collectors
+        PackageDefinition.all_collectors
+      end
+
+      def start(env)
+        all_collectors.each do |collector|
+          collector.request_start(env, @start)
+        end
+      end
+
+      def finish(env, status, headers, body)
+        @timing = Timing.new(@start, @start, Time.now)
+        all_collectors.each do |collector|
+          collector.request_finish(env, status, headers, body, @timing)
+        end
+      end
+
+      def duration
+        @timing.duration
+      end
+    end
+  end
+end

data/lib/rack/insight/instrumentation/package-definition.rb

@@ -0,0 +1,58 @@
+module Rack::Insight::Instrumentation
+  class PackageDefinition
+    class << self
+      def start
+        @started = begin
+                     probes.each do |probe|
+                       probe.fulfill_probe_orders
+                     end
+                     true
+                   end
+      end
+
+      def probes
+        InstanceProbe.all_probes + ClassProbe.all_probes
+      end
+
+      def clear_collectors
+        all_collectors.clear
+      end
+
+      def all_collectors
+        @all_collectors ||= []
+      end
+
+      def add_collector(collector)
+        unless all_collectors.include?(collector)
+          all_collectors << collector
+        end
+      end
+
+      def probe(collector, &block)
+        add_collector(collector)
+        definer = self.new(collector)
+        definer.instance_eval &block
+      end
+    end
+
+    def get_class_probe(name)
+      ClassProbe.probe_for(name)
+    end
+
+    def get_instance_probe(name)
+      InstanceProbe.probe_for(name)
+    end
+
+    def initialize(collector)
+      @collector = collector
+    end
+
+    attr_reader :collector
+
+    def instrument(name, &block)
+      definer = ProbeDefinition.new(self, name)
+      definer.instance_eval(&block) unless block.nil?
+      return definer
+    end
+  end
+end

data/lib/rack/insight/instrumentation/probe-definition.rb

@@ -0,0 +1,20 @@
+module Rack::Insight::Instrumentation
+  class ProbeDefinition
+    def initialize(package, target_name)
+      @package = package
+      @target_name = target_name
+    end
+
+    def instance_probe(*method_names)
+      if probes = @package.get_instance_probe(@target_name)
+        probes.probe(@package.collector, *method_names)
+      end
+    end
+
+    def class_probe(*method_names)
+      if probes = @package.get_class_probe(@target_name)
+        probes.probe(@package.collector, *method_names)
+      end
+    end
+  end
+end

data/lib/rack/insight/instrumentation/probe.rb

@@ -0,0 +1,196 @@
+module Rack::Insight
+  module Instrumentation
+    class Probe
+      module Interpose
+      end
+
+      @@class_list = nil
+
+      module ProbeRunner
+        include Backstage
+        include Logging
+
+        def probe_run(object, context = "::", kind=:instance, args=[], called_at=caller[1], method_name = nil)
+          if Thread.current['instrumented_backstage']
+            #warn "probe_run while backstage: #{context}, #{kind},
+            ##{method_name}" unless method_name.to_sym == :add
+            return yield
+          end
+          instrument = Thread.current['rack-insight.instrument']
+          result = nil
+          if instrument.nil?
+            backstage do
+              result = yield
+            end
+          else
+            instrument.run(object, context, kind, called_at, method_name, args){ result = yield }
+          end
+          result
+        end
+        extend self
+      end
+
+      class << self
+        include Logging
+
+        def class_list
+          @@class_list ||= begin
+                             classes = []
+                             ObjectSpace.each_object(Class) do |klass|
+                               classes << klass
+                             end
+                             classes
+                           end
+        end
+
+        def get_probe_chain(name)
+          const = const_from_name(name)
+          chain = []
+          const.ancestors.each do |mod|
+            if probes.has_key?(mod.name)
+              chain << probes[mod.name]
+            end
+          end
+          chain
+        end
+
+        def const_from_name(name)
+          parts = name.split("::")
+          const = parts.inject(Kernel) do |namespace, part|
+            namespace.const_get(part)
+          end
+        end
+
+        def probes
+          @probes ||= Hash.new do |h,k|
+            begin
+              h[k] = self.new(const_from_name(k))
+            rescue NameError
+              logger.warn{ "Cannot find constant: #{k}" }
+            end
+          end
+        end
+
+        def all_probes
+          probes.values
+        end
+
+        def probe_for(const)
+          probes[const]
+        end
+      end
+
+      def initialize(const)
+        @const = const
+        @probed = {}
+        @collectors = Hash.new{|h,k| h[k] = []}
+        @probe_orders = []
+      end
+
+      def collectors(key)
+        @collectors[key.to_sym]
+      end
+
+      def all_collectors
+        @collectors.values
+      end
+
+      def clear_collectors
+        @collectors.clear
+      end
+
+      def probe(collector, *methods)
+        methods.each do |name|
+          unless @collectors[name.to_sym].include?(collector)
+            @collectors[name.to_sym] << collector
+          end
+          @probe_orders << name
+        end
+      end
+
+      def descendants
+        @descendants ||= self.class.class_list.find_all do |klass|
+          klass.ancestors.include?(@const)
+        end
+      end
+
+      def local_method_defs(klass)
+        klass.instance_methods(false)
+      end
+
+      def descendants_that_define(method_name)
+        log{{ :descendants => descendants }}
+        descendants.find_all do |klass|
+          (@const != klass and local_method_defs(klass).include?(method_name))
+        end
+      end
+
+      include Logging
+      def log &block
+        logger.debug &block
+      end
+
+      def fulfill_probe_orders
+        log{{:probes_for => @const.name, :type => self.class}}
+        @probe_orders.each do |method_name|
+          log{{ :method => method_name }}
+          build_tracing_wrappers(@const, method_name)
+          descendants_that_define(method_name).each do |klass|
+            log{{ :subclass => klass.name }}
+            build_tracing_wrappers(klass, method_name)
+          end
+        end
+        @probe_orders.clear
+      end
+
+      def get_method(klass, method_name)
+        klass.instance_method(method_name)
+      end
+
+      def define_trace_method(target, method)
+        target.class_exec() do
+          define_method(method.name) do |*args, &block|
+            ProbeRunner::probe_run(self, method.owner.name, :instance, args, caller(0)[0], method.name) do
+              method.bind(self).call(*args, &block)
+            end
+          end
+        end
+      end
+
+      def build_tracing_wrappers(target, method_name)
+        return if @probed.has_key?([target,method_name])
+        @probed[[target,method_name]] = true
+
+        meth = get_method(target, method_name)
+
+        log{ {:tracing => meth } }
+        define_trace_method(target, meth)
+      rescue NameError => ne
+        log{ {:not_tracing => NameError } }
+      end
+    end
+
+    class ClassProbe < Probe
+      def local_method_defs(klass)
+        klass.singleton_methods(false)
+      end
+
+      def get_method(klass, method_name)
+        (class << klass; self; end).instance_method(method_name)
+      end
+
+      def define_trace_method(target, method)
+        (class << target; self; end).class_exec() do
+          define_method(method.name) do |*args, &block|
+          ProbeRunner::probe_run(self, target.name, :class, args, caller(0)[0], method.name) do
+            method.bind(self).call(*args, &block)
+          end
+          end
+        end
+      end
+    end
+
+    class InstanceProbe < Probe
+    end
+  end
+end