visionary-sdk 0.4.0

data/lib/visionary/store/sql.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Visionary
+  module Store
+    class ConfigError < StandardError; end
+
+    # A connection the SDK opens itself from VISIONARY_DATABASE_URL, through
+    # the pg, mysql2 or sqlite3 gem (whichever the app has installed). One
+    # connection, used by one background thread at a time, reopened after an
+    # error.
+    class SQL
+      attr_reader :dialect
+
+      def initialize(dialect, &connect)
+        @dialect = dialect
+        @connect = connect
+        @mutex = Mutex.new
+        @conn = nil
+      end
+
+      def string_params? = false
+
+      def exec_script(statements)
+        statements.each do |s|
+          run { |c| c.execute(s, []) }
+        rescue StandardError => e
+          next if dialect == "mysql" && Store.duplicate_index?(e)
+          raise
+        end
+      end
+
+      def exec(sql)
+        run { |c| c.execute(sql, []) }
+      end
+
+      def column_names(sql)
+        run { |c| c.column(sql) }
+      end
+
+      # One transaction for the whole batch.
+      def batch(stmts)
+        run do |c|
+          c.execute("BEGIN", [])
+          begin
+            stmts.each { |sql, args| c.execute(sql, args) }
+            c.execute("COMMIT", [])
+          rescue StandardError
+            begin
+              c.execute("ROLLBACK", [])
+            rescue StandardError
+              nil
+            end
+            raise
+          end
+        end
+      end
+
+      def changes(sql, args)
+        run { |c| c.execute(sql, args) }
+      end
+
+      # The parent's connection (a socket) must not be used or closed from
+      # the child: it is kept referenced (so no finalizer closes it) and a new
+      # one is opened lazily.
+      def after_fork
+        @mutex = Mutex.new
+        (@inherited ||= []) << @conn if @conn
+        @conn = nil
+      end
+
+      def close
+        @mutex.synchronize { discard }
+      end
+
+      private
+
+      def run
+        @mutex.synchronize do
+          @conn ||= @connect.call
+          yield @conn
+        rescue StandardError
+          discard if @conn&.broken?
+          raise
+        end
+      end
+
+      def discard
+        @conn&.close
+      rescue StandardError
+        nil
+      ensure
+        @conn = nil
+      end
+    end
+
+    # MySQL has no CREATE INDEX IF NOT EXISTS; an existing index is fine.
+    def self.duplicate_index?(error)
+      (error.respond_to?(:error_number) && error.error_number == 1061) ||
+        error.message.match?(/1061|Duplicate key name/i)
+    end
+
+    # Turns "?" into "$1, $2, ..." for PostgreSQL, leaving quoted text alone.
+    def self.rebind(sql)
+      return sql unless sql.include?("?")
+      n = 0
+      quote = nil
+      out = +""
+      sql.each_char do |ch|
+        if quote
+          quote = nil if ch == quote
+        elsif ch == "'" || ch == '"'
+          quote = ch
+        elsif ch == "?"
+          n += 1
+          out << "$" << n.to_s
+          next
+        end
+        out << ch
+      end
+      out
+    end
+
+    # Opens the store for a database URL: postgres://, postgresql://,
+    # mysql://, sqlite:///absolute/path.db or sqlite://relative.db.
+    def self.open_url(raw)
+      u = URI.parse(raw)
+      case u.scheme.to_s.downcase
+      when "postgres", "postgresql"
+        driver("pg", "postgres")
+        SQL.new("postgres") { PgConn.new(PG.connect(raw).tap { |c| c.set_notice_processor { nil } }) }
+      when "mysql", "mysql2"
+        driver("mysql2", "mysql")
+        SQL.new("mysql") { Mysql2Conn.new(Mysql2Conn.client(u)) }
+      when "sqlite", "sqlite3"
+        driver("sqlite3", "sqlite")
+        path = sqlite_path(raw, u.scheme)
+        SQL.new("sqlite") { Sqlite3Conn.new(path) }
+      else
+        raise ConfigError, "visionary: unsupported database URL scheme #{u.scheme.inspect}"
+      end
+    rescue URI::InvalidURIError => e
+      raise ConfigError, "visionary: database URL: #{e.message}"
+    end
+
+    def self.sqlite_path(raw, scheme)
+      rest = raw.sub(%r{\A#{Regexp.escape(scheme)}://}i, "").sub(%r{\A/}, "")
+      rest = "/#{rest}" if raw.match?(%r{\A#{Regexp.escape(scheme)}:///}i) && !rest.include?(":")
+      URI.decode_www_form_component(rest.sub(/\?.*\z/, ""))
+    end
+
+    def self.driver(gem_name, dialect)
+      require gem_name
+    rescue LoadError
+      raise ConfigError, "visionary: #{dialect} needs the #{gem_name} gem (add it to your Gemfile)"
+    end
+
+    # Thin driver adapters: execute returns affected rows, column returns the
+    # first column of every row.
+    class PgConn
+      def initialize(conn)
+        @conn = conn
+      end
+
+      def execute(sql, args)
+        res = @conn.exec_params(Store.rebind(sql), args.map { |a| pg_param(a) })
+        res.cmd_tuples
+      ensure
+        res&.clear
+      end
+
+      def column(sql)
+        res = @conn.exec(sql)
+        res.column_values(0).map(&:to_s)
+      ensure
+        res&.clear
+      end
+
+      def broken?
+        @conn.finished? || @conn.status != PG::CONNECTION_OK
+      rescue StandardError
+        true
+      end
+
+      def close
+        @conn.close unless @conn.finished?
+      end
+
+      private
+
+      # Text params; PostgreSQL types them from the target column. NUL is
+      # the one character text columns reject.
+      def pg_param(v)
+        case v
+        when nil then nil
+        when Float then D1.param(v)
+        when String then v.include?("\0") ? v.delete("\0") : v
+        else v.to_s
+        end
+      end
+    end
+
+    class Mysql2Conn
+      def self.client(u)
+        q = URI.decode_www_form(u.query.to_s).to_h
+        Mysql2::Client.new(
+          host: u.host || "localhost", port: u.port || 3306,
+          username: u.user && URI.decode_www_form_component(u.user),
+          password: u.password && URI.decode_www_form_component(u.password),
+          database: u.path.to_s.delete_prefix("/"),
+          encoding: q.fetch("encoding", "utf8mb4"),
+          connect_timeout: 10, read_timeout: 30, write_timeout: 30
+        )
+      end
+
+      def initialize(client)
+        @client = client
+        @stmts = {}
+      end
+
+      def execute(sql, args)
+        return @client.query(sql).then { @client.affected_rows } if args.empty?
+
+        stmt = (@stmts[sql] ||= @client.prepare(sql))
+        stmt.execute(*args)
+        stmt.affected_rows
+      end
+
+      def column(sql)
+        @client.query(sql, as: :array).map { |r| r[0].to_s }
+      end
+
+      def broken?
+        !@client.ping
+      rescue StandardError
+        true
+      end
+
+      def close
+        @stmts.each_value do |s|
+          s.close
+        rescue StandardError
+          nil
+        end
+        @client.close
+      end
+    end
+
+    class Sqlite3Conn
+      def initialize(path)
+        @db = SQLite3::Database.new(path)
+        @db.busy_timeout = 5000
+      end
+
+      def execute(sql, args)
+        @db.execute(sql, args)
+        @db.changes
+      end
+
+      def column(sql)
+        @db.execute(sql).map { |r| r[0].to_s }
+      end
+
+      def broken? = @db.closed?
+
+      def close
+        @db.close unless @db.closed?
+      end
+    end
+  end
+end

data/lib/visionary/store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "store/sql"
+require_relative "store/d1"
+require_relative "store/active_record"
+
+module Visionary
+  # Where rows go: D1 over REST, a connection opened from a database URL, or
+  # the app's ActiveRecord pool. Every store answers the same calls:
+  # exec_script, exec, column_names, batch([[sql, args], ...]), changes,
+  # after_fork and close.
+  module Store
+    # Picks the store from the config, or nil when none is configured.
+    def self.open(cfg)
+      return ActiveRecord.new(cfg.connection) if cfg.connection
+
+      url = cfg.database_url.to_s.strip
+      return open_url(url) unless url.empty? || url.downcase.start_with?("d1:")
+
+      creds = [cfg.d1_account_id, cfg.d1_database_id, cfg.d1_api_token].map { |v| v.to_s.strip }
+      return nil if creds.any?(&:empty?)
+
+      D1.new(account_id: creds[0], database_id: creds[1], api_token: creds[2], api_base: cfg.d1_api_base.to_s)
+    end
+
+    # Makes values acceptable to the backend: PostgreSQL text rejects NUL,
+    # and strict MySQL rejects values longer than the column.
+    def self.fit(dialect, table, values)
+      case dialect
+      when "postgres"
+        values.map { |v| v.is_a?(String) && v.include?("\0") ? v.delete("\0") : v }
+      when "mysql"
+        limits = Schema.mysql_limits[table] || {}
+        Schema::TABLES.fetch(table).each_with_index.map do |col, i|
+          v = values[i]
+          (lim = limits[col]) && v.is_a?(String) ? cut(v, *lim) : v
+        end
+      else
+        values
+      end
+    end
+
+    def self.cut(s, unit, max)
+      if unit == :chars
+        s.length > max ? s[0, max] : s
+      elsif s.bytesize > max
+        s.byteslice(0, max).scrub("")
+      else
+        s
+      end
+    end
+  end
+end

data/lib/visionary/system/recorder.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+module Visionary
+  module System
+    # Throughput seen by the middleware, read by the sampler.
+    class HttpCounters
+      def initialize
+        @mutex = Mutex.new
+        @requests = @errors = @in_flight = 0
+      end
+
+      def started
+        @mutex.synchronize { @in_flight += 1 }
+      end
+
+      def finished(status)
+        @mutex.synchronize do
+          @in_flight -= 1
+          @requests += 1
+          @errors += 1 if status >= 500
+        end
+      end
+
+      def snapshot = @mutex.synchronize { [@requests, @errors, @in_flight] }
+    end
+
+    # Samples host, process and runtime figures every interval on a
+    # background thread and writes them four at a time.
+    class Recorder
+      SAMPLES_PER_WRITE = 4
+      MB = 1024.0 * 1024
+
+      def initialize(cfg, instance, store, schemas, http, logger)
+        @cfg = cfg
+        @interval = cfg.system_interval.to_f
+        @instance = instance
+        @store = store
+        @schemas = schemas
+        @http = http
+        @logger = logger
+        @disk_path = cfg.disk_path.to_s.empty? ? Dir.pwd : cfg.disk_path
+        @sql = Schema.insert_sql("system_metrics", store.string_params?)
+        @started = mono
+        reset
+      end
+
+      attr_writer :http
+
+      def start
+        prime
+        @thread = Thread.new { run }
+        @thread.name = "visionary-system" if @thread.respond_to?(:name=)
+        self
+      end
+
+      def after_fork
+        reset
+        start
+      end
+
+      def close(timeout)
+        @mutex.synchronize do
+          @stopped = true
+          @cond.broadcast
+        end
+        @thread.nil? || !@thread.join(timeout).nil?
+      end
+
+      # One row in Schema::TABLES["system_metrics"] order. A source that
+      # fails or doesn't exist here is NULL, never an error.
+      def sample
+        now = mono
+        secs = now - @last
+        @last = now
+        secs = @interval if secs <= 0
+        v = { "created_at" => Visionary.timestamp(Time.now), "instance" => @instance, "interval_s" => secs.round(2) }
+        stat = Sources::LINUX ? Sources.proc_stat : {}
+        tcp = Sources::LINUX ? Sources.tcp : {}
+
+        host(v, stat, secs)
+        process(v)
+        runtime(v, secs)
+        db(v)
+        throughput(v, secs, now)
+        node_gauges(v, stat, tcp)
+        counters = read_counters(stat, tcp)
+        node_deltas(v, counters, @prev, secs)
+        @prev = counters
+        v["service"] = @cfg.service
+        v["version"] = @cfg.version
+        v["sdk"] = "ruby"
+        v["runtime"] = Telemetry.runtime
+        Schema::TABLES["system_metrics"].map { |c| v[c] }
+      end
+
+      private
+
+      def reset
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @stopped = false
+        @thread = nil
+        @buf = []
+      end
+
+      def mono = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Baseline readings so the first sample has real deltas.
+      def prime
+        @last = mono
+        @requests, @errors, = @http.snapshot
+        stat = Sources::LINUX ? Sources.proc_stat : {}
+        @cpu_prev = stat[:cpu]
+        @net_prev = Sources.net_dev
+        @proc_cpu_prev = Sources.process_cpu_seconds
+        @proc_cpu_at = mono
+        heap = Sources.heap
+        @gc_count_prev = heap[:gc_count]
+        @gc_ms_prev = heap[:gc_ms]
+        @db_prev = db_stats || {}
+        @prev = read_counters(stat, Sources::LINUX ? Sources.tcp : {})
+      end
+
+      def run
+        Telemetry.internal!
+        @schemas.ensure(:system)
+        next_at = mono + @interval
+        loop do
+          break if wait_until(next_at)
+          next_at += @interval
+          next_at = mono + @interval if next_at < mono # fell behind (suspended host); don't burst
+          begin
+            @buf << sample
+          rescue StandardError => e
+            @logger.error("visionary: system sample failed: #{e.class}: #{e.message}")
+          end
+          flush if @buf.size >= SAMPLES_PER_WRITE
+        end
+        flush
+      rescue StandardError => e
+        @logger.error("visionary: system sampler stopped: #{e.message}")
+      end
+
+      # True once stopped.
+      def wait_until(at)
+        @mutex.synchronize do
+          until @stopped || (left = at - mono) <= 0
+            @cond.wait(@mutex, left)
+          end
+          @stopped
+        end
+      end
+
+      # Keeps the rows (at most an hour's worth) when the write fails.
+      def flush
+        return if @buf.empty?
+        @schemas.ensure(:system)
+        begin
+          @store.batch(@buf.map { |row| [@sql, Store.fit(@store.dialect, "system_metrics", row)] })
+          @buf.clear
+        rescue StandardError => e
+          @logger.warn("visionary: system metrics write failed (#{@buf.size} rows kept): #{e.message}")
+          keep = [1, (3600 / @interval).to_i].max
+          @buf.shift(@buf.size - keep) if @buf.size > keep
+        end
+      end
+
+      def host(v, stat, secs)
+        if (cpu = stat[:cpu]) && @cpu_prev
+          total = cpu_total(cpu) - cpu_total(@cpu_prev)
+          if total.positive?
+            idle = (cpu[:idle].to_f + cpu[:iowait].to_f) - (@cpu_prev[:idle].to_f + @cpu_prev[:iowait].to_f)
+            v["host_cpu_percent"] = (100.0 * (total - idle) / total).clamp(0, 100).round(1)
+          end
+        end
+        @cpu_prev = stat[:cpu]
+        if (load = Sources::LINUX && Sources.loadavg)
+          v["load_1"], v["load_5"], v["load_15"] = load.map { |x| x.round(2) }
+        end
+        mem = Sources::LINUX ? Sources.meminfo : {}
+        if (total = mem["MemTotal"]).to_i.positive?
+          cached = mem["Cached"].to_i + mem["SReclaimable"].to_i
+          # psutil's definition: used is what isn't available.
+          available = mem["MemAvailable"] || (mem["MemFree"].to_i + mem["Buffers"].to_i + cached)
+          used = total - available
+          v["host_mem_used_mb"] = (used / MB).round(1)
+          v["host_mem_total_mb"] = (total / MB).round(1)
+          v["host_mem_percent"] = (100.0 * used / total).round(1)
+          v["host_mem_available_mb"] = (mem["MemAvailable"] / MB).round(1) if mem["MemAvailable"]
+          v["host_mem_cached_mb"] = (cached / MB).round(1) if cached.positive?
+          if mem["SwapTotal"]
+            v["swap_total_mb"] = (mem["SwapTotal"] / MB).round(1)
+            v["swap_used_mb"] = ((mem["SwapTotal"] - mem["SwapFree"].to_i) / MB).round(1)
+          end
+        end
+        if (du = Sources.disk(@disk_path)) && du[:total].positive?
+          v["disk_used_percent"] = (100.0 * du[:used] / (du[:used] + du[:free])).round(1)
+          v["disk_free_gb"] = (du[:free] / (MB * 1024)).round(2)
+          v["disk_total_gb"] = (du[:total] / (MB * 1024)).round(2)
+          v["disk_inodes_percent"] = du[:inodes_percent].round(1) if du[:inodes_percent]
+        end
+        net = Sources.net_dev
+        if net && @net_prev && net[0] >= @net_prev[0] && net[1] >= @net_prev[1]
+          v["net_rx_kbps"] = ((net[0] - @net_prev[0]) / 1024.0 / secs).round(1)
+          v["net_tx_kbps"] = ((net[1] - @net_prev[1]) / 1024.0 / secs).round(1)
+        end
+        @net_prev = net
+      end
+
+      def process(v)
+        cpu = Sources.process_cpu_seconds
+        # Timed on its own: under GVL contention the readers before this can
+        # take seconds, which would skew a share of the sample's interval.
+        at = mono
+        v["proc_cpu_percent"] = (100.0 * (cpu - @proc_cpu_prev) / (at - @proc_cpu_at)).round(1) if cpu && @proc_cpu_prev && at > @proc_cpu_at
+        @proc_cpu_prev = cpu
+        @proc_cpu_at = at
+        st = Sources::LINUX ? Sources.self_status : {}
+        v["proc_rss_mb"] = (st[:rss] / MB).round(1) if st[:rss]
+        v["proc_threads"] = st[:threads] || Thread.list.size
+        v["proc_open_fds"] = Sources.open_fds
+      end
+
+      def runtime(v, secs)
+        v["goroutines"] = Thread.list.count(&:alive?)
+        heap = Sources.heap
+        v["heap_alloc_mb"] = (heap[:alloc_bytes] / MB).round(1) if heap[:alloc_bytes]
+        v["heap_inuse_mb"] = (heap[:inuse_bytes] / MB).round(1) if heap[:inuse_bytes]
+        v["heap_objects"] = heap[:live]
+        v["gc_count"] = heap[:gc_count] - @gc_count_prev
+        if heap[:gc_ms] && @gc_ms_prev
+          ms = (heap[:gc_ms] - @gc_ms_prev).to_f
+          v["gc_pause_ms"] = ms.round(2)
+          v["gc_cpu_percent"] = (ms / (secs * 1000.0) * 100.0).round(2)
+        end
+        @gc_count_prev = heap[:gc_count]
+        @gc_ms_prev = heap[:gc_ms]
+      end
+
+      def db_stats
+        st = @cfg.db_stats ? Sources.quiet { @cfg.db_stats.call } : Sources.active_record_pool
+        st.is_a?(Hash) ? st.transform_keys(&:to_sym) : nil
+      end
+
+      def db(v)
+        st = db_stats or return
+        { total: "db_total_conns", idle: "db_idle_conns", in_use: "db_acquired_conns", max: "db_max_conns" }.each do |k, col|
+          v[col] = st[k].to_i unless st[k].nil?
+        end
+        { acquires: "db_acquires", empty_acquires: "db_empty_acquires" }.each do |k, col|
+          v[col] = st[k].to_i - @db_prev[k].to_i unless st[k].nil?
+        end
+        v["db_acquire_wait_ms"] = (st[:acquire_wait_ms].to_f - @db_prev[:acquire_wait_ms].to_f).round(1) unless st[:acquire_wait_ms].nil?
+        @db_prev = st
+      end
+
+      def throughput(v, secs, now)
+        reqs, errs, in_flight = @http.snapshot
+        d_reqs = reqs - @requests
+        v["http_requests"] = d_reqs
+        v["http_errors"] = errs - @errors
+        v["http_rps"] = (d_reqs / secs).round(2)
+        v["http_in_flight"] = in_flight
+        @requests = reqs
+        @errors = errs
+        v["uptime_s"] = (now - @started).to_i
+      end
+
+      def node_gauges(v, stat, tcp)
+        v["cpu_count"] = Sources.cpu_count
+        v["host_procs"] = Sources.host_procs
+        v["procs_running"] = stat[:procs_running]
+        v["procs_blocked"] = stat[:procs_blocked]
+        v["tcp_established"] = tcp["CurrEstab"]
+        v["proc_max_fds"] = Sources.max_fds
+      end
+
+      # Cumulative readings; a key is present only when its source worked.
+      def read_counters(stat, tcp)
+        c = {}
+        c[:cpu] = stat[:cpu] if stat[:cpu]
+        if Sources::LINUX && !(disks = Sources.diskstats).empty?
+          c[:disk] = (0..4).map { |i| disks.values.sum { |d| d[i] } } << disks.transform_values { |d| d[5] }
+        end
+        if (net = Sources.net_dev)
+          c[:net] = net[2, 4]
+        end
+        c[:tcp_retrans] = tcp["RetransSegs"] if tcp["RetransSegs"]
+        c[:ctxt] = stat[:ctxt] if stat[:ctxt]
+        if Sources::LINUX && (io = Sources.self_io)
+          c[:proc_io] = io
+        end
+        c
+      end
+
+      def node_deltas(v, now, prev, secs)
+        if now[:cpu] && prev[:cpu]
+          a = now[:cpu]
+          b = prev[:cpu]
+          total = cpu_total(a) - cpu_total(b)
+          if total.positive?
+            pct = ->(*f) { (100.0 * f.sum { |k| a[k].to_f - b[k].to_f } / total).round(1) }
+            v["cpu_user_percent"] = pct.call(:user, :nice)
+            v["cpu_system_percent"] = pct.call(:system, :irq, :softirq)
+            v["cpu_iowait_percent"] = pct.call(:iowait)
+            v["cpu_steal_percent"] = pct.call(:steal)
+          end
+        end
+        if now[:disk] && prev[:disk]
+          rb, wb, rc, wc, tm, busy = now[:disk]
+          prb, pwb, prc, pwc, ptm, pbusy = prev[:disk]
+          if rb >= prb && wb >= pwb
+            reads = rc - prc
+            writes = wc - pwc
+            v["disk_read_kbps"] = ((rb - prb) / 1024.0 / secs).round(1)
+            v["disk_write_kbps"] = ((wb - pwb) / 1024.0 / secs).round(1)
+            v["disk_read_iops"] = (reads / secs).round(1)
+            v["disk_write_iops"] = (writes / secs).round(1)
+            v["disk_await_ms"] = ((tm - ptm).to_f / (reads + writes)).round(2) if (reads + writes).positive? && tm >= ptm
+            busiest = busy.filter_map { |n, t| pbusy[n] && t >= pbusy[n] ? t - pbusy[n] : nil }.max || 0
+            v["disk_busy_percent"] = [100.0, 100.0 * busiest / (secs * 1000.0)].min.round(1) unless busy.empty?
+          end
+        end
+        if now[:net] && prev[:net]
+          rx, tx, errs, drops = now[:net]
+          prx, ptx, perrs, pdrops = prev[:net]
+          if rx >= prx && tx >= ptx
+            v["net_rx_pps"] = ((rx - prx) / secs).round(1)
+            v["net_tx_pps"] = ((tx - ptx) / secs).round(1)
+            v["net_errors"] = errs - perrs if errs >= perrs
+            v["net_drops"] = drops - pdrops if drops >= pdrops
+          end
+        end
+        if now[:tcp_retrans] && prev[:tcp_retrans] && now[:tcp_retrans] >= prev[:tcp_retrans]
+          v["tcp_retrans"] = now[:tcp_retrans] - prev[:tcp_retrans]
+        end
+        if now[:ctxt] && prev[:ctxt] && now[:ctxt] >= prev[:ctxt]
+          v["ctx_switches_ps"] = ((now[:ctxt] - prev[:ctxt]) / secs).round(1)
+        end
+        return unless now[:proc_io] && prev[:proc_io]
+        (r, w), (pr, pw) = now[:proc_io], prev[:proc_io]
+        return unless r >= pr && w >= pw
+        v["proc_read_kbps"] = ((r - pr) / 1024.0 / secs).round(1)
+        v["proc_write_kbps"] = ((w - pw) / 1024.0 / secs).round(1)
+      end
+
+      # Linux counts guest time inside user/nice already.
+      def cpu_total(t)
+        t.values.sum - t[:guest].to_f - t[:guest_nice].to_f
+      end
+    end
+  end
+end