upright 0.1.0

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

@@ -0,0 +1,137 @@
+module Upright::Playwright::OtelTracing
+  extend ActiveSupport::Concern
+
+  included do
+    set_callback :perform_check, :around, :with_resource_tracing
+  end
+
+  def with_resource_tracing(&block)
+    return block.call unless defined?(OpenTelemetry)
+
+    collected_responses = []
+
+    page.on("response", ->(response) {
+      unless skip_span?(response)
+        collected_responses << response
+      end
+    })
+
+    trace_check_with_responses(collected_responses, &block)
+  end
+
+  private
+    SKIP_URL_PATTERNS = %w[ image asset avatar ]
+
+    def tracer
+      @tracer ||= OpenTelemetry.tracer_provider.tracer(
+        Upright.configuration.service_name,
+        Upright::VERSION
+      )
+    end
+
+    def skip_span?(response)
+      SKIP_URL_PATTERNS.any? { |skip_pattern| response.url.include?(skip_pattern) || response.request.resource_type == skip_pattern }
+    end
+
+    def trace_check_with_responses(collected_responses, &block)
+      tracer.in_span(:probe, attributes: root_span_attributes) do |span|
+        result = block.call
+        create_response_spans_for(collected_responses)
+        result
+      end
+    end
+
+    def root_span_attributes
+      {
+        "probe.name" => self.class.name
+      }
+    end
+
+    def create_response_spans_for(collected_responses)
+      collected_responses.each do |response|
+        create_response_span(response)
+      end
+    end
+
+    def create_response_span(response)
+      span_time_range = calculate_span_timestamps(response.request.timing)
+      span_name = "#{response.request.resource_type} #{extract_path(response.url)}"
+
+      span = tracer.start_span(
+        span_name,
+        kind: :client,
+        start_timestamp: span_time_range.begin,
+        attributes: response_span_attributes(response)
+      )
+
+      span.status = map_http_status_to_otel(response.status)
+      span.set_attribute("error", true) if response.status >= 400
+      add_browser_performance_metrics_to_span(span) if response.request.resource_type == "document"
+      span.finish(end_timestamp: span_time_range.end)
+    end
+
+    def calculate_span_timestamps(timing)
+      start_timestamp_seconds = timing[:startTime] / 1000.0
+      end_timestamp_seconds = (timing[:startTime] + timing[:responseEnd]) / 1000.0
+      start_timestamp_seconds..end_timestamp_seconds
+    end
+
+    def extract_path(url)
+      uri = URI.parse(url)
+      path = uri.path.presence || "/"
+      path += "?#{uri.query}" if uri.query.present?
+      path
+    end
+
+    def response_span_attributes(response)
+      {
+        "http.url" => response.url,
+        "http.status_code" => response.status,
+        "http.resource_type" => response.request.resource_type,
+        "http.timing.time_to_first_byte" => calculate_time_to_first_byte(response.request.timing),
+        "http.timing.total" => calculate_total_time(response.request.timing),
+        "http.request.size" => response.request.sizes[:requestBodySize],
+        "http.response.size" => response.request.sizes[:responseBodySize],
+        "http.response.header.x_runtime" => response.headers["x-runtime"].to_f,
+        "http.response.header.x_request_id" => response.headers["x-request-id"],
+        "http.response.header.server_timing" => response.headers["server-timing"]
+      }.compact
+    end
+
+    def calculate_time_to_first_byte(timing)
+      (timing[:responseStart] - timing[:requestStart]).round(2)
+    end
+
+    def calculate_total_time(timing)
+      (timing[:responseEnd] - timing[:requestStart]).round(2)
+    end
+
+    def map_http_status_to_otel(http_status)
+      case http_status
+      when 200..299
+        OpenTelemetry::Trace::Status.ok
+      when 400..599
+        OpenTelemetry::Trace::Status.error("HTTP #{http_status}")
+      else
+        OpenTelemetry::Trace::Status.unset
+      end
+    end
+
+    def add_browser_performance_metrics_to_span(span)
+      metrics = collect_browser_performance_metrics
+
+      metrics.each do |key, value|
+        span.set_attribute("browser.performance.#{key}", value) if value
+      end
+    end
+
+    def collect_browser_performance_metrics
+      page.evaluate(performance_metrics_script)
+    end
+
+    def performance_metrics_script
+      @performance_metrics_script ||= File.read(
+        Upright::Engine.root.join("lib", "upright", "playwright", "collect_performance_metrics.js")
+      )
+    end
+end

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

