upright 0.1.0

data/lib/omniauth/strategies/static_credentials.rb

@@ -0,0 +1,57 @@
+require "omniauth"
+
+module OmniAuth
+  module Strategies
+    class StaticCredentials
+      include OmniAuth::Strategy
+
+      option :name, "static_credentials"
+      option :title, "Sign In"
+      option :credentials, {}
+
+      def request_phase
+        OmniAuth::Form.build(title: options.title, url: callback_path) do
+          text_field "Username", "username"
+          password_field "Password", "password"
+        end.to_response
+      end
+
+      def callback_phase
+        if valid_credentials?
+          super
+        else
+          fail!(:invalid_credentials)
+        end
+      end
+
+      uid { username }
+
+      info do
+        { name: username, email: "#{username}@localhost" }
+      end
+
+      protected
+
+        def valid_credentials?
+          return false if username.blank? || password.blank?
+
+          configured_credentials.any? do |user, pass|
+            ActiveSupport::SecurityUtils.secure_compare(username, user.to_s) &&
+              ActiveSupport::SecurityUtils.secure_compare(password, pass.to_s)
+          end
+        end
+
+        def configured_credentials
+          options.credentials || {}
+        end
+
+        def username
+          request.params["username"]
+        end
+
+        def password
+          request.params["password"]
+        end
+    end
+  end
+end

data/lib/tasks/upright_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :upright do
+#   # Task goes here
+# end

data/lib/upright/configuration.rb

