site_health 0.1.0 → 0.2.0

data/lib/site_health/issues.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SiteHealth
+  class Issues
+    include Enumerable
+
+    attr_reader :id
+
+    def initialize(id)
+      @id = id
+      @issues = []
+    end
+
+    # Adds an issue
+    # @param [Issue] issue if nil then a keywords are expected
+    # @return [Array<Issue>] the current list of issues
+    # @see Issue#initialize for supported keyword arguments
+    def add(issue = nil, **args)
+      unless issue
+        args[:name] ||= id
+        issue = Issue.new(args)
+      end
+
+      @issues << issue
+    end
+    alias_method :<<, :add
+
+    # @return [TrueClass, FalseClass] true if there are no issues
+    def empty?
+      @issues.empty?
+    end
+
+    # Enumerates over every issue.
+    #
+    # @yieldparam [Issue] issue
+    #
+    # @return [Enumerator]
+    #   If no block is given, an enumerator object will be returned.
+    def each(&block)
+      @issues.each(&block)
+    end
+  end
+end

data/lib/site_health/issues_report.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'json'
+require 'site_health/issue'
+
+module SiteHealth
+  class IssuesReport
+    def initialize(issues)
+      @issues = issues
+      @fields = Issue.fields
+      @select_block = proc { true }
+      yield(self) if block_given?
+    end
+
+    def fields=(fields)
+      @fields = fields.map(&:to_sym)
+    end
+
+    def select(&block)
+      @select_block = block
+    end
+
+    def to_a
+      issues = []
+      each { |data| issues << data }
+      issues
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << @fields
+        each { |data| csv << data.values_at(*@fields) }
+      end
+    end
+
+    def to_json
+      JSON.dump(to_a)
+    end
+
+    private
+
+    def each
+      @issues.each do |issue|
+        next unless @select_block.call(issue)
+
+        hash = issue.to_h.select { |k| @fields.include?(k) }
+        yield(hash)
+      end
+    end
+  end
+end

data/lib/site_health/key_struct.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module SiteHealth
+  # Enhance Struct to work with keywords
   class KeyStruct < Struct
     def initialize(**keyword_args)
       keyword_args.each do |key, value|
-        if members.include?(key)
-          self[key] = value
-        else
+        unless members.include?(key)
           raise ArgumentError, "Unknown key struct member: #{key}"
         end
+
+        self[key] = value
       end
     end
   end

data/lib/site_health/link.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module SiteHealth
+  class Link
+    def self.valid?(*args)
+      new(*args).valid?
+    end
+
+    attr_reader :uri, :url
+
+    def initialize(url)
+      @url = url
+      @uri = safe_parse_url(@url)
+      @valid = @uri.absolute?
+    end
+
+    def valid?
+      @valid
+    end
+
+    private
+
+    # @param [String] url
+    def safe_parse_url(url)
+      URI.parse(url)
+    rescue URI::InvalidURIError
+      URI.parse('')
+    end
+  end
+end

data/lib/site_health/null_logger.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module SiteHealth
+  # Don't log anyting / Send the logs to the abyss
+  class NullLogger < Logger
+    # Allow any and all params
+    def initialize(*args); end
+
+    # Allow any and alls params and don't do anyting
+    def add(*args, &block); end
+  end
+end

