upright 0.2.0 → 0.4.0

data/lib/upright/configuration.rb

@@ -2,6 +2,11 @@ class Upright::Configuration
   # Global subdomain is always "app" - this is documented behavior
   GLOBAL_SUBDOMAIN = "app"
 
+  # Public status pages live at status.<hostname>; custom CNAMEs match by subdomain.
+  PUBLIC_STATUS_SUBDOMAIN = "status"
+
+  DEFAULT_TRACE_VIEWER_URL = "https://trace.playwright.dev/"
+
   # Core settings
   attr_accessor :service_name
   attr_accessor :user_agent
@@ -10,6 +15,7 @@ class Upright::Configuration
   # Storage paths
   attr_accessor :prometheus_dir
   attr_accessor :video_storage_dir
+  attr_accessor :recording_base_dir
   attr_accessor :storage_state_dir
   attr_accessor :frozen_record_path
 
@@ -17,8 +23,13 @@ class Upright::Configuration
   attr_writer :probes_path
   attr_writer :authenticators_path
 
+  # Public status page services definition (env-overridable, like probes_path)
+  attr_writer :services_path
+
   # Playwright
-  attr_accessor :playwright_server_url
+  attr_accessor :playwright_cli_path
+
+  attr_reader :trace_viewer_url
 
   # Authentication
   attr_accessor :auth_provider
@@ -29,6 +40,28 @@ class Upright::Configuration
   attr_accessor :prometheus_url
   attr_accessor :alert_webhook_url
 
+  attr_writer :proxy_token
+
+  attr_writer :rollup_minimum_coverage
+  attr_writer :rollup_evaluation_interval
+
+  # Probe types
+  attr_reader :probe_types
+
+  # Probe result cleanup
+  attr_accessor :stale_success_threshold
+  attr_accessor :stale_failure_threshold
+  attr_accessor :failure_retention_limit
+
+  # Public status pages
+  attr_accessor :public_status_enabled
+  attr_reader :public_status_custom_domains
+
+  # Extra stylesheets host apps layer on top of the engine's for the public
+  # status page (theming, branding). Logical asset names, loaded last so their
+  # :root overrides win the cascade.
+  attr_writer :public_stylesheets
+
   def initialize
     @service_name = "upright"
     @user_agent = "Upright/1.0"
@@ -36,16 +69,59 @@ class Upright::Configuration
 
     @prometheus_dir = nil
     @video_storage_dir = nil
+    @recording_base_dir = nil
     @storage_state_dir = nil
     @frozen_record_path = nil
     @probes_path = nil
     @authenticators_path = nil
+    @services_path = nil
 
-    @playwright_server_url = ENV["PLAYWRIGHT_SERVER_URL"]
+    @probe_types = Upright::ProbeTypeRegistry.new
+
+    @playwright_cli_path = ENV.fetch("PLAYWRIGHT_CLI_PATH", "npx playwright")
     @otel_endpoint = ENV["OTEL_EXPORTER_OTLP_ENDPOINT"]
+    @prometheus_url = nil
 
     @auth_provider = :static_credentials
     @auth_options = {}
+
+    @stale_success_threshold = 24.hours
+    @stale_failure_threshold = 30.days
+    @failure_retention_limit = 20_000
+
+    self.trace_viewer_url = ENV.fetch("TRACE_VIEWER_URL", DEFAULT_TRACE_VIEWER_URL)
+
+    @public_status_enabled = false
+    @public_status_custom_domains = []
+    @public_stylesheets = nil
+  end
+
+  def trace_viewer_url=(url)
+    @trace_viewer_url = url.presence
+    host = trace_viewer_uri&.host
+
+    if @trace_viewer_url && (host.nil? || admin_domain?(host))
+      raise Upright::ConfigurationError, "config.trace_viewer_url must be an http(s) URL outside #{@hostname}"
+    end
+  end
+
+  def trace_viewer_origin
+    trace_viewer_uri&.then do |url|
+      "#{url.scheme}://#{url.host}#{":#{url.port}" unless url.port == url.default_port}"
+    end
+  end
+
+  def public_status_subdomain
+    PUBLIC_STATUS_SUBDOMAIN
+  end
+
+  def public_stylesheets
+    Array(@public_stylesheets)
+  end
+
+  def public_status_custom_domains=(domains)
+    @public_status_custom_domains = Array(domains)
+    configure_allowed_hosts if @hostname
   end
 
   def global_subdomain
