upright 0.1.0

data/app/models/upright/playwright/authenticator/base.rb

@@ -0,0 +1,128 @@
+class Upright::Playwright::Authenticator::Base
+  include Upright::Playwright::Helpers
+
+  attr_reader :page
+
+  def self.authenticate_on(page)
+    new.authenticate_on(page)
+  end
+
+  def initialize(browser = nil, context_options = {})
+    @browser = browser
+    @context_options = context_options
+    @storage_state = Upright::Playwright::StorageState.new(service_name)
+  end
+
+  def authenticate_on(page)
+    @page = page
+    authenticate
+    self
+  end
+
+  def session_valid?
+    wait_for_network_idle(page)
+
+    if page.url == signin_redirect_url
+      true
+    else
+      page.goto(signin_redirect_url, timeout: 10.seconds.in_ms)
+      !page.url.include?(signin_path)
+    end
+  end
+
+  def authenticated_context
+    if (cached_state = @storage_state.load)
+      context = create_context(cached_state)
+      return context if context_has_valid_session?(context)
+      context.close
+    end
+
+    perform_authentication
+  end
+
+  protected
+
+  def signin_redirect_url
+    raise NotImplementedError
+  end
+
+  def signin_path
+    raise NotImplementedError
+  end
+
+  private
+
+  def service_name
+    raise NotImplementedError
+  end
+
+  def authenticate
+    raise NotImplementedError
+  end
+
+  def context_has_valid_session?(context)
+    page = context.new_page
+    page.goto(signin_redirect_url, timeout: 10.seconds.in_ms)
+    !page.url.include?(signin_path)
+  rescue ::Playwright::TimeoutError
+    false
+  ensure
+    page&.close
+  end
+
+  def perform_authentication
+    context = create_context
+    @page = context.new_page
+    setup_page_logging(page)
+
+    authenticate
+
+    state = context.storage_state
+    @storage_state.save(state)
+    context.close
+
+    create_context(state)
+  end
+
+  def user_agent
+    Upright.configuration.user_agent.presence ||
+      Upright::Playwright::Lifecycle::DEFAULT_USER_AGENT
+  end
+
+  def create_context(state = nil)
+    options = { userAgent: user_agent, serviceWorkers: "block" }
+    options[:storageState] = state if state
+    options.merge!(@context_options)
+    @browser.new_context(**options)
+  end
+
+  def setup_page_logging(page)
+    if defined?(RailsStructuredLogging::Recorder)
+      RailsStructuredLogging::Recorder.instance.messages.tap do |messages|
+        page.on("response", ->(response) {
+          next if skip_logging?(response)
+          RailsStructuredLogging::Recorder.instance.sharing(messages)
+          log_response(response)
+        })
+      end
+    else
+      page.on("response", ->(response) {
+        next if skip_logging?(response)
+        log_response(response)
+      })
+    end
+  end
+
+  def log_response(response)
+    headers = response.headers.slice("x-request-id", "x-runtime").compact
+    Rails.logger.info "#{response.status} #{response.request.resource_type.upcase} #{response.url} #{headers.to_query}"
+  end
+
+  def skip_logging?(response)
+    %w[image asset avatar].any? { |pattern| response.url.include?(pattern) }
+  end
+
+  def credentials
+    Rails.application.credentials
+  end
+end

data/app/models/upright/playwright/storage_state.rb

@@ -0,0 +1,31 @@
+class Upright::Playwright::StorageState
+  def initialize(service)
+    @service = service
+  end
+
+  def exists?
+    path.exist?
+  end
+
+  def load
+    JSON.parse(path.read) if exists?
+  end
+
+  def save(state)
+    FileUtils.mkdir_p(storage_dir)
+    path.write(JSON.pretty_generate(state))
+  end
+
+  def clear
+    path.delete if exists?
+  end
+
+  private
+    def storage_dir
+      Upright.configuration.storage_state_dir
+    end
+
+    def path
+      storage_dir.join("#{@service}.json")
+    end
+end

