logical-insight 0.4.0

data/lib/insight/database.rb

@@ -0,0 +1,186 @@
+require 'insight'
+require 'sqlite3'
+require 'base64'
+
+module Insight
+  class Database
+    module RequestDataClient
+      def key_sql_template(sql)
+        @key_sql_template = sql
+      end
+
+      def table_setup(name, *keys)
+        @table = DataTable.new(name, *keys)
+        if keys.empty?
+          @key_sql_template = ""
+        end
+      end
+
+      def store(env, *keys_and_value)
+        return if env.nil?
+        request_id = env["insight.request-id"]
+        return if request_id.nil?
+
+        value = keys_and_value[-1]
+        keys = keys_and_value[0...-1]
+
+        @table.store(request_id, value, @key_sql_template % keys)
+      end
+
+      def retrieve(request_id)
+        @table.for_request(request_id)
+      end
+      alias retreive retrieve #JDL cannot spell
+
+      def table_length
+        @table.length
+      end
+    end
+
+    class << self
+      include Logging
+      def db
+        @db ||= open_database
+      end
+
+      def reset
+        @db = nil
+      end
+
+      def open_database
+        @db = SQLite3::Database.new("insight.sqlite")
+        @db.execute("pragma foreign_keys = on")
+        @db
+      rescue Object => ex
+        msg = "Issue while loading SQLite DB:" + [ex.class, ex.message, ex.backtrace[0..4]].inspect
+        logger.debug{ msg }
+
+        return {}
+      end
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          open_database if forked
+        end
+      end
+    end
+
+    class Table
+      include Logging
+
+      def db
+        Insight::Database.db
+      end
+
+      def create_keys_clause
+        "#{@keys.map{|key| "#{key} varchar"}.join(", ")}"
+      end
+
+      def create_sql
+        "create table #@table_name ( id integer primary key, #{create_keys_clause} )"
+      end
+
+      def execute(*args)
+        logger.debug{ ins_args = args.inspect; "(#{[ins_args.length,120].min}/#{ins_args.length})" + ins_args[0..120] }
+        db.execute(*args)
+      end
+
+      def initialize(table_name, *keys)
+        @table_name = table_name
+        @keys = keys
+        if(execute("select * from sqlite_master where name = ?", table_name).empty?)
+          execute(create_sql)
+
+          logger.debug{ "Initializing a table called #{table_name}" }
+        end
+      end
+
+      def select(which_sql, condition_sql)
+        execute("select #{which_sql} from #@table_name where #{condition_sql}")
+      end
+
+      def fields_sql
+        "#{@keys.join(",")}"
+      end
+
+      def insert(values_sql)
+        execute("insert into #@table_name(#{fields_sql}) values (#{values_sql})")
+      end
+
+      def keys(name)
+        execute("select #{name} from #@table_name").flatten
+      end
+
+      def length(where = "1 = 1")
+        execute("select count(1) from #@table_name where #{where}").first.first
+      end
+
+      def to_a
+        execute("select * from #@table_name")
+      end
+    end
+
+    class RequestTable < Table
+      def initialize()
+        super("requests", "method", "url", "date")
+      end
+
+      def store(method, url)
+        result = insert("'#{method}', '#{url}', #{Time.now.to_i}")
+        db.last_insert_row_id
+      end
+
+      def last_request_id
+        execute("select max(id) from #@table_name").first.first
+      end
+
+      def sweep
+        execute("delete from #@table_name where date < #{Time.now.to_i - (60 * 60 * 12)}")
+      end
+    end
+
+    require 'yaml'
+    class DataTable < Table
+      def initialize(name, *keys)
+        super(name, *(%w{request_id} + keys + %w{value}))
+      end
+
+      def create_keys_clause
+        non_request_keys = @keys - %w"request_id"
+        sql = non_request_keys.map{|key| "#{key} varchar"}.join(", ")
+        sql += ", request_id references requests(id) on delete cascade"
+        sql
+      end
+
+      def store(request_id, value, keys_sql = "")
+        sql = "'#{encode_value(value)}'"
+        sql = keys_sql + ", " + sql unless keys_sql.empty?
+        sql = "#{request_id}, #{sql}"
+        insert(sql)
+      end
+
+      def encode_value(value)
+        Base64.encode64(YAML.dump(value))
+      end
+
+      def decode_value(value)
+        YAML.load(Base64.decode64(value))
+      end
+
+      def retrieve(key_sql)
+        select("value", key_sql).map{|value| decode_value(value.first)}
+      end
+
+      def for_request(id)
+        retrieve("request_id = #{id}")
+      end
+
+      def to_a
+        super.map do |row|
+          row[-1] = decode_value(row[-1])
+        end
+      end
+    end
+  end
+end
+

data/lib/insight/enable-button.rb

@@ -0,0 +1,43 @@
+module Insight
+  class EnableButton
+    include Render
+
+    MIME_TYPES = ["text/html", "application/xhtml+xml"]
+
+    def initialize(app, insight)
+      @app = app
+      @insight = insight
+    end
+
+    def call(env)
+      @env = env
+      status, headers, body = @app.call(@env)
+
+      response = Rack::Response.new(body, status, headers)
+
+      inject_button(response) if okay_to_modify?(env, response)
+
+      return response.to_a
+    end
+
+    def okay_to_modify?(env, response)
+      req = Rack::Request.new(env)
+      content_type, charset = response.content_type.split(";")
+
+      response.ok? && MIME_TYPES.include?(content_type) && !req.xhr?
+    end
+
+    def inject_button(response)
+      full_body = response.body.join
+      full_body.sub! /<\/body>/, render + "</body>"
+
+      response["Content-Length"] = full_body.size.to_s
+
+      response.body = [full_body]
+    end
+
+    def render
+      render_template("enable-button")
+    end
+  end
+end

data/lib/insight/filtered_backtrace.rb

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

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

data/lib/insight/instrumentation/backstage.rb

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

data/lib/insight/instrumentation/client.rb

@@ -0,0 +1,20 @@
+require 'insight/instrumentation/package-definition'
+module Insight::Instrumentation
+  module Client
+    def probe(collector, &block)
+      ::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/insight/instrumentation/instrument.rb

@@ -0,0 +1,109 @@
+require 'insight/instrumentation/backstage'
+require 'insight/logger'
+
+module 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/insight/instrumentation/package-definition.rb

@@ -0,0 +1,58 @@
+module 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