foreman_statistics 0.1.0

data/app/models/foreman_statistics/fact_trend.rb

@@ -0,0 +1,57 @@
+module ForemanStatistics
+  class FactTrend < Trend
+    validates :trendable_id, :presence => true, :uniqueness => { :scope => %i[trendable_type fact_value] }, :allow_blank => false
+
+    before_save :update_fact_name
+
+    def to_label
+      name.presence || fact_value || fact_name
+    end
+
+    def type_name
+      if fact_value.blank?
+        name.presence || fact_name
+      else
+        fact_name
+      end
+    end
+
+    def create_values
+      self.class.create_values(trendable_id)
+    end
+
+    def self.create_values(fact_name_id)
+      FactValue.select('fact_name_id, value').group(:fact_name_id, :value).where(:fact_name_id => fact_name_id).includes(:fact_name).map do |fact|
+        create(:trendable_type => 'FactName',
+               :trendable_id => fact.fact_name.id,
+               :fact_name => fact.fact_name.name,
+               :fact_value => fact.value,
+               :name => fact.value)
+      end
+    end
+
+    def destroy_values
+      ids = FactTrend.where(:trendable_id => trendable_id, :trendable_type => trendable_type).pluck(:id)
+      super(ids)
+    end
+
+    def values
+      return FactTrend.where(:id => self) if fact_value
+      FactTrend.has_value.where(:trendable_type => trendable_type, :trendable_id => trendable_id)
+    end
+
+    def self.model_name
+      Trend.model_name
+    end
+
+    def find_hosts
+      Host.joins(:fact_values).where(:fact_values => { :value => fact_value }).order(:name)
+    end
+
+    private
+
+    def update_fact_name
+      self.fact_name = FactName.find(trendable_id).name if trendable_id
+    end
+  end
+end

data/app/models/foreman_statistics/foreman_trend.rb

@@ -0,0 +1,41 @@
+module ForemanStatistics
+  class ForemanTrend < Trend
+    validates :trendable_id, :uniqueness => { :scope => :trendable_type }
+    validates :trendable_type, :presence => true
+
+    def to_label
+      trendable ? trendable.to_label : trendable_type
+    end
+
+    def type_name
+      trendable_type
+    end
+
+    def create_values
+      self.class.create_values(trendable_type)
+    end
+
+    def self.create_values(trendable_type)
+      trendable_type.constantize.all.map { |t| t.trends.create(:fact_value => t.to_label) }
+    end
+
+    def destroy_values
+      ids = ForemanTrend.where(:trendable_type => trendable_type).pluck(:id)
+      super(ids)
+    end
+
+    def values
+      return ForemanTrend.where(:id => self) if fact_value
+      ForemanTrend.has_value.where(:trendable_type => trendable_type)
+    end
+
+    def self.model_name
+      Trend.model_name
+    end
+
+    def find_hosts
+      return Host::Managed.none unless trendable
+      trendable.hosts.order(:name)
+    end
+  end
+end

data/app/models/foreman_statistics/trend.rb

@@ -0,0 +1,38 @@
+module ForemanStatistics
+  class Trend < ApplicationRecord
+    self.table_name = 'trends'
+
+    validates_lengths_from_database
+    after_save :create_values, :if => ->(o) { o.fact_value.nil? }
+    after_destroy :destroy_values, :if => ->(o) { o.fact_value.nil? }
+
+    belongs_to :trendable, :polymorphic => true
+    has_many :trend_counters, :dependent => :destroy
+
+    scope :has_value, -> { where('fact_value IS NOT NULL').order('fact_value') }
+    scope :types, -> { where(:fact_value => nil) }
+
+    def to_param
+      Parameterizable.parameterize("#{id}-#{to_label}")
+    end
+
+    def self.title_name
+      'label'.freeze
+    end
+
+    def self.humanize_class_name(_name = nil)
+      super('Trend')
+    end
+
+    def self.build_trend(trend_params = {})
+      trend_params[:trendable_type] == 'FactName' ? FactTrend.new(trend_params) : ForemanTrend.new(trend_params)
+    end
+
+    private
+
+    def destroy_values(ids = [])
+      TrendCounter.where(:trend_id => ids).delete_all
+      Trend.where(:id => ids).delete_all
+    end
+  end
+end

