logical-insight 0.4.0

data/lib/insight/panels/sql_panel.rb

@@ -0,0 +1,53 @@
+require "digest"
+
+module Insight
+
+  class SQLPanel < Panel
+
+    require "insight/panels/sql_panel/panel_app"
+    require "insight/panels/sql_panel/query"
+
+    def initialize(app)
+      super
+      probe(self) do
+        %w{ PostgreSQLAdapter MysqlAdapter SQLiteAdapter
+            Mysql2Adapter OracleEnhancedAdapter }.each do |adapter|
+          instrument "ActiveRecord::ConnectionAdapters::#{adapter}" do
+            instance_probe :execute
+          end
+            end
+      end
+      table_setup("sql_queries")
+    end
+
+    def self.panel_mappings
+      { "sql" => PanelApp.new }
+    end
+
+    def after_detect(method_call, timing, arguments, results)
+      store(@env, QueryResult.new(arguments.first, timing.duration, method_call.backtrace, results))
+    end
+
+    def total_time(queries)
+      (queries.inject(0) do |memo, query|
+        memo + query.time
+      end)
+    end
+
+    def name
+      "sql"
+    end
+
+    def heading_for_request(number)
+      queries = retrieve(number)
+      "#{queries.size} Queries (%.2fms)" % total_time(queries)
+    end
+
+    def content_for_request(number)
+      queries = retrieve(number)
+      render_template "panels/sql", :queries => queries
+    end
+
+  end
+
+end

data/lib/insight/panels/sql_panel/panel_app.rb

@@ -0,0 +1,37 @@
+require 'insight/panels/sql_panel/query'
+
+module Insight
+  class SQLPanel
+
+    class PanelApp < ::Insight::PanelApp
+
+      def dispatch
+        case request.path_info
+        when "/explain" then explain_sql
+        when "/profile" then profile_sql
+        when "/execute" then execute_sql
+        else not_found
+        end
+      end
+
+      def explain_sql
+        validate_params
+        query = ExplainResult.new(params["query"], params["time"].to_f)
+        render_template "panels/explain_sql", :query => query
+      end
+
+      def profile_sql
+        validate_params
+        query = ProfileResult.new(params["query"], params["time"].to_f)
+        render_template "panels/profile_sql", :query => query
+      end
+
+      def execute_sql
+        validate_params
+        query = QueryResult.new(params["query"], params["time"].to_f)
+        render_template "panels/execute_sql", :query => query
+      end
+
+    end
+  end
+end

data/lib/insight/panels/sql_panel/query.rb

@@ -0,0 +1,94 @@
+module Insight
+  class SQLPanel
+
+    class QueryResult
+      include Insight::FilteredBacktrace
+
+      attr_reader :sql
+      attr_reader :time
+
+      def initialize(sql, time, backtrace = [], result=nil)
+        @sql = sql
+        @time = time
+        @backtrace = backtrace
+        @result = result
+        @results = nil
+      end
+
+      def result
+        @results ||= execute
+        return @results
+      end
+
+      def column_names
+        if result.respond_to?(:fields)
+          return result.fields
+        else
+          return result.fetch_fields.map{|col| col.name}
+        end
+      end
+
+      def rows
+        if result.respond_to?(:values)
+          result.values
+        else
+          result.map do |row|
+            row
+          end
+        end
+      end
+
+      def human_time
+        "%.2fms" % (@time)
+      end
+
+      def inspectable?
+        sql.strip =~ /^SELECT /i
+      end
+
+      #Downside is: we re-execute the SQL...
+      def self.execute(sql)
+        ActiveRecord::Base.connection.execute(sql)
+      end
+
+      def execute
+        self.class.execute(@sql)
+      end
+
+      def valid_hash?(secret_key, possible_hash)
+        hash = Digest::SHA1.hexdigest [secret_key, @sql].join(":")
+        possible_hash == hash
+      end
+    end
+
+    class ExplainResult < QueryResult
+      def execute
+        self.class.execute "EXPLAIN #{@sql}"
+      end
+    end
+
+    class ProfileResult < QueryResult
+      def with_profiling
+        result = nil
+        begin
+          self.class.execute("SET PROFILING=1")
+          result = yield
+        ensure
+          self.class.execute("SET PROFILING=0")
+        end
+        return result
+      end
+
+      def execute
+        with_profiling do
+          super
+          self.class.execute <<-SQL
+              SELECT *
+                FROM information_schema.profiling
+               WHERE query_id = (SELECT query_id FROM information_schema.profiling ORDER BY query_id DESC LIMIT 1)
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/insight/panels/templates_panel.rb

