upright 0.1.0

data/app/controllers/upright/artifacts_controller.rb

@@ -0,0 +1,5 @@
+class Upright::ArtifactsController < Upright::ApplicationController
+  def show
+    @artifact = ActiveStorage::Attachment.find(params[:id])
+  end
+end

data/app/controllers/upright/dashboards/uptimes_controller.rb

@@ -0,0 +1,6 @@
+class Upright::Dashboards::UptimesController < Upright::ApplicationController
+  def show
+    @probe_type = params.fetch(:probe_type, :http)
+    @probes = Upright::Probes::Uptime.for_type(@probe_type)
+  end
+end

data/app/controllers/upright/jobs_controller.rb

@@ -0,0 +1,4 @@
+class Upright::JobsController < Upright::ApplicationController
+  def show
+  end
+end

data/app/controllers/upright/probe_results_controller.rb

@@ -0,0 +1,17 @@
+class Upright::ProbeResultsController < Upright::ApplicationController
+  def index
+    set_page_and_extract_portion_from probe_results, ordered_by: { id: :desc }
+
+    @probe_names = Upright::ProbeResult.by_type(params[:probe_type]).distinct.pluck(:probe_name).sort
+    @chart_data = @page.records.map(&:to_chart)
+  end
+
+  private
+    def probe_results
+      Upright::ProbeResult
+        .by_type(params[:probe_type])
+        .by_status(params[:status])
+        .by_name(params[:probe_name])
+        .with_attached_artifacts
+    end
+end

data/app/controllers/upright/prometheus_proxy_controller.rb

@@ -0,0 +1,62 @@
+class Upright::PrometheusProxyController < Upright::ApplicationController
+  skip_forgery_protection
+
+  skip_before_action :authenticate_user, only: :otlp
+  before_action :authenticate_otlp_token, only: :otlp
+
+  UNSUPPORTED_PATHS = %w[/api/v1/notifications]
+
+  def show
+  end
+
+  def proxy
+    path = request.fullpath.sub(%r{^/prometheus}, "")
+
+    if path.start_with?(*UNSUPPORTED_PATHS)
+      head :not_found
+    else
+      proxy_to_prometheus(path)
+    end
+  end
+
+  def otlp
+    response = prometheus_connection.post("/api/v1/otlp/v1/metrics") do |req|
+      req.headers["Content-Type"] = request.content_type
+      req.body = request.body.read
+    end
+
+    render body: response.body, status: response.status, content_type: response.headers["content-type"]
+  end
+
+  private
+    def proxy_to_prometheus(path, method: request.method, body: nil)
+      response = prometheus_connection.run_request(
+        method.downcase.to_sym,
+        path,
+        body,
+        { "Content-Type" => request.content_type }
+      )
+
+      if response.status.in?([ 301, 302 ]) && response.headers["location"]
+        redirect_to "/prometheus#{response.headers['location']}", status: response.status, allow_other_host: true
+      else
+        render body: response.body, status: response.status, content_type: response.headers["content-type"]
+      end
+    end
+
+    def prometheus_connection
+      @prometheus_connection ||= Faraday.new(url: prometheus_url) do |f|
+        f.options.timeout = 30
+      end
+    end
+
+    def prometheus_url
+      ENV.fetch("PROMETHEUS_URL", "http://localhost:9090")
+    end
+
+    def authenticate_otlp_token
+      authenticate_or_request_with_http_token do |token|
+        ActiveSupport::SecurityUtils.secure_compare(token, ENV.fetch("PROMETHEUS_OTLP_TOKEN", ""))
+      end
+    end
+end

data/app/controllers/upright/sessions_controller.rb

@@ -0,0 +1,29 @@
+class Upright::SessionsController < Upright::ApplicationController
+  skip_before_action :authenticate_user, only: [ :new, :create ]
+  skip_forgery_protection only: :create
+
+  before_action :ensure_not_signed_in, only: [ :new, :create ]
+
+  def new
+  end
+
+  def create
+    user = Upright::User.from_omniauth(request.env["omniauth.auth"])
+    session[:user_info] = { email: user.email, name: user.name }
+    redirect_to upright.root_path
+  end
+
+  def destroy
+    reset_session
+    redirect_to upright.root_path(subdomain: Upright.configuration.global_subdomain), allow_other_host: true
+  end
+
+  private
+    def ensure_not_signed_in
+      redirect_to upright.site_root_path if session[:user_info].present?
+    end
+
+    def upright
+      Upright::Engine.routes.url_helpers
+    end
+end

