snowman-io 0.0.4 → 0.0.5

data/lib/snowman-io/cli.rb

@@ -0,0 +1,69 @@
+require 'digest/sha1'
+
+module SnowmanIO
+  # The command line interface for SnowmanIO.
+  class CLI
+    attr_reader :options
+
+    def self.run
+      options = Options.new.parse!(ARGV)
+      new(options).run
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def run
+      setup_logger
+
+      # Self-pipe for deferred signal-handling (http://cr.yp.to/docs/selfpipe.html)
+      self_read, self_write = IO.pipe
+
+      %w(INT TERM USR1 USR2 TTIN).each do |sig|
+        begin
+          trap sig do
+            self_write.puts(sig)
+          end
+        rescue ArgumentError
+          puts "Signal #{sig} not supported"
+        end
+      end
+
+      launcher = Launcher.new(options)
+
+      begin
+        launcher.start
+        while readable_io = IO.select([self_read])
+          signal = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        SnowmanIO.logger.info 'Shutting down'
+        launcher.stop
+        exit(0)
+      end
+    end
+
+    private
+
+    def handle_signal(sig)
+      SnowmanIO.logger.debug "Received #{sig} signal"
+      case sig
+      when 'TERM'
+        raise Interrupt
+      when 'INT'
+        raise Interrupt
+      end
+    end
+
+    def setup_logger
+      Celluloid.logger = (options[:verbose] ? SnowmanIO.logger : nil)
+      if options[:verbose]
+        SnowmanIO.logger.level = ::Logger::DEBUG
+      else
+        SnowmanIO.logger.level = ::Logger::INFO
+      end
+    end
+  end
+end

data/lib/snowman-io/launcher.rb

@@ -1,24 +1,25 @@
-require 'snowman-io/scheduler'
-require 'snowman-io/handler'
-
 module SnowmanIO
   class Launcher
     include Celluloid
 
-    attr_reader :scheduler, :handler
-
-    def initialize(checks)
-      @handler = Handler.new_link
-      @scheduler = Scheduler.new_link(checks)
-      @scheduler.handler = handler
+    def initialize(options)
+      @options = options
     end
 
     def start
-      scheduler.async.start
+      Migration.new.migrate
+      app = Rack::Cascade.new [API::Root, Web]
+      @web_server = WebServer.supervise_as(:web_server, app, @options.slice(:port, :host, :verbose))
+      @ping = Loop::Ping.supervise_as(:ping)
+      @main = Loop::Main.supervise_as(:main)
+      @checks = Loop::Checks.supervise_as(:checks)
     end
 
     def stop
-      #TODO
+      @checks.terminate
+      @main.terminate
+      @ping.terminate
+      @web_server.terminate # TODO: shutdown blocking?
     end
   end
 end

data/lib/snowman-io/loop/check_processor.rb

@@ -0,0 +1,29 @@
+module SnowmanIO
+  module Loop
+    class CheckProcessor
+      def initialize(check)
+        @check  = check
+        @metric = check.metric
+      end
+
+      def process
+        if @check.template == Check::TEMPLATE_LAST_VALUE_LIMIT
+          @check.cmp_fn.call(@metric.last_value, @check.value)
+
+        elsif @check.template == Check::TEMPLATE_PREV_DAY_DATAPOINTS_LIMIT
+          # use aggregation for prev day
+          at = Time.now.beginning_of_day - 1.day
+          if @metric.created_at < at # require full gather day
+            count = @metric.aggregations.where("precision" => "daily", "at" => at).first.try(&:count).to_i
+            @check.cmp_fn.call(count, @check.value)
+          else
+            false
+          end
+
+        else
+          raise "Unknown check template: #{@check.template}"
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/loop/checks.rb

@@ -0,0 +1,59 @@
+require 'snowman-io/loop/check_processor'
+
+module SnowmanIO
+  module Loop
+    class Checks
+      include Celluloid
+
+      def initialize
+        after(1) { tick }
+      end
+
+      def tick
+        perform
+        after(3) { tick }
+      end
+
+      private
+
+      def perform
+        Check.each do |check|
+          result = CheckProcessor.new(check).process
+          send_mail = false
+          check.last_run_at = DateTime.now
+          if result
+            puts "Check for #{check.metric.name} triggered"
+            unless check.triggered
+              send_mail = true
+            end
+            check.triggered = true
+            check.last_status = Check::STATUS_FAILED
+          else
+            check.last_status = Check::STATUS_OK
+          end
+          check.save!
+
+          if send_mail
+            ReportMailer.check_triggered(
+              check,
+              check.last_run_at,
+              Setting.get(SnowmanIO::BASE_URL_KEY),
+              check.user.email,
+              true
+            ).deliver_now
+
+            check.user.followers.each do |user|
+              ReportMailer.check_triggered(
+                check,
+                check.last_run_at,
+                Setting.get(SnowmanIO::BASE_URL_KEY),
+                user.email,
+                false
+              ).deliver_now
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/loop/main.rb