@@ -0,0 +1,58 @@
+module Insight
+
+  class TemplatesPanel < Panel
+    require "insight/panels/templates_panel/rendering"
+
+    def initialize(app)
+      super
+
+      probe(self) do
+        instrument "ActionView::Template" do
+          instance_probe :render
+        end
+      end
+
+      table_setup("templates")
+
+      @current = nil
+    end
+
+
+    def request_start(env, start)
+      @current = Rendering.new("root")
+    end
+
+    def request_finish(env, status, headers, body, timing)
+      store(env, @current)
+      @current = nil
+    end
+
+    def before_detect(method_call, args)
+      template_name = method_call.object.virtual_path
+
+      rendering = Rendering.new(template_name)
+      @current.add(rendering)
+      @current = rendering
+    end
+
+    def after_detect(method_call, timing, args, result)
+      @current.timing = timing
+      @current = @current.parent
+    end
+
+    def name
+      "templates"
+    end
+
+    def heading_for_request(number)
+      "Templates: %.2fms" % (retrieve(number).inject(0.0){|memo, rendering| memo + rendering.duration})
+    end
+
+    def content_for_request(number)
+      result = render_template "panels/templates", :root_rendering => retrieve(number).first
+      return result
+    end
+
+  end
+
+end

data/lib/insight/panels/templates_panel/rendering.rb

@@ -0,0 +1,81 @@
+module Insight
+  class TemplatesPanel
+
+    class Rendering
+      attr_accessor :name
+      attr_accessor :parent
+      attr_accessor :timing
+      attr_reader :children
+
+      def initialize(name, timing = nil)
+        @name = name
+        @timing = timing
+        @children = []
+      end
+
+      def start_time
+        @timing.start
+      end
+      alias_method :time, :start_time
+
+      def end_time
+        @timing.end
+      end
+
+      def add(rendering)
+        @children << rendering
+        rendering.parent = self
+      end
+
+      def delete(rendering)
+        @children.delete(rendering)
+      end
+
+      def duration
+        if @timing
+          @timing.duration
+        else
+          child_duration
+        end
+      end
+
+      def exclusive_duration
+        duration - child_duration
+      end
+
+      def child_duration
+        children.inject(0.0) { |memo, c| memo + c.duration }
+      end
+
+      def duration_summary
+        if children.any?
+          "%.2fms, %.2f exclusive" % [duration, exclusive_duration]
+        else
+          "%.2fms" % (duration)
+        end
+      end
+      def html
+        <<-HTML
+            <li>
+              <p>#{name} (#{duration_summary})</p>
+
+        #{children_html}
+            </li>
+        HTML
+      end
+
+      def children_html
+        return "" unless children.any?
+
+        <<-HTML
+            <ul>#{joined_children_html}</ul>
+        HTML
+      end
+
+      def joined_children_html
+        children.map { |c| c.html }.join
+      end
+    end
+
+  end
+end

data/lib/insight/panels/timer_panel.rb

@@ -0,0 +1,40 @@
+require 'benchmark'
+
+module Insight
+  class TimerPanel < Panel
+    def initialize(app)
+      super
+      table_setup("timer")
+    end
+
+    def name
+      "timer"
+    end
+
+    def call(env)
+      status, headers, body = nil
+      @times = Benchmark.measure do
+        status, headers, body = @app.call(env)
+      end
+
+      store(env, [
+            ["User CPU time",   "%.2fms" % (@times.utime * 1_000)],
+            ["System CPU time", "%.2fms" % (@times.stime * 1_000)],
+            ["Total CPU time",  "%.2fms" % (@times.total * 1_000)],
+            ["Elapsed time",    "%.2fms" % (@times.real  * 1_000)]
+      ])
+
+      return [status, headers, body]
+    end
+
+    def heading_for_request(number)
+      measurements = retreive(number).first
+
+      measurements.last.last
+    end
+
+    def content_for_request(number)
+      render_template "panels/timer", :measurements => retrieve(number).first
+    end
+  end
+end

