foreman_host_reports 0.0.4 → 1.0.0

data/app/controllers/api/v2/host_reports_controller.rb

@@ -3,6 +3,7 @@
 module Api
   module V2
     class HostReportsController < V2::BaseController
+      include Foreman::TelemetryHelper
       include Api::Version2
       include Foreman::Controller::CsvResponder
       include Foreman::Controller::SmartProxyAuth
@@ -23,7 +24,7 @@ module Api
         @host_reports = resource_scope_for_index(options)
       end
 
-      api :GET, '/host_report/:id', N_('Show host report details')
+      api :GET, '/host_reports/:id', N_('Show host report details')
       param :id, :identifier, required: true
       def show
         @host_report = resource_scope.find(params[:id])
@@ -34,38 +35,55 @@ module Api
           param :host, String, required: true, desc: N_("Hostname of the report's host origin")
           param :format, HostReport.formats.keys, required: false, desc: N_('Format of the report, e.g. Ansible')
           param :reported_at, String, required: true, desc: N_('UTC time of the report')
-          param :applied, Integer, required: false, desc: N_('Number of applied resources or tasks')
-          param :failed, Integer, required: false, desc: N_('Number of failed resources or tasks')
-          param :pending, Integer, required: false, desc: N_('Number of pending resources or tasks')
-          param :other, Integer, required: false, desc: N_('Number of other resources or tasks')
+          param :change, Integer, required: false, desc: N_('Summary count of actions with change (semantics is different for each report type)')
+          param :nochange, Integer, required: false, desc: N_('Summary count of actions without change (semantics is different for each report type)')
+          param :failure, Integer, required: false, desc: N_('Summary count of actions with failure (semantics is different for each report type)')
           param :body, String, required: true, desc: N_('String with JSON formatted body of the report')
-          param :proxy, String, required: false, desc: N_('Hostname of the proxy processed the report')
+          param :proxy, String, required: false, desc: N_('Hostname of the proxy processed the report (will be detected from SSL cert for HTTPS requests)')
           param :keywords, Array, of: String, required: false, desc: N_('A list of keywords to associate with the report for better searching')
         end
       end
 
-      api :POST, '/host_report/', N_('Create a host report')
+      api :POST, '/host_reports/', N_('Create a host report')
       param_group :host_report, as: :create
-
       def create
+        result = nil
+        # version is unused at the moment (version = 1)
         params[:host_report].delete(:version)
+        # check existing host and proxy
+        raise("Unknown host: #{@hostname}") unless params[:host_report][:host_id]
+        # fetch the body
         the_body = params[:host_report].delete(:body)
         if the_body && !the_body.is_a?(String)
           logger.warn "Report body not as a string, serializing JSON"
           the_body = JSON.pretty_generate(the_body)
         end
+        # process keywords
         keywords = params[:host_report].delete(:keywords)
-        @host_report = HostReport.new(host_report_params.merge(body: the_body))
-        if keywords.present?
-          keywords_to_insert = keywords.each_with_object([]) do |n, ks|
-            ks << { name: n }
+        report_keyword_ids = []
+        telemetry_duration_histogram(:host_report_create_keywords, :ms) do
+          if keywords.present?
+            keywords_to_insert = keywords.each_with_object([]) do |n, ks|
+              ks << { name: n }
+            end
+            ReportKeyword.upsert_all(keywords_to_insert, unique_by: :name)
+            report_keyword_ids = ReportKeyword.where(name: keywords).distinct.pluck(:id)
           end
-          ReportKeyword.upsert_all(keywords_to_insert, unique_by: :name)
-          @host_report.report_keyword_ids = ReportKeyword.where(name: keywords).distinct.pluck(:id)
         end
-        result = @host_report.save
-        @host_report.body = nil
+        # create new record
+        @host_report = HostReport.new(host_report_params.merge(body: the_body, report_keyword_ids: report_keyword_ids))
+        telemetry_duration_histogram(:host_report_create, :ms) do
+          result = @host_report.save
+        end
+        # refresh status and last_report flag
+        telemetry_duration_histogram(:host_report_create_refresh, :ms) do
+          time = Time.parse(params[:host_report][:reported_at]).utc
+          @host.update_attribute(:last_report, time) if @host.last_report.nil? || @host.last_report.utc < time
+          @host.refresh_statuses([HostStatus::HostReportStatus])
+        end
         process_response result
