stackeye 0.1.0

data/bin/console

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'stackeye'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/generators/stackeye/install_generator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+class Stackeye::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_initializer_file
+    copy_file('install.rb', 'config/initializers/stackeye.rb')
+  end
+
+end

data/lib/generators/stackeye/templates/install.rb

@@ -0,0 +1,5 @@
+Stackeye.configure do |config|
+  config.max_data = 288
+  config.metrics = %w[server mysql]
+  config.credentials = {}
+end

data/lib/stackeye.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+%w[version configuration application].each do |filename|
+  require "stackeye/#{filename}"
+end
+
+require 'generators/stackeye/install_generator'

data/lib/stackeye/application.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+%w[base cookies].each do |filename|
+  require "sinatra/#{filename}"
+end
+
+%w[tools metrics helpers routes].each do |dirname|
+  require_relative "#{dirname}/init"
+end
+
+require 'logger'
+
+class Stackeye::Application < Sinatra::Base
+  helpers Sinatra::Cookies
+
+  set :app_file, __FILE__
+  set :bind, '0.0.0.0'
+
+  configure :development do
+    enable :logging, :dump_errors, :raise_errors
+  end
+
+  configure :production do
+    dir = File.expand_path('log')
+    Dir.mkdir(dir) unless File.directory?(dir)
+    file = File.new("#{dir}/stackeye.log", 'a+')
+    file.sync = true
+
+    use ::Rack::CommonLogger, file
+  end
+
+end

data/lib/stackeye/configuration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Stackeye
+  class Configuration
+
+    MAX_DATA ||= 288
+    METRICS ||= %w[server mysql].freeze
+
+    attr_accessor :credentials, :max_data, :metrics
+
+    def initialize
+      @max_data = MAX_DATA
+      @metrics = METRICS
+      @credentials = {}
+    end
+
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+end

data/lib/stackeye/helpers/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+def base_path
+  return unless ENV['RAILS_ENV']
+
+  '/stackeye'
+end
+
+def metric_icon_decorator(metric)
+  case metric
+  when 'server' then 'server'
+  else 'database'
+  end
+end
+
+def metric_name_decorator(metric)
+  case metric
+  when 'mysql' then 'MySQL'
+  else titleize(metric)
+  end
+end
+
+def modulize(str)
+  str.tr('_-', ' ').split(' ').map(&:capitalize).join('')
+end
+
+def page?(path)
+  request.path == "#{base_path}#{path}"
+end
+
+def refreshing?
+  cookies[:refresh] == '1'
+end
+
+def titleize(str)
+  str.tr('_', ' ').capitalize
+end
+
+def verified_distro?
+  Stackeye::Tools::Os.linux?
+end
+
+def verified_os?
+  cmd = 'lsb_release -ds'
+  Stackeye::Tools::Cli.execute(cmd).strip.include?('Ubuntu')
+end
+
+def verified_distro_and_os?
+  verified_distro? && verified_os?
+end
+
+def verify_distro_and_os!
+  return if verified_distro_and_os?
+
+  redirect("#{base_path}/unsupported")
+end

data/lib/stackeye/helpers/init.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+%w[base].each do |filename|
+  require_relative filename
+end

data/lib/stackeye/metrics/all.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Stackeye
+  module Metrics
+    class All
+
+      def initialize; end
+
+      def set
+        Stackeye.configuration.metrics.each do |metric|
+          klass = "Stackeye::Metrics::#{modulize(metric)}"
+          Module.const_get(klass).set
+        end
+      end
+
+      class << self
+        def set
+          klass = new
+          klass.set
+        end
+      end
+
+    end
+  end
+end

data/lib/stackeye/metrics/base.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Stackeye
+  module Metrics
+    class Base
+
+      MB ||= 1024.0
+      GB ||= MB**2
+
+      def initialize
+        @data = { timestamp: Time.now.to_i }
+      end
+
+      def filepath
+        return @filepath if defined?(@filepath)
+
+        @filepath ||= begin
+          path = Stackeye::Tools::Database::DATA_PATH
+          name = self.class.name.split('::').last.downcase
+
+          "#{path}/#{name}.json"
+        end
+      end
+
+      def set
+        generate_data
+        return if @data.empty?
+
+        Stackeye::Tools::Database.set(filepath, @data)
+      end
+
+      def get
+        return @get if defined?(@get)
+
+        @get ||= Stackeye::Tools::Database.get(filepath)
+      end
+
+      def pluck(key)
+        @pluck ||= {}
+        return @pluck[key] if @pluck.key?(key)
+
+        @pluck[key] = get.collect { |hash| hash[key] }
+      end
+
+      def mean(key)
+        @mean ||= {}
+        return @mean[key] if @mean.key?(key)
+
+        values = pluck(key)
+        return @mean[key] = 0.0 if values.empty?
+
+        @mean[key] = values.sum / values.length.to_f
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def median(key)
+        @median ||= {}
+        return @median[key] if @median.key?(key)
+
+        values = pluck(key)
+        return @median[key] = 0.0 if values.empty?
+
+        values_sorted = values.sort
+        values_halved = values.length / 2.0
+        values_halved_sorted = values_sorted[values_halved]
+        return @median[key] = values_halved_sorted unless (values.length % 2).zero?
+
+        @median[key] = (values_sorted[values_halved - 1.0] + values_halved_sorted) / 2.0
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def mode(key)
+        @mode ||= {}
+        return @mode[key] if @mode.key?(key)
+
+        values = pluck(key)
+        return @mode[key] = 0.0 if values.empty?
+
+        values_distro = values.each_with_object(Hash.new(0)) { |val, hsh| hsh[val] += 1 }
+        values_top_two = values_distro.sort_by { |_, val| -val }.take(2)
+        @mode[key] = values_top_two.first.first
+      end
+
+      def range(key)
+        @range ||= {}
+        return @range[key] if @range.key?(key)
+
+        values = pluck(key)
+        return @range[key] = 0.0 if values.empty?
+
+        values_sorted = values.sort
+        @mode[key] = values_sorted.last - values_sorted.first
+      end
+
+      class << self
+        %i[filepath set get].each do |name|
+          define_method(name) do
+            klass = new
+            klass.send(name)
+          end
+        end
+
+        %i[pluck mean median mode range].each do |name|
+          define_method(name) do |key|
+            klass = new
+            klass.send(name, key)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stackeye/metrics/init.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+%w[base server mysql all].each do |filename|
+  require_relative filename
+end

