rearview 1.0.0-jruby

data/lib/rearview/alerts/pagerduty_alert.rb

@@ -0,0 +1,65 @@
+require 'json'
+
+module Rearview
+  module Alerts
+    class PagerDutyAlert < Base
+
+      def alert(job, result)
+        job.alert_keys.each do |key|
+          params = PagerDutyAlert.params(key)
+          if PagerDutyAlert.key?(params)
+            logger.info "#{self} send alert for #{job.inspect} and key #{key} with params #{params}"
+            pagerduty_uri = Rearview.config.pagerduty_url
+            job_uri       = Rearview::UriHelper.rearview_uri(job)
+            msg           = result[:message]
+
+            description = if msg
+                            "#{msg.first(1024)} #{job_uri}"
+                          else
+                            "Rearview job #{job.id} #{job_uri}"
+                          end
+
+            options = { :body =>
+              {
+                :service_key  => params["token"],
+                :event_type   => "trigger",
+                :incident_key => "rearview/#{job.id}",
+                :description  => description,
+                :details     => result
+              }.to_json
+            }
+
+            HTTParty.post(pagerduty_uri, options)
+          end
+        end
+      end
+
+      def self.params(key)
+        uri = URI(key)
+        if uri.scheme.present?
+          {
+            "scheme" => uri.scheme,
+            "token" => uri.opaque,
+          }
+        end
+      rescue
+        {}
+      end
+
+      def self.key?(key)
+        p = key_to_params(key)
+        valid_scheme?(p["scheme"]) && valid_token?(p["token"])
+      end
+
+      def self.valid_token?(token)
+        token.present? && token.match(/^\h{32}$/)
+      end
+
+      def self.scheme
+        "pagerduty"
+      end
+
+    end
+  end
+end
+

data/lib/rearview/alerts.rb

@@ -0,0 +1,20 @@
+require 'rearview/alerts/base'
+require 'rearview/alerts/email_alert'
+require 'rearview/alerts/pagerduty_alert'
+require 'rearview/alerts/campfire_alert'
+
+module Rearview
+  module Alerts
+    module_function
+    def registry
+      unless @registry
+        @registry = {}.tap do |h|
+          h[Rearview::Alerts::PagerDutyAlert.scheme] = Rearview::Alerts::PagerDutyAlert
+          h[Rearview::Alerts::EmailAlert.scheme] = Rearview::Alerts::EmailAlert
+          h[Rearview::Alerts::CampfireAlert.scheme] = Rearview::Alerts::CampfireAlert
+        end
+      end
+      @registry
+    end
+  end
+end

data/lib/rearview/alerts_handler.rb

@@ -0,0 +1,34 @@
+
+module Rearview
+  class AlertsHandler
+    include Rearview::Logger
+    attr_reader :job,:monitor_result
+    def initialize(job,monitor_results)
+      @job = job
+      @monitor_results = monitor_results
+    end
+    def run
+      logger.info "#{self} run"
+      if Rearview.config.alerts_enabled?
+        Rearview.alert_clients.each do |client|
+          alert_agent = client.new
+          begin
+            alert_agent.alert(@job,@monitor_results)
+          rescue
+            logger.error "#{self} #{alert_agent} failed: #{$!}\n#{$@.join("\n")}"
+          end
+        end
+      end
+      self
+    rescue
+      logger.error "#{self} failed: #{$!}\n#{$@.join("\n")}"
+      self
+    end
+
+    def to_s
+      "#{super.to_s} [jobId:#{@job.id} threadId:#{java.lang.Thread.currentThread.getId} threadName:#{java.lang.Thread.currentThread.getName}]"
+    end
+
+  end
+end
+

data/lib/rearview/concerns/models/user.rb

@@ -0,0 +1,15 @@
+module Rearview::Concerns::Models::User
+  extend ActiveSupport::Concern
+  included do
+
+    self.table_name = "users"
+
+    has_many :monitors, :dependent => :destroy
+
+    serialize :preferences, JSON
+
+    validates_uniqueness_of :email
+    validates_presence_of :email
+
+  end
+end

data/lib/rearview/concerns/models.rb

@@ -0,0 +1,5 @@
+
+module Rearview::Concerns::Models
+end
+
+require "rearview/concerns/models/user"

data/lib/rearview/concerns.rb

@@ -0,0 +1,5 @@
+
+module Rearview::Concerns
+end
+
+require "rearview/concerns/models"