+      rescue StandardError => e
+        render_exception(e, :status => :unprocessable_entity)
       end
 
       api :DELETE, '/host_reports/:id', N_('Delete a host report')
@@ -86,10 +104,11 @@ module Api
       private
 
       def resolve_ids
-        hostname = params[:host_report].delete(:host)
-        proxyname = params[:host_report].delete(:proxy)
-        params[:host_report][:host_id] ||= Host.find_by(name: hostname)&.id
-        params[:host_report][:proxy_id] ||= SmartProxy.unscoped.find_by(name: proxyname)&.id
+        @hostname = params[:host_report].delete(:host)
+        @proxyname = params[:host_report].delete(:proxy)
+        @host = Host.find_by(name: @hostname)
+        params[:host_report][:host_id] ||= @host&.id
+        params[:host_report][:proxy_id] = detected_proxy&.id # provided by SmartProxyAuth concern
       end
 
       def resource_scope(options = {})

data/app/controllers/concerns/foreman_host_reports/controller/hosts_controller_extensions.rb

@@ -0,0 +1,18 @@
+module ForemanHostReports
+  module Controller
+    module HostsControllerExtensions
+      extend ActiveSupport::Concern
+
+      module Overrides
+        def preload_reports
+          @last_report_ids = HostReport.where(:host_id => @hosts.map(&:id)).reorder('').group(:host_id).maximum(:id)
+          @last_reports = HostReport.where(:id => @last_report_ids.values)
+        end
+      end
+
+      included do
+        prepend Overrides
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_host_reports/controller/parameters/host_report.rb

@@ -11,7 +11,7 @@ module ForemanHostReports
             Foreman::ParameterFilter.new(::HostReport).tap do |filter|
               # body is permitted in controller
               filter.permit :format, :version, :host, :proxy, :reported_at,
-                :proxy_id, :host_id, :applied, :failed, :pending, :other
+                :proxy_id, :host_id, :change, :nochange, :failure
               filter.permit :keywords => []
             end
           end

data/app/controllers/host_reports_controller.rb

@@ -2,6 +2,28 @@
 
 class HostReportsController < ::ApplicationController
   include Foreman::Controller::AutoCompleteSearch
+  def index
+    respond_to do |format|
+      format.html do
+        render '/react/index'
+      end
+
+      format.json do
+        reports = resource_base_search_and_page
+        render json: {
+          itemCount: reports.count,
+          reports: reports.map do |r|
+            r.attributes.except('body').merge(
+              keywords: r.report_keywords.map(&:name),
+              can_delete: can_delete?(r),
+              can_view: can_view?(r),
+              status: r.status
+            )
+          end,
+        }, status: :ok
+      end
+    end
+  end
 
   def show
     @host_report = resource_scope.find(params[:id])
@@ -29,8 +51,8 @@ class HostReportsController < ::ApplicationController
             reported_at: @host_report.reported_at,
           },
           permissions: {
-            can_delete: authorized_for(auth_object: @host_report, authorizer: authorizer, permission: "destroy_#{controller_permission}"),
-            can_view: authorized_for(auth_object: @host_report, authorizer: authorizer, permission: "view_#{controller_permission}"),
+            can_delete: can_delete?(@host_report),
+            can_view: can_view?(@host_report),
           },
         }, status: :ok
       end
@@ -43,4 +65,12 @@ class HostReportsController < ::ApplicationController
     options[:permission] = :view_host_reports
     super(options).my_reports
   end
+
+  def can_delete?(report)
+    authorized_for(auth_object: report, authorizer: authorizer, permission: "destroy_#{controller_permission}")
+  end
+
+  def can_view?(report)
+    authorized_for(auth_object: report, authorizer: authorizer, permission: "view_#{controller_permission}")
+  end
 end

data/app/helpers/concerns/foreman_host_reports/hosts_helper_extensions.rb