@@ -0,0 +1,60 @@
+module Upright::Playwright::VideoRecording
+  extend ActiveSupport::Concern
+
+  VIDEO_SIZE = { width: 1280, height: 720 }
+
+  included do
+    attr_accessor :video_path, :video_object
+
+    set_callback :page_ready, :after, :capture_video_reference
+    set_callback :page_close, :after, :finalize_video
+  end
+
+  private
+    def video_dir
+      Upright.configuration.video_storage_dir
+    end
+
+    def finalize_video
+      save_video
+    end
+
+    def video_recording_options
+      if record_video?
+        FileUtils.mkdir_p(video_dir)
+        { record_video_dir: video_dir.to_s, record_video_size: VIDEO_SIZE }
+      else
+        {}
+      end
+    end
+
+    def record_video?
+      !Rails.env.test?
+    end
+
+    def capture_video_reference
+      self.video_object = page.video if record_video?
+    end
+
+    def save_video
+      if video_object
+        self.video_path = video_dir.join("#{SecureRandom.hex}.webm").to_s
+        video_object.save_as(video_path)
+      end
+    end
+
+    def attach_video(probe_result)
+      if video_path
+        File.open(video_path, "rb") do |file|
+          Upright::Artifact.new(name: "#{probe_name}.webm", content: file).attach_to(probe_result, timestamped: true)
+        end
+
+        if logger.respond_to?(:struct) && probe_result.artifacts.any?
+          logger.struct probe_artifact_url: Rails.application.routes.url_helpers.rails_blob_url(probe_result.artifacts.first, expires_in: 24.hours)
+        end
+
+        FileUtils.rm(video_path)
+        self.video_path = nil
+      end
+    end
+end

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

@@ -0,0 +1,10 @@
+module Upright::ProbeYamlSource
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def file_path
+      filename = name.demodulize.underscore.pluralize
+      Upright.configuration.probes_path.join("#{filename}.yml").to_s
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Upright::Probeable
+  extend ActiveSupport::Concern
+  include Upright::Staggerable
+
+  TYPES = %w[ http playwright smtp traceroute ]
+
+  included do
+    attr_writer :logger
+
+    def logger
+      @logger || Rails.logger
+    end
+  end
+
+  class_methods do
+    def check_and_record_all_later
+      all.each(&:check_and_record_later)
+    end
+  end
+
+  def perform_check
+    # Overridden in subclasses that need setup around the actual check
+    check
+  end
+
+  def check_and_record_later
+    Upright::ProbeCheckJob.set(wait: self.class.stagger_delay).perform_later(self.class.name, name)
+  end
+
+  def check_and_record
+    result = failsafe_check
+
+    Upright::ProbeResult.create!(
+      probe_type: probe_type,
+      probe_name: probe_name,
+      probe_target: probe_target,
+      probe_service: probe_service,
+      status: result[:status],
+      duration: result[:duration],
+      error: result[:error]
+    ).tap do |probe_result|
+      on_check_recorded(probe_result)
+    end
+  end
+
+  def probe_name
+    try(:name) || self.class.name.demodulize.underscore.delete_suffix("_probe")
+  end
+
+  def probe_type
+    raise NotImplementedError
+  end
+
+  def probe_target
+    raise NotImplementedError
+  end
+
+  def on_check_recorded(probe_result)
+    raise NotImplementedError
+  end
+
+  def probe_service
+    nil
+  end
+
+  private
+    def failsafe_check
+      result, error, duration = nil
+
+      result, duration = measure { perform_check }
+    rescue => error
+      Rails.error.report(error)
+      raise error if Rails.env.development?
+    ensure
+      log_probe_result(result:, error:, duration:)
+
+      return { status: result_description(result, error), duration:, error: }
+    end
+
+    def result_description(result, error = nil)
+      if error || !result
+        :fail
+      else
+        :ok
+      end
+    end
+
+    def measure
+      start_time = monotonic_now
+      result = yield
+      [ result, monotonic_now - start_time ]
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def log_probe_result(result:, error:, duration:)
+      current_site = Upright.current_site
+
+      log_data = {
+        probe: {
+          name: probe_name,
+          target: probe_target,
+          service: probe_service,
+          type: probe_type,
+          result: result_description(result, error),
+          duration: duration,
+          site_code: current_site.code,
+          site_city: current_site.city,
+          site_country: current_site.country,
+          site_geohash: current_site.geohash,
+          site_provider: current_site.provider,
+          error_class: (error.class.name if error),
+          error_message: (error.message if error)
+        }.compact
+      }
+
+      if logger.respond_to?(:struct)
+        logger.struct(**log_data)
+      else
+        logger.info(log_data.to_json)
+      end
+    end
+end

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