data/app/controllers/upright/sites_controller.rb

@@ -0,0 +1,5 @@
+class Upright::SitesController < Upright::ApplicationController
+  def index
+    @sites = Upright.sites
+  end
+end

data/app/helpers/upright/application_helper.rb

@@ -0,0 +1,11 @@
+module Upright::ApplicationHelper
+  def current_or_default_site
+    Upright::Current.site || Upright.sites.first
+  end
+
+  def upright_stylesheet_link_tag(**options)
+    Upright::Engine.root.join("app/assets/stylesheets/upright").glob("*.css")
+      .map { |f| "upright/#{f.basename('.css')}" }.sort
+      .then { |stylesheets| stylesheet_link_tag(*stylesheets, **options) }
+  end
+end

data/app/helpers/upright/dashboards_helper.rb

@@ -0,0 +1,31 @@
+module Upright::DashboardsHelper
+  def date_range
+    (29.days.ago.to_date..Date.current).to_a
+  end
+
+  def uptime_label(percentage)
+    case percentage
+    when 100      then "excellent"
+    when 99..100  then "good"
+    when 95..99   then "warning"
+    when 0.01..95 then "critical"
+    else               "down"
+    end
+  end
+
+  def uptime_bar_tooltip(date, uptime_percent, downtime_minutes)
+    tooltip = "#{date.to_fs(:short)}: #{number_with_precision(uptime_percent, precision: 1)}% uptime"
+    tooltip += " (#{format_downtime(downtime_minutes)} down)" if downtime_minutes > 0
+    tooltip
+  end
+
+  def format_downtime(minutes)
+    if minutes < 60
+      "#{minutes}m"
+    else
+      hours = minutes / 60
+      mins = minutes % 60
+      mins.zero? ? "#{hours}h" : "#{hours}h #{mins}m"
+    end
+  end
+end

data/app/helpers/upright/probe_results_helper.rb

@@ -0,0 +1,49 @@
+module Upright::ProbeResultsHelper
+  PROBE_TYPE_ICONS = {
+    http: "🌐",
+    playwright: "🎭",
+    ping: "📶",
+    smtp: "✉️",
+    traceroute: "🛤️"
+  }
+
+  def probe_type_icon(probe_type)
+    icon = PROBE_TYPE_ICONS.fetch(probe_type.to_s.downcase.to_sym)
+    content_tag(:span, icon, title: probe_type.titleize)
+  end
+
+  def type_filter_link(label, probe_type = nil)
+    display_label = probe_type ? safe_join([ probe_type_icon(probe_type), " ", label ]) : label
+
+    link_to display_label,
+            site_root_path(probe_type: probe_type.presence, status: params[:status].presence),
+            class: class_names(active: params[:probe_type].presence == probe_type)
+  end
+
+  def artifact_icon(artifact)
+    case artifact.filename
+    when Upright::ExceptionRecording::EXCEPTION_FILENAME then "💥"
+    when /\.webm$/        then "🎬"
+    when /^request\.log$/ then "📤"
+    when /^response\./    then "📥"
+    when /^smtp\.log$/    then "📧"
+    else "📎"
+    end
+  end
+
+  def results_summary(page)
+    total = page.recordset.records_count
+    current_count = page.records.size
+
+    parts = if page.recordset.page_count > 1
+      [ "Showing #{current_count} of #{total} results" ]
+    else
+      [ "Showing #{total} results" ]
+    end
+
+    parts << "for #{params[:probe_type].titleize} probes" if params[:probe_type].present?
+    parts << "named #{params[:probe_name]}" if params[:probe_name].present?
+    parts << "with status #{params[:status]}" if params[:status].present?
+    parts.join(" ")
+  end
+end

data/app/javascript/upright/application.js