@@ -0,0 +1,106 @@
+class Upright::Configuration
+  # Global subdomain is always "app" - this is documented behavior
+  GLOBAL_SUBDOMAIN = "app"
+
+  # Core settings
+  attr_accessor :service_name
+  attr_accessor :user_agent
+  attr_accessor :default_timeout
+
+  # Storage paths
+  attr_accessor :prometheus_dir
+  attr_accessor :video_storage_dir
+  attr_accessor :storage_state_dir
+  attr_accessor :frozen_record_path
+
+  # Probe and authenticator paths (for auto-loading app-specific code)
+  attr_writer :probes_path
+  attr_writer :authenticators_path
+
+  # Playwright
+  attr_accessor :playwright_server_url
+
+  # Authentication
+  attr_accessor :auth_provider
+  attr_accessor :auth_options
+
+  # Observability
+  attr_accessor :otel_endpoint
+  attr_accessor :prometheus_url
+  attr_accessor :alert_webhook_url
+
+  def initialize
+    @service_name = "upright"
+    @user_agent = "Upright/1.0"
+    @default_timeout = 10.seconds
+
+    @prometheus_dir = nil
+    @video_storage_dir = nil
+    @storage_state_dir = nil
+    @frozen_record_path = nil
+    @probes_path = nil
+    @authenticators_path = nil
+
+    @playwright_server_url = ENV["PLAYWRIGHT_SERVER_URL"]
+    @otel_endpoint = ENV["OTEL_EXPORTER_OTLP_ENDPOINT"]
+
+    @auth_provider = :static_credentials
+    @auth_options = {}
+  end
+
+  def global_subdomain
+    GLOBAL_SUBDOMAIN
+  end
+
+  def site_subdomains
+    Upright.sites.map { |site| site.code.to_s }
+  end
+
+  def prometheus_dir
+    @prometheus_dir || Rails.root.join("tmp", "prometheus")
+  end
+
+  def video_storage_dir
+    @video_storage_dir || Rails.root.join("storage", "playwright_videos")
+  end
+
+  def storage_state_dir
+    @storage_state_dir || Rails.root.join("storage", "playwright_storage_states")
+  end
+
+  def frozen_record_path
+    @frozen_record_path || Rails.root.join("config", "probes")
+  end
+
+  def probes_path
+    @probes_path || Rails.root.join("probes")
+  end
+
+  def authenticators_path
+    @authenticators_path || Rails.root.join("probes", "authenticators")
+  end
+
+  def hostname=(value)
+    @hostname = value
+    configure_allowed_hosts
+  end
+
+  def hostname
+    @hostname
+  end
+
+  def default_url_options
+    if Rails.env.production?
+      { protocol: "https", host: "#{global_subdomain}.#{hostname}", domain: hostname }
+    else
+      { protocol: "http", host: "#{global_subdomain}.#{hostname}", port: ENV.fetch("PORT", 3000).to_i, domain: hostname }
+    end
+  end
+
+  private
+    def configure_allowed_hosts
+      port_suffix = Rails.env.local? ? "(:\\d+)?" : ""
+      Rails.application.config.hosts = [ /.*\.#{Regexp.escape(hostname)}#{port_suffix}/, /#{Regexp.escape(hostname)}#{port_suffix}/ ]
+      Rails.application.config.action_dispatch.tld_length = 1
+    end
+end

data/lib/upright/engine.rb

@@ -0,0 +1,157 @@
+class Upright::Engine < ::Rails::Engine
+  isolate_namespace Upright
+
+  # Add concerns to autoload paths
+  config.autoload_paths << root.join("app/models/concerns")
+
+  # Session store configuration
+  initializer "upright.session_store", before: :load_config_initializers do |app|
+    app.config.session_store :cookie_store,
+      key: "_upright_session",
+      domain: :all,
+      same_site: :lax,
+      secure: Rails.env.production?,
+      expire_after: 24.hours
+  end
+
+  config.after_initialize do
+    url_options = Upright.configuration.default_url_options
+    Rails.application.routes.default_url_options = url_options
+    Upright::Engine.routes.default_url_options = url_options
+  end
+
+  initializer "upright.solid_queue", before: :set_configs_for_current_railties do |app|
+    unless Rails.env.test?
+      app.config.active_job.queue_adapter = :solid_queue
+      app.config.solid_queue.connects_to = { database: { writing: :queue, reading: :queue } }
+    end
+  end
+
+  # Configure Mission Control to use engine's authenticated controller
+  initializer "upright.mission_control" do
+    MissionControl::Jobs.base_controller_class = "Upright::ApplicationController"
+    MissionControl::Jobs.http_basic_auth_enabled = false
+  end
+
+  # Configure acronym inflections for autoloading
+  initializer "upright.inflections", before: :bootstrap_hook do
+    ActiveSupport::Inflector.inflections(:en) do |inflect|
+      inflect.acronym "HTTP"
+      inflect.acronym "SMTP"
+    end
+  end
+
+  config.generators do |g|
+    g.test_framework :minitest
+  end
+
+  initializer "upright.assets" do |app|
+    app.config.assets.paths << root.join("app/javascript")
+  end
+
+  initializer "upright.importmap", before: "importmap" do |app|
+    if defined?(Importmap::Engine)
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+    end
+  end
+
+  initializer "upright.frozen_record" do
+    FrozenRecord::Base.base_path = Upright.configuration.frozen_record_path
+  end
+
+  initializer "upright.yabeda" do
+    Upright::Metrics.configure
+  end
+
+  initializer "upright.opentelemetry" do
+    Upright::Tracing.configure
+  end
+
+  # Start metrics server for Solid Queue worker process
+  initializer "upright.solid_queue_metrics" do
+    SolidQueue.on_start do
+      ENV["PROMETHEUS_EXPORTER_PORT"] ||= Rails.env.local? ? "9395" : "9394"
+      ENV["PROMETHEUS_EXPORTER_LOG_REQUESTS"] = "false"
+      Yabeda::Prometheus::Exporter.start_metrics_server!
+    end
+  end
+
+  initializer "upright.duration_extension" do
+    ActiveSupport::Duration.class_eval do
+      def in_ms
+        (to_f * 1000).to_i
+      end
+    end
+  end
+
+  # Silence Ethon's verbose debug output to stdout
+  # By default, Ethon's debug callback prints curl verbose messages which pollutes logs
+  initializer "upright.ethon" do
+    Ethon::Easy::Callbacks.module_eval do
+      def debug_callback
+        @debug_callback ||= proc { |handle, type, data, size, udata|
+          message = data.read_string(size)
+          @debug_info.add(type, message)
+          0
+        }
+      end
+    end
+  end
+
+  # Allow host app to override views
+  config.to_prepare do
+    Upright::ApplicationController.helper Rails.application.helpers
+  end
+
+  # Print available URLs in development
+  config.after_initialize do
+    if Rails.env.development? && defined?(Rails::Server)
+      url_options = Upright.configuration.default_url_options
+      hostname = url_options[:domain]
+      port = url_options[:port]
+      protocol = url_options[:protocol]
+
+      puts ""
+      puts "Upright is running at:"
+      puts "  Global: #{protocol}://#{Upright.configuration.global_subdomain}.#{hostname}:#{port}"
+      Upright.sites.each do |site|
+        puts "  #{site.city || site.code}:  #{protocol}://#{site.code}.#{hostname}:#{port}"
+      end
+      puts ""
+    end
+  end
+
+  # Auto-load Playwright probes and authenticators from configured paths
+  config.after_initialize do
+    # Define namespaces for app-specific probes and authenticators
+    module ::Probes
+      module Playwright
+      end
+    end
+
+    module ::Playwright
+      module Authenticator
+      end
+    end
+
+    probes_path = Upright.configuration.probes_path
+    if probes_path && Dir.exist?(probes_path)
+      Dir[probes_path.join("*_probe.rb")].sort.each { |file| require file }
+    end
+
+    authenticators_path = Upright.configuration.authenticators_path
+    if authenticators_path && Dir.exist?(authenticators_path)
+      Dir[authenticators_path.join("*.rb")].sort.each { |file| require file }
+    end
+  end
+
+  # Add engine migrations to host app
+  initializer "upright.migrations" do |app|
+    unless app.root.to_s == root.join("test/dummy").to_s
+      config.paths["db/migrate"].expanded.each do |expanded_path|
+        app.config.paths["db/migrate"] << expanded_path
+      end
+    end
+  end
+end

data/lib/upright/metrics.rb

@@ -0,0 +1,62 @@
+require "prometheus/client"
+require "prometheus/client/data_stores/direct_file_store"
+require "yabeda"
+
+module Upright::Metrics
+  class << self
+    def configure
+      setup_prometheus_store unless Rails.env.test?
+      define_metrics
+      Yabeda.configure!
+    end
+
+    def probe_duration_seconds
+      Yabeda.upright_probe_duration_seconds
+    end
+
+    def probe_up
+      Yabeda.upright_probe_up
+    end
+
+    def http_response_status
+      Yabeda.upright_http_response_status
+    end
+
+    private
+      def setup_prometheus_store
+        prometheus_dir = Upright.configuration.prometheus_dir
+        FileUtils.mkdir_p(prometheus_dir)
+
+        Prometheus::Client.config.data_store = Prometheus::Client::DataStores::DirectFileStore.new(dir: prometheus_dir.to_s)
+      end
+
+      def define_metrics
+        current_site = Upright.current_site
+
+        Yabeda.configure do
+          default_tag :site_code, current_site&.code
+          default_tag :site_city, current_site&.city
+          default_tag :site_country, current_site&.country
+          default_tag :site_geohash, current_site&.geohash
+          default_tag :site_provider, current_site&.provider
+
+          group :upright do
+            gauge :probe_duration_seconds,
+              comment: "Duration of each probe",
+              aggregation: :max,
+              tags: %i[type name probe_target probe_service status]
+
+            gauge :probe_up,
+              comment: "Probe status (1 = up, 0 = down)",
+              aggregation: :most_recent,
+              tags: %i[type name probe_target probe_service]
+
+            gauge :http_response_status,
+              comment: "HTTP response status code",
+              aggregation: :max,
+              tags: %i[name probe_target probe_service]
+          end
+        end
+      end
+  end
+end

data/lib/upright/playwright/collect_performance_metrics.js

@@ -0,0 +1,36 @@
+(() => {
+  const metrics = {};
+
+  const [navigation] = performance.getEntriesByType("navigation");
+  if (navigation) {
+    metrics.ttfb = Math.round(navigation.responseStart);
+    metrics.dns = Math.round(navigation.domainLookupEnd - navigation.domainLookupStart);
+    metrics.tcp = Math.round(navigation.connectEnd - navigation.connectStart);
+    metrics.request = Math.round(navigation.responseStart - navigation.requestStart);
+    metrics.response = Math.round(navigation.responseEnd - navigation.responseStart);
+    metrics.domInteractive = Math.round(navigation.domInteractive);
+    metrics.domContentLoaded = Math.round(navigation.domContentLoadedEventEnd);
+    metrics.domComplete = Math.round(navigation.domComplete);
+    metrics.loadComplete = Math.round(navigation.loadEventEnd);
+    metrics.transferSize = navigation.transferSize;
+    metrics.encodedBodySize = navigation.encodedBodySize;
+    metrics.decodedBodySize = navigation.decodedBodySize;
+  }
+
+  const [fcp] = performance.getEntriesByType("paint").filter(e => e.name === "first-contentful-paint");
+  if (fcp) {
+    metrics.fcp = Math.round(fcp.startTime);
+  }
+
+  const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
+  if (lcpEntries.length > 0) {
+    metrics.lcp = Math.round(lcpEntries[lcpEntries.length - 1].startTime);
+  }
+
+  const [fid] = performance.getEntriesByType("first-input");
+  if (fid) {
+    metrics.fid = Math.round(fid.processingStart - fid.startTime);
+  }
+
+  return metrics;
+})();

data/lib/upright/site.rb

@@ -0,0 +1,49 @@
+require "geohash_ruby"
+
+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)
+      @code = code.to_sym
+      @city = city
+      @country = country
+      @geohash = geohash
+      @provider = provider
+      @stagger_index = stagger_index
+    end
+
+    def host
+      URI.parse(url).host
+    end
+
+    def provider
+      @provider.to_s.inquiry
+    end
+
+    def default_timeout
+      Upright.configuration.default_timeout
+    end
+
+    def latitude
+      coordinates.first
+    end
+
+    def longitude
+      coordinates.last
+    end
+
+    def url
+      Upright::Engine.routes.url_helpers.root_url(subdomain: code)
+    end
+
+    def to_leaflet
+      { hostname: host, city: city, lat: latitude, lon: longitude, url: url }
+    end
+
+    private
+      def coordinates
+        @coordinates ||= Geohash.decode(geohash).first
+      end
+  end
+end