@@ -0,0 +1,22 @@
+module Upright::Staggerable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def stagger_by_site(interval)
+      self.stagger_interval = interval
+    end
+
+    def stagger_delay
+      if stagger_interval
+        current_site = Upright.current_site
+        stagger_interval * current_site.stagger_index
+      else
+        0.seconds
+      end
+    end
+  end
+
+  included do
+    class_attribute :stagger_interval, default: nil
+  end
+end

data/app/models/concerns/upright/traceroute/otel_tracing.rb

@@ -0,0 +1,108 @@
+module Upright::Traceroute::OtelTracing
+  extend ActiveSupport::Concern
+
+  private
+    def tracer
+      @tracer ||= OpenTelemetry.tracer_provider.tracer("upright.traceroute", "1.0.0")
+    end
+
+    def trace_result(result)
+      tracer.in_span(root_span_name, attributes: root_span_attributes) do |root_span|
+        logger.struct probe_trace_id: root_span.context.hex_trace_id if logger.respond_to?(:struct)
+
+        result.hops.each_with_index do |hop, index|
+          previous_hop = index > 0 ? result.hops[index - 1] : nil
+          create_hop_span(hop, previous_hop)
+        end
+
+        root_span.status = if result.reached_destination?
+          success_status
+        else
+          error_status("Failed to reach destination")
+        end
+      end
+    end
+
+    def create_hop_span(hop, previous_hop)
+      previous_rtt_ms = previous_hop&.avg_ms.to_i
+      current_rtt_ms = hop.avg_ms.to_i
+      duration_ms = [ current_rtt_ms - previous_rtt_ms, 0 ].max
+
+      tracer.in_span(hop.display_name, attributes: hop_span_attributes(hop, previous_hop)) do |span|
+        span.status = hop_status(hop)
+        sleep(duration_ms / 1000.0)
+      end
+    end
+
+    def root_span_name
+      "traceroute #{host}"
+    end
+
+    def hop_status(hop)
+      if !hop.responded?
+        error_status("No response")
+      elsif hop.high_packet_loss?
+        error_status("High packet loss: #{hop.loss_percent}%")
+      elsif hop.any_packet_loss?
+        success_status("Packet loss: #{hop.loss_percent}%")
+      else
+        success_status
+      end
+    end
+
+    def success_status(message = nil)
+      if message
+        OpenTelemetry::Trace::Status.ok(message)
+      else
+        OpenTelemetry::Trace::Status.ok
+      end
+    end
+
+    def error_status(message)
+      OpenTelemetry::Trace::Status.error(message)
+    end
+
+    def root_span_attributes
+      site = Upright.current_site
+      {
+        "traceroute.target" => host,
+        "traceroute.max_hops" => self.class::MAX_HOPS,
+        "traceroute.probe_count" => self.class::PROBE_COUNT,
+        "upright.probe.name" => probe_name,
+        "upright.probe.type" => probe_type,
+        "upright.site.code" => site.code.to_s,
+        "upright.site.city" => site.city.to_s,
+        "upright.site.country" => site.country.to_s,
+        "upright.site.geohash" => site.geohash.to_s,
+        "upright.site.provider" => site.provider.to_s
+      }.compact_blank
+    end
+
+    def hop_span_attributes(hop, previous_hop)
+      {
+        "traceroute.hop.number" => hop.number,
+        "traceroute.hop.ip" => hop.ip,
+        "traceroute.hop.hostname" => hop.hostname,
+        "traceroute.hop.as" => hop.as,
+        "traceroute.hop.isp" => hop.isp,
+        "traceroute.hop.city" => hop.city,
+        "traceroute.hop.country" => hop.country,
+        "traceroute.hop.country_code" => hop.country_code,
+        "traceroute.hop.geohash" => hop.geohash,
+        "traceroute.hop.loss_percent" => hop.loss_percent,
+        "traceroute.hop.rtt_last_ms" => hop.last_ms,
+        "traceroute.hop.rtt_avg_ms" => hop.avg_ms,
+        "traceroute.hop.rtt_best_ms" => hop.best_ms,
+        "traceroute.hop.rtt_worst_ms" => hop.worst_ms,
+        "traceroute.hop.rtt_stddev_ms" => hop.stddev_ms,
+        "traceroute.hop.previous_ip" => previous_hop&.ip,
+        "traceroute.hop.previous_isp" => previous_hop&.isp,
+        "traceroute.hop.rtt_delta_ms" => rtt_delta_ms(hop, previous_hop)
+      }.compact
+    end
+
+    def rtt_delta_ms(hop, previous_hop)
+      delta = hop.avg_ms.to_i - previous_hop&.avg_ms.to_i
+      [ delta, 0 ].max
+    end
+end

data/app/models/upright/application_record.rb

@@ -0,0 +1,3 @@
+class Upright::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/upright/artifact.rb

