lib/rack/insight/panel.rb
require "erb"
require "rack/insight/logging"
require 'rack/insight/database'
require 'rack/insight/instrumentation'
require 'rack/insight/render'
module Rack::Insight
# Panels are also Rack middleware
class Panel
include ERB::Util
include Rack::Insight::Logging
include Rack::Insight::Render
include Rack::Insight::Database::RequestDataClient
include Rack::Insight::Instrumentation::Client
attr_reader :request
# has table defaults to true for panels.
def self.has_table
self.has_table.nil? ? true : self.class.table.nil?
end
class << self
include Rack::Insight::Logging
# This will allow the following:
# p = Panel.new
# p.class.is_probing = true
include Rack::Insight::Instrumentation::EigenClient
include Rack::Insight::Database::EigenClient
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['rack-panel_file'] = Thread::current['rack-panel_file'], rel_path
num_load_paths_to_check = Rack::Insight::Config.config[:panel_load_paths].length
Rack::Insight::Config.config[:panel_load_paths].each_with_index do |load_path, index|
begin
require File::join(load_path, rel_path)
break # once found
rescue LoadError => e
# TODO: If probes are defined for this panel, instantiate a magic panel
# if self.has_custom_probes?
if !verbose(:high) && (index + 1) == num_load_paths_to_check # You have failed me for the last time!
warn "Rack::Insight #{e.class} while attempting to load '#{rel_path}' from :panel_load_paths #{Rack::Insight::Config.config[:panel_load_paths].inspect}."
elsif verbose(:high)
warn "Rack::Insight #{e.class} #{e.message} while attempting to load '#{rel_path}' from :panel_load_paths #{Rack::Insight::Config.config[:panel_load_paths].inspect} (just checked: #{load_path})."
end
end
end
return (file_index[rel_path] - panel_exclusion)
ensure
Thread::current['rack-panel_file'] = old_rel
end
def set_sub_class_template_root(sub_class, path)
sub_class.template_root = path
end
def current_panel_file(sub)
file_name = nil
matched_line = nil
caller.each do |line|
# First make sure we are not matching rack-insight's own panel class, which will be in the caller stack,
# and which may match some custom load path added (try adding 'rack' as a custom load path!)
# .*panel because the panels that ship with rack-insight also do not need custom template roots.
next if line =~ /rack-insight.*\/lib\/rack\/insight\/.*panel.rb:/
Rack::Insight::Config.config[:panel_load_paths].each do |load_path|
regex = %r{^[^:]*#{load_path}/([^:]*)\.rb:}
md = regex.match line
file_name = md[1] unless md.nil?
matched_line = line unless file_name.nil?
break unless file_name.nil?
end
break unless file_name.nil?
end
set_sub_class_template_root(sub, File.dirname(matched_line.split(':')[0])) if matched_line.respond_to?(:split)
return Thread::current['rack-panel_file'] || file_name
end
def inherited(sub)
if filename = current_panel_file(sub)
logger.debug("panel inherited by #{sub.inspect} with template_root: #{sub.template_root}") if verbose(:high)
Panel::file_index[filename] << sub
else
warn "Rack::Insight::Panel inherited by #{sub.name} outside rack-insight's :panel_load_paths. Discarded. Configured panel load paths are: #{Rack::Insight::Config.config[:panel_load_paths].inspect}"
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
# User has explicitly declared what classes/methods to probe:
# Rack::Insight::Config.configure do |config|
# config[:panel_configs][:log] = {:probes => {'Logger' => [:instance, :add] } }
# # OR EQUIVALENTLY
# config[:panel_configs][:log] = {:probes => ['Logger', :instance, :add] }
# end
panel_name = self.underscored_name.to_sym
if self.has_custom_probes?(panel_name)
# Both formats are valid and must be supported
#config[:panel_configs][:log] = {:probes => {'Logger' => [:instance, :add]}}
#config[:panel_configs][:log] = {:probes => ['Logger', :instance, :add]}
custom_probes = Rack::Insight::Config.config[:panel_configs][panel_name][:probes]
if custom_probes.kind_of?(Hash)
probe(self) do
custom_probes.each do |klass, method_probes|
instrument klass do
self.send("#{method_probes[0]}_probe", *(method_probes[1..-1]))
end
end
end
elsif custom_probes.kind_of?(Array) && custom_probes.length >=3
probe(self) do
custom_probes.each do |probe|
klass = probe.shift
probe_type = probe.shift
instrument klass do
self.send("#{probe_type}_probe", *probe)
end
end
end
else
raise "Expected Rack::Insight::Config.config[:panel_configs][#{panel_name}][:probes] to be a kind of Hash or an Array with length >= 3, but is a #{Rack::Insight::Config.config[:panel_configs][self.as_sym][:probes].class}"
end
end
# Setup a table for the panel unless
# 1. self.has_table = false has been set for the Panel class
# 2. class instance variable @has_table has been set to false
# 3. table_setup has already been called by the sub class' initializer
if !has_table?
table_setup(self.name)
end
end
def inspect
"#{self.underscored_name} Magic:#{self.bool_prop(:is_magic?)} Table:#{self.bool_prop(:has_table?)} Probe:#{self.bool_prop(:is_probing?)} Custom:#{self.bool_prop(:has_custom_probes?)}" rescue "XXX inspect failed"
end
def bool_prop(prop)
self.send(prop) ? 'Y' : 'N'
end
def call(env)
@env = env
logger.debug{ "Before call: #{self.name}" } if verbose(:debug)
before(env)
status, headers, body = @app.call(env)
@request = Rack::Request.new(env)
logger.debug{ "After call: #{self.name}" } if verbose(:debug)
after(env, status, headers, body)
env["rack-insight.panels"] << self
return [status, headers, body]
end
def panel_app
nil
end
def self.panel_mappings
{}
end
def has_table?
!!self.class.has_table
end
def is_magic?
!!self.class.is_magic
end
def has_content?
true
end
def is_probing?
!!self.class.is_probing
end
def has_custom_probes?(panel_name = self.underscored_name.to_sym)
Rack::Insight::Config.config[:panel_configs][panel_name].respond_to?(:[]) &&
!Rack::Insight::Config.config[:panel_configs][panel_name][:probes].nil?
end
# The name informs the table name, and the panel_configs hash among other things.
# Override in subclass panels if you want a custom name
def name
self.underscored_name
end
# Mostly stolen from Rails' ActiveSupport' underscore method:
# See activesupport/lib/active_support/inflector/methods.rb, line 77
# HTTPClientPanel => http_client
# LogPanel => log
# ActiveRecordPanel => active_record
def underscored_name(word = self.class.to_s)
@underscored_name ||= begin
words = word.dup.split('::')
word = words.last
if word == 'Panel'
word = words[-2] # Panel class is Panel... and this won't do.
end
# This bit from rails probably isn't needed here, and wouldn't work anyways.
#word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
word.gsub!(/Panel$/,'')
word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
word.tr!("-", "_")
word.downcase!
word
end
end
def camelized_name(str = self.underscored_name)
str.split('_').map {|w| w.capitalize}.join
end
def heading_for_request(number)
if !self.has_table?
heading
else
num = count(number)
if num.kind_of?(Numeric)
if num == 0
heading
else
"#{self.camelized_name} (#{num})"
end
else
heading
end
end
rescue StandardError => exception
handle_error_for('heading_for_request', exception)
end
def content_for_request(number)
logger.info("Rack::Insight is using default content_for_request for #{self.class}") if verbose(:med)
if !self.has_table?
logger.info("#{self.class} is being used without a table") if verbose(:med)
content
elsif self.is_probing? # Checking probed because we only get here when the subclass panel hasn't overridden this method
invocations = retrieve(number)
if invocations.length > 0
logger.info("Rack::Insight is using #{self.is_magic? ? 'magic' : 'default'} content for #{self.class}, which is probed")# if verbose(:med)
render_template 'magic_panel', :magic_insights => invocations, :name => self.camelized_name
else
logger.info("Rack::Insight has no data for #{self.is_magic? ? 'magic' : 'default'} content for #{self.class}, which is probed")
render_template 'no_data', :name => self.camelized_name
end
else
content
end
rescue StandardError => exception
handle_error_for('content_for_request', exception)
end
def heading
self.camelized_name
rescue StandardError => exception
handle_error_for('heading', exception)
end
def content
logger.info("Rack::Insight is using default content for #{self.class}") if verbose(:med)
render_template 'no_content', :name => self.camelized_name
rescue StandardError => exception
handle_error_for('content', exception)
end
def handle_error_for(method_name, exception)
nom = self.name rescue "xxx"
msg = ["#{self.class}##{method_name} failed","#{exception.class}: #{exception.message}"] + exception.backtrace
logger.error(msg.join("\n"))
# return HTML
"Error in #{nom}
<!-- Panel: #{self.inspect}\n
#{msg.join("\n")} -->"
end
# Override in subclasses.
# This is to make magic classes work.
def after_detect(method_call, timing, args, result)
if self.is_magic? && self.has_table? && self.is_probing?
store(@env, Rack::Insight::DefaultInvocation.new(method_call.method.to_s, timing, args, result, method_call.backtrace[2..-1]))
end
end
def before(env)
end
def after(env, status, headers, body)
end
def render(template)
end
end
end