data/app/models/upright/probe_result.rb

@@ -0,0 +1,31 @@
+class Upright::ProbeResult < Upright::ApplicationRecord
+  include Upright::ExceptionRecording
+
+  has_many_attached :artifacts
+
+  scope :by_type,   ->(type) { where(probe_type: type) if type.present? }
+  scope :by_status, ->(status) { where(status: status) if status.present? }
+  scope :by_name,   ->(name) { where(probe_name: name) if name.present? }
+  scope :stale,     -> { where(created_at: ...24.hours.ago) }
+
+  enum :status, [ :ok, :fail ]
+
+  after_create :increment_metrics
+
+  def to_chart
+    {
+      probe_name:  probe_name,
+      status:     status,
+      created_at: created_at.iso8601,
+      duration:   duration.to_f
+    }
+  end
+
+  private
+    def increment_metrics
+      labels = { type: probe_type, name: probe_name, probe_target: probe_target, probe_service: probe_service }
+
+      Yabeda.upright_probe_duration_seconds.set(labels.merge(status: status), duration.to_f)
+      Yabeda.upright_probe_up.set(labels, ok? ? 1 : 0)
+    end
+end

data/app/models/upright/probes/http_probe.rb

@@ -0,0 +1,102 @@
+class Upright::Probes::HTTPProbe < FrozenRecord::Base
+  include Upright::Probeable
+  include Upright::ProbeYamlSource
+
+  stagger_by_site 3.seconds
+
+  DEFAULT_EXPECTED_STATUS = 200..399
+
+  attr_accessor :last_response
+
+  def check
+    self.last_response = perform_request
+    record_response_status
+    status_matches_expected?
+  end
+
+  def on_check_recorded(probe_result)
+    attach_verbose_log(probe_result)
+    attach_response_body(probe_result)
+  end
+
+  def probe_type = "http"
+  def probe_target = url
+
+  private
+    def perform_request
+      Upright::HTTP::Request.new(url, **request_options).get
+    end
+
+    def request_options
+      credentials_hash.merge(proxy_hash)
+    end
+
+    def status_matches_expected?
+      if last_response.network_error?
+        false
+      else
+        last_response.status_in?(expected_status_range)
+      end
+    end
+
+    def expected_status_range
+      if try(:expected_status).is_a?(Integer)
+        expected_status..expected_status
+      else
+        DEFAULT_EXPECTED_STATUS
+      end
+    end
+
+    def credentials_hash
+      if credentials
+        { username: credentials[:username], password: credentials[:password] }
+      else
+        {}
+      end
+    end
+
+    def credentials
+      if try(:basic_auth_credentials)
+        Rails.application.credentials.dig(:http_probes, basic_auth_credentials.to_sym)
+      end
+    end
+
+    def proxy_hash
+      if proxy_credentials
+        {
+          proxy: proxy_credentials[:url],
+          proxy_username: proxy_credentials[:username],
+          proxy_password: proxy_credentials[:password]
+        }.compact
+      else
+        {}
+      end
+    end
+
+    def proxy_credentials
+      if try(:proxy)
+        Rails.application.credentials.dig(:proxies, proxy.to_sym)
+      end
+    end
+
+    def record_response_status
+      if last_response && !last_response.network_error? && defined?(Yabeda)
+        Yabeda.upright_http_response_status.set(
+          { name: probe_name, probe_target: probe_target, probe_service: probe_service },
+          last_response.status
+        )
+      end
+    end
+
+    def attach_verbose_log(probe_result)
+      if last_response
+        Upright::Artifact.new(name: "curl.log", content: last_response.verbose_log_content).attach_to(probe_result)
+      end
+    end
+
+    def attach_response_body(probe_result)
+      if last_response && last_response.body.present?
+        Upright::Artifact.new(name: "response.#{last_response.file_extension}", content: last_response.body).attach_to(probe_result)
+      end
+    end
+end