@@ -60,10 +136,30 @@ class Upright::Configuration
     @prometheus_dir || Rails.root.join("tmp", "prometheus")
   end
 
+  def prometheus_url
+    @prometheus_url || ENV.fetch("PROMETHEUS_URL", "http://localhost:9090")
+  end
+
+  def proxy_token
+    @proxy_token || ENV["PROMETHEUS_OTLP_TOKEN"]
+  end
+
+  def rollup_minimum_coverage
+    @rollup_minimum_coverage || 0.9
+  end
+
+  def rollup_evaluation_interval
+    @rollup_evaluation_interval || 30.seconds
+  end
+
   def video_storage_dir
     @video_storage_dir || Rails.root.join("storage", "playwright_videos")
   end
 
+  def recording_base_dir
+    @recording_base_dir || Rails.root.join("storage", "playwright_recordings")
+  end
+
   def storage_state_dir
     @storage_state_dir || Rails.root.join("storage", "playwright_storage_states")
   end
@@ -76,6 +172,10 @@ class Upright::Configuration
     @probes_path || Rails.root.join("probes")
   end
 
+  def services_path
+    @services_path || Rails.root.join("config", "services.yml")
+  end
+
   def authenticators_path
     @authenticators_path || Rails.root.join("probes", "authenticators")
   end
@@ -90,17 +190,38 @@ class Upright::Configuration
   end
 
   def default_url_options
-    if Rails.env.production?
-      { protocol: "https", host: "#{global_subdomain}.#{hostname}", domain: hostname }
-    else
+    if Rails.env.local?
       { protocol: "http", host: "#{global_subdomain}.#{hostname}", port: ENV.fetch("PORT", 3000).to_i, domain: hostname }
+    else
+      { protocol: "https", host: "#{global_subdomain}.#{hostname}", domain: hostname }
     end
   end
 
   private
+    def trace_viewer_uri
+      url = URI(@trace_viewer_url.to_s)
+      url if url.is_a?(URI::HTTP) && url.host.present?
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    # DNS is case-insensitive and tolerates a trailing dot, so compare folded.
+    def admin_domain?(host)
+      return false if @hostname.blank?
+
+      host = host.downcase.chomp(".")
+      admin = @hostname.downcase
+
+      host == admin || host.end_with?(".#{admin}")
+    end
+
     def configure_allowed_hosts
       port_suffix = Rails.env.local? ? "(:\\d+)?" : ""