data/lib/insight/params_signature.rb

@@ -0,0 +1,61 @@
+require "digest"
+
+module Insight
+
+  class ParamsSignature
+    extend ERB::Util
+
+    def self.sign(request, hash)
+      parts = []
+
+      hash.keys.sort.each do |key|
+        parts << "#{key}=#{u(hash[key])}"
+      end
+
+      signature = new(request).signature(hash)
+      parts << "hash=#{u(signature)}"
+
+      parts.join("&amp;")
+    end
+
+    attr_reader :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def secret_key
+      @request.env['insight.secret_key']
+    end
+
+    def secret_key_blank?
+      secret_key.nil? || secret_key == ""
+    end
+
+    def validate!
+      if secret_key_blank?
+        raise SecurityError.new("Missing secret key")
+      elsif request.params["hash"] != signature(request.params)
+        raise SecurityError.new("Invalid query hash.")
+      end
+    end
+
+    def signature(params)
+      Digest::SHA1.hexdigest(signature_base(params))
+    end
+
+    def signature_base(params)
+      signature = []
+      signature << secret_key
+
+      params.keys.sort.each do |key|
+        next if key == "hash"
+        signature << params[key].to_s
+      end
+
+      signature.join(":")
+    end
+
+  end
+
+end

data/lib/insight/public/__insight__/bookmarklet.html

@@ -0,0 +1,10 @@
+<html>
+  <head>
+  </head>
+  <body>
+    <br/><br/><br/>
+    <a href="javascript: (function(){var script=document.createElement('script'); script.src='/__insight__/bookmarklet.js'; document.getElementsByTagName('head')[0].appendChild(script);})()">
+      Toggle Insight
+    </a>
+  </body>
+</html>

data/lib/insight/public/__insight__/bookmarklet.js