@@ -0,0 +1,25 @@
+module ForemanHostReports
+  module HostsHelperExtensions
+    extend ActiveSupport::Concern
+
+    module Overrides
+      def last_report_column(record)
+        opts = { :rel => "twipsy" }
+        date = record.last_report.nil? ? '' : "#{date_time_absolute_value(record.last_report)}, "
+        time = record.last_report? ? date_time_relative_value(record.last_report) : ""
+        if @last_report_ids[record.id]
+          opts["data-original-title"] = date + _("view last report details")
+          link_to_if_authorized(time, hash_for_host_report_path(:id => record.last_host_report_object_any_format&.id), opts)
+        else
+          opts.merge!(:disabled => true, :class => "disabled", :onclick => 'return false')
+          opts["data-original-title"] = date + _("report already deleted") unless record.last_report.nil?
+          link_to_if_authorized(time, hash_for_host_reports_path, opts)
+        end
+      end
+    end
+
+    included do
+      prepend Overrides
+    end
+  end
+end

data/app/models/concerns/foreman_host_reports/host_extensions.rb

@@ -4,6 +4,12 @@ module ForemanHostReports
 
     included do
       has_many :host_reports, foreign_key: :host_id, class_name: 'HostReport', inverse_of: :host, dependent: :destroy
+      has_one :last_host_report_object_any_format, -> { order("#{HostReport.table_name}.reported_at DESC, #{HostReport.table_name}.id").limit(1) }, foreign_key: :host_id, class_name: 'HostReport', inverse_of: :host, dependent: :delete
+      has_one :host_report_status_object, class_name: 'HostStatus::HostReportStatus', foreign_key: :host_id, inverse_of: :host, dependent: :delete
+
+      scoped_search relation: :host_reports, on: :change, rename: :report_changes, only_explicit: true
+      scoped_search relation: :host_reports, on: :nochange, rename: :report_nochanges, only_explicit: true
+      scoped_search relation: :host_reports, on: :failure, rename: :report_failures, only_explicit: true
     end
   end
 end

data/app/models/host_report.rb

@@ -24,6 +24,9 @@ class HostReport < ApplicationRecord
   scoped_search relation: :proxy, on: :name, complete_value: true, rename: :proxy
   scoped_search relation: :organization, on: :name, complete_value: true, rename: :organization
   scoped_search relation: :location, on: :name, complete_value: true, rename: :location
+  scoped_search on: :change, aliases: %i[changed changes]
+  scoped_search on: :nochange, aliases: %i[unchanged nochanges]
+  scoped_search on: :failure, aliases: %i[failed failures]
   scoped_search on: :reported_at, complete_value: true, default_order: :desc, rename: :reported, only_explicit: true, aliases: %i[last_report reported_at]
   scoped_search on: :format, complete_value: { plain: 0, puppet: 1, ansible: 2 }
   # This is to simulate has_many :report_keywords relation for scoped_search library to work
@@ -52,4 +55,16 @@ class HostReport < ApplicationRecord
       conditions: sanitize_sql_for_conditions(["host_reports.report_keyword_ids @> ?", "{#{keyword_ids.join(',')}}"]),
     }
   end
+
+  def status
+    if failure&.positive?
+      :failure
+    elsif change&.positive?
+      :change
+    elsif nochange&.positive?
+      :nochange
+    else
+      :empty
+    end
+  end
 end

data/app/models/host_status/host_report_status.rb