@@ -0,0 +1,2 @@
+import "@hotwired/turbo-rails"
+import "upright/controllers"

data/app/javascript/upright/controllers/application.js

@@ -0,0 +1,5 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+
+export { application }

data/app/javascript/upright/controllers/form_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  submit() {
+    this.element.requestSubmit()
+  }
+}

data/app/javascript/upright/controllers/index.js

@@ -0,0 +1,4 @@
+import { application } from "upright/controllers/application"
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+
+eagerLoadControllersFrom("upright/controllers", application)

data/app/javascript/upright/controllers/popover_controller.js

@@ -0,0 +1,15 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["frame"]
+
+  loadFrame() {
+    if (this.element.open && this.hasFrameTarget) {
+      this.frameTarget.loading = "eager"
+    }
+  }
+
+  close() {
+    this.element.removeAttribute("open")
+  }
+}

data/app/javascript/upright/controllers/probe_results_chart_controller.js

@@ -0,0 +1,79 @@
+import { Controller } from "@hotwired/stimulus"
+import { Chart } from "frappe-charts"
+
+export default class extends Controller {
+  static values = { results: Array }
+
+  connect() {
+    this.results = this.resultsValue.slice().reverse()
+
+    if (this.results.length > 0) {
+      this.renderChart()
+    }
+  }
+
+  renderChart() {
+    new Chart(this.element, {
+      data: this.chartData,
+      type: "line",
+      height: 200,
+      colors: this.colors,
+      lineOptions: { hideDots: 0, dotSize: 3, regionFill: 0 },
+      axisOptions: { xAxisMode: "tick", xIsSeries: true },
+      tooltipOptions: {
+        formatTooltipX: d => this.tooltipLabels[this.labels.indexOf(d)] || d,
+        formatTooltipY: d => d ? `${d.toFixed(3)}s` : null
+      }
+    })
+  }
+
+  get chartData() {
+    return { labels: this.labels, datasets: this.datasets }
+  }
+
+  get labels() {
+    return this._labels ||= this.results.map(r => this.formatTime(r.created_at))
+  }
+
+  get tooltipLabels() {
+    return this._tooltipLabels ||= this.results.map(r => `${r.probe_name} @ ${this.formatTime(r.created_at)}`)
+  }
+
+  get datasets() {
+    const datasets = []
+    if (this.hasOkResults) datasets.push({ name: "Ok", values: this.okData, chartType: "line" })
+    if (this.hasFailResults) datasets.push({ name: "Fail", values: this.failData, chartType: "line" })
+    return datasets
+  }
+
+  get colors() {
+    const colors = []
+    if (this.hasOkResults) colors.push(this.isDarkMode ? "#4ade80" : "#22c55e")
+    if (this.hasFailResults) colors.push(this.isDarkMode ? "#f87171" : "#ef4444")
+    return colors
+  }
+
+  get okData() {
+    return this._okData ||= this.results.map(r => r.status === "ok" ? r.duration : null)
+  }
+
+  get failData() {
+    return this._failData ||= this.results.map(r => r.status !== "ok" ? r.duration : null)
+  }
+
+  get hasOkResults() {
+    return this.okData.some(d => d !== null)
+  }
+
+  get hasFailResults() {
+    return this.failData.some(d => d !== null)
+  }
+
+  get isDarkMode() {
+    return window.matchMedia("(prefers-color-scheme: dark)").matches
+  }
+
+  formatTime(timestamp) {
+    return new Date(timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })
+  }
+}

data/app/javascript/upright/controllers/results_table_controller.js

@@ -0,0 +1,16 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["popover"]
+
+  openArtifact(event) {
+    if (event.target.closest("details, a, button")) return
+
+    const row = event.target.closest("tr")
+    const popover = this.popoverTargets.find(p => row.contains(p))
+
+    if (popover) {
+      popover.open = true
+    }
+  }
+}

data/app/javascript/upright/controllers/sites_map_controller.js

