dvdplm-taskr 0.3.1

data/lib/taskr/models.rb

@@ -0,0 +1,370 @@
+# This file is part of Taskr.
+#
+# Taskr is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Taskr is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Taskr.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'camping/db'
+require 'openwfe/util/scheduler'
+require 'date'
+
+class Rufus::Scheduler
+  public :duration_to_f
+end
+
+
+module Taskr::Models
+
+  class Task < Base
+    has_many :task_actions, 
+      :include => :action_parameters, 
+      :dependent => :destroy
+    
+    serialize :schedule_options
+    serialize :last_triggered_error
+    
+    validates_presence_of :schedule_method
+    validates_presence_of :schedule_when
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :task_actions
+    validates_associated :task_actions
+    
+    def schedule!(scheduler = Taskr.scheduler)
+      case schedule_method
+      when 'cron'
+        method = :schedule
+      when 'at'
+        method = :schedule_at
+      when 'in'
+        method = :schedule_in
+      when 'every'
+        method = :schedule_every
+      end
+      
+      if method == :schedule_at || method == :schedule_in
+        t = next_trigger_time
+        method = :schedule_at
+        if t < Time.now
+          $LOG.warn "Task #{name.inspect} will not be scheduled because its trigger time is in the past (#{t.inspect})."
+          return nil
+        end
+      end
+      
+      $LOG.debug "Scheduling task #{name.inspect}: #{self.inspect}"
+      
+      if task_actions(true).length > 0
+        action = prepare_action
+      else
+        $LOG.warn "Task #{name.inspect} has no actions and as a result will not be scheduled!"
+        return false
+      end
+      
+      job_id = scheduler.send(method, t || schedule_when, :schedulable => action)
+      
+      if job_id
+        $LOG.debug "Task #{name.inspect} scheduled with job id #{job_id}"
+      else
+        $LOG.error "Task #{name.inspect} was NOT scheduled!"
+        return nil
+      end
+      
+      self.update_attribute(:scheduler_job_id, job_id)
+      if method == :schedule_at || method == :schedule_in
+        job = scheduler.get_job(job_id)
+        at = job.schedule_info
+        self.update_attribute(:schedule_when, at)
+        self.update_attribute(:schedule_method, 'at')
+      end
+      
+      return job_id
+    end
+    
+    def prepare_action
+      if task_actions.length == 1
+        ta = task_actions.first
+        
+        parameters = {}
+        ta.action_parameters.each{|p| parameters[p.name] = p.value}
+        
+        action = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
+        action.task = self
+        action.task_action = ta
+      elsif task_actions.length > 1
+        action = Taskr::Actions::Multi.new
+        task_actions.each do |ta|
+          parameters = {}
+          ta.action_parameters.each{|p| parameters[p.name] = p.value}
+          
+          a = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
+          a.task = self
+          a.task_action = ta
+          
+          action.actions << a 
+        end
+        action.task = self
+      else
+        raise "Task #{name.inspect} has no actions!"
+      end
+      
+      action
+    end
+    
+    def next_trigger_time
+      # TODO: need to figure out how to calulate trigger_time for these.. for now return :unknown
+      return :unknown unless schedule_method == 'at' || schedule_method == 'in'
+          
+      if schedule_method == 'in'
+        return (created_on || Time.now) + Taskr.scheduler.duration_to_f(schedule_when)
+      end
+      
+      # Time parsing code from Rails
+      time_hash = Date._parse(schedule_when)
+      time_hash[:sec_fraction] = ((time_hash[:sec_fraction].to_f % 1) * 1_000_000).to_i
+      time_array = time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction)
+      # treat 0000-00-00 00:00:00 as nil
+      Time.send(Base.default_timezone, *time_array) rescue DateTime.new(*time_array[0..5]) rescue nil
+    end
+
+    
+    def to_s
+      "#{name.inspect}@#{schedule_when}"
+    end
+    
+  end
+  
+  class TaskAction < Base
+    belongs_to :task
+    
+    has_many :action_parameters, 
+      :class_name => 'TaskActionParameter', 
+      :foreign_key => :task_action_id,
+      :dependent => :destroy
+    alias_method :parameters, :action_parameters
+    
+    has_many :log_entries
+    has_one :last_log_entry,
+      :class_name => 'LogEntry',
+      :foreign_key => :task_id,
+      :order => 'timestamp DESC'
+    
+    validates_associated :action_parameters
+    
+    def action_class=(class_name)
+      if class_name.kind_of? Class
+        self[:action_class_name] = class_name.to_s
+      else
+        self[:action_class_name] = class_name
+      end
+    end
+    
+    def action_class
+      self[:action_class_name].constantize
+    end
+    
+    def description
+      action_class.description
+    end
+    
+    def to_xml(options = {})
+      options[:indent] ||= 2
+      xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      xml.instruct! unless options[:skip_instruct]
+      xml.tag!('task-action', :type => self.class) do
+        xml.tag!('id', {:type => 'integer'}, id)
+        xml.tag!('action-class-name', action_class_name)
+        xml.tag!('order', {:type => 'integer'}, order) unless order.blank?
+        xml.tag!('task-id', {:type => 'integer'}, task_id)
+        xml.tag!('action-parameters', {:type => 'array'}) do
+          action_parameters.each {|ap| ap.to_xml(options)}
+        end
+      end
+    end
+    
+    def to_s
+      "#{self.class.name.demodulize}(#{task_action})"
+    end
+  end
+
+  class TaskActionParameter < Base
+    belongs_to :task_action
+    serialize :value
+    
+    def to_xml(options = {})
+      options[:indent] ||= 2
+      xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      xml.instruct! unless options[:skip_instruct]
+      xml.tag!('action-parameter', :type => self.class) do
+        xml.tag!('id', {:type => 'integer'}, id)
+        xml.tag!('name', name)
+        xml.tag!('value') do
+          xml.cdata!(value)
+        end
+      end
+    end
+    
+    def to_s
+      "#{self.class.name.demodulize}(#{name}:#{value})"
+    end
+  end
+  
+  class LogEntry < Base
+    belongs_to :task
+    belongs_to :task_action
+    
+    class << self
+      def log(level, action_or_task, data)
+        level = level.upcase
+        if action_or_task.kind_of? TaskAction
+          action = action_or_task
+          task = action.task
+        elsif action_or_task.kind_of? Task
+          action = nil
+          task = action_or_task
+        elsif action_or_task.kind_of? Integer
+          action = TaskAction.find(action_or_task)
+          task = action.task
+        elsif action_or_task.kind_of? Taskr::Actions::Base
+          action = action_or_task.task_action
+          task = action.task
+        else
+          raise ArgumentError, "#{action_or_task.inspect} is not a valid Task or TaskAction!"
+        end
+        
+        threshold = Taskr::Conf[:task_log][:level].upcase if Taskr::Conf[:task_log] && Taskr::Conf[:task_log][:level]
+        
+        if threshold.blank? || 
+            ['DEBUG', 'INFO', 'WARN', 'ERROR'].index(threshold) <= ['DEBUG', 'INFO', 'WARN', 'ERROR'].index(level) 
+          LogEntry.create(
+            :level => level,
+            :timestamp => Time.now,
+            :task => task,
+            :task_action => action,
+            :data => data
+          )
+        end
+      end
+      
+      # Produces a Logger-like class that will create log entries for the given
+      # TaskAction. The returned object exploses behaviour much like a standard
+      # Ruby Logger, so that it can be used in place of a Logger when necessary. 
+      def logger_for_action(action)
+        ActionLogger.new(action)
+      end
+    
+      ['debug', 'info', 'warn', 'error'].each do |level|
+        define_method(level) do |action, data|
+          log(level, action, data)
+        end
+      end
+    end
+    
+    # Exposes a Logger-like interface for logging entries for some particular
+    # TaskAction.
+    class ActionLogger
+      def initialize(action)
+        @action = action
+      end
+      
+      def method_missing(method, data)
+        LogEntry.send(method, @action, "#{"#{@progname}: " unless @progname.blank?}#{data}")
+      end
+      
+      def respond_to?(method)
+        [:debug, :info, :warn, :error].include?(method)
+      end
+      
+      def progname
+        action.task.name
+      end
+      
+      def progname=(p)
+      end
+    end
+  end
+
+  class CreateTaskr < V 0.01
+    def self.up
+      $LOG.info("Migrating database")
+      
+      create_table :taskr_tasks, :force => true do |t|
+        t.column :name, :string, :null => false
+        t.column :created_on, :timestamp, :null => false
+        t.column :created_by, :string
+        
+        t.column :schedule_method, :string, :null => false
+        t.column :schedule_when, :string, :null => false
+        t.column :schedule_options, :text
+        
+        t.column :scheduler_job_id, :integer
+        t.column :last_triggered, :datetime
+        t.column :last_triggered_error, :text
+      end
+      
+      add_index :taskr_tasks, [:name], :unique => true
+      
+      create_table :taskr_task_actions, :force => true do |t|
+        t.column :task_id, :integer, :null => false
+        t.column :action_class_name, :string, :null => false
+        t.column :order, :integer
+      end
+      
+      add_index :taskr_task_actions, [:task_id]
+      
+      create_table :taskr_task_action_parameters, :force => true do |t|
+        t.column :task_action_id, :integer, :null => false
+        t.column :name, :string, :null => false
+        t.column :value, :text
+      end
+      
+      add_index :taskr_task_action_parameters, [:task_action_id]
+      add_index :taskr_task_action_parameters, [:task_action_id, :name]
+    end
+    
+    def self.down
+      drop_table :taskr_task_action_parameters
+      drop_table :taskr_tasks
+    end
+  end
+  
+  class AddLoggingTables < V 0.3
+    def self.up
+      $LOG.info("Creating logging tables")
+      
+      create_table :taskr_log_entries, :force => true do |t|
+        t.column :task_id, :integer
+        t.column :task_action_id, :integer
+        
+        t.column :timestamp, :timestamp, :null => false
+        t.column :level, :string, :null => false
+        t.column :data, :text
+      end
+      
+      add_index :taskr_log_entries, :task_id
+      add_index :taskr_log_entries, :task_action_id
+    end
+    
+    def self.down
+      drop_table :taskr_log_entries
+    end
+  end
+  
+  class AddMemoToTasks < V 0.3001
+    def self.up
+      add_column :taskr_tasks, :memo, :text
+    end
+    
+    def self.down
+      remove_column :taskr_tasks, :memo
+    end
+  end
+end

data/lib/taskr/version.rb

@@ -0,0 +1,9 @@
+module Taskr #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/taskr/views.rb

@@ -0,0 +1,455 @@
+# This file is part of Taskr.
+#
+# Taskr is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Taskr is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Taskr.  If not, see <http://www.gnu.org/licenses/>.
+
+# need auto_validation off to render non-XHTML XML
+Markaby::Builder.set(:auto_validation, false)
+Markaby::Builder.set(:indent, 2)
+
+module Taskr::Views
+  module XML
+    include Taskr::Models
+    
+    CONTENT_TYPE = 'text/xml'
+    
+    def tasks_list
+      @tasks.to_xml(:root => 'tasks')#, :include => [:task_actions])
+    end
+    
+    def view_task
+      @task.to_xml(:root => 'task')#, :include => [:task_actions])
+    end
+  end
+  
+  module HTML
+    include Taskr::Controllers
+    
+    CONTENT_TYPE = 'text/html'
+    
+    def tasks_list
+      html_scaffold do
+        h1 {"Tasks"}
+        
+        p{a(:href => R(Taskr::Controllers::Tasks, 'new')) {"Schedule New Task"}}
+        
+        table do
+          thead do
+            tr do
+              th "Name"
+              th "Schedule"
+              th "Last Triggered"
+              th "Job ID"
+              th "Created On"
+              th "Created By"
+              th ""
+            end
+          end
+          tbody do
+            @tasks.each do |t|
+              tr_css = []
+              tr_css << "error" if t.last_triggered_error
+              tr_css << "expired" if t.next_trigger_time != :unknown && t.next_trigger_time < Time.now
+              
+              tr(:class => tr_css.join(" ")) do
+                td {a(:href => R(t)) {strong{t.name}}}
+                td "#{t.schedule_method} #{t.schedule_when}"
+                td do
+                  if t.last_triggered
+                    "#{distance_of_time_in_words(t.last_triggered, Time.now, true)} ago"
+                  else
+                    em "Not yet triggered"
+                  end
+                end
+                td(:class => "job-id") {t.scheduler_job_id}
+                td t.created_on
+                td t.created_by
+                td {a(:href => R(t, 'edit')) {"Edit"}}
+              end
+            end
+          end
+        end
+        
+        br
+        div {scheduler_status}
+      end
+    end
+    
+    def edit_task
+      html_scaffold do
+        script(:type => 'text/javascript') do
+          %{
+            function show_action_parameters(num) {
+              new Ajax.Updater('parameters_'+num, '#{R(Actions)}', {
+                  method: 'get',
+                  parameters: { 
+                    id: $F('action_class_name_'+num), 
+                    action: 'parameters_form',
+                    num: num
+                  }
+              });
+            }
+          }
+        end
+
+        a(:href => R(Tasks, :list)) {"Back to Task List"}
+
+        form :method => 'put', :action => R(@task, 'update') do
+          h1 "Edit Task \"#{@task.name}\""
+
+          p do
+            label 'name' 
+            br
+            input :type => 'text', :name => 'name', :value => @task.name, :size => 40
+          end
+          
+          p do
+            label 'schedule'
+            br
+            select(:name => 'schedule_method') do
+              ['every','at','in','cron'].each do |method|
+                if @task.schedule_method == method
+                  option(:value => method, :selected => 'selected') {method}
+                else
+                  option(:value => method) {method}
+                end
+              end
+            end
+            input :type => 'text', :name => 'schedule_when', :value => @task.schedule_when, :size => 30
+          end
+          
+          p do
+            label 'description/memo' 
+            br
+            textarea(:name => 'memo', :cols => '60', :rows => '4'){@task.memo}
+          end
+          
+          p do
+            label "Actions:"
+            @task.task_actions.each do |action|
+              div {action_parameters_form(action)}
+            end
+            # div do 
+            #   if @task.task_actions.length > 1
+            #     ol(:style => 'padding-left: 20px') do
+            #       @task.task_actions.each do |ta|
+            #         html_task_action_li(ta)
+            #       end
+            #     end
+            #   else
+            #     html_task_action_li(@task.task_actions.first)
+            #   end
+            # end
+          end
+          
+          
+          p do
+            a(:id => 'add_action', :href => '#'){'Add another action'}
+          end
+
+          script(:type => 'text/javascript') do
+            %{
+              Event.observe('add_action', 'click', function() {
+                new Ajax.Updater('add_action', '#{R(Actions, :new)}', {
+                    method: 'get',
+                    parameters: { num: $$('select.action_class_name').size() },
+                    insertion: Insertion.Before
+                });
+                return false;
+              })
+            }
+          end
+          
+          button(:type => 'submit') {"Save"}
+        end
+      end
+    end
+
+    def new_task
+      html_scaffold do
+        script(:type => 'text/javascript') do
+          %{
+            function show_action_parameters(num) {
+              new Ajax.Updater('parameters_'+num, '#{R(Actions)}', {
+                  method: 'get',
+                  parameters: { 
+                    id: $F('action_class_name_'+num), 
+                    action: 'parameters_form',
+                    num: num
+                  }
+              });
+            }
+          }
+        end
+        
+        form :method => 'post', :action => self/"/tasks?format=#{@format}" do
+          h1 "New Task"
+          input :type => 'hidden', :name => '_method', :value => 'post'
+          
+          p do
+            label 'name' 
+            br
+            input :type => 'text', :name => 'name', :size => 40
+          end
+          
+          p do
+            label 'schedule'
+            br
+            select(:name => 'schedule_method') do
+              ['every','at','in','cron'].each do |method|
+                option(:value => method) {method}
+              end
+            end
+            input :type => 'text', :name => 'schedule_when', :size => 30
+          end
+          
+          p do
+            label 'description/memo' 
+            br
+            textarea(:name => 'memo', :cols => '60', :rows => '4'){""}
+          end
+          
+          action_form
+          
+          p do
+            a(:id => 'add_action', :href => '#'){'Add another action'}
+          end
+          script(:type => 'text/javascript') do
+            %{
+              Event.observe('add_action', 'click', function() {
+                new Ajax.Updater('add_action', '#{R(Actions, :new)}', {
+                    method: 'get',
+                    parameters: { num: $$('select.action_class_name').size() },
+                    insertion: Insertion.Before
+                });
+                return false;
+              })
+            }
+          end
+          
+          button(:type => 'submit') {"submit"}
+        end
+      end
+    end
+    
+    def view_task
+      html_scaffold do
+        form(:method => 'delete', :style => 'display: inline', :action => R(@task)) do
+          button(:type => 'submit', :value => 'delete', :onclick => 'return confirm("Are you sure you want to unschedule and delete this task?")') {"Delete"}
+        end
+        form(:method => 'put', :style => 'display: inline', :action => R(@task, 'run')) do
+          button(:type => 'submit', :value => 'run') {"Run Now!"}
+        end
+        form(:method => 'put', :style => 'display: inline', :action => R(@task, 'reload')) do
+          button(:type => 'submit', :value => 'reload') {"Reload!"}
+        end
+        br
+        a(:href => R(Tasks, :list)) {"Back to Task List"}
+        
+        h1 "Task #{@task.id}"
+        table do
+          tr do
+            th "Name:"
+            td @task.name
+          end
+          tr do
+            th "Schedule:"
+            td "#{@task.schedule_method} #{@task.schedule_when}"
+          end
+          tr do
+            th "Description/Memo:"
+            td "#{@task.memo}"
+          end
+          tr do
+            th "Job ID:"
+            td @task.scheduler_job_id
+          end
+          tr do
+            th "Triggered:"
+            td do
+              if @task.last_triggered
+                span "#{distance_of_time_in_words(@task.last_triggered, Time.now, true)} ago"
+                span(:style => 'font-size: 8pt; color: #bbb'){"(#{@task.last_triggered})"}
+              else
+                em "Not yet triggered"
+              end
+            end 
+          end
+          if @task.last_triggered_error
+            th "Error:"
+            td(:style => 'color: #e00;') do
+              strong "#{@task.last_triggered_error[:type]}"
+              br
+              pre @task.last_triggered_error[:message]
+            end
+          end
+          tr do
+            th "Actions:"
+            td do 
+              if @task.task_actions.length > 1
+                ol(:style => 'padding-left: 20px') do
+                  @task.task_actions.each do |ta|
+                    html_task_action_li(ta)
+                  end
+                end
+              else
+                html_task_action_li(@task.task_actions.first)
+              end
+            end
+          end
+          tr do
+            th "Created By:"
+            td @task.created_by
+          end
+          tr do
+            th "Created On:"
+            td @task.created_on
+          end
+        end
+        
+        script %{
+          function clickbold(el) {
+            $$('#logfilter a').each(function(a){a.style.fontWeight = 'normal'})
+            el.style.fontWeight = 'bold'
+          } 
+        }
+        
+        p(:style => "margin-top: 20px; border-top: 1px dotted black; padding-top: 10px", :id => 'logfilter') do
+          strong "Show: "
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :since => (Time.now - 1.day).to_formatted_s(:db)),
+            :target => 'log', :onclick => "clickbold(this)", :style => 'font-weight: bold') {"Last 24 Hours"}
+          text "|"
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :since => (Time.now - 2.days).to_formatted_s(:db)),
+            :target => 'log', :onclick => "clickbold(this)") {"48 Hours"}
+          text "|"
+          a(:href => R(LogEntries, :list, :task_id => @task.id),
+            :target => 'log', :onclick => "clickbold(this)") {"All"}
+          br
+          
+          strong "Level: "
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :level => 'DEBUG'),
+            :target => 'log', :onclick => "clickbold(this)") {"DEBUG"}
+          text "|"
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :level => 'INFO'),
+            :target => 'log', :onclick => "clickbold(this)") {"INFO"}
+          text "|"
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :level => 'WARN'),
+            :target => 'log', :onclick => "clickbold(this)") {"WARN"}
+          text "|"
+          a(:href => R(LogEntries, :list, :task_id => @task.id, :level => 'ERROR'),
+            :target => 'log', :onclick => "clickbold(this)") {"ERROR"}
+        end        
+        iframe(:src => R(LogEntries, :list, :task_id => @task.id, :since => (Time.now - 1.day).to_formatted_s(:db)), 
+                :style => 'width: 100%; height: 300px', :name => 'log')
+      end
+    end
+    
+    def scheduler_status
+      s = Taskr.scheduler
+      h3(:style => "margin-bottom: 8px;") {"Scheduler Status"}
+      strong "Running?"
+      span(:style => 'margin-right: 10px') {s.instance_variable_get(:@stopped) ? "NO" : "Yes"}
+      strong "Precision:"
+      span(:style => 'margin-right: 10px') {"#{s.instance_variable_get(:@precision)}s"}
+      strong "Pending Jobs:"
+      span(:style => 'margin-right: 10px') {s.instance_variable_get(:@pending_jobs).size}
+      strong "Thread Status:"
+      span(:style => 'margin-right: 10px') {s.instance_variable_get(:@scheduler_thread).status}
+    end
+    
+    def action_list
+      h1 "Actions"
+      ul do
+        @actions.each do |a|
+          li a
+        end
+      end
+    end
+    
+    def action_parameters_form(action = @action)
+      @num ||= 0
+      
+      p {em action.description}
+      
+      action.parameters.each do |param|
+        p do
+          label param
+          br
+          unless action.is_a?(Taskr::Models::TaskAction) # Setting up a new task
+            input :type => 'text', :name => "action[#{@num}][#{param}]", :size => 50
+          else # Editing an existing task
+            input :type => 'text', :name => "action[action_id_#{action.id}][#{param.name}]", :size => 50, :value => param.value
+          end
+        end
+      end
+    end
+    
+    def action_form
+      @num ||= 0
+      
+      p do
+        label 'action_class_name'
+        br
+        select(:name => "action[#{@num}][action_class_name]", 
+            :id => "action_class_name_#{@num}", 
+            :class => "action_class_name",
+            :onchange => "show_action_parameters(#{@num})") do
+          option(:value => "")
+          @actions.each do |a|
+            a.to_s =~ /Taskr::Actions::([^:]*?)$/
+            option(:value => $~[1]) {$~[1]}
+          end
+        end
+      end
+    
+      div(:id => "parameters_#{@num}")
+      
+    end
+   
+    def log_entries_list
+      h2 "Log"
+      
+      p(:style => 'margin: 0px') do
+        em(:style => "font-weight: normal; font-size: 9pt"){"Entries since #{@since}<br />"} unless @since.blank?
+        em(:style => "font-weight: normal; font-size: 9pt"){"With levels #{@level.join(", ")}<br />"} unless @level.blank?
+      end
+            
+      table do
+        @log_entries.each do |entry|
+          case entry.level.downcase.intern
+          when :error
+            bg_color = '#faa'
+          when :warn
+            bg_color = '#ffa'
+          when :info
+            bg_color = '#aaf'
+          when :debug
+            bg_color = '#eee'
+          else
+            bg_color = '#fff; '+entry.level.inspect
+          end
+          tr do
+            td(:style => "vertical-align: top; font-size: 9pt; white-space: nowrap; background: #{bg_color}") do
+              entry.timestamp
+            end
+            td(:style => "vertical-align: top; font-size: 9pt; background-color: #{bg_color}; font-size: 9pt; font-family: monospace") do
+              entry.data.gsub(/<\/?(html|body)>/, '').gsub(/\n/, "<br />")
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  default_format :HTML
+end