-      Rails.application.config.hosts = [ /.*\.#{Regexp.escape(hostname)}#{port_suffix}/, /#{Regexp.escape(hostname)}#{port_suffix}/ ]
+      hosts = [ /.*\.#{Regexp.escape(hostname)}#{port_suffix}/, /#{Regexp.escape(hostname)}#{port_suffix}/ ]
+      Array(@public_status_custom_domains).each do |domain|
+        hosts << /\A#{Regexp.escape(domain)}#{port_suffix}\z/
+      end
+      Rails.application.config.hosts = hosts
       Rails.application.config.action_dispatch.tld_length = 1
     end
 end

data/lib/upright/engine.rb

@@ -6,14 +6,34 @@ class Upright::Engine < ::Rails::Engine
 
   # Session store configuration
   initializer "upright.session_store", before: :load_config_initializers do |app|
+    # Scope the cookie to the configured hostname (resolved per-request, since the
+    # host app sets it in an initializer that runs after this one) rather than
+    # `domain: :all`, which — with a multi-label hostname like upright.example.com
+    # — would hand the cookie to the registrable parent and every sibling under it
+    # (F-08). This is independent of tld_length, so custom status domains still
+    # parse normally.
     app.config.session_store :cookie_store,
       key: "_upright_session",
-      domain: :all,
+      domain: ->(_request) { Upright.configuration.hostname&.then { |h| ".#{h}" } },
       same_site: :lax,
-      secure: Rails.env.production?,
+      secure: !Rails.env.local?,
+      httponly: true,
       expire_after: 24.hours
   end
 
+  # The proxy token stands in for an admin session on the metrics proxies, so a
+  # blank one in a deployed environment is a fail-open: any bearer value would be
+  # compared against "" . Refuse to boot without one outside local envs — but not
+  # during `assets:precompile`, which Rails runs with SECRET_KEY_BASE_DUMMY and no
+  # runtime secrets (the Docker image builds before the token is available).
+  config.after_initialize do
+    building_assets = ENV["SECRET_KEY_BASE_DUMMY"].present?
+
+    if !Rails.env.local? && !building_assets && Upright.configuration.proxy_token.blank?
+      raise Upright::ConfigurationError, "Upright.configuration.proxy_token (or PROMETHEUS_OTLP_TOKEN) must be set outside development/test"
+    end
+  end
+
   config.after_initialize do
     url_options = Upright.configuration.default_url_options
     Rails.application.routes.default_url_options = url_options
@@ -56,6 +76,13 @@ class Upright::Engine < ::Rails::Engine
     end
   end
 
+  initializer "upright.probe_types", before: :load_config_initializers do
+    Upright.config.probe_types.register :http, name: "HTTP", icon: "🌐"
+    Upright.config.probe_types.register :playwright, name: "Playwright", icon: "🎭"
+    Upright.config.probe_types.register :smtp, name: "SMTP", icon: "✉️"
+    Upright.config.probe_types.register :traceroute, name: "Traceroute", icon: "🛤️"
+  end
+
   initializer "upright.frozen_record" do
     FrozenRecord::Base.base_path = Upright.configuration.frozen_record_path
   end
@@ -118,6 +145,9 @@ class Upright::Engine < ::Rails::Engine
       Upright.sites.each do |site|
         puts "  #{site.city || site.code}:  #{protocol}://#{site.code}.#{hostname}:#{port}"
       end
+      if Upright.configuration.public_status_enabled
+        puts "  Public status: #{protocol}://#{Upright.configuration.public_status_subdomain}.#{hostname}:#{port}"
+      end
       puts ""
     end
   end

data/lib/upright/metrics.rb

@@ -44,17 +44,42 @@ module Upright::Metrics
             gauge :probe_duration_seconds,
               comment: "Duration of each probe",
               aggregation: :max,
-              tags: %i[type name probe_target probe_service status]
+              tags: %i[type name probe_target probe_service alert_severity status]
 
             gauge :probe_up,
               comment: "Probe status (1 = up, 0 = down)",
               aggregation: :most_recent,
-              tags: %i[type name probe_target probe_service]
+              tags: %i[type name probe_target probe_service alert_severity]
 
             gauge :http_response_status,
               comment: "HTTP response status code",
               aggregation: :max,
               tags: %i[name probe_target probe_service]
+
+            gauge :service_under_maintenance,
+              comment: "Whether a service is under active maintenance (1 = yes, 0 = no)",
+              aggregation: :most_recent,
+              tags: %i[probe_service]
+
+            gauge :primary_site,
+              comment: "Whether this site is the primary (1 = yes, 0 = no)",
+              aggregation: :most_recent,
+              tags: []
+
+            gauge :persistent_db_up,
+              comment: "Whether the persistent database answers (1 = yes, 0 = no)",
+              aggregation: :most_recent,
+              tags: []
+
+            gauge :rollup_skipped_probes,
+              comment: "Probes the last rollup run left unwritten for insufficient Prometheus coverage",
+              aggregation: :most_recent,
+              tags: []
+
+            gauge :rollup_last_run_timestamp_seconds,
+              comment: "Unix time of the most recently written daily rollup",
+              aggregation: :max,
+              tags: []
           end
         end
       end

data/lib/upright/probe_type_registry.rb

@@ -0,0 +1,33 @@
+module Upright
+  class ProbeTypeRegistry
+    ProbeType = Data.define(:type, :name, :icon)
+
+    include Enumerable
+
+    def initialize
+      @probe_types = []
+    end
+
+    def register(type, name:, icon:)
+      type = type.to_s
+      @probe_types.reject! { |pt| pt.type == type }
+      @probe_types << ProbeType.new(type:, name:, icon:)
+    end
+
+    def types
+      @probe_types.map(&:type)
+    end
+
+    def find(type)
+      @probe_types.find { |pt| pt.type == type.to_s }
+    end
+
+    def unregister(type)
+      @probe_types.reject! { |pt| pt.type == type.to_s }
+    end
+
+    def each(&block)
+      @probe_types.each(&block)
+    end
+  end
+end

data/lib/upright/site.rb

@@ -2,19 +2,37 @@ module Upright
   class Site
     attr_reader :code, :city, :country, :geohash, :stagger_index
 
-    def initialize(code:, city: nil, country: nil, geohash: nil, provider: nil, stagger_index: 0)
+    def initialize(code:, city: nil, country: nil, geohash: nil, provider: nil, stores_metrics: false, primary: false, stagger_index: 0)
       @code = code.to_sym
       @city = city
       @country = country
       @geohash = geohash
       @provider = provider
+      @stores_metrics = stores_metrics
+      @primary = primary
       @stagger_index = stagger_index
     end
 
+    def stores_metrics?
+      @stores_metrics
+    end
+
+    def primary?
+      @primary
+    end
+
     def host
       URI.parse(url).host
     end
 
+    def current?
+      code == Upright.current_site&.code
+    end
+
+    def prometheus_client
+      current? ? Upright.prometheus_client : peer_prometheus_client
+    end
+
     def provider
       @provider.to_s.inquiry
     end
@@ -40,6 +58,18 @@ module Upright
     end
 
     private
+      def peer_prometheus_client
+        Prometheus::ApiClient.client(url: prometheus_proxy_url, headers: proxy_authorization, options: { timeout: 30 })
+      end
+
+      def prometheus_proxy_url
+        "#{url.chomp("/")}/prometheus"
+      end
+
+      def proxy_authorization
+        { "Authorization" => "Bearer #{Upright.configuration.proxy_token}" }
+      end
+
       def coordinates
         @coordinates ||= Upright::Geohash.decode(geohash).first
       end

data/lib/upright/version.rb

@@ -1,3 +1,5 @@
 module Upright
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
+  # Keep in sync with the playwright-ruby-client constraint in upright.gemspec
+  PLAYWRIGHT_VERSION = "1.59"
 end

data/lib/upright.rb

@@ -13,12 +13,14 @@ require "propshaft"
 require "importmap-rails"
 require "turbo-rails"
 require "stimulus-rails"
+require "local_time"
 require "geared_pagination"
 require "yabeda/prometheus"
 require "yabeda/puma/plugin"
 
 require "upright/version"
 require "upright/configuration"
+require "upright/probe_type_registry"
 require "upright/geohash"
 require "upright/site"
 require "upright/metrics"
@@ -38,6 +40,17 @@ module Upright
       yield(configuration)
     end
 
+    def probe_types
+      configuration.probe_types
+    end
+
+    def prometheus_client
+      Prometheus::ApiClient.client(
+        url: configuration.prometheus_url,
+        options: { timeout: 30.seconds }
+      )
+    end
+
     def sites
       @sites ||= load_sites
     end
@@ -47,7 +60,15 @@ module Upright
     end
 
     def current_site
-      find_site(ENV["SITE_SUBDOMAIN"]) || sites.first
+      if (subdomain = ENV["SITE_SUBDOMAIN"]).present?
+        find_site(subdomain) || raise(ConfigurationError, "SITE_SUBDOMAIN=#{subdomain} is not a site in sites.yml (#{sites.map(&:code).join(', ')})")
+      else
+        sites.first
+      end
+    end
+
+    def primary_site
+      sites.find(&:primary?)
     end
 
     private
@@ -59,10 +80,21 @@ module Upright
 
           config[:sites].map.with_index do |site_config, index|
             Site.new(stagger_index: index, **site_config)
-          end
+          end.tap { |sites| ensure_at_most_one_primary(sites) }
         else
           []
         end
       end
+
+      # Two primaries means two hosts running the singleton jobs that write the
+      # shared persistent database. None is how a host looks before it adopts
+      # the flag, so that stays legal.
+      def ensure_at_most_one_primary(sites)
+        primaries = sites.select(&:primary?)
+
+        if primaries.many?
+          raise ConfigurationError, "sites.yml declares #{primaries.count} primary sites (#{primaries.map(&:code).join(', ')}); at most one may be primary"
+        end
+      end
   end
 end