@@ -0,0 +1,185 @@
+module HostStatus
+  # rubocop:disable Style/GuardClause
+  class HostReportStatus < Status
+    def last_report
+      self.last_report = host.last_host_report_object_any_format unless @last_report_set
+      @last_report
+    end
+
+    def last_report=(report)
+      @last_report_set = true
+      @last_report = report
+    end
+
+    # <host report fields>
+    def change
+      last_report&.change || 0
+    end
+
+    def nochange
+      last_report&.nochange || 0
+    end
+
+    def failure
+      last_report&.failure || 0
+    end
+
+    def change?
+      change.positive?
+    end
+
+    def nochange?
+      nochange.positive?
+    end
+
+    def failure?
+      failure.positive?
+    end
+    # </host report fields>
+
+    # <legacy report compatibility fields>
+    def restarted
+      0
+    end
+
+    def failed_restarts
+      0
+    end
+
+    def skipped
+      0
+    end
+    # </legacy report compatibility fields>
+
+    def expected_report_interval
+      (reported_format_interval.presence || default_report_interval).to_i.minutes
+    end
+
+    def reported_format_interval
+      if host.params.key? "#{last_report.format.downcase}_interval"
+        host.params["#{last_report.format.downcase}_interval"]
+      else
+        Setting[:"#{last_report.format.downcase}_interval"]
+      end
+    end
+
+    def out_of_sync?
+      if (host && !host.enabled?) || no_reports? || out_of_sync_disabled?
+        false
+      else
+        !reported_at.nil? && reported_at < (Time.now.utc - expected_report_interval)
+      end
+    end
+
+    def no_reports?
+      host && last_report.nil?
+    end
+
+    def self.status_name
+      N_("Configuration")
+    end
+
+    # Constants are bit-mask friendly in case we want to query them in the DB
+    UNKNOWN     = -0b000000000000010000000000000000 # -65536
+    FAILURES    = -0b000000000000000000000000000001 # -1
+    EMPTY       =  0b000000000000000000000000000000 # 0
+    NO_CHANGES  =  0b000000000000000000000100000000 # 256
+    CHANGES     =  0b000000000000010000000000000000 # 65536
+
+    LABELS = {
+      FAILURES => N_("Failure(s)"),
+      EMPTY => N_("Empty"),
+      NO_CHANGES => N_("No changes"),
+      CHANGES => N_("Changes applied"),
+    }.freeze
+
+    def to_label(_options = {})
+      if host && !host.enabled
+        return N_("Alerts disabled")
+      elsif out_of_sync?
+        return N_("Out of sync")
+      end
+
+      LABELS.fetch(to_status, N_("Unknown config status"))
+    end
+
+    def to_global(options = {})
+      handle_options(options)
+
+      if failure?
+        HostStatus::Global::ERROR
+      elsif out_of_sync?
+        HostStatus::Global::WARN
+      elsif no_reports? && (host.configuration? || Setting[:always_show_configuration_status])
+        HostStatus::Global::WARN
+      else
+        HostStatus::Global::OK
+      end
+    end
+
+    def to_status(options = {})
+      handle_options(options)
+
+      if host&.enabled && last_report.present?
+        if last_report.failure.positive?
+          FAILURES
+        elsif last_report.change.positive?
+          CHANGES
+        elsif last_report.nochange.positive?
+          NO_CHANGES
+        else
+          EMPTY
+        end
+      else
+        UNKNOWN
+      end
+    end
+
+    def relevant?(options = {})
+      handle_options(options)
+
+      host.configuration? || last_report.present? || Setting[:always_show_configuration_status]
+    end
+
+    def status_link
+      return @status_link if defined?(@status_link)
+      return @status_link = nil if last_report.nil?
+      return @status_link = nil unless User.current.can?(:view_host_reports, last_report, false)
+
+      @status_link = last_report && Rails.application.routes.url_helpers.host_report_path(last_report)
+    end
+
+    private
+
+    # Configuration status can be calculated from database state, but also reports can be
+    # passed in via options. In that case, report is matched with the host and set.
+    # Don't ask me why this is implemented this way, this is copy-paste from the original
+    # ConfigurationStatus in Foreman core.
+    def handle_options(options)
+      if options.key?(:last_reports) && !options[:last_reports].nil?
+        cached_report = options[:last_reports].find { |r| r.host_id == host_id }
+        self.last_report = cached_report
+      end
+    end
+
+    def update_timestamp
+      self.reported_at = last_report.try(:reported_at) || Time.now.utc
+    end
+
+    def default_report_interval
+      if host.params.key? 'outofsync_interval'
+        host.params['outofsync_interval']
+      else
+        Setting[:outofsync_interval]
+      end
+    end
+
+    def out_of_sync_disabled?
+      Setting[:"#{last_report.format.downcase}_out_of_sync_disabled"]
+    end
+  end
+  # rubocop:enable Style/GuardClause
+end
+
+HostStatus.status_registry.delete(HostStatus::ConfigurationStatus)
+HostStatus.status_registry.add(HostStatus::HostReportStatus)