data/app/models/foreman_statistics/trend_counter.rb

@@ -0,0 +1,11 @@
+module ForemanStatistics
+  class TrendCounter < ApplicationRecord
+    self.table_name = 'trend_counters'
+
+    belongs_to :trend
+    validates :count, :numericality => { :greater_than_or_equal_to => 0 }
+    validates :created_at, :uniqueness => { :scope => :trend_id }
+    default_scope -> { order(:created_at) }
+    scope :recent, ->(*args) { where('created_at > ?', (args.first || 30.days.ago)).order(:created_at) }
+  end
+end

data/app/services/foreman_statistics/statistics.rb

@@ -0,0 +1,21 @@
+module ForemanStatistics
+  module Statistics
+    def self.charts(org_id, loc_id)
+      charts = [
+        CountHosts.new(:count_by => :operatingsystem, :title => 'OS Distribution', :search => 'os_title=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :architecture, :title => _('Architecture Distribution'), :search => 'facts.architecture=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :environment, :title => _('Environment Distribution'), :search => 'environment=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :hostgroup, :title => _('Host Group Distribution'), :search => 'hostgroup_title=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :compute_resource, :title => _('Compute Resource Distribution'), :search => 'compute_resource=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountFacts.new(:count_by => :processorcount, :unit => Nn_('%s core', '%s cores'), :title => _('Number of CPUs'), :search => 'facts.processorcount=~VAL1~', :organization_id => org_id, :location_id => loc_id),
+        CountFacts.new(:count_by => :manufacturer, :title => _('Hardware'), :search => 'facts.manufacturer~~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountNumericalFactPair.new(:count_by => :memory, :title => _('Average Memory Usage'), :organization_id => org_id, :location_id => loc_id),
+        CountNumericalFactPair.new(:count_by => :swap, :title => _('Average Swap Usage'), :organization_id => org_id, :location_id => loc_id),
+        CountPuppetClasses.new(:id => :puppetclass, :title => _('Class Distribution'), :search => 'class=~VAL1~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :location, :title => _('Location Distribution'), :search => 'location=~VAL~', :organization_id => org_id, :location_id => loc_id),
+        CountHosts.new(:count_by => :organization, :title => _('Organization Distribution'), :search => 'organization=~VAL~', :organization_id => org_id, :location_id => loc_id)
+      ]
+      charts
+    end
+  end
+end

data/app/services/foreman_statistics/statistics/base.rb

@@ -0,0 +1,39 @@
+module ForemanStatistics
+  module Statistics
+    class Base
+      attr_reader :title, :count_by, :url
+
+      def initialize(options = {})
+        @id = options[:id]
+        @title = options[:title]
+        @search = options[:search]
+        @count_by = options[:count_by]
+        @organization_id = options[:organization_id]
+        @location_id = options[:location_id]
+        @url = options[:url] || build_url
+      end
+
+      def calculate
+        raise NotImplementedError, "Method 'calculate' method needs to be implemented"
+      end
+
+      def id
+        @id || count_by.to_s
+      end
+
+      def search
+        Rails.application.routes.url_helpers.hosts_path(:search => @search)
+      end
+
+      def metadata
+        { :id => id, :title => title, :url => url, :search => search }
+      end
+
+      private
+
+      def build_url
+        ForemanStatistics::Engine.routes.url_helpers.statistic_path(id, :location_id => @location_id, :organization_id => @organization_id)
+      end
+    end
+  end
+end

data/app/services/foreman_statistics/statistics/count_facts.rb

@@ -0,0 +1,17 @@
+module ForemanStatistics
+  module Statistics
+    class CountFacts < Base
+      attr_reader :unit
+
+      def initialize(options = {})
+        super(options)
+        @count_by = @count_by.to_s
+        @unit     = options[:unit]
+      end
+
+      def calculate
+        FactValue.authorized(:view_facts).my_facts.count_each(count_by, :unit => unit)
+      end
+    end
+  end
+end

data/app/services/foreman_statistics/statistics/count_hosts.rb

@@ -0,0 +1,9 @@
+module ForemanStatistics
+  module Statistics
+    class CountHosts < Base
+      def calculate
+        Host.authorized(:view_hosts, Host).count_distribution(count_by)
+      end
+    end
+  end
+end

data/app/services/foreman_statistics/statistics/count_numerical_fact_pair.rb

@@ -0,0 +1,43 @@
+module ForemanStatistics
+  module Statistics
+    class CountNumericalFactPair < Base
+      attr_reader :total, :used
+
+      def initialize(options = {})
+        super(options)
+        if @count_by.empty?
+          raise(ArgumentError, 'Must provide :count_by option')
+        end
+        @count_by = @count_by.to_s
+        @total    = options[:total] || 'size'
+        @used     = options[:used]  || 'free'
+      end
+
+      def calculate
+        mem_size = FactValue.authorized(:view_facts).my_facts.mem_average(total_name)
+        mem_free = FactValue.authorized(:view_facts).my_facts.mem_average(used_name)
+
+        [
+          {
+            :label => _('free memory'),
+            :data => mem_free
+          },
+          {
+            :label => _('used memory'),
+            :data => (mem_size - mem_free).round(2)
+          }
+        ]
+      end
+
+      private
+
+      def total_name
+        count_by + total
+      end
+
+      def used_name
+        count_by + used
+      end
+    end
+  end
+end

data/app/services/foreman_statistics/statistics/count_puppet_classes.rb

@@ -0,0 +1,23 @@
+module ForemanStatistics
+  module Statistics
+    class CountPuppetClasses < Base
+      def initialize(options = {})
+        super(options)
+        if id.empty?
+          raise(ArgumentError, 'Must provide an :id or :count_by option')
+        end
+      end
+
+      def calculate
+        Puppetclass.authorized(:view_puppetclasses).map do |pc|
+          count = pc.hosts_count
+          next if count.zero?
+          {
+            :label => pc.to_label,
+            :data => count
+          }
+        end.compact
+      end
+    end
+  end
+end

data/app/services/foreman_statistics/trend_importer.rb

@@ -0,0 +1,63 @@
+module ForemanStatistics
+  class TrendImporter
+    def self.update!
+      importer = new
+      importer.check_values
+      importer.update_trend_counters
+      importer.aggregate_counters
+    end
+
+    # Check for missing values
+    # Comparing a count prior to trying to recreating them all for efficiency sake
+    def check_values
+      ForemanTrend.types.pluck(:trendable_type).each do |trend_type|
+        changes = trend_type.constantize.pluck(:id) - ForemanTrend.has_value.where(:trendable_type => trend_type).pluck(:trendable_id)
+        ForemanTrend.create_values(trend_type) unless changes.empty?
+      end
+
+      FactTrend.types.pluck(:trendable_id).each do |fact_name_id|
+        changes = FactValue.where(:fact_name_id => fact_name_id).group(:value).pluck(:value) - FactTrend.has_value.where(:trendable_id => fact_name_id).pluck(:fact_value)
+        FactTrend.create_values(fact_name_id) unless changes.empty?
+      end
+    end
+
+    def update_trend_counters
+      timestamp = Time.now.utc
+      counter_hash = {}
+      Trend.types.each do |trend|
+        if trend.is_a? FactTrend
+          counter_hash[trend.trendable_id]   = Host.joins(:fact_values).where(:fact_values => { :fact_name_id => trend.trendable_id }).group(:value).count
+        else
+          counter_hash[trend.trendable_type] = Host.group(trend.trendable_type.foreign_key.to_sym).count
+        end
+      end
+      Trend.has_value.each do |trend|
+        new_count = if trend.is_a? FactTrend
+                      counter_hash[trend.trendable_id][trend.fact_value]
+                    else
+                      counter_hash[trend.trendable_type][trend.trendable_id]
+                    end || 0
+
+        latest_counter = trend.trend_counters.order(:created_at).last
+        if latest_counter
+          latest_counter.interval_end = timestamp
+          latest_counter.save!
+        end
+
+        next unless self.class.should_create_counter?(latest_counter, new_count, timestamp)
+
+        trend.trend_counters.create!  :count => new_count,
+                                      :created_at => timestamp,
+                                      :interval_start => timestamp
+      end
+    end
+
+    def self.should_create_counter?(latest_counter, new_count, _timestamp)
+      return true if latest_counter.nil?
+
+      latest_counter.count != new_count
+    end
+
+    def aggregate_counters; end
+  end
+end

data/app/views/foreman_statistics/api/v2/trends/base.json.rabl

@@ -0,0 +1,4 @@
+object @trend
+
+attributes :id, :trendable_type, :trendable_id, :fact_name, :type, :name
+attribute to_label: :label

data/app/views/foreman_statistics/api/v2/trends/create.json.rabl

@@ -0,0 +1,3 @@
+object @trend
+
+extends 'foreman_statistics/api/v2/trends/show'

data/app/views/foreman_statistics/api/v2/trends/index.json.rabl

@@ -0,0 +1,3 @@
+collection @trends
+
+extends 'foreman_statistics/api/v2/trends/main'

data/app/views/foreman_statistics/api/v2/trends/main.json.rabl

@@ -0,0 +1,5 @@
+object @trends
+
+extends 'foreman_statistics/api/v2/trends/base'
+
+attributes :created_at, :updated_at

data/app/views/foreman_statistics/api/v2/trends/show.json.rabl

@@ -0,0 +1,3 @@
+object @trend
+
+extends 'foreman_statistics/api/v2/trends/main'

data/app/views/foreman_statistics/api/v2/trends/update.json.rabl

@@ -0,0 +1,3 @@
+object @trend
+
+extends 'foreman_statistics/api/v2/trends/show'

data/app/views/foreman_statistics/layouts/application_react.html.erb

@@ -0,0 +1,16 @@
+
+<% content_for(:javascripts) do %>
+  <%= webpacked_plugins_js_for :foreman_statistics %>
+<% end %>
+<% content_for(:stylesheets) do %>
+  <%= webpacked_plugins_css_for :foreman_statistics %>
+<% end %>
+
+<% content_for(:content) do %>
+  <%= notifications %>
+  <div id="organization-id" data-id="<%= Organization.current.id if Organization.current %>" ></div>
+  <div id="user-id" data-id="<%= User.current.id if User.current %>" ></div>
+  <div id="foremanStatisticsRoot"></div>
+<% end %>
+<%= render file: "layouts/base" %>
+<%= mount_react_component('ForemanStatistics', '#foremanStatisticsRoot') %>

data/app/views/foreman_statistics/trends/_empty_data.html.erb

@@ -0,0 +1,7 @@
+<% title(_("Trends for %s") % trend_title(@trend)) %>
+<div class="row">
+  <div class="stats-well col-md-12">
+    <p><strong><%= _('No data for this trend.') %></strong></p>
+    <div><%= (_("Is the cron job that executes %s enabled?") % "<span class='black'>foreman-rake foreman_statistics:trends:counter</span>").html_safe %></div>
+  </div>
+</div>

data/app/views/foreman_statistics/trends/_fields.html.erb

@@ -0,0 +1,7 @@
+<%# base_errors_for f %>
+<td>
+  <%= trend.fact_value %>
+</td>
+<td>
+  <%= f.text_field :name %>
+</td>