data/lib/rearview/configuration.rb

@@ -0,0 +1,59 @@
+require 'optparse'
+
+module Rearview
+  class Configuration < Struct.new(:default_from, :graphite_url, :pagerduty_url, :sandbox_exec,
+      :sandbox_timeout, :sandbox_dir, :enable_alerts, :preload_jobs, :logger, :enable_monitor, :verify)
+
+    DEFAULTS = {
+      default_from: "rearview@localhost",
+      graphite_url: nil,
+      pagerduty_url: "https://events.pagerduty.com/generic/2010-04-15/create_event.json",
+      sandbox_timeout: 5,
+      enable_alerts: true,
+      preload_jobs: true,
+      verify: false,
+      enable_monitor: true
+    }
+
+    def initialize
+      super
+      set_defaults
+    end
+
+    def alerts_enabled?
+      enable_alerts
+    end
+
+    def monitor_enabled?
+      enable_monitor
+    end
+
+    def preload_jobs?
+      preload_jobs
+    end
+
+    def verify?
+      verify
+    end
+
+    def with_argv(argv)
+      OptionParser.new do |opts|
+        opts.on("--[no-]preload", "Enable/disable job loading")  { |v| self.preload_jobs = v }
+        opts.on("--[no-]alerts", "Enable/disable alerts")  { |v| self.enable_alerts = v }
+        opts.on("--[no-]monitor", "Enable/disable monitor")  { |v| self.enable_monitor = v }
+        opts.on("--[no-]verify", "Enable/disable verification")  { |v| self.verify = v }
+      end.parse!(argv)
+    end
+
+    def set_defaults
+      members.each { |member| send("#{member}=", DEFAULTS[member.to_sym]) }
+    end
+
+    def to_s
+      @elems = []
+      members.each { |m| @elems << "Rearview::Configuration #{m} : #{self[m]}" }
+      @elems.join("\n")
+    end
+
+  end
+end

data/lib/rearview/constants_module_maker.rb