data/lib/upright/tracing.rb

@@ -0,0 +1,49 @@
+module Upright::Tracing
+  class << self
+    def configure
+      current_site = Upright.current_site
+
+      OpenTelemetry::SDK.configure do |c|
+        c.service_name = Upright.configuration.service_name
+        c.service_version = Upright::VERSION
+
+        c.resource = OpenTelemetry::SDK::Resources::Resource.create(
+          resource_attributes(current_site)
+        )
+
+        # Use OTLP exporter if endpoint is configured
+        if Upright.configuration.otel_endpoint
+          c.add_span_processor(
+            OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+              OpenTelemetry::Exporter::OTLP::Exporter.new(
+                endpoint: Upright.configuration.otel_endpoint
+              )
+            )
+          )
+        end
+
+        c.use_all
+      end
+    end
+
+    def tracer
+      OpenTelemetry.tracer_provider.tracer(Upright.configuration.service_name, Upright::VERSION)
+    end
+
+    def with_span(name, attributes: {}, &block)
+      tracer.in_span(name, attributes: attributes, &block)
+    end
+
+    private
+      def resource_attributes(site)
+        {
+          "deployment.environment" => Rails.env.to_s,
+          "site.code" => site.code.to_s,
+          "site.city" => site.city.to_s,
+          "site.country" => site.country.to_s,
+          "site.geohash" => site.geohash.to_s,
+          "site.provider" => site.provider.to_s
+        }.compact_blank
+      end
+  end
+end