@@ -0,0 +1,223 @@
+/**
+*
+*  Secure Hash Algorithm (SHA1)
+*  http://www.webtoolkit.info/
+*
+**/
+
+document.SHA1 = function(msg) {
+  function rotate_left(n,s) {
+    var t4 = ( n<<s ) | (n>>>(32-s));
+    return t4;
+  };
+
+  function lsb_hex(val) {
+    var str="";
+    var i;
+    var vh;
+    var vl;
+
+    for( i=0; i<=6; i+=2 ) {
+      vh = (val>>>(i*4+4))&0x0f;
+      vl = (val>>>(i*4))&0x0f;
+      str += vh.toString(16) + vl.toString(16);
+    }
+    return str;
+  };
+
+  function cvt_hex(val) {
+    var str="";
+    var i;
+    var v;
+
+    for( i=7; i>=0; i-- ) {
+      v = (val>>>(i*4))&0x0f;
+      str += v.toString(16);
+    }
+    return str;
+  };
+
+
+  function Utf8Encode(string) {
+    string = string.replace(/\r\n/g,"\n");
+    var utftext = "";
+
+    for (var n = 0; n < string.length; n++) {
+
+      var c = string.charCodeAt(n);
+
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      }
+      else if((c > 127) && (c < 2048)) {
+        utftext += String.fromCharCode((c >> 6) | 192);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+      else {
+        utftext += String.fromCharCode((c >> 12) | 224);
+        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+
+    }
+
+    return utftext;
+  };
+
+  var blockstart;
+  var i, j;
+  var W = new Array(80);
+  var H0 = 0x67452301;
+  var H1 = 0xEFCDAB89;
+  var H2 = 0x98BADCFE;
+  var H3 = 0x10325476;
+  var H4 = 0xC3D2E1F0;
+  var A, B, C, D, E;
+  var temp;
+
+  msg = Utf8Encode(msg);
+
+  var msg_len = msg.length;
+
+  var word_array = new Array();
+  for( i=0; i<msg_len-3; i+=4 ) {
+    j = msg.charCodeAt(i)<<24 | msg.charCodeAt(i+1)<<16 |
+    msg.charCodeAt(i+2)<<8 | msg.charCodeAt(i+3);
+    word_array.push( j );
+  }
+
+  switch( msg_len % 4 ) {
+    case 0:
+      i = 0x080000000;
+    break;
+    case 1:
+      i = msg.charCodeAt(msg_len-1)<<24 | 0x0800000;
+    break;
+
+    case 2:
+      i = msg.charCodeAt(msg_len-2)<<24 | msg.charCodeAt(msg_len-1)<<16 | 0x08000;
+    break;
+
+    case 3:
+      i = msg.charCodeAt(msg_len-3)<<24 | msg.charCodeAt(msg_len-2)<<16 | msg.charCodeAt(msg_len-1)<<8  | 0x80;
+    break;
+  }
+
+  word_array.push( i );
+
+  while( (word_array.length % 16) != 14 ) word_array.push( 0 );
+
+  word_array.push( msg_len>>>29 );
+  word_array.push( (msg_len<<3)&0x0ffffffff );
+
+
+  for ( blockstart=0; blockstart<word_array.length; blockstart+=16 ) {
+
+    for( i=0; i<16; i++ ) W[i] = word_array[blockstart+i];
+    for( i=16; i<=79; i++ ) W[i] = rotate_left(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
+
+    A = H0;
+    B = H1;
+    C = H2;
+    D = H3;
+    E = H4;
+
+    for( i= 0; i<=19; i++ ) {
+      temp = (rotate_left(A,5) + ((B&C) | (~B&D)) + E + W[i] + 0x5A827999) & 0x0ffffffff;
+      E = D;
+      D = C;
+      C = rotate_left(B,30);
+      B = A;
+      A = temp;
+    }
+
+    for( i=20; i<=39; i++ ) {
+      temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0x6ED9EBA1) & 0x0ffffffff;
+      E = D;
+      D = C;
+      C = rotate_left(B,30);
+      B = A;
+      A = temp;
+    }
+
+    for( i=40; i<=59; i++ ) {
+      temp = (rotate_left(A,5) + ((B&C) | (B&D) | (C&D)) + E + W[i] + 0x8F1BBCDC) & 0x0ffffffff;
+      E = D;
+      D = C;
+      C = rotate_left(B,30);
+      B = A;
+      A = temp;
+    }
+
+    for( i=60; i<=79; i++ ) {
+      temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0xCA62C1D6) & 0x0ffffffff;
+      E = D;
+      D = C;
+      C = rotate_left(B,30);
+      B = A;
+      A = temp;
+    }
+
+    H0 = (H0 + A) & 0x0ffffffff;
+    H1 = (H1 + B) & 0x0ffffffff;
+    H2 = (H2 + C) & 0x0ffffffff;
+    H3 = (H3 + D) & 0x0ffffffff;
+    H4 = (H4 + E) & 0x0ffffffff;
+
+  }
+
+  var temp = cvt_hex(H0) + cvt_hex(H1) + cvt_hex(H2) + cvt_hex(H3) + cvt_hex(H4);
+
+  return temp.toLowerCase();
+}
+
+document.createCookie = function(name,value,days) {
+  if (days) {
+    var date = new Date();
+    date.setTime(date.getTime()+(days*24*60*60*1000));
+    var expires = "; expires="+date.toGMTString();
+  }
+  else
+    var expires = "";
+  document.cookie = name+"="+value+expires+"; path=/";
+}
+
+document.readCookie = function(name) {
+  var nameEQ = name + "=";
+  var ca = document.cookie.split(';');
+  for(var i=0;i < ca.length;i++) {
+    var c = ca[i];
+    while (c.charAt(0)==' ')
+      c = c.substring(1,c.length);
+    if (c.indexOf(nameEQ) == 0)
+      return c.substring(nameEQ.length,c.length);
+  }
+  return null;
+}
+
+document.eraseCookie = function(name) {
+  document.createCookie(name,"",-1);
+}
+
+document.insightEnable = function() {
+  var password = prompt("Insight password:", "");
+  if (password != null) {
+    document.createCookie('insight_password', document.SHA1('insight:'+password));
+    document.createCookie('insight_enabled', "1");
+    window.location.reload();
+  }
+}
+
+document.insightDisable = function() {
+  document.eraseCookie('insight_password');
+  document.eraseCookie('insight_enabled');
+  window.location.reload();
+}
+
+document.insightBookmarklet = function() {
+  if (document.readCookie('insight_password')) {
+    document.insightDisable()
+  } else {
+    document.insightEnable()
+  }
+}