data/app/models/upright/probes/playwright/base.rb

@@ -0,0 +1,48 @@
+require "playwright"
+
+class Upright::Probes::Playwright::Base
+  include ActiveSupport::Callbacks
+  include Upright::Probeable
+
+  define_callbacks :perform_check
+
+  include Upright::Playwright::Lifecycle
+  include Upright::Playwright::FormAuthentication
+  include Upright::Playwright::Logging
+  include Upright::Playwright::OtelTracing
+  include Upright::Playwright::VideoRecording
+  include Upright::Playwright::Helpers
+
+  set_callback :perform_check, :after, :wait_for_network_idle
+
+  def self.check
+    new.perform_check
+  end
+
+  def self.check_and_record_later
+    Upright::ProbeCheckJob.set(wait: stagger_delay).perform_later(name)
+  end
+
+  def perform_check
+    with_browser do |browser|
+      with_context(browser, **video_recording_options) do
+        run_callbacks :perform_check do
+          check
+        end
+      end
+    end
+  end
+
+  def check
+    raise NotImplementedError
+  end
+
+  def on_check_recorded(probe_result)
+    attach_video(probe_result)
+    attach_log(probe_result)
+  end
+
+  def probe_type = "playwright"
+  def probe_target = nil
+  def probe_service = authentication_service&.to_s
+end

data/app/models/upright/probes/smtp_probe.rb

@@ -0,0 +1,48 @@
+require "net/smtp"
+
+class Upright::Probes::SMTPProbe < FrozenRecord::Base
+  include Upright::Probeable
+  include Upright::ProbeYamlSource
+
+  stagger_by_site 3.seconds
+
+  attr_accessor :smtp_log
+
+  def check
+    self.smtp_log = StringIO.new
+
+    current_site = Upright.current_site
+
+    smtp = Net::SMTP.new(host)
+    smtp.open_timeout = current_site.default_timeout
+    smtp.read_timeout = current_site.default_timeout
+    smtp.debug_output = smtp_log
+
+    smtp.start("upright") { }
+
+    true
+  rescue Net::SMTPError, Net::OpenTimeout, Net::ReadTimeout
+    false
+  end
+
+  def on_check_recorded(probe_result)
+    attach_log(probe_result)
+  end
+
+  def probe_type = "smtp"
+  def probe_target = host
+
+  private
+    def attach_log(probe_result)
+      if smtp_log
+        smtp_log.rewind
+        log_content = smtp_log.read
+
+        if log_content.present?
+          logger.debug { log_content }
+
+          Upright::Artifact.new(name: "smtp.log", content: log_content).attach_to(probe_result)
+        end
+      end
+    end
+end

data/app/models/upright/probes/traceroute_probe.rb

@@ -0,0 +1,32 @@
+class Upright::Probes::TracerouteProbe < FrozenRecord::Base
+  include Upright::Probeable
+  include Upright::ProbeYamlSource
+  include Upright::Traceroute::OtelTracing
+
+  stagger_by_site 3.seconds
+
+  TIMEOUT = 60.seconds
+  MAX_HOPS = Upright::Traceroute::Result::MAX_HOPS
+  PROBE_COUNT = Upright::Traceroute::Result::PROBE_COUNT
+
+  def check
+    Upright::Traceroute::Result.for(host).tap do |result|
+      @traceroute_result = result
+      trace_result(result)
+    end.reached_destination?
+  end
+
+  def on_check_recorded(probe_result)
+    attach_traceroute_json(probe_result, @traceroute_result)
+  end
+
+  def probe_type = "traceroute"
+  def probe_target = host
+
+  private
+    def attach_traceroute_json(probe_result, traceroute_result)
+      if traceroute_result.raw_json.present?
+        Upright::Artifact.new(name: "traceroute.json", content: traceroute_result.raw_json).attach_to(probe_result)
+      end
+    end
+end

