rearview 1.0.0-jruby

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 64037f7f0f6b40dca52f2d17af7c64292116fc23
+  data.tar.gz: ac56d552730b97c5723f6c80c83b7079740e9471
+SHA512:
+  metadata.gz: d44e767077ad0a9528bf7834f5e1d49fd63b21c0489edf2b3ff2db81930cd775131016fd47c3f8aa3485e719d93b4366e3081c700d894e88a2e09589a87cc29c
+  data.tar.gz: 20702a46c753452463a2decfd5c3d8c818d6ba10e8a373088f89c8cc061a680b264d776edd5a7b053f30ebb3a50b15884eeb64dc84fde49e0cde8da4cb4ef9ea

data/README.md

@@ -0,0 +1 @@
+Rails engine for ![rearview](http://github.com/livingsocial/rearview). This project is for rearview developers only. For users please go to ![rearview](http://github.com/livingsocial/rearview) project for installation, configuration, and other details.

data/Rakefile

@@ -0,0 +1,30 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rearview'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+load 'tasks/rearview.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec
+

data/app/assets/javascripts/rearview/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/rearview/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/controllers/rearview/application_controller.rb

@@ -0,0 +1,6 @@
+module Rearview
+  class ApplicationController < ActionController::Base
+    helper Rearview::Engine.helpers
+    before_filter :authenticate_user!
+  end
+end

data/app/controllers/rearview/dashboard_children_controller.rb

@@ -0,0 +1,25 @@
+
+module Rearview
+  class DashboardChildrenController < ApplicationController
+    def index
+      @dashboards = if params[:dashboard_id]
+                      Rearview::Dashboard.find(params[:dashboard_id]).children
+                    else
+                      []
+                    end
+      render 'rearview/dashboards/index'
+    end
+    def create
+      @dashboard = Rearview::Dashboard.new
+      @dashboard.name = params[:name]
+      @dashboard.user = current_user
+      @dashboard.description = params[:description]
+      if params[:dashboard_id]
+        @dashboard.parent=Rearview::Dashboard.find(params[:dashboard_id])
+      end
+      @dashboard.save!
+      render 'rearview/dashboards/show'
+    end
+  end
+end
+

data/app/controllers/rearview/dashboards_controller.rb

@@ -0,0 +1,46 @@
+require_dependency "rearview/application_controller"
+
+module Rearview
+  class DashboardsController < ApplicationController
+    respond_to :json
+
+    def index
+      @dashboards = Rearview::Dashboard.roots
+    end
+
+    def show
+      @dashboard = Rearview::Dashboard.find(params[:id])
+    end
+
+    def create
+      upsert
+      render :show
+    end
+
+    def update
+      upsert
+      render :show
+    end
+
+    def destroy
+      @dashboard = Rearview::Dashboard.find params[:id]
+      @dashboard.destroy
+      render :show
+    end
+
+    def errors
+      @job_errors = Rearview::JobError.calculate_durations(Rearview::JobError.application_errors(params[:id]).order_created.load)
+    end
+
+    private
+
+    def upsert
+      @dashboard = Rearview::Dashboard.find_or_initialize_by(id: params[:id])
+      @dashboard.name = params[:name]
+      @dashboard.user = current_user
+      @dashboard.description = params[:description]
+      @dashboard.save!
+    end
+
+  end
+end

data/app/controllers/rearview/home_controller.rb

@@ -0,0 +1,6 @@
+require_dependency "rearview/application_controller"
+module Rearview
+  class HomeController < ApplicationController
+    layout false
+  end
+end

data/app/controllers/rearview/jobs_controller.rb

@@ -0,0 +1,81 @@
+module Rearview
+  class JobsController < ApplicationController
+    respond_to :json
+
+    def index
+      @jobs = if params[:dashboard_id].present?
+                Rearview::Job.where(:app_id=>params[:dashboard_id])
+              else
+                Rearview::Job.all
+              end
+    end
+
+    def create
+      upsert(allowed_create_params)
+      render :show
+    end
+
+    def update
+      upsert(allowed_update_params)
+      render :show
+    end
+
+    def destroy
+      @job = Rearview::Job.find(params[:id])
+      @job.destroy
+      render :show
+    end
+
+    def reset
+      @job = Rearview::Job.find(params[:id])
+      @job.reset
+      render :show
+    end
+
+    def show
+      @job = Rearview::Job.find(params[:id])
+    end
+
+    def data
+      @job_data = Rearview::Job.find(params[:id]).try(:job_data)
+      unless @job_data.present?
+        head :status => 404
+      end
+    end
+
+    def errors
+      @job_errors = Rearview::JobError.calculate_durations(Rearview::JobError.search(params).load)
+    end
+
+    private
+
+    def upsert(filtered_params)
+      @job = Rearview::Job.find_or_initialize_by(id: params[:id])
+      dashboard_id = filtered_params.delete("dashboard_id")
+      if dashboard_id.present? && dashboard_id.to_i!=@job.app_id
+        @job.dashboard = Rearview::Dashboard.find(dashboard_id.to_i)
+      end
+      @job.update_attributes!(filtered_params)
+      @job.sync_monitor_service
+    end
+
+    def allowed_create_params
+      filtered_params = underscore_params
+      filtered_params.delete_if { |k,v|
+        ["controller","job_type","version","action","job","id","format","created_at","modified_at"].include?(k)
+      }
+    end
+
+    def allowed_update_params
+      filtered_params = underscore_params
+      filtered_params.delete_if { |k,v|
+        !["dashboard_id","name","active","alert_keys","cron_expr","error_timeout","minutes","metrics","monitor_expr","to_date","description"].include?(k)
+      }
+    end
+
+    def underscore_params
+      params.inject({}.with_indifferent_access) { |a,(k,v)| a[k.to_s.underscore] = v; a }
+    end
+
+  end
+end

data/app/controllers/rearview/monitor_controller.rb

@@ -0,0 +1,12 @@
+
+module Rearview
+  class MonitorController < ApplicationController
+
+    def create
+      results = Rearview::MonitorRunner.run(params[:metrics],params[:monitorExpr],params[:minutes],{},false,params[:toDate],true)
+      @monitor_output = Rearview::MonitorRunner.normalize_results(results)
+    end
+
+  end
+end
+

data/app/controllers/rearview/user_controller.rb

@@ -0,0 +1,21 @@
+require_dependency "rearview/application_controller"
+
+module Rearview
+  class UserController < ApplicationController
+    respond_to :json
+    def show
+      @user = current_user
+    end
+    def update
+      # https://github.com/rails/rails/issues/8831
+      # https://github.com/rails/rails/issues/8832
+      preferences = JSON.parse(request.body.string).with_indifferent_access.try(:[],:preferences)
+      @user = current_user
+      if preferences.present?
+        @user.preferences = preferences
+        @user.save!
+      end
+      render :show
+    end
+  end
+end

data/app/helpers/rearview/application_helper.rb

@@ -0,0 +1,22 @@
+module Rearview
+  module ApplicationHelper
+    def rearview_static_path(segment)
+      prefix = if Rails.env.development?
+               "/rearview-src"
+               else
+               "/rearview"
+               end
+      ( segment.present? ? prefix + segment : prefix )
+    end
+    def rearview_link_tag(href,options)
+      options = options.symbolize_keys
+      options[:href] = rearview_static_path(href)
+      tag("link",options)
+    end
+    def rearview_img_tag(source,options)
+      options = options.symbolize_keys
+      options[:src] = rearview_static_path("/img"+source)
+      tag("img", options)
+    end
+  end
+end

data/app/mailers/rearview/alert_mailer.rb

@@ -0,0 +1,13 @@
+java_import "org.apache.commons.validator.EmailValidator"
+
+module Rearview
+  class AlertMailer < ActionMailer::Base
+    default from: Rearview.config.default_from
+    def alert_email(recipient, job, result)
+      @job    = job
+      @result = result
+      mail(:to => recipient, :subject => "[Rearview ALERT] #{job.name}")
+    end
+  end
+end
+

data/app/models/rearview/dashboard.rb

@@ -0,0 +1,11 @@
+module Rearview
+  class Dashboard < ActiveRecord::Base
+    self.table_name='applications'
+    attr_accessible :created, :deleted_at, :name, :user, :user_id, :modified,:description
+    belongs_to :user
+    has_many :jobs, dependent: :destroy, foreign_key: :app_id
+
+    has_ancestry
+    validates :name, :user_id, presence: true
+  end
+end

data/app/models/rearview/job.rb

@@ -0,0 +1,174 @@
+
+module Rearview
+  class Job < ActiveRecord::Base
+
+    include Rearview::ConstantsModuleMaker
+    include Rearview::Ext::StateMachine
+
+    self.table_name = "jobs"
+
+    make_constants_module :status,
+      :constants => [:success,:failed,:error,:graphite_error,:graphite_metric_error,:security_error]
+
+    attr_accessible :created_at, :updated_at, :name, :active, :last_run, :cron_expr, :status, :user_id, :alert_keys, :deleted_at, :error_timeout, :next_run, :description, :app_id, :metrics, :monitor_expr, :minutes, :to_date
+
+    belongs_to :dashboard, :foreign_key => :app_id
+    belongs_to :user
+    has_one :job_data, :dependent => :destroy
+    has_many :job_errors, :dependent => :destroy
+
+    serialize :metrics, JSON
+    serialize :alert_keys, JSON
+
+    before_save :set_defaults
+    before_update :set_defaults
+    before_destroy :unschedule
+
+    validates :app_id, :cron_expr, :name, :metrics, :presence => true
+    validate :valid_cron_expression
+    validate :valid_alert_keys
+
+    scope :schedulable, -> { where(:active=>true) }
+
+    state_machine :status, :initial => nil do
+
+      error_group = [:failed,:error,:graphite_metric_error,:graphite_error,:security_error]
+
+      after_transition nil => any, :do => :create_associated_event
+      after_transition :success => error_group , :do => :create_associated_event
+      after_transition error_group => :success, :do => :create_associated_event
+      after_transition :success => :success, :do => :update_associated_event
+      after_transition error_group => error_group, :do => :update_associated_event
+
+      event :success do
+        transition all => :success
+      end
+
+      event :failed do
+        transition all => :failed
+      end
+
+      event :error do
+        transition all => :error
+      end
+
+      event :graphite_error do
+        transition all => :graphite_error
+      end
+
+      event :graphite_metric_error do
+        transition all => :graphite_metric_error
+      end
+
+      event :security_error do
+        transition all => :security_error
+      end
+
+      state :success
+      state :failed
+      state :error
+      state :graphite_error
+      state :graphite_metric_error
+      state :security_error
+
+    end
+
+    def schedule
+      Rearview.monitor_service.schedule(self)
+    end
+
+    def unschedule
+      Rearview.monitor_service.unschedule(self)
+    end
+
+    def reset
+      self.unschedule if active
+      self.job_data.destroy unless(self.job_data.nil?)
+      self.job_errors.clear
+      self.status = nil
+      self.save!
+      self.reload
+      self.schedule if active
+    end
+
+    # The number of seconds to delay before the next time this job should run
+    def delay
+      if cron_expr == "0 * * * * ?"
+        60.0
+      else
+        Rearview::CronHelper.next_valid_time_after(cron_expr)
+      end
+    end
+
+    # This doesn't fit nicely as a callback -- the monitor itself needs to update
+    # the job which triggers a fun cycle of events =)
+    def sync_monitor_service
+      if active
+        schedule
+      else
+        unschedule
+      end
+    end
+
+    def valid_cron_expression
+      if cron_expr.present? && !Rearview::CronHelper.valid_expression?(cron_expr)
+        errors.add(:cron_expr, "not a valid cron expression")
+      end
+    end
+
+    def valid_alert_keys
+      if alert_keys.present?
+        schemes = Rearview::Alerts.registry.keys
+        alert_keys.each do |key|
+          begin
+            uri = URI(key)
+            scheme = uri.scheme
+            unless scheme.present? && schemes.include?(scheme)
+              errors.add(:alert_keys,"unsupported scheme")
+            else
+              scheme_class = Rearview::Alerts.registry[scheme]
+              unless scheme_class.key?(key)
+                errors.add(:alert_keys,"#{scheme} URI is invalid")
+              end
+            end
+          rescue URI::InvalidURIError
+            errors.add(:alert_keys,"invalid URI")
+          end
+        end
+      end
+    end
+
+    def create_associated_event(transition)
+      logger.debug "#{self}#create_associated_event for transition #{transition.inspect}"
+      job_error_attrs = {}
+      job_error_attrs.merge!(event_data[:job_error]) if event_data.try(:[],:job_error)
+      job_error = job_errors.create(job_error_attrs)
+      job_error.fire_event(translate_associated_event(transition),event_data)
+    end
+
+    def update_associated_event(transition)
+      logger.debug "#{self}#update_associated_event for transition #{transition.inspect}"
+      job_error = Rearview::JobError.latest_entry(self)
+      if job_error.present?
+        job_error.fire_event(translate_associated_event(transition),event_data)
+      end
+    end
+
+    protected
+
+    def translate_associated_event(transition)
+      if transition.event.to_s == Status::SECURITY_ERROR
+        :error
+      else
+        transition.event
+      end
+    end
+
+    def set_defaults
+      unless self.alert_keys.present?
+        self.alert_keys = []
+      end
+    end
+
+  end
+end

data/app/models/rearview/job_data.rb

@@ -0,0 +1,13 @@
+
+module Rearview
+  class JobData < ActiveRecord::Base
+
+    self.table_name = "job_data"
+
+    attr_accessible :created_at, :updated_at, :job_id, :data
+    belongs_to :job
+    serialize :data, JSON
+
+    validates :job_id, :data, :presence => true
+  end
+end

data/app/models/rearview/job_error.rb

@@ -0,0 +1,120 @@
+
+module Rearview
+  class JobError < ActiveRecord::Base
+
+    self.table_name = "job_errors"
+
+    include Rearview::ConstantsModuleMaker
+    include Rearview::Ext::StateMachine
+
+    make_constants_module :status,
+      :constants => [:success,:failed,:error,:graphite_error,:graphite_metric_error]
+
+    attr_accessible :created_at, :job_id, :message, :status
+    attr_accessor :end_date
+    belongs_to :job
+
+    validates :job_id, :presence => true
+
+    scope :only_errors, -> { where('status != ?',Status::SUCCESS) }
+    scope :order_created, -> { order('created_at DESC') }
+
+    state_machine :status, :initial => nil do
+
+      # Temporarily removed :error from this group so alerts don't get sent at that state [REAR-183]
+      error_group = [:failed,:graphite_error,:graphite_metric_error]
+
+      after_transition nil => error_group, :do => :create_alert
+      after_transition error_group => error_group, :do => :update_alert
+
+      event :success do
+        transition all => :success
+      end
+
+      event :failed do
+        transition all => :failed
+      end
+
+      event :error do
+        transition all => :error
+      end
+
+      event :graphite_error do
+        transition all => :graphite_error
+      end
+
+      event :graphite_metric_error do
+        transition all => :graphite_metric_error
+      end
+
+      state :success
+      state :failed
+      state :error
+      state :graphite_error
+      state :graphite_metric_error
+    end
+
+    def self.search(params)
+      filter = self.where(:job_id=>params[:id])
+      order_direction = "DESC"
+      if params[:start_date]
+        filter = filter.where("created_at >= ?",params[:start_date])
+        order_direction = "ASC"
+      end
+      if params[:end_date]
+        filter = filter.where("created_at <= ?",params[:end_date])
+        order_direction = "ASC"
+      end
+      if params[:limit]
+        filter = filter.limit(params[:limit])
+      end
+      if params[:offset]
+        filter = filter.offset(params[:offset])
+      end
+      filter.order("created_at #{order_direction}")
+    end
+
+    def self.calculate_durations(errors)
+      last_with_error = nil         # most recently found error
+      (errors.each do |e|
+        if e.status == Status::SUCCESS
+          unless last_with_error.nil?
+            last_with_error.end_date = e.created_at.utc.to_i
+            last_with_error = nil
+          end
+        else
+          last_with_error = e
+        end
+      end).reject { |e| e.status == Status::SUCCESS }
+    end
+
+    def self.application_errors(application_id)
+      joins("INNER JOIN jobs ON jobs.id = job_errors.job_id").joins("INNER JOIN applications ON applications.id = jobs.app_id").where("applications.id = ?",application_id)
+    end
+
+    def self.last_error(job_id)
+      only_errors.where("job_id = ?",job_id).order_created.limit(1).first
+    end
+
+    def self.latest_entry(job_id)
+      where("job_id = ?",job_id).order_created.limit(1).first
+    end
+
+    def create_alert(transition)
+      logger.debug "#{self}#create_alert for transition #{transition.inspect}"
+      Rearview::AlertsHandler.new(self.job,event_data[:monitor_results]).run
+      self.last_alerted_at = Time.now.utc
+      save!
+    end
+
+    def update_alert(transition)
+      logger.debug "#{self}#update_alert for transition #{transition.inspect}"
+      if !self.last_alerted_at || Time.now.utc >= self.last_alerted_at.utc + self.job.error_timeout.minutes
+        Rearview::AlertsHandler.new(self.job,event_data[:monitor_results]).run
+        self.last_alerted_at = Time.now.utc
+        save!
+      end
+    end
+
+  end
+end

data/app/models/rearview/user.rb

@@ -0,0 +1,5 @@
+module Rearview
+  class User < ActiveRecord::Base
+    include Rearview::Concerns::Models::User
+  end
+end

data/app/views/devise/sessions/new.html.erb

@@ -0,0 +1,21 @@
+<form class="form-horizontal" method="post" action="<%= session_path(:user) %>">
+<div class="control-group">
+    <label class="control-label" for="inputEmail">Email</label>
+    <div class="controls">
+      <input type="text" id="inputEmail" placeholder="Email" name="user[email]" autofocus="autofocus">
+    </div>
+</div>
+<div class="control-group">
+    <label class="control-label" for="inputPassword">Password</label>
+    <div class="controls">
+      <input type="password" id="inputPassword" placeholder="Password" name="user[password]">
+    </div>
+</div>
+<div class="control-group">
+  <div class="controls">
+    <button type="submit" class="btn">Sign in</button>
+  </div>
+</div>
+</form>
+
+<%# <%= render "devise/shared/links" %>