logical-insight 0.4.0

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

@@ -0,0 +1,20 @@
+module 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/insight/instrumentation/probe.rb

@@ -0,0 +1,199 @@
+module 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['insight.instrument']
+          result = nil
+          if instrument.nil?
+            backstage do
+              # Rails.logger.debug{"No instrument in thread - #{context} /
+              # #{called_at}"}
+              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.info{ "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
+        #$stderr.puts block.call.inspect
+      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

data/lib/insight/instrumentation/setup.rb

@@ -0,0 +1,32 @@
+module Insight::Instrumentation
+  class Setup
+    def initialize(app)
+      @app = app
+    end
+
+    def setup(env)
+      instrument = Instrument.new
+
+      PackageDefinition.start
+      instrument.start(env)
+
+      env["insight.instrument"] = instrument
+      Thread::current["insight.instrument"] = instrument
+    end
+
+    def teardown(env, status, headers, body)
+      instrument, env["insight.instrument"] = env["insight.instrument"], nil
+      instrument.finish(env, status, headers, body)
+      Thread::current["insight.instrument"] = nil
+
+      env["insight.duration"] = instrument.duration
+    end
+
+    def call(env)
+      setup(env)
+      status, headers, body = @app.call(env)
+      teardown(env, status, headers, body)
+      return [status, headers, body]
+    end
+  end
+end

data/lib/insight/logger.rb

@@ -0,0 +1,55 @@
+module Insight
+  class Logger
+    def initialize(level, path)
+      @level = level
+      @log_path = path
+      @logfile = nil
+    end
+
+    attr_accessor :level
+
+    DEBUG    =  0
+    INFO     =  1
+    WARN     =  2
+    ERROR    =  3
+    FATAL    =  4
+    UNKNOWN  =  5
+
+    def log(severity, message)
+      message = message.inspect unless String === message
+      return unless severity >= @level
+
+      if defined? Rails and
+        Rails.respond_to? :logger
+        not Rails.logger.nil?
+        Rails.logger.add(severity, "[Insight]: " + message)
+      end
+
+      logfile.puts(message)
+    end
+
+    def logfile
+      @logfile ||= File::open(@log_path, "a+")
+    rescue
+      $stderr
+    end
+
+    def debug;   log(DEBUG,   yield) end
+    def info;    log(INFO,    yield) end
+    def warn;    log(WARN,    yield) end
+    def error;   log(ERROR,   yield) end
+    def fatal;   log(FATAL,   yield) end
+    def unknown; log(UNKNOWN, yield) end
+  end
+
+  module Logging
+    def logger(env = nil)
+      if env.nil?
+        Thread.current['insight.logger'] ||= Logger.new(Logger::DEBUG, "")
+      else
+        env["insight.logger"]
+      end
+    end
+    module_function :logger
+  end
+end

data/lib/insight/options.rb

@@ -0,0 +1,102 @@
+require 'ipaddr'
+module Insight
+  module Options
+    class << self
+      private
+      def option_accessor(key)
+        define_method(key) { || read_option(key) }
+        define_method("#{key}=") { |value| write_option(key, value) }
+        define_method("#{key}?") { || !! read_option(key) }
+      end
+    end
+
+    option_accessor :secret_key
+    option_accessor :ip_masks
+    option_accessor :password
+    option_accessor :panel_classes
+    option_accessor :intercept_redirects
+
+    # The underlying options Hash. During initialization (or outside of a
+    # request), this is a default values Hash. During a request, this is the
+    # Rack environment Hash. The default values Hash is merged in underneath
+    # the Rack environment before each request is processed.
+    def options
+      @env || @default_options
+    end
+
+    # Set multiple options.
+    def options=(hash={})
+      hash.each { |key,value| write_option(key, value) }
+    end
+
+    # Set an option. When +option+ is a Symbol, it is set in the Rack
+    # Environment as "rack-cache.option". When +option+ is a String, it
+    # exactly as specified. The +option+ argument may also be a Hash in
+    # which case each key/value pair is merged into the environment as if
+    # the #set method were called on each.
+    def set(option, value=self, &block)
+      if block_given?
+        write_option option, block
+      elsif value == self
+        self.options = option.to_hash
+      else
+        write_option option, value
+      end
+    end
+
+    private
+
+    def read_option(key)
+      options[option_name(key)]
+    end
+
+    def write_option(key, value)
+      options[option_name(key)] = value
+    end
+
+    def option_name(key)
+      case key
+      when Symbol ; "insight.#{key}"
+      when String ; key
+      else raise ArgumentError
+      end
+    end
+
+    def process_options
+      if(file_list = read_option('insight.panel_files'))
+        class_list = read_option('insight.panel_classes') || []
+        file_list.each do |file|
+          class_list |= Insight::Panel.from_file(file)
+        end
+        write_option('insight.panel_classes', class_list)
+      end
+    end
+
+    def initialize_options(options=nil)
+      @default_options = {
+        'insight.ip_masks'             =>  [IPAddr.new("127.0.0.1")],
+        'insight.password'             =>  nil,
+        'insight.verbose'              =>  nil,
+        'insight.secret_key'           =>  nil,
+        'insight.intercept_redirects'  =>  false,
+        'insight.panels'               =>  [],
+        'insight.log_level'            =>  Logger::INFO,
+        'insight.log_path'             =>  "log/insight.log",
+        'insight.panel_files'          =>  %w{
+          rails_info_panel
+          timer_panel
+          request_variables_panel
+          sql_panel
+          active_record_panel
+          cache_panel
+          templates_panel
+          log_panel
+          memory_panel
+        }
+      }
+      self.options = options || {}
+      process_options
+    end
+
+  end
+end

data/lib/insight/panel.rb

@@ -0,0 +1,119 @@
+require "erb"
+require 'insight/database'
+require 'insight/instrumentation'
+require 'insight/render'
+
+module Insight
+
+  # Panels are also Rack middleware
+  class Panel
+    include Render
+    include ERB::Util
+    include Database::RequestDataClient
+    include Logging
+    include Instrumentation::Client
+
+    attr_reader :request
+
+    class << self
+      def file_index
+        return @file_index ||= Hash.new do |h,k|
+          h[k] = []
+        end
+      end
+
+      def panel_exclusion
+        return @panel_exclusion ||= []
+      end
+
+      def from_file(rel_path)
+        old_rel, Thread::current['panel_file'] = Thread::current['panel_file'], rel_path
+        require File::join('insight', 'panels', rel_path)
+        return (file_index[rel_path] - panel_exclusion)
+      ensure
+        Thread::current['panel_file'] = old_rel
+      end
+
+      def current_panel_file
+        return Thread::current['panel_file'] ||
+          begin
+            file_name = nil
+            caller.each do |line|
+              md = %r{^[^:]*insight/panels/([^:]*)\.rb:}.match line
+              unless md.nil?
+                file_name = md[1]
+              end
+            end
+            file_name
+          end
+      end
+
+      def inherited(sub)
+        if filename = current_panel_file
+          Panel::file_index[current_panel_file] << sub
+        else
+          warn "Insight::Panel inherited by #{sub.name} outside of an insight/panels/* file.  Discarded"
+        end
+      end
+
+      def excluded(klass = nil)
+        Panel::panel_exclusion << klass || self
+      end
+
+    end
+
+    def initialize(app)
+      if panel_app
+        #XXX use mappings
+        @app = Rack::Cascade.new([panel_app, app])
+      else
+        @app = app
+      end
+    end
+
+    def call(env)
+      @env = env
+      before(env)
+      status, headers, body = @app.call(env)
+      @request = Rack::Request.new(env)
+      after(env, status, headers, body)
+      env["insight.panels"] << self
+      return [status, headers, body]
+    end
+
+    def panel_app
+      nil
+    end
+
+    def self.panel_mappings
+      {}
+    end
+
+    def has_content?
+      true
+    end
+
+    def name
+      "Unnamed panel: #{__FILE__}" #for shame
+    end
+
+    def heading_for_request(number)
+      heading rescue "xxx" #XXX: no panel should need this
+    end
+
+    def content_for_request(number)
+      content rescue "" #XXX: no panel should need this
+    end
+
+    def before(env)
+    end
+
+    def after(env, status, headers, body)
+    end
+
+    def render(template)
+    end
+
+  end
+
+end