data/app/models/upright/probes/uptime/summary.rb

@@ -0,0 +1,36 @@
+class Upright::Probes::Uptime::Summary
+  include Comparable
+
+  def initialize(result)
+    @result = result
+  end
+
+  def name
+    @result[:metric][:name]
+  end
+
+  def type
+    @result[:metric][:type]
+  end
+
+  def overall_uptime
+    if daily_uptimes.empty?
+      0
+    else
+      (daily_uptimes.values.sum / daily_uptimes.size) * 100
+    end
+  end
+
+  def uptime_for_date(date)
+    daily_uptimes[date.to_date]
+  end
+
+  def <=>(other)
+    [ type, name ] <=> [ other.type, other.name ]
+  end
+
+  private
+    def daily_uptimes
+      @daily_uptimes ||= @result[:values].to_h { |timestamp, value| [ Time.at(timestamp).to_date, value.to_f ] }
+    end
+end

data/app/models/upright/probes/uptime.rb

@@ -0,0 +1,36 @@
+class Upright::Probes::Uptime
+  class << self
+    def all
+      for_type(nil)
+    end
+
+    def for_type(probe_type)
+      results = prometheus_client.query_range(
+        query: query(probe_type),
+        start: 30.days.ago.iso8601,
+        end:   Time.current.iso8601,
+        step:  "86400s" # 1 day
+      ).deep_symbolize_keys
+
+      results[:result].map { |result| Summary.new(result) }.sort
+    end
+
+    private
+      def query(probe_type)
+        "upright:probe_uptime_daily#{label_selector(probe_type)}"
+      end
+
+      def label_selector(probe_type)
+        if probe_type.present?
+          "{type=\"#{probe_type}\"}"
+        end
+      end
+
+      def prometheus_client
+        Prometheus::ApiClient.client(
+          url: ENV.fetch("PROMETHEUS_URL", "http://localhost:9090"),
+          options: { timeout: 30.seconds }
+        )
+      end
+  end
+end

data/app/models/upright/traceroute/hop.rb

@@ -0,0 +1,49 @@
+class Upright::Traceroute::Hop
+  attr_reader :number, :ip, :loss_percent,
+              :last_ms, :avg_ms, :best_ms, :worst_ms, :stddev_ms,
+              :hostname, :as, :isp, :city, :country, :country_code, :geohash
+
+  def initialize(hop_number: nil, ip: nil, hostname: nil, loss_percent: nil,
+                 last_ms: nil, avg_ms: nil, best_ms: nil, worst_ms: nil, stddev_ms: nil,
+                 as: nil, isp: nil, city: nil, country: nil, country_code: nil, geohash: nil)
+    @number = hop_number
+    @ip = ip
+    @hostname = hostname
+    @loss_percent = loss_percent
+    @last_ms = last_ms
+    @avg_ms = avg_ms
+    @best_ms = best_ms
+    @worst_ms = worst_ms
+    @stddev_ms = stddev_ms
+    @as = as
+    @isp = isp
+    @city = city
+    @country = country
+    @country_code = country_code
+    @geohash = geohash
+  end
+
+  def responded?
+    ip.present?
+  end
+
+  def high_packet_loss?
+    loss_percent && loss_percent > 50
+  end
+
+  def any_packet_loss?
+    loss_percent && loss_percent > 0
+  end
+
+  def display_name
+    if responded?
+      if isp.present?
+        isp
+      else
+        ip
+      end
+    else
+      "???"
+    end
+  end
+end

data/app/models/upright/traceroute/ip_metadata_lookup.rb