data/lib/upright/version.rb

@@ -0,0 +1,3 @@
+module Upright
+  VERSION = "0.1.0"
+end

data/lib/upright.rb

@@ -0,0 +1,68 @@
+require "frozen_record"
+require "prometheus/api_client"
+require "opentelemetry-sdk"
+require "opentelemetry-exporter-otlp"
+require "typhoeus"
+require "solid_queue"
+require "mission_control/jobs"
+require "omniauth"
+require "omniauth_openid_connect"
+require "omniauth/rails_csrf_protection"
+require "omniauth/strategies/static_credentials"
+require "propshaft"
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+require "geared_pagination"
+require "geohash_ruby"
+require "yabeda/prometheus"
+require "yabeda/puma/plugin"
+
+require "upright/version"
+require "upright/configuration"
+require "upright/site"
+require "upright/metrics"
+require "upright/tracing"
+require "upright/engine"
+
+module Upright
+  class ConfigurationError < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias_method :config, :configuration
+
+    def configure
+      yield(configuration)
+    end
+
+    def sites
+      @sites ||= load_sites
+    end
+
+    def find_site(code)
+      sites.find { |site| site.code.to_s == code.to_s }
+    end
+
+    def current_site
+      find_site(ENV["SITE_SUBDOMAIN"]) || sites.first
+    end
+
+    private
+      def load_sites
+        sites_config_path = Rails.root.join("config/sites.yml")
+
+        if sites_config_path.exist?
+          config = Rails.application.config_for(:sites)
+
+          config[:sites].map.with_index do |site_config, index|
+            Site.new(stagger_index: index, **site_config)
+          end
+        else
+          []
+        end
+      end
+  end
+end