data/lib/site_health/nurse.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'site_health/url_map'
+require 'site_health/event_emitter'
+require 'site_health/timer'
+
+module SiteHealth
+  # Holds page analysis data
+  class Nurse
+    attr_reader :config, :failures, :checkers
+
+    # @return [Array<Issue>] found issues
+    attr_reader :issues
+
+    def initialize(config: SiteHealth.config)
+      @config = config
+      @checkers = config.checkers
+      @pages_journal = UrlMap.new { {} }
+      @failures = []
+      @issues = []
+      @clerk = nil
+      @punched_out = false
+    end
+
+    # @return [Nurse] returns self
+    def punch_out!
+      post_shift_analysis unless @punched_out
+
+      @punched_out = true
+      self
+    end
+
+    # @return [Hash] check results
+    def journal
+      {
+        checked_urls: @pages_journal.to_h,
+        internal_server_error_urls: failures,
+      }
+    end
+
+    # @return [Array] all URL that have failed
+    def check_failed_url(url)
+      clerk.emit_failed_url(url)
+      @failures << url
+    end
+
+    # @return [Object] the event emitter
+    # @yieldparam [Object] the event emiiter
+    def clerk
+      @clerk ||= begin
+        events = %w[journal failed_url check page issue].concat(checkers.map(&:name))
+        EventEmitter.define(*events).new.tap { |e| yield(e) if block_given? }
+      end
+    end
+
+    # @return [Hash] result data
+    def check_page(page)
+      @pages_journal[page.url].tap do |journal|
+        timer = Timer.start
+        clerk.emit_page(page)
+
+        journal[:started_at] = timer.started_at
+        journal[:checked] = true
+        journal[:url] = page.url
+        journal[:content_type] = page.content_type
+        journal[:http_status] = page.code
+        journal[:redirect] = page.redirect?
+        journal[:title] = page.title
+        journal[:links_to] = page.each_url.map do |url|
+          (@pages_journal[url][:links_from] ||= []) << page.url
+          url.to_s
+        end
+
+        journal[:checks] = lab_results(page)
+
+        timer.finish
+
+        journal[:finished_at] = timer.finished_at
+        journal[:runtime_in_seconds] = timer.diff.round(1)
+
+        clerk.emit_journal(journal, page)
+      end
+    end
+
+    # @return [Hash] results of all checkers for page
+    def lab_results(page)
+      journal = {}
+      checkers.each do |checker_klass|
+        checker = checker_klass.new(page, config: config)
+        next unless checker.should_check?
+
+        checker.call
+
+        issues = checker.issues
+        @issues.concat(issues.to_a)
+
+        clerk.emit_check(checker)
+        clerk.emit(checker.name, checker)
+        clerk.emit_each_issue(issues)
+
+        journal[checker.name.to_sym] = checker.to_h
+      end
+      journal
+    end
+
+    # Provides transparent access to the methods in {#clerk}.
+    # @param [Symbol] name
+    #   The name of the missing method.
+    # @param [Array] arguments
+    #   Additional arguments for the missing method.
+    # @raise [NoMethodError]
+    #   The missing method did not map to a method in {#clerk}.
+    # @see #clerk
+    def method_missing(method, *args, &block)
+      if clerk.respond_to?(method)
+        return clerk.public_send(method, *args, &block)
+      end
+
+      super
+    end
+
+    # @param [Symbol] name
+    #   The name of the missing method.
+    # @param [Boolean] include_private optional (default: false)
+    #   Whether to include private methods
+    # @return [Boolean]
+    #   true if it can respond to method name, false otherwise
+    def respond_to_missing?(method, include_private = false)
+      clerk.respond_to?(method, include_private) || super
+    end
+
+    private
+
+    def post_shift_analysis
+      issues = links_to_page_not_found_issues
+      clerk.emit_each_issue(issues)
+      @issues.concat(issues)
+    end
+
+    def links_to_page_not_found_issues
+      issues = []
+      not_found = @issues.
+                  select { |issue| issue.code == :not_found }.
+                  map { |issue| issue.url.to_s }
+
+      not_found.each do |url|
+        (@pages_journal[url][:links_from] || []).each do |link_from_url|
+          issues << build_links_to_not_found_issue(link_from_url, url)
+        end
+      end
+
+      issues
+    end
+
+    def build_links_to_not_found_issue(url, not_found_url)
+      Issue.new(
+        name: 'links_to_page_not_found',
+        code: :links_to_not_found,
+        title: 'Links to page not found',
+        detail: "Links to #{not_found_url} that is 404 page not found",
+        severity: :major,
+        priority: :high,
+        url: url
+      )
+    end
+  end
+end

data/lib/site_health/summarizers/page_size_summarizer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SiteHealth
+  class PageSpeedSummarizer
+    def initialize(data)
+      @data = data[:checked_urls]
+    end
+
+    def to_csv
+      to_matrix.map { |row| row.join(',') }.join("\n")
+    end
+
+    def to_matrix
+      header = %w[
+        url
+        total_speed_score
+        css_kb
+        html_kb
+        image_kb
+        javascript_kb
+        other_kb
+        total_kbytes
+        number_hosts
+        number_js_resources
+        number_css_resources
+        number_resources
+        number_static_resources
+        started_at
+        finished_at
+        runtime_in_seconds
+      ]
+      rows = @data.map do |_, data|
+        pagespeed_data = data.dig(:checks, :google_page_speed).data
+        next unless pagespeed_data
+
+        url = data[:url]
+        started_at = data[:started_at]
+        finished_at = data[:finished_at]
+        runtime = data[:runtime_in_seconds]
+
+        build_row(url, runtime, started_at, finished_at, pagespeed_data)
+      end.reject(&:nil?)
+
+      [header] + rows
+    end
+
+    def build_row(url, runtime_in_seconds, started_at, finished_at, pagespeed_data)
+      stats = pagespeed_data[:page_stats]
+
+      kbytes_columns = [
+        bytes_to_kb(stats[:css_response_bytes]),
+        bytes_to_kb(stats[:html_response_bytes]),
+        bytes_to_kb(stats[:image_response_bytes]),
+        bytes_to_kb(stats[:javascript_response_bytes]),
+        bytes_to_kb(stats[:other_response_bytes]),
+      ]
+      kbytes_columns << kbytes_columns.sum.round(1)
+
+      host_columns = [
+        stats[:number_hosts],
+        stats[:number_js_resources],
+        stats[:number_css_resources],
+        stats[:number_resources],
+        stats[:number_static_resources],
+      ]
+
+      total_speed_score = pagespeed_data.dig(:rule_groups, :SPEED, :score)
+
+      [url, total_speed_score] + kbytes_columns + host_columns +
+        [started_at, finished_at, runtime_in_seconds]
+    end
+
+    def bytes_to_kb(bytes, round: 1)
+      (bytes / 1024.0).round(round)
+    end
+  end
+end

data/lib/site_health/timer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module SiteHealth
+  class Timer
+    attr_reader :started_at, :finished_at
+
+    def self.start
+      new.tap(&:start)
+    end
+
+    def self.measure(&block)
+      new.tap { |timer| timer.measure(&block) }
+    end
+
+    def measure
+      start
+      yield
+      finish
+      self
+    end
+
+    def start
+      @started = high_precision_time
+      @started_at = Time.now
+    end
+
+    def finish
+      @finished = high_precision_time
+      @finished_at = Time.now
+    end
+
+    def diff
+      fail(StandardError, 'timer must be started') unless @started
+
+      finish = @finished || high_precision_time
+      finish - @started
+    end
+
+    private
+
+    def high_precision_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end