@@ -0,0 +1,107 @@
+require "net/http"
+require "json"
+require "resolv"
+require "geohash_ruby"
+
+class Upright::Traceroute::IpMetadataLookup
+  API_URL = "http://ip-api.com/batch"
+  TIMEOUT = 5.seconds
+  GEOHASH_PRECISION = 6
+  CACHE_TTL = 24.hours
+
+  class << self
+    def for_many(ips)
+      results, uncached_ips = partition_cached(ips)
+
+      if uncached_ips.any?
+        fetch_batch(uncached_ips).each do |ip, metadata|
+          cache_write(ip, metadata)
+          results[ip] = metadata
+        end
+      end
+
+      results
+    end
+
+    def clear_cache
+      cache.clear
+    end
+
+    private
+      def partition_cached(ips)
+        results = {}
+        uncached = []
+
+        valid_ips(ips).each do |ip|
+          cached = cache_read(ip)
+          if cached
+            results[ip] = cached
+          else
+            uncached << ip
+          end
+        end
+
+        [ results, uncached ]
+      end
+
+      def valid_ips(ips)
+        ips.compact.uniq.select { |ip| ip =~ Resolv::IPv4::Regex }
+      end
+
+      def fetch_batch(ips)
+        uri = URI(API_URL)
+        request = Net::HTTP::Post.new(uri)
+        request.content_type = "application/json"
+        request.body = ips.to_json
+
+        response = Net::HTTP.start(uri.hostname, uri.port, read_timeout: TIMEOUT, open_timeout: TIMEOUT) do |http|
+          http.request(request)
+        end
+
+        if response.is_a?(Net::HTTPSuccess)
+          parse_response(JSON.parse(response.body))
+        else
+          {}
+        end
+      end
+
+      def parse_response(results)
+        results.select { |result| result["status"] == "success" }.to_h do |result|
+          [ result["query"], build_metadata(result) ]
+        end
+      end
+
+      def build_metadata(result)
+        {
+          as: result["as"],
+          isp: result["isp"],
+          city: result["city"],
+          country: result["country"],
+          country_code: result["countryCode"],
+          geohash: encode_geohash(result["lat"], result["lon"])
+        }
+      end
+
+      def encode_geohash(latitude, longitude)
+        if latitude && longitude
+          Geohash.encode(latitude, longitude, GEOHASH_PRECISION)
+        end
+      end
+
+      def cache_read(ip)
+        cache.read("traceroute/ip_metadata/#{ip}")
+      end
+
+      def cache_write(ip, metadata)
+        cache.write("traceroute/ip_metadata/#{ip}", metadata, expires_in: CACHE_TTL)
+      end
+
+      def cache
+        @cache ||= if Rails.env.test?
+          ActiveSupport::Cache::MemoryStore.new
+        else
+          ActiveSupport::Cache::FileStore.new(Rails.root.join("storage/ip_metadata"))
+        end
+      end
+  end
+end

data/app/models/upright/traceroute/mtr_parser.rb

@@ -0,0 +1,47 @@
+require "json"
+require "resolv"
+
+class Upright::Traceroute::MtrParser
+  def initialize(json_output)
+    @json_output = json_output
+  end
+
+  def parse
+    data = JSON.parse(@json_output)
+    hubs = data.dig("report", "hubs").to_a
+
+    hubs.map { |hub| parse_hub(hub) }
+  end
+
+  private
+    def parse_hub(hub)
+      {
+        **ip_and_hostname(hub["host"]),
+        hop_number: hub["count"],
+        loss_percent: hub["Loss%"],
+        last_ms: hub["Last"],
+        avg_ms: hub["Avg"],
+        best_ms: hub["Best"],
+        worst_ms: hub["Wrst"],
+        stddev_ms: hub["StDev"]
+      }
+    end
+
+    def ip_and_hostname(host)
+      if host.nil? || host == "???"
+        { ip: nil, hostname: nil }
+      elsif ip_address?(host)
+        { ip: host, hostname: nil }
+      else
+        { ip: resolve_ip(host), hostname: host }
+      end
+    end
+
+    def resolve_ip(hostname)
+      Resolv.getaddress(hostname) rescue nil
+    end
+
+    def ip_address?(address)
+      address.match?(Resolv::IPv4::Regex)
+    end
+end