@@ -0,0 +1,33 @@
+import { Controller } from "@hotwired/stimulus"
+import * as L from "leaflet"
+
+export default class extends Controller {
+  static values = { sites: Array }
+
+  connect() {
+    const map = L.map(this.element, { scrollWheelZoom: false }).setView([30, 0], 2)
+
+    L.tileLayer(this.tileUrl, { attribution: this.attribution }).addTo(map)
+
+    for (const site of this.sitesValue) {
+      if (!site.lat || !site.lon) continue
+
+      L.marker([site.lat, site.lon])
+        .addTo(map)
+        .bindPopup(`<strong>${site.hostname}</strong><br>${site.city}`)
+        .on("mouseover", function() { this.openPopup() })
+        .on("mouseout", function() { this.closePopup() })
+        .on("click", () => window.location.href = site.url)
+    }
+  }
+
+  get tileUrl() {
+    return window.matchMedia("(prefers-color-scheme: dark)").matches
+      ? "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png"
+      : "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+  }
+
+  get attribution() {
+    return '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> &copy; <a href="https://carto.com/attributions">CARTO</a>'
+  }
+}

data/app/jobs/upright/application_job.rb

@@ -0,0 +1,2 @@
+class Upright::ApplicationJob < ActiveJob::Base
+end

data/app/jobs/upright/probe_check_job.rb

@@ -0,0 +1,42 @@
+class Upright::ProbeCheckJob < Upright::ApplicationJob
+  MAX_ATTEMPTS = 2
+  RETRY_DELAY = 5.seconds
+
+  before_enqueue { self.scheduled_at = stagger_delay.from_now }
+  before_perform :discard_if_stale
+  around_perform { |job, block| Timeout.timeout(3.minutes, &block) }
+
+  def perform(klass, name = nil)
+    result = resolve_probe(klass, name).check_and_record
+
+    if !result.ok? && executions < MAX_ATTEMPTS
+      retry_job(wait: RETRY_DELAY)
+    end
+  end
+
+  private
+    def stagger_delay
+      arguments[0].constantize.stagger_delay
+    end
+
+    def discard_if_stale
+      if scheduled_at && scheduled_at < 5.minutes.ago
+        logger.info "Discarding stale probe job scheduled at #{scheduled_at}"
+        throw :abort
+      end
+    end
+
+    def resolve_probe(klass, name)
+      klass = klass.safe_constantize
+
+      instance = if klass < FrozenRecord::Base
+        klass.find_by(name: name)
+      else
+        klass.new
+      end
+
+      instance.logger = logger
+
+      instance
+    end
+end

data/app/models/concerns/upright/exception_recording.rb

@@ -0,0 +1,38 @@
+module Upright::ExceptionRecording
+  extend ActiveSupport::Concern
+
+  EXCEPTION_FILENAME = "exception.txt"
+
+  included do
+    attr_accessor :error
+
+    after_create :attach_exception
+  end
+
+  def attach_exception
+    if error
+      artifacts.attach(
+        io: StringIO.new(format_exception(error)),
+        filename: EXCEPTION_FILENAME,
+        content_type: "text/plain"
+      )
+    end
+  end
+
+  def exception_artifact
+    artifacts.find { |a| a.filename.to_s == EXCEPTION_FILENAME }
+  end
+
+  def exception_report
+    exception_artifact&.download
+  end
+
+  private
+    def format_exception(exception)
+      lines = [ "#{exception.class}: #{exception.message}" ]
+      if exception.backtrace
+        lines.concat(exception.backtrace.first(20).map { |line| "  #{line}" })
+      end
+      lines.join("\n")
+    end
+end

data/app/models/concerns/upright/playwright/form_authentication.rb

@@ -0,0 +1,27 @@
+module Upright::Playwright::FormAuthentication
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :authentication_service
+  end
+
+  class_methods do
+    def authenticate_with_form(service)
+      self.authentication_service = service
+    end
+  end
+
+  private
+    def authenticated_context(browser, context_options = {})
+      if authentication_service
+        authenticator_for(authentication_service).new(browser, context_options).authenticated_context
+      end
+    end
+
+    def authenticator_for(service)
+      # First try the host app's authenticator, then fall back to engine's
+      "::Playwright::Authenticator::#{service.to_s.camelize}".constantize
+    rescue NameError
+      "Upright::Playwright::Authenticator::#{service.to_s.camelize}".constantize
+    end
+end

data/app/models/concerns/upright/playwright/helpers.rb

@@ -0,0 +1,7 @@
+module Upright::Playwright::Helpers
+  extend ActiveSupport::Concern
+
+  def wait_for_network_idle(target_page = nil)
+    (target_page || page).wait_for_load_state(state: "networkidle")
+  end
+end

data/app/models/concerns/upright/playwright/lifecycle.rb

@@ -0,0 +1,44 @@
+module Upright::Playwright::Lifecycle
+  extend ActiveSupport::Concern
+
+  DEFAULT_USER_AGENT = "Upright/1.0 Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+
+  included do
+    attr_accessor :context, :page
+
+    define_callbacks :page_ready
+    define_callbacks :page_close
+  end
+
+  def user_agent
+    Upright.configuration.user_agent.presence || DEFAULT_USER_AGENT
+  end
+
+  private
+    def with_browser(&block)
+      if ENV["LOCAL_PLAYWRIGHT"]
+        ::Playwright.create(playwright_cli_executable_path: "./node_modules/.bin/playwright") do |playwright|
+          playwright.chromium.launch(headless: false, &block)
+        end
+      else
+        server_url = Upright.configuration.playwright_server_url ||
+                     Rails.application.config_for(:playwright).fetch(:server_url)
+        ::Playwright.connect_to_browser_server(server_url, &block)
+      end
+    end
+
+    def with_context(browser, **options, &block)
+      self.context = create_context(browser, **options)
+      self.page = context.new_page
+      run_callbacks :page_ready
+      yield
+    ensure
+      page&.close
+      context&.close
+      run_callbacks :page_close
+    end
+
+    def create_context(browser, **options)
+      authenticated_context(browser, options) || browser.new_context(userAgent: user_agent, **options)
+    end
+end

data/app/models/concerns/upright/playwright/logging.rb

@@ -0,0 +1,87 @@
+module Upright::Playwright::Logging
+  extend ActiveSupport::Concern
+
+  included do
+    attr_reader :log_lines
+
+    set_callback :perform_check, :before, :start_resource_logging
+    set_callback :perform_check, :after, :log_performance_metrics
+  end
+
+  def start_resource_logging
+    @log_lines = []
+
+    # Use structured logging if available, otherwise just log normally
+    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", "x-ratelimit-limit", "x-ratelimit-remaining").compact.map { |k, v| "#{k}=#{v}" }.join(" ")
+    "#{response.status} #{response.request.resource_type.upcase} #{response.url} #{headers}".strip.tap do |line|
+      log_lines << line
+      Rails.logger.info line
+    end
+  end
+
+  def log_performance_metrics
+    current_site = Upright.current_site
+
+    log_metrics url: page.url,
+      total_resource_bytes: fetch_total_resource_bytes,
+      total_load_ms: fetch_total_load_ms,
+      site_code: current_site.code,
+      site_city: current_site.city,
+      site_country: current_site.country,
+      site_geohash: current_site.geohash
+  end
+
+  def log_metrics(**metrics)
+    if logger.respond_to?(:struct)
+      logger.struct probe: metrics
+    else
+      logger.info metrics.to_json
+    end
+  end
+
+  def fetch_total_resource_bytes
+    page.evaluate <<~JS
+      performance.getEntriesByType("resource").reduce((size, item) => {
+        size += item.decodedBodySize;
+        return size;
+      }, 0);
+    JS
+  end
+
+  def fetch_total_load_ms
+    page.evaluate <<~JS
+      const perfEntries = performance.getEntriesByType("navigation")
+      perfEntries[0].loadEventEnd - perfEntries[0].startTime;
+    JS
+  end
+
+  def attach_log(probe_result)
+    if log_lines&.any?
+      Upright::Artifact.new(name: "#{probe_name}.log", content: log_lines.join("\n")).attach_to(probe_result, timestamped: true)
+    end
+  end
+
+  private
+    SKIP_URL_PATTERNS = %w[ image asset avatar ]
+
+    def skip_logging?(response)
+      SKIP_URL_PATTERNS.any? { |skip_pattern| response.url.include?(skip_pattern) }
+    end
+end