@@ -0,0 +1,61 @@
+class Upright::Artifact
+  ICONS = {
+    "webm" => "video",
+    "log"  => "log",
+    "json" => "download",
+    "html" => "download",
+    "xml"  => "download",
+    "txt"  => "download",
+    "bin"  => "download"
+  }.freeze
+
+  attr_reader :filename, :content
+
+  def initialize(name:, content:)
+    @filename = name
+    @content = content
+  end
+
+  def extension
+    File.extname(filename).delete_prefix(".")
+  end
+
+  def basename
+    File.basename(filename, ".*")
+  end
+
+  def timestamped_filename
+    current_site = Upright.current_site
+    [ Time.current.to_fs(:number), current_site.code, safe_name ].join("_") + ".#{extension}"
+  end
+
+  def content_type
+    Marcel::MimeType.for(extension: extension)
+  end
+
+  def icon
+    ICONS.fetch(extension, "attachment")
+  end
+
+  def attach_to(probe_result, timestamped: false)
+    probe_result.artifacts.attach(
+      io: to_io,
+      filename: timestamped ? timestamped_filename : filename,
+      content_type: content_type
+    )
+  end
+
+  private
+    def to_io
+      case content
+      when StringIO, File, IO
+        content.tap(&:rewind)
+      else
+        StringIO.new(content.to_s)
+      end
+    end
+
+    def safe_name
+      basename.parameterize(separator: "_")
+    end
+end

data/app/models/upright/current.rb

@@ -0,0 +1,9 @@
+class Upright::Current < ActiveSupport::CurrentAttributes
+  attribute :user
+  attribute :subdomain
+  attribute :site
+
+  def site
+    super || Upright.current_site
+  end
+end

data/app/models/upright/http/request.rb

@@ -0,0 +1,59 @@
+class Upright::HTTP::Request
+  attr_reader :url, :options
+
+  def initialize(url, **options)
+    @url = url
+    @options = options
+  end
+
+  def get
+    response = Typhoeus.get(url, request_options)
+    Upright::HTTP::Response.new(response, build_log(response))
+  end
+
+  private
+    def request_options
+      current_site = Upright.current_site
+
+      {
+        timeout: current_site.default_timeout,
+        connecttimeout: current_site.default_timeout,
+        headers: request_headers,
+        userpwd: userpwd,
+        proxy: proxy_url,
+        proxyuserpwd: proxy_userpwd,
+        verbose: true,
+        forbid_reuse: true
+      }.compact
+    end
+
+    def request_headers
+      { "User-Agent" => Upright.configuration.user_agent }
+    end
+
+    def userpwd
+      if options[:username] && options[:password]
+        "#{options[:username]}:#{options[:password]}"
+      end
+    end
+
+    def proxy_url
+      options[:proxy]
+    end
+
+    def proxy_userpwd
+      if options[:proxy_username] && options[:proxy_password]
+        "#{options[:proxy_username]}:#{options[:proxy_password]}"
+      end
+    end
+
+    def build_log(response)
+      StringIO.new.tap do |log|
+        if response.debug_info
+          response.debug_info.text.each { |msg| log.puts "* #{msg.chomp}" }
+          response.debug_info.header_out.each { |msg| log.puts "> #{msg.chomp}" }
+          response.debug_info.header_in.each { |msg| log.puts "< #{msg.chomp}" }
+        end
+      end
+    end
+end

data/app/models/upright/http/response.rb

@@ -0,0 +1,55 @@
+class Upright::HTTP::Response
+  def initialize(typhoeus_response, log)
+    @typhoeus_response = typhoeus_response
+    @log = log
+  end
+
+  def status
+    typhoeus_response.code
+  end
+
+  def body
+    typhoeus_response.body
+  end
+
+  def status_in?(range)
+    status.in?(range)
+  end
+
+  def network_error?
+    timed_out? || connection_failed? || ssl_error?
+  end
+
+  def content_type
+    typhoeus_response.headers&.[]("content-type") || "application/octet-stream"
+  end
+
+  def file_extension
+    case content_type
+    when /json/ then "json"
+    when /html/ then "html"
+    when /xml/  then "xml"
+    when /text/ then "txt"
+    else "bin"
+    end
+  end
+
+  def verbose_log_content
+    @log.tap(&:rewind).read
+  end
+
+  private
+    attr_reader :typhoeus_response
+
+    def timed_out?
+      typhoeus_response.timed_out?
+    end
+
+    def connection_failed?
+      typhoeus_response.return_code == :couldnt_connect
+    end
+
+    def ssl_error?
+      typhoeus_response.return_code.to_s.start_with?("ssl")
+    end
+end