saboteur 0.2.0

data/lib/saboteur/execution/reevaluator.rb

@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Execution
+    # Redefines a subject's method from (possibly mutated) text, in the running
+    # process, without touching the file on disk.
+    #
+    # Strategies (see docs/design.md 6.1):
+    #   class_eval - owner.class_eval(text, file, line), as specified. Constants
+    #                from enclosing modules are not in lexical scope.
+    #   nesting    - rebuild the original `module A; class B` nesting on one line
+    #                and eval at top level, so constant lookup matches the file.
+    #
+    # Both keep the original file and line numbers, carry a frozen_string_literal
+    # magic comment, and restore the method's visibility afterwards.
+    class Reevaluator
+      STRATEGIES = %w[class_eval nesting].freeze
+      FROZEN_HEADER = "# frozen_string_literal: true\n"
+
+      def initialize(strategy = "nesting")
+        raise Error, "unknown reeval strategy: #{strategy}" unless STRATEGIES.include?(strategy.to_s)
+
+        @strategy = strategy.to_s
+      end
+
+      def call(subject, text)
+        owner = resolve_owner(subject)
+        target = subject.singleton ? owner.singleton_class : owner
+        visibility = visibility_of(target, subject.name)
+        module_function = module_function?(owner, subject)
+        aliases = aliases_of(target, subject.name)
+
+        @strategy == "nesting" ? eval_nested(subject, text) : eval_in_owner(owner, subject, text)
+
+        restore(owner, target, subject.name, visibility, module_function)
+        repoint(target, subject.name, aliases)
+      end
+
+      # Resolves the subject's owner the way Ruby would resolve the nesting in
+      # the file. const_get also triggers autoload (Zeitwerk) before any reopening.
+      def resolve_owner(subject)
+        scopes = [Object]
+        subject.nesting.reject(&:sclass?).each do |scope|
+          scopes << resolve_path(scope.path, scopes)
+        end
+        owner = scopes.last
+        raise Error, "#{subject.owner} is not a class or module" unless owner.is_a?(Module)
+
+        owner
+      rescue NameError => e
+        raise Error, "cannot resolve #{subject.owner}: #{e.message}"
+      end
+
+      private
+
+      def resolve_path(path, scopes)
+        return Object.const_get(path.delete_prefix("::")) if path.start_with?("::")
+
+        first, *rest = path.split("::")
+        base = if rest.empty?
+                 # `class B` inside `module A` opens A::B (or ::B at top level).
+                 scopes.last.const_get(first, false)
+               else
+                 lexical_lookup(first, scopes)
+               end
+        rest.reduce(base) { |mod, name| mod.const_get(name, false) }
+      end
+
+      def lexical_lookup(name, scopes)
+        found = scopes.reverse.find { |scope| scope.const_defined?(name, false) }
+        (found || Object).const_get(name, false)
+      end
+
+      def visibility_of(target, name)
+        if target.private_method_defined?(name, false) then :private
+        elsif target.protected_method_defined?(name, false) then :protected
+        else :public
+        end
+      end
+
+      def module_function?(owner, subject)
+        return false if subject.singleton || owner.is_a?(Class)
+        return false unless owner.private_method_defined?(subject.name, false)
+        return false unless owner.singleton_class.public_method_defined?(subject.name, false)
+
+        owner.instance_method(subject.name).source_location ==
+          owner.singleton_class.instance_method(subject.name).source_location
+      end
+
+      def eval_in_owner(owner, subject, text)
+        code, line = with_magic_comment(subject, text)
+        eval_target = subject.sclass ? owner.singleton_class : owner
+        eval_target.class_eval(code, subject.file, line)
+      end
+
+      def eval_nested(subject, text)
+        headers = subject.nesting.map(&:header)
+        wrapped = "#{headers.join('; ')}; #{text}; #{(['end'] * headers.size).join('; ')}"
+        code, line = with_magic_comment(subject, wrapped)
+        TOPLEVEL_BINDING.eval(code, subject.file, line)
+      end
+
+      def with_magic_comment(subject, code)
+        return [code, subject.start_line] unless subject.frozen_literals
+
+        [FROZEN_HEADER + code, subject.start_line - 1]
+      end
+
+      # Methods defined with alias/alias_method copy the old body. Callers
+      # that use the alias would never see the mutant, which would then
+      # survive for no reason. Only aliases of the current definition count
+      # (same source location): an alias taken before the method was
+      # redefined keeps the older body on purpose. Returns { alias => visibility }.
+      def aliases_of(target, name)
+        current = target.instance_method(name).source_location
+        names = target.instance_methods(false) + target.private_instance_methods(false)
+        names.each_with_object({}) do |other, found|
+          next if other == name
+
+          method = target.instance_method(other)
+          next unless method.original_name == name && method.source_location == current
+
+          found[other] = visibility_of(target, other)
+        end
+      end
+
+      def repoint(target, name, aliases)
+        aliases.each do |other, visibility|
+          target.send(:alias_method, other, name)
+          target.send(visibility, other)
+        end
+      end
+
+      def restore(owner, target, name, visibility, module_function)
+        if module_function
+          owner.send(:module_function, name)
+        elsif visibility != :public
+          target.send(visibility, name)
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/execution/runner.rb

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "json"
+
+module Saboteur
+  module Execution
+    # Runs one subject variant (unchanged or mutated) in a supervised child.
+    #
+    # The child re-evaluates the method, reports "started", runs the selected
+    # tests and reports the result over a pipe. Supervisor owns the child's
+    # whole process tree: deadline, memory and process caps, and killing every
+    # descendant afterwards, including ones that left the process group.
+    class Runner
+      # kill_cause: "assertion" when the killing test failed an expectation,
+      # else the class of the error it died with (a crash, not a check).
+      Outcome = Data.define(:status, :runtime, :failed_ids, :message, :leftover_pids, :kill_cause) do
+        def initialize(status:, runtime:, failed_ids: [], message: nil, leftover_pids: [], kill_cause: nil)
+          super
+        end
+      end
+
+      ASSERTION_FAILURES = %w[
+        RSpec::Expectations::ExpectationNotMetError
+        RSpec::Expectations::MultipleExpectationsNotMetError
+        RSpec::Mocks::MockExpectationError
+      ].freeze
+
+      # Everything one child needs. mutation is nil for the verdict check.
+      Job = Data.define(:subject, :text, :test_ids, :timeout, :mutation, :log_path)
+
+      LOG_TAIL_BYTES = 2000
+
+      # log_dir: where children write their output; a child's log is kept
+      # only when it ends in an error.
+      # seed: every child seeds Ruby's random numbers with it before its
+      # tests, so a test that uses rand sees the same values in every run.
+      def initialize(integration:, reevaluator:, log_dir:, hooks: Hooks.new, supervisor: Supervisor.new, seed: 1)
+        @integration = integration
+        @reevaluator = reevaluator
+        @hooks = hooks
+        @log_dir = log_dir
+        @supervisor = supervisor
+        @seed = seed
+      end
+
+      # text: method source to evaluate in the child (the unchanged source for
+      # the neutral check). mutation: passed to around_mutant hooks (nil for
+      # the neutral check). Returns an Outcome with status
+      # :killed, :survived, :timeout, :resource_limit (memory or process cap) or
+      # :error.
+      def run(subject:, text:, test_ids:, timeout:, mutation: nil)
+        @hooks.run(:before_fork, mutation)
+        @sequence = @sequence.to_i + 1
+        job = Job.new(subject:, text:, test_ids:, timeout:, mutation:,
+                      log_path: File.join(@log_dir, "child-#{Process.pid}-#{@sequence}.log"))
+        result = @supervisor.run(timeout: timeout) { |writer| child(writer, job) }
+        outcome = outcome_for(result, job)
+        File.delete(job.log_path) if outcome.status != :error && File.exist?(job.log_path)
+        outcome
+      end
+
+      private
+
+      # --- child ----------------------------------------------------------
+
+      def child(writer, job)
+        Process.setproctitle(title(job))
+        redirect_output(job.log_path)
+        @hooks.run(:after_fork)
+        @reevaluator.call(job.subject, job.text)
+        Protocol.emit(writer, "started")
+        Kernel.srand(@seed)
+        result = @hooks.around(job.mutation) { run_tests(job.test_ids) }
+        if result.nil?
+          Protocol.emit(writer, "error", message: "around_mutant hook did not run the tests")
+        else
+          Protocol.emit(writer, "result", **result)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        Protocol.emit(writer, "error", message: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(5))
+        exit!(1)
+      end
+
+      # What `ps` shows for this child: which method, and which mutant.
+      def title(job)
+        "saboteur: #{job.subject.id} #{job.mutation ? job.mutation.operator : 'neutral check'}"
+      end
+
+      def run_tests(test_ids)
+        result = @integration.run(test_ids)
+        { passed: result.passed, failed: result.failed_ids, executed: result.executed_ids, runtime: result.runtime,
+          failure_classes: result.failure_classes, failure_messages: result.failure_messages }
+      rescue SystemExit => e
+        # A test called `exit`. The tests noticed something; count it as a failure.
+        { passed: false, failed: [], executed: [], runtime: 0.0, exited: e.status }
+      end
+
+      def redirect_output(log_path)
+        $stdout.reopen(log_path, "w")
+        $stderr.reopen($stdout)
+        $stdout.sync = true
+        $stderr.sync = true
+      end
+
+      # --- parent ---------------------------------------------------------
+
+      def outcome_for(result, job)
+        outcome = case result.stopped_by
+                  when :timeout
+                    Outcome.new(status: :timeout, runtime: result.runtime,
+                                message: "exceeded #{job.timeout.round(2)} s")
+                  when :memory, :processes
+                    Outcome.new(status: :resource_limit, runtime: result.runtime, message: result.detail)
+                  else
+                    classify(Protocol.parse(result.payload), result.exit_status, result.runtime, job)
+                  end
+        outcome.with(leftover_pids: result.leftover_pids)
+      end
+
+      def classify(events, exit_status, runtime, job)
+        started = events.any? { |event| event["event"] == "started" }
+        result = events.find { |event| event["event"] == "result" }
+        error = events.find { |event| event["event"] == "error" }
+
+        if result
+          classify_result(result, runtime, job.test_ids)
+        else
+          message = if error
+                      error["message"]
+                    else
+                      "child #{describe(exit_status)} #{started ? 'during' : 'before'} tests"
+                    end
+          message = "#{message} (before tests)" if error && !started
+          Outcome.new(status: :error, runtime: runtime, message: [message, log_tail(job.log_path)].compact.join("\n"))
+        end
+      end
+
+      def classify_result(result, runtime, test_ids)
+        failed = Array(result["failed"])
+        executed = Array(result["executed"])
+        return Outcome.new(status: :killed, runtime: runtime, message: "test called exit") if result.key?("exited")
+
+        if failed.any?
+          unexpected = failed - test_ids
+          return mismatch(runtime, "failed tests not requested: #{unexpected.first(3).join(', ')}") if unexpected.any?
+
+          return Outcome.new(status: :killed, runtime: runtime, failed_ids: failed,
+                             message: result.fetch("failure_messages", {})[failed.first],
+                             kill_cause: kill_cause(result.fetch("failure_classes", {})[failed.first]))
+        end
+        return Outcome.new(status: :killed, runtime: runtime, message: "suite-level failure") unless result["passed"]
+
+        if executed.sort != test_ids.sort
+          return mismatch(runtime, "executed #{executed.size} of #{test_ids.size} requested tests")
+        end
+
+        Outcome.new(status: :survived, runtime: runtime)
+      end
+
+      def kill_cause(failure_class)
+        return nil if failure_class.nil?
+
+        ASSERTION_FAILURES.include?(failure_class) ? "assertion" : failure_class
+      end
+
+      def mismatch(runtime, message)
+        Outcome.new(status: :error, runtime: runtime, message: message)
+      end
+
+      def describe(status)
+        return "exited" unless status.is_a?(Process::Status)
+        return "killed by signal #{status.termsig}" if status.signaled?
+
+        "exited with status #{status.exitstatus}"
+      end
+
+      def log_tail(path)
+        return nil unless File.exist?(path)
+
+        size = File.size(path)
+        return nil if size.zero?
+
+        File.open(path) do |file|
+          file.seek([size - LOG_TAIL_BYTES, 0].max)
+          file.read.scrub.strip
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/execution/supervisor.rb