@@ -0,0 +1,43 @@
+module SnowmanIO
+  module Loop
+    class Main
+      include Celluloid
+
+      def initialize
+        after(1) { tick }
+      end
+
+      def tick
+        perform
+        after(3) { tick }
+      end
+
+      private
+
+      def perform
+        now = Time.now
+
+        # next time let send report for today
+        next_report_date = Time.now.beginning_of_day
+
+        # aggregate
+        start = Time.now.to_f
+        Aggregate.metrics_aggregate_5min
+        Aggregate.metrics_aggregate_hour
+        Aggregate.metrics_aggregate_daily
+        Aggregate.metrics_clean_old
+
+        # init report time
+        unless Setting.get(SnowmanIO::NEXT_REPORT_DATE_KEY)
+          Setting.set(SnowmanIO::NEXT_REPORT_DATE_KEY, next_report_date.to_i)
+        end
+
+        # send report at 7:00 next day
+        if now.to_i > Setting.get(SnowmanIO::NEXT_REPORT_DATE_KEY) + 1.day + 7.hours
+          Reports.report_send(Time.at(Setting.get(SnowmanIO::NEXT_REPORT_DATE_KEY)))
+          Setting.set(SnowmanIO::NEXT_REPORT_DATE_KEY, next_report_date.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/loop/ping.rb

@@ -0,0 +1,25 @@
+module SnowmanIO
+  module Loop
+    # Ping itself every 5 minutes to be in fit
+    class Ping
+      include Celluloid
+
+      def initialize
+        after(10) { tick }
+      end
+
+      def tick
+        perform
+        after(5*60) { tick }
+      end
+
+      private
+
+      def perform
+        if base_url = Setting.get(SnowmanIO::BASE_URL_KEY)
+          open(base_url + "/ping")
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/migration.rb

@@ -0,0 +1,79 @@
+module SnowmanIO
+  # Helpfull class to seed data and update DB
+  class Migration
+    def initialize
+      @db = Mongoid::Sessions.default
+      puts "[DEBUG] #{@db[:snowman_io_schema].find.to_a.inspect}"
+      @done_versions = @db[:snowman_io_schema].find.map { |c| c["version"] }
+      @migration_versions = []
+    end
+
+    def migrate
+      SnowmanIO.logger.info "Migration start"
+
+      migration "Set boundary template for all checks" do
+        @db[:snowman_io_checks].find().update_all("$set" => {"template" => "boundary"})
+      end
+
+      migration "boundary => last_value_limit" do
+        @db[:snowman_io_checks].find({template: "boundary"}).update_all("$set" => {"template" => "last_value_limit"})
+      end
+
+      migration "daily_datapoints => prev_day_datapoints_limit" do
+        @db[:snowman_io_checks].find({template: "daily_datapoints"}).update_all("$set" => {"template" => "prev_day_datapoints_limit"})
+      end
+
+      migration "set owner to each check" do
+        if user = @db[:snowman_io_users].find.first
+          @db[:snowman_io_checks].find.update_all("$set" => {"user_id" => user["_id"]})
+        end
+      end
+
+      migration "users timestamps" do
+        @db[:snowman_io_users].find.update_all("$set" => {"created_at" => Time.now})
+        @db[:snowman_io_users].find.update_all("$set" => {"updated_at" => Time.now})
+      end
+
+      migration "users daily_report" do
+        @db[:snowman_io_users].find.update_all("$set" => {"daily_report" => true})
+      end
+
+      migration "users invite_token" do
+        @db[:snowman_io_users].find.update_all("$set" => {"invite_token" => ""})
+      end
+
+      migration "users invite_send_count" do
+        @db[:snowman_io_users].find.update_all("$set" => {"invite_send_count" => 0})
+      end
+
+      migration "users status" do
+        @db[:snowman_io_users].find.update_all("$set" => {"status" => "wait_invite"})
+        @db[:snowman_io_users].where(invite_token: "").update_all("$set" => {"status" => "active"})
+      end
+
+      migration "users name" do
+        @db[:snowman_io_users].where(status: "active").each do |record|
+          @db[:snowman_io_users].where(_id: record["_id"]).update_all("$set" => {"name" => record["email"]})
+        end
+      end
+
+      SnowmanIO.logger.info "Migration done"
+    end
+
+    private
+
+    def migration(version, &block)
+      if @migration_versions.include?(version)
+        raise "Duplicate migration version '#{version}'"
+      end
+      @migration_versions.push version
+
+      return if @done_versions.include?(version)
+
+      SnowmanIO.logger.info "Apply: #{version} ..."
+      yield
+      @db[:snowman_io_schema].insert(version: version)
+      SnowmanIO.logger.info "Apply: #{version} ... OK"
+    end
+  end
+end

data/lib/snowman-io/models/aggregation.rb

@@ -0,0 +1,15 @@
+module SnowmanIO
+  class Aggregation
+    include Mongoid::Document
+    belongs_to :metric
+
+    field :precision, type: String
+    field :at, type: DateTime
+    field :min, type: Float
+    field :avg, type: Float
+    field :up, type: Float
+    field :max, type: Float
+    field :sum, type: Float
+    field :count, type: Integer
+  end
+end

data/lib/snowman-io/models/app.rb

@@ -0,0 +1,61 @@
+module SnowmanIO
+  class App
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Concerns::Tokenable
+    has_many :metrics, dependent: :destroy
+
+    field :name,  type: String
+    field :token, type: String
+
+    validates :name, :token, presence: true
+
+    before_validation on: :create do
+      self.token = generate_token(:token)
+    end
+
+    def as_json(options = {})
+      super(options.merge(methods: [:datapoints, :metric_ids])).tap do |o|
+        o["id"] = o.delete("_id").to_s
+        o["metric_ids"] = o["metric_ids"].map(&:to_s)
+      end
+    end
+
+    # Returns amount of datapoints for `at` and day before
+    def daily_metrics(at)
+      json = {}
+
+      today = at.beginning_of_day
+      yesterday = at.beginning_of_day - 1.day
+      json["today"] = {"at" => today.strftime("%Y-%m-%d"), "count" => 0}
+      json["yesterday"] = {"at" => yesterday.strftime("%Y-%m-%d"), "count" => 0}
+      json["total"] = {"count" => 0}
+
+      # TODO: impl it more performable
+      metrics.each do |metric|
+        if aggr = metric.aggregations.where(precision: "daily", at: today).first
+          json["today"]["count"] += aggr.count.to_i
+        end
+
+        if aggr = metric.aggregations.where(precision: "daily", at: yesterday).first
+          json["yesterday"]["count"] += aggr.count.to_i
+        end
+
+        json["total"]["count"] += metric.aggregations.where(precision: "daily").sum(:count).to_i
+      end
+
+      json
+    end
+
+    def register_metric_value(name, kind, value, at = Time.now)
+      metric = metrics.where(name: name, kind: kind).first_or_create!
+      metric.update_attributes!(last_value: value, last_value_updated_at: Time.now)
+      metric.data_points.create!(at: at, value: value)
+      touch
+    end
+
+    def datapoints
+      daily_metrics(Time.now)
+    end
+  end
+end

data/lib/snowman-io/models/check.rb

@@ -0,0 +1,48 @@
+module SnowmanIO
+  class Check
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    STATUS_NEVER_RUNNED = "NEVER RUNNED"
+    STATUS_OK = "OK"
+    STATUS_FAILED = "FAILED"
+
+    TEMPLATE_LAST_VALUE_LIMIT = "last_value_limit"
+    TEMPLATE_PREV_DAY_DATAPOINTS_LIMIT = "prev_day_datapoints_limit"
+
+    belongs_to :metric
+    belongs_to :user
+
+    # Each check should be one of available templates. Each metric is compatible only
+    # with some templates.
+    field :template, type: String
+
+    # TEMPLATE_LAST_VALUE_LIMIT, TEMPLATE_PREV_DAY_DATAPOINTS_LIMIT
+    field :cmp, type: String
+    field :value, type: Float
+
+    # COMMON
+    field :triggered, type: Boolean, default: false
+    field :last_run_at, type: DateTime
+    field :last_status, type: String, default: STATUS_NEVER_RUNNED
+
+    def as_json(options = {})
+      super(options).tap do |o|
+        o["id"] = o.delete("_id").to_s
+        o["metric_id"] = o["metric_id"].to_s
+        o["user_id"] = o["user_id"].to_s
+      end
+    end
+
+    def cmp_fn
+      case cmp
+      when "more"
+        -> (a, b) { a ? a > b : false }
+      when "less"
+        -> (a, b) { a ? a < b : false }
+      else
+        raise "unreachable"
+      end
+    end
+  end
+end