data/lib/stackeye/metrics/mysql.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Stackeye
+  module Metrics
+    class Mysql < Stackeye::Metrics::Base
+
+      CREDENTIALS ||= {
+        user: 'root',
+        host: 'localhost',
+        password: nil
+      }.freeze
+
+      def generate_data
+        generate_stats
+      end
+
+      private
+
+      def generate_stats
+        cmd = "mysqladmin -u#{user} -h#{host} -p#{password} status"
+        lines = Stackeye::Tools::Cli.execute(cmd).split("\n")
+        stats = lines.last.strip.split('  ')
+
+        stats.each do |stat|
+          key, val = stat.split(': ')
+          key = key.downcase.tr(' ', '_')
+          key = 'velocity' if key == 'queries_per_second_avg'
+
+          @data[key] = val.to_f.round(2)
+        end
+      end
+
+      %i[host password user].each do |name|
+        define_method(name) do
+          credentials = Stackeye.configuration.credentials[:mysql]
+          credentials[name] || CREDENTIALS[name]
+        end
+      end
+
+    end
+  end
+end

data/lib/stackeye/metrics/server.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Stackeye
+  module Metrics
+    class Server < Stackeye::Metrics::Base
+
+      def generate_data
+        generate_cpu_loadavg
+        generate_cpu_utilization
+        generate_memory_utilization
+        generate_process_utilization
+        generate_swap_utilization
+        generate_volume_utilization
+      end
+
+      private
+
+      def generate_cpu_loadavg
+        { cpu_load_1m: 1, cpu_load_5m: 2, cpu_load_15m: 3 }.each do |name, col|
+          cmd = "cat /proc/loadavg | awk '{ print $#{col} }'"
+          @data[name] = Stackeye::Tools::Cli.execute(cmd).strip.to_f
+        end
+      end
+
+      def generate_cpu_utilization
+        cmd = "ps -Ao %cpu | awk '{ s += $1 } END { print s }'"
+        @data[:cpu_utilization] = Stackeye::Tools::Cli.execute(cmd).strip.to_f
+      end
+
+      def generate_process_utilization
+        { cpu: 'pcpu', memory: 'pmem' }.each do |label, sort|
+          key = "#{label}_processes".to_sym
+          cmd = "ps -Ao user,uid,comm,pid,pcpu,pmem --sort=-#{sort} | head -n 11"
+          processes = Stackeye::Tools::Cli.execute(cmd)
+
+          @data[key] = []
+          processes.split("\n").each_with_index do |process, i|
+            next if i.zero?
+
+            @data[key] << process.strip.gsub(/\s+/, ' ').split(' ')
+          end
+        end
+      end
+
+      def generate_memory_utilization
+        { memory_free: 4, memory_total: 2, memory_used: 3 }.each do |name, col|
+          cmd = "/usr/bin/free | head -n 2 | tail -n 1 | awk '{ print $#{col} }'"
+          memory = Stackeye::Tools::Cli.execute(cmd).strip.to_f
+
+          @data[name] = (memory / GB).round(2)
+        end
+      end
+
+      def generate_swap_utilization
+        { swap_free: 4, swap_total: 2, swap_used: 3 }.each do |name, col|
+          cmd = "/usr/bin/free | tail -n 1 | awk '{ print $#{col} }'"
+          swap = Stackeye::Tools::Cli.execute(cmd).strip.to_f
+
+          @data[name] = (swap / GB).round(2)
+        end
+      end
+
+      def generate_volume_utilization
+        { disk_free: 4, disk_total: 2, disk_used: 3 }.each do |name, col|
+          cmd = "/bin/df --total | tail -n 1 | awk '{ print $#{col} }'"
+          volume = Stackeye::Tools::Cli.execute(cmd).strip.to_f
+
+          @data[name] = (volume / GB).round(2)
+        end
+      end
+
+    end
+  end
+end