data/app/views/api/v2/host_reports/main.json.rabl

@@ -5,8 +5,7 @@ object @host_report
 extends 'api/v2/host_reports/base'
 extends 'api/v2/layouts/permissions'
 
-attributes :format, :host_id, :proxy_id, :reported_at, :applied, :failed,
-  :pending, :other
+attributes :format, :host_id, :proxy_id, :reported_at, :change, :nochange, :failure
 
 node(:host_name) do |report|
   report.host.name

data/config/routes.rb

@@ -1,13 +1,11 @@
 Rails.application.routes.draw do
-  match '/host_reports' => 'react#index', via: :get
-
   resources :hosts do
     member do
       match 'host_reports', to: 'react#index', via: :get
     end
   end
 
-  resources :host_reports, only: %i[show] do
+  resources :host_reports, only: %i[index show] do
     collection do
       get 'auto_complete_search'
     end
@@ -15,7 +13,7 @@ Rails.application.routes.draw do
 
   namespace :api, defaults: { format: 'json' } do
     scope '(:apiv)', module: :v2, defaults: { apiv: 'v2' }, apiv: /v2/,
-                     constraints: ApiConstraints.new(version: 2, default: true) do
+      constraints: ApiConstraints.new(version: 2, default: true) do
       resources :host_reports, only: %i[index show create destroy] do
         collection do
           get 'export'

data/db/migrate/20220113064436_rename_status_summaries.rb

@@ -0,0 +1,12 @@
+class RenameStatusSummaries < ActiveRecord::Migration[6.0]
+  def change
+    remove_column :host_reports, :applied, :integer
+    remove_column :host_reports, :pending, :integer
+    remove_column :host_reports, :other, :integer
+    remove_column :host_reports, :failed, :integer
+
+    add_column :host_reports, :change, :integer, default: 0
+    add_column :host_reports, :nochange, :integer, default: 0
+    add_column :host_reports, :failure, :integer, default: 0
+  end
+end

data/lib/foreman_host_reports/engine.rb

@@ -18,7 +18,7 @@ module ForemanHostReports
 
     initializer 'foreman_host_reports.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :foreman_host_reports do
-        requires_foreman '>= 3.0.0'
+        requires_foreman '>= 3.2.0'
 
         apipie_documented_controllers ["#{ForemanHostReports::Engine.root}/app/controllers/api/v2/*.rb"]
         # Add Global files for extending foreman-core components and routes
@@ -36,10 +36,14 @@ module ForemanHostReports
 
         # add menu entry
         menu :top_menu, :host_reports, url: '/host_reports',
-                                       url_hash: { controller: :host_reports, action: :index },
-                                       caption: N_('Host Reports'),
-                                       parent: :monitor_menu,
-                                       before: :reports
+          url_hash: { controller: :host_reports, action: :index },
+          caption: N_('Host Reports'),
+          parent: :monitor_menu,
+          before: :reports
+
+        add_histogram_telemetry(:host_report_create_keywords, 'Time spent processing keywords (ms)')
+        add_histogram_telemetry(:host_report_create_refresh, 'Time spent processing status refresh (ms)')
+        add_histogram_telemetry(:host_report_create, 'Time spent saving record (ms)')
       end
     end
 
@@ -48,6 +52,8 @@ module ForemanHostReports
     config.to_prepare do
       Host::Managed.include ForemanHostReports::HostExtensions
       SmartProxy.include ForemanHostReports::HostExtensions
+      ::HostsController.include ForemanHostReports::Controller::HostsControllerExtensions
+      ::HostsHelper.include ForemanHostReports::HostsHelperExtensions
     rescue => e
       Rails.logger.warn "ForemanHostReports: skipping engine hook (#{e})"
     end

data/lib/foreman_host_reports/version.rb

@@ -1,3 +1,3 @@
 module ForemanHostReports
-  VERSION = '0.0.4'.freeze
+  VERSION = '1.0.0'.freeze
 end