@@ -0,0 +1,59 @@
+module Rearview
+  module ConstantsModuleMaker
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def make_constants_module(*args)
+        mod_name = args[0]
+        mod_opts = args[1]
+        m = Module.new
+        constant_values = []
+        if(mod_opts[:constants].kind_of?(Array))
+          mod_opts[:constants].each { |c|
+            key = c.to_s.upcase
+            value = if( mod_opts[:upcase_values] )
+                      c.to_s.upcase
+                    elsif( mod_opts[:camelize_value] )
+                      c.to_s.camelize
+                    else
+                      c.to_s
+                    end
+            m.const_set(key,value)
+            constant_values.push(value)
+          }
+        else
+          mod_opts[:constants].each { |k,v|
+            m.const_set(k.to_s.upcase,v)
+            constant_values.push(v)
+          }
+        end
+        m.const_set("ALL_VALUES__",constant_values)
+        m.instance_eval {
+          def values
+            const_get("ALL_VALUES__")
+          end
+        }
+        i18n_format = nil
+        if(!mod_opts[:i18n_format])
+          i18n_format = "models.#{self.name.underscore}.#{mod_name}.%s"
+        else
+          i18n_format = mod_opts[:i18n_format]
+        end
+        if(i18n_format)
+          m.instance_eval %Q{
+            def t(c)
+               name = ( c.kind_of?(Symbol) ? const_get(c) : c)
+               I18n.t sprintf(\"#{i18n_format}\",name)
+            end
+          }
+        end
+        self.const_set(mod_name.to_s.camelize,m)
+        m
+      end
+    end
+
+  end
+end

data/lib/rearview/cron_helper.rb

@@ -0,0 +1,24 @@
+java_import 'org.quartz.CronExpression'
+
+module Rearview
+  module CronHelper
+    class << self
+      include Rearview::Logger
+      def next_valid_time_after(expr)
+        now = Time.now
+        java_now = java.util.Date.new(now.to_i*1000)
+        next_valid_time = CronExpression.new(expr).getNextValidTimeAfter(java_now)
+        get_time = next_valid_time.getTime / 1000
+        next_time = Time.at(get_time)
+        # Use (now.to_i*1000) so we can use timecop for testing...
+        # next_time = Time.at(CronExpression.new(expr).getNextValidTimeAfter(java.util.Date.new(now.to_i*1000)).getTime / 1000)
+        logger.debug "#{self} expr:\"#{expr}\" now:\"#{now}\" java_now:\"#{java_now}\" next_valid_time:\"#{next_valid_time}\" get_time:\"#{get_time}\" next_time:\"#{next_time}\" delay:#{next_time - now}"
+        next_time - now
+      end
+      def valid_expression?(expr)
+        CronExpression.is_valid_expression(expr)
+      end
+    end
+  end
+end
+

data/lib/rearview/distribute.rb

@@ -0,0 +1,36 @@
+module Rearview
+  module Distribute
+    class << self
+
+      def by_delay(jobs)
+        job_meta = jobs.map { |j| [j,{:delay=>j.delay,:initial_delay=>0}] }
+        job_meta.sort! { |a,b| a.last[:delay] <=> b.last[:delay] }
+        default_offset_amnt = 2.0
+        other_offset_amnt = 2.0
+        default_offset_count = 0
+        other_offset_count = 0
+        job_meta.each do |m|
+          if m.first.cron_expr == "0 * * * * ?"
+            m.last[:initial_delay] = default_offset_amnt * default_offset_count
+            default_offset_count+=1
+          else
+            m.last[:initial_delay] = other_offset_amnt * other_offset_count
+            other_offset_count+=1
+          end
+        end
+        job_meta
+      end
+
+      def inspect(dist_jobs)
+        parts = []
+        dist_jobs.each do |dj|
+          job = dj.first
+          meta = dj.second
+          parts << sprintf("job: %.5d cron:%30.25s meta:%s",job.id,job.cron_expr,meta.inspect)
+        end
+        parts.join("\n")
+      end
+
+    end
+  end
+end

data/lib/rearview/engine.rb

@@ -0,0 +1,36 @@
+require 'ostruct'
+require 'optparse'
+require 'devise'
+require 'ancestry'
+require 'state_machine'
+require 'protected_attributes'
+require 'httparty'
+require 'celluloid'
+require 'jbuilder'
+
+jar_dir =  File.expand_path('../../jar',  __FILE__)
+for jar in Dir["#{jar_dir}/*.jar"]
+  require jar
+end
+
+module Rearview
+  class Engine < ::Rails::Engine
+    isolate_namespace Rearview
+    config.generators do |g|
+      g.test_framework :rspec, :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+    config.assets.enabled = false
+    config.serve_static_assets = true
+    config.i18n.enforce_available_locales = false
+    initializer 'static_assets.load_static_assets' do |app|
+      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    end
+    initializer 'devise.use_rearview_helpers' do |app|
+      Devise::SessionsController.class_eval { helper Rearview::ApplicationHelper }
+    end
+    Jbuilder.key_format :camelize => :lower
+  end
+end

data/lib/rearview/ext/state_machine.rb

@@ -0,0 +1,15 @@
+module Rearview
+  module Ext
+    module StateMachine
+      extend ActiveSupport::Concern
+      included do
+        attr_accessor :event_data
+      end
+
+      def fire_event(name,event_data={})
+        self.event_data = event_data
+        fire_events(name)
+      end
+    end
+  end
+end

data/lib/rearview/graphite_parser.rb

@@ -0,0 +1,20 @@
+module Rearview
+  class GraphiteParser
+    ## returns an array of arrays of pairs with 2 elements timestamp and value (may be nil)
+    def self.parse(lines)
+      lines.strip.split("\n").map do |line|
+        metric, startTime, endTime, interval, dataStr = /(.*),(\d+),(\d+),(\d+)\|(.*)/.match(line)[1..-1]
+        data = dataStr.split(",")
+
+        0.upto(data.length - 1).map do |i|
+          value = data[i]
+          {
+            :metric    => metric,
+            :timestamp => startTime.to_i + (interval.to_i * i),
+            :value     => !value.nil?  ? value.to_f : value
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rearview/logger.rb

@@ -0,0 +1,10 @@
+
+module Rearview
+  module Logger
+    extend self
+    def logger
+      Rearview.logger
+    end
+  end
+end
+

data/lib/rearview/monitor_runner.rb

@@ -0,0 +1,277 @@
+require 'active_support'
+require 'date/format'
+require 'json'
+require 'time'
+
+java_import "java.lang.ProcessBuilder"
+
+class GraphiteException < Exception; end
+class GraphiteMetricException < Exception; end
+
+module Rearview
+  class MonitorRunner
+    @@DEFAULT_MINUTES = 60
+    @@monitor_script = nil
+    @@utilities_script = nil
+    @@sandbox_utils_template = "#{Rearview::Engine.root}/lib/rearview/templates/utilities.rb"
+    @@sandbox_monitor_template = "#{Rearview::Engine.root}/lib/rearview/templates/monitor.rb"
+    class << self
+
+      include Rearview::Logger
+
+      # Main worker method whic fetches data then calls eval
+      def run(metrics,
+              monitor_expr = nil,
+              minutes      = nil,
+              namespace    = {},
+              verbose      = false,
+              to_date      = nil,
+              immediate = false)
+        logger.debug "#{self} run"
+        begin
+          data = fetch_data(metrics, minutes, to_date)
+          if !data.empty?
+            namespace.merge!({ :minutes => minutes.nil? ? @@DEFAULT_MINUTES : minutes.to_i })
+            eval(data, monitor_expr, namespace, verbose, immediate)
+          end
+        rescue Exception => e
+          logger.error("Monitor failure #{e.message}\n#{e.backtrace.join("\n")}")
+          handleError(e)
+        end
+      end
+
+      def monitor_script
+        unless(@@monitor_script)
+          @@monitor_script = open(@@sandbox_monitor_template).read
+        end
+        @@monitor_script
+      end
+
+      def utilities_script
+        unless(@@utilities_script)
+          @@utilities_script = open(@@sandbox_utils_template).read
+        end
+        @@utilities_script
+      end
+
+      # Handles building a graphite API uri, issuing the request and parsing the result into a TimeSeries.
+      # FYI, I just killed a monitor which was fetching a shitload of data and spiking rearview's memory.
+      # I think you ought to make it a priority to move the graphite call into the monitor_template so it's
+      # not within the same proc as the main server....
+      def fetch_data(metrics, minutes = nil, to_date = nil)
+        logger.debug "#{self} fetch_data"
+        encMetrics = metrics.delete_if { |m| m.empty? }.map { |m| URI.escape(m) }
+        from, to   = create_from_to_dates(minutes, to_date)
+        uri        = "#{Rearview.config.graphite_url}/render?from=#{from}&until=#{to}&format=raw&target=" + encMetrics.join("&target=")
+
+        logger.debug("#{self} fetch_data #{uri}")
+
+        begin
+          response = HTTParty.get(uri)
+
+          case response.code
+          when 200
+            Rearview::GraphiteParser.parse(response.body)
+          else
+            message = response.body
+            logger.error("Graphite request failure: #{message}")
+            raise GraphiteMetricException.new(message)
+          end
+        rescue Exception => e
+          logger.error e
+          raise e
+        end
+      end
+
+      def eval(data, expr = nil, initial_ns = {}, verbose = false, immediate = false)
+        logger.debug "#{self} eval"
+        # prepare variable map for the monitor process
+        namespace = create_namespace(data, initial_ns)
+
+        # spawn the monitor and return the JSON result
+        result = exec_process(expr, namespace,immediate)
+
+        # # Use monitor-generated graph or create a default
+        graph_data = result[:graph_data]
+        output     = result[:output]
+        error      = result[:error]
+
+        graph_data = if graph_data.nil? or graph_data.empty?
+                       default_graph_data(data)
+                     else
+                       graph_data
+                     end
+
+        status = if error
+                   if error.index("Timeout Error") or error.index("Insecure operation")
+                     "security_error"
+                   else
+                     "failed"
+                   end
+                 else
+                   "success"
+                 end
+
+        {
+          :monitor_output => {
+            :status     => status,
+            :output     => output,
+            :graph_data => graph_data
+          },
+          :message => error,
+          :data => data
+        }
+      end
+
+      def exec_process(expr = "", namespace = {}.to_json, immediate=false)
+        logger.debug "#{self} exec_process"
+
+        # create script template
+        script_text = self.monitor_script % {utilities: self.utilities_script, expression: expr, timeout: Rearview.config.sandbox_timeout, namespace: namespace}
+        script_file = Tempfile.new("monitor_script",Rearview.config.sandbox_dir.to_s)
+        script_file.sync = true
+        script_file.write(script_text)
+        cmd = Rearview.config.sandbox_exec.clone << script_file.path
+        logger.info "#{self} exec_process #{cmd}"
+
+        # setup process
+        process_builder = ProcessBuilder.new(cmd).redirectErrorStream(true)
+        process_builder.directory(java.io.File.new(Rearview.config.sandbox_dir.to_s))
+        process_builder.environment.delete("GEM_HOME")
+        process_builder.environment.delete("GEM_PATH")
+        process_builder.environment.delete("BUNDLE_BIN_PATH")
+        process_builder.environment.delete("BUNDLE_GEMFILE")
+
+        # run process
+        exit_code = nil
+        output = nil
+        process = nil
+        begin
+          logger.info "#{self} exec_process start"
+          process = process_builder.start
+          exit_code = Celluloid::Future.new { process.wait_for }.value(Rearview.config.sandbox_timeout)
+          output  = process.get_input_stream.to_io.read
+        rescue Celluloid::TimeoutError => e
+          exit_code = 1
+          process.destroy rescue nil
+          output = "Execution of script timed out in #{Rearview.config.sandbox_timeout}s"
+        rescue Exception => e
+          exit_code = 2
+          output = e.message
+        end
+
+        # handle results
+        if exit_code == 0
+          begin
+            JSON.parse(output).to_hash.symbolize_keys
+          rescue Exception => e
+            { :graph_data => nil, :output => output.to_s, :error => e.message }
+          end
+        else
+          { :graph_data => nil, :output => output, :error => output }
+        end
+
+      ensure
+        script_file.close
+        script_file.unlink
+      end
+
+
+      # Populates the NS will vars passed in initialNS. Also plops the data in @timeseries
+      def create_namespace(data, initial_ns)
+        # Build the namespace with all the prepped tuples above
+        init = initial_ns.map { |kv| ["@" + kv.first.to_s, kv.last] }.flatten
+        ns = Hash[*init]
+        { "@timeseries" => data }.merge(ns).to_json
+      end
+
+      def default_graph_data(data)
+        data.map do |ts|
+          {
+            ts.first[:metric] => ts.map do |dp|
+              value = dp[:value]
+              [ dp[:timestamp], value.nil? ? nil : value.to_f ]
+            end
+          }
+        end
+      end
+
+      # Helper to create an AnalysisResult from an Exception.
+      def handleError(e)
+        # these should probably become some sort of class
+        status = case e.class
+                 when GraphiteMetricException
+                   "graphite_metric_error"
+                 when GraphiteException
+                   "graphite_error"
+                 else
+                   "error"
+                 end
+
+        message = e.message
+
+        output  = {
+          :status     => status,
+          :output     => message,
+          :graph_data => nil
+        }
+
+        {
+          :status  => status,
+          :output  => output,
+          :message => message,
+          :data    => nil
+        }
+      end
+
+      def normalize_results(results)
+        normalized = { status: "error", output: nil, graph_data: nil }
+        unless results.nil?
+          if results[:monitor_output]
+            normalized[:status] = results[:monitor_output][:status]
+            normalized[:output] = results[:monitor_output][:output]
+            if results[:monitor_output][:graph_data].present?
+              normalized[:graph_data] = if results[:monitor_output][:graph_data].kind_of?(Array)
+                results[:monitor_output][:graph_data].inject({}) do |acc,v|
+                  v.each { |k,v| acc[k] = v }
+                  acc
+                end
+              else
+                results[:monitor_output][:graph_data]
+              end
+            end
+          elsif results[:output]
+            if results[:output][:status].present?
+              normalized[:status] = results[:output][:status]
+            end
+            if results[:output][:output].present?
+              normalized[:output] = results[:output][:output]
+            end
+          end
+        end
+        normalized
+      end
+
+      def create_from_to_dates(minutes = nil, to_date = nil)
+        logger.debug "#{self}#create_from_to_dates minutes:#{minutes} to_date:#{to_date}"
+        graphite_date_format = '%H:%M_%Y%m%d'
+        incoming_date_format = '%m/%d/%Y %H:%M'
+        mins = minutes.nil? ? @@DEFAULT_MINUTES : minutes.to_i
+        if to_date == "now" || to_date.nil?
+          now = Time.now.gmtime
+        else
+          now = DateTime.strptime(to_date, incoming_date_format)
+        end
+        to = (now - 1.minutes).strftime(graphite_date_format)
+        from = (now - (mins + 1).minutes).strftime(graphite_date_format)
+        logger.debug "#{self}#create_from_to_dates from:#{from} to:#{to}"
+        [from,to]
+      end
+
+      def to_s
+        "#{super.to_s} [threadId:#{java.lang.Thread.currentThread.getId} threadName:#{java.lang.Thread.currentThread.getName}]"
+      end
+
+    end
+  end
+end