@@ -0,0 +1,337 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "process_tree"
+require_relative "protocol"
+
+module Saboteur
+  module Execution
+    # Forks one child and owns everything it starts until a verdict is reached.
+    #
+    # Invariant: no process started on behalf of a child outlives that child's
+    # supervision. Enforced by, in order:
+    #   1. Tracking the whole descendant tree (ProcessTree), not just the
+    #      process group, and killing all of it after every child, whether it
+    #      passed, failed, crashed or timed out.
+    #   2. A deadline, a memory cap and a process cap over the tree, checked
+    #      while the child runs.
+    #   3. Kernel backstops the tree tracking cannot miss: RLIMIT_CPU in the
+    #      child, which every descendant inherits even if it escapes the tree,
+    #      and a parent-death check in the child.
+    #   4. Refusing recursion: the child is marked with CHILD_ENV, and Engine
+    #      refuses to start a run inside a marked process.
+    #   5. On Linux, the supervisor is a child subreaper, so escaped orphans are
+    #      re-parented to it instead of init and stay in its tree.
+    class Supervisor
+      # Set in every child to its nesting depth (1 for a child of a top-level
+      # run). Engine refuses to start when it is set; the supervisor itself
+      # refuses to fork past MAX_DEPTH, so even a run with that guard removed
+      # (a mutant of the guard, say) cannot recurse without bound.
+      CHILD_ENV = "SABOTEUR_CHILD"
+      MAX_DEPTH = 4
+      # The hard CPU limit, as a multiple of the budget (see limit_cpu).
+      HARD_CPU_FACTOR = 20
+
+      Limits = Data.define(:max_memory_mb, :max_processes) do
+        def self.default
+          new(max_memory_mb: 2048, max_processes: 64)
+        end
+      end
+
+      # payload: bytes the child wrote to its pipe. stop: nil when the child
+      # finished on its own, else :timeout, :memory or :processes.
+      Result = Data.define(:payload, :exit_status, :stopped_by, :detail, :runtime, :leftover_pids)
+
+      POLL_INTERVAL = 0.5
+      PR_SET_CHILD_SUBREAPER = 36
+      TERM_GRACE = 1.0
+      REAP_DEADLINE = 5.0
+
+      @live = {}
+      @close_in_child = []
+      class << self
+        # close_in_child: IOs a supervised child must close first (a worker's
+        # pipes, so a stray grandchild cannot keep them open).
+        attr_reader :live, :close_in_child
+
+        # In a freshly forked worker: forget the parent's trees (they are
+        # siblings, not ours) and handle INT/TERM for this process.
+        def reset_in_worker!
+          @live = {}
+          @close_in_child = []
+          @installed = false
+          install_parent_handlers
+        end
+
+        # Kills every tree still under supervision. Used on parent exit and on
+        # INT/TERM, so Ctrl-C never leaves mutants running.
+        def kill_live_trees
+          live.each_value(&:kill_all)
+          live.clear
+        end
+
+        def install_parent_handlers
+          return if @installed
+
+          @installed = true
+          owner = Process.pid
+          at_exit { kill_live_trees if Process.pid == owner }
+          %w[INT TERM].each do |signal|
+            previous = trap(signal) do
+              kill_live_trees if Process.pid == owner
+              previous.respond_to?(:call) ? previous.call : exit(128 + Signal.list.fetch(signal))
+            end
+          end
+        end
+      end
+
+      def initialize(limits: Limits.default)
+        @limits = limits
+        self.class.install_parent_handlers
+        become_subreaper
+      end
+
+      # Runs the block in a forked child with a pipe writer; the child exits
+      # when the block returns. Returns a Result. cpu_seconds bounds every
+      # descendant's CPU time (default: twice the deadline, at least 10 s).
+      def run(timeout:, cpu_seconds: nil, &block)
+        depth = ENV.fetch(CHILD_ENV, "0").to_i
+        raise Error, "refusing to fork: saboteur children nested #{depth} deep (limit #{MAX_DEPTH})" if
+          depth >= MAX_DEPTH
+
+        cpu_seconds ||= [(timeout * 2).ceil, 10].max
+        reader, writer = IO.pipe
+        $stdout.flush
+        $stderr.flush
+        started = monotonic
+        supervisor = Process.pid
+        pid = fork { child(reader, writer, supervisor, cpu_seconds, depth + 1, &block) }
+        writer.close
+        contain(pid, reader, started, timeout)
+      ensure
+        reader&.close unless reader&.closed?
+      end
+
+      private
+
+      # --- child ----------------------------------------------------------
+
+      def child(reader, writer, supervisor, cpu_seconds, depth)
+        reader.close
+        self.class.close_in_child.each { |io| io.close unless io.closed? }
+        ENV[CHILD_ENV] = depth.to_s
+        Process.setpgid(0, 0)
+        limit_cpu(cpu_seconds)
+        trap("TERM") { exit!(143) }
+        watch_parent(supervisor)
+        yield writer
+        exit!(0)
+      rescue Exception # rubocop:disable Lint/RescueException
+        exit!(1)
+      end
+
+      # SIGXCPU at the soft limit, SIGKILL at the hard one. Limits can only be
+      # lowered, so a nested supervisor stays within the one it inherited.
+      #
+      # macOS over-counts CPU time for a process with many waking threads
+      # and sends SIGXCPU early (a Rails test child has ~20 threads). So
+      # SIGXCPU is checked against the CPU time really used: below the
+      # budget it is ignored and the soft limit moves out; at the budget the
+      # process dies by SIGXCPU. The hard limit (SIGKILL, cannot be caught)
+      # sits far out (HARD_CPU_FACTOR), for a process that ignores SIGXCPU.
+      def limit_cpu(seconds)
+        _, hard = Process.getrlimit(Process::RLIMIT_CPU)
+        hard_cap = [seconds * HARD_CPU_FACTOR, hard].min
+        Process.setrlimit(Process::RLIMIT_CPU, [seconds, hard_cap].min, hard_cap)
+        trap("XCPU") { cpu_alarm(seconds) }
+      end
+
+      def cpu_alarm(budget)
+        if Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) >= budget
+          trap("XCPU", "DEFAULT")
+          Process.kill("XCPU", Process.pid)
+        else
+          soft, hard = Process.getrlimit(Process::RLIMIT_CPU)
+          Process.setrlimit(Process::RLIMIT_CPU, [soft * 2, hard].min, hard)
+        end
+      end
+
+      # macOS has no PDEATHSIG: poll, and exit if the supervisor is gone.
+      def watch_parent(supervisor)
+        Thread.new do
+          loop do
+            sleep 1
+            exit!(1) if Process.ppid != supervisor
+          end
+        end
+      end
+
+      # --- parent ---------------------------------------------------------
+
+      def contain(pid, reader, started, timeout)
+        tree = ProcessTree.new(pid)
+        self.class.live[pid] = tree
+        own_group(pid)
+        payload, stop, detail = watch(tree, reader, started + timeout)
+        exit_status = stop == :timeout ? terminate(pid) : nil
+        leftover_pids = tree.kill_all - [pid]
+        exit_status ||= reap(pid)
+        self.class.live.delete(pid)
+        reap_adopted(leftover_pids)
+        reap_group(pid)
+        Result.new(payload: payload, exit_status: exit_status, stopped_by: stop, detail: detail,
+                   runtime: monotonic - started, leftover_pids: leftover_pids)
+      end
+
+      # Reads until EOF, polling the tree's size and memory. Returns
+      # [payload, stop, detail].
+      def watch(tree, reader, deadline)
+        payload = +""
+        next_poll = monotonic + POLL_INTERVAL
+        tree.live_members
+        loop do
+          now = monotonic
+          return [payload, :timeout, "exceeded deadline"] if now >= deadline
+
+          if now >= next_poll
+            stop = over_limit(tree)
+            return [payload, *stop] if stop
+
+            next_poll = now + POLL_INTERVAL
+          end
+          next unless reader.wait_readable([deadline, next_poll].min - now)
+
+          chunk = reader.read_nonblock(65_536, exception: false)
+          break if chunk.nil?
+
+          payload << chunk unless chunk == :wait_readable
+        end
+        [payload, nil, nil]
+      end
+
+      def over_limit(tree)
+        count, growth_kb = tree.usage(baseline_rss_kb)
+        if growth_kb > @limits.max_memory_mb * 1024
+          [:memory, "process tree grew by #{growth_kb / 1024} MB (limit #{@limits.max_memory_mb} MB)"]
+        elsif count > @limits.max_processes
+          [:processes, "process tree reached #{count} processes (limit #{@limits.max_processes})"]
+        end
+      end
+
+      # The supervisor's own RSS, refreshed at most every 10 s (forked children
+      # share it, so it is the baseline for growth).
+      def baseline_rss_kb
+        now = monotonic
+        if @baseline_at.nil? || now - @baseline_at > 10
+          @baseline_rss_kb = ProcessTable.snapshot.fetch(Process.pid).rss_kb
+          @baseline_at = now
+        end
+        @baseline_rss_kb
+      end
+
+      def terminate(pid)
+        signal("TERM", -pid)
+        deadline = monotonic + TERM_GRACE
+        until monotonic > deadline
+          status = waitpid(pid)
+          return status if status
+
+          sleep 0.01
+        end
+        nil
+      end
+
+      # Never blocks forever: the child was SIGKILLed by kill_all, so it is
+      # reaped within milliseconds; give up after REAP_DEADLINE and say so.
+      def reap(pid)
+        deadline = monotonic + REAP_DEADLINE
+        until monotonic > deadline
+          status = waitpid(pid)
+          return status if status
+
+          signal("KILL", pid)
+          sleep 0.01
+        end
+        :unreaped
+      end
+
+      def waitpid(pid)
+        _, status = Process.waitpid2(pid, Process::WNOHANG)
+        status
+      rescue Errno::ECHILD
+        :reaped
+      end
+
+      # With a subreaper (Linux), killed orphans are re-parented to us; reap
+      # exactly those, never another child of the supervisor. SIGKILL takes
+      # effect asynchronously and re-parenting happens only once each parent
+      # has died, so one look is not enough: keep looking until every leftover
+      # is reaped or gone, for at most REAP_DEADLINE.
+      def reap_adopted(pids)
+        pending = pids.dup
+        deadline = monotonic + REAP_DEADLINE
+        until pending.empty? || monotonic > deadline
+          pending.reject! { |pid| settled?(pid) }
+          sleep 0.01 unless pending.empty?
+        end
+      end
+
+      # A process the child started just before it was killed may never have
+      # been seen by the tree, yet the group signal killed it and, with a
+      # subreaper, it is now ours. The child led its own process group, so
+      # reap whatever of that group was adopted, for at most REAP_DEADLINE.
+      def reap_group(pgid)
+        signal("KILL", -pgid)
+        deadline = monotonic + REAP_DEADLINE
+        until monotonic > deadline
+          sleep 0.01 unless Process.waitpid(-pgid, Process::WNOHANG)
+        end
+      rescue Errno::ECHILD
+        nil
+      end
+
+      # True once the process is reaped by us, or gone and not ours to reap.
+      def settled?(pid)
+        Process.waitpid(pid, Process::WNOHANG) ? true : false
+      rescue Errno::ECHILD
+        !exists?(pid)
+      end
+
+      def exists?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
+      def own_group(pid)
+        Process.setpgid(pid, pid)
+      rescue Errno::EACCES, Errno::ESRCH, Errno::EPERM
+        nil
+      end
+
+      def signal(name, target)
+        Process.kill(name, target)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+
+      def become_subreaper
+        return unless RUBY_PLATFORM.include?("linux")
+
+        require "fiddle"
+        prctl = Fiddle::Function.new(Fiddle::Handle::DEFAULT["prctl"],
+                                     [Fiddle::TYPE_INT, Fiddle::TYPE_LONG], Fiddle::TYPE_INT)
+        prctl.call(PR_SET_CHILD_SUBREAPER, 1)
+      rescue StandardError, Fiddle::DLError
+        nil
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end