wurk 0.0.1

data/lib/wurk/limiter/points.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Wurk
+  module Limiter
+    # Token-bucket with explicit `estimate:` per call. Refills at
+    # `refill_per_second` capped at `initial_points`. Failure mode is
+    # immediate (spec §1.4 — no sleep loop). The block is invoked with a
+    # `Handle` so user code may refund/over-charge via `handle.points_used`.
+    class Points < Base
+      class Handle
+        def initialize(limiter, estimate)
+          @limiter = limiter
+          @estimate = estimate
+        end
+
+        # Positive delta returns points to the bucket; negative records an
+        # under-estimate. Either way, clamped to [0, cap].
+        def points_used(actual)
+          delta = @estimate - actual
+          @limiter.send(:refund, delta)
+        end
+      end
+
+      def type = :points
+
+      # Apply refill on read so the size matches what the *next* acquire
+      # would see. Stored balance only updates on acquire/refund; without
+      # this, a fully-refilled bucket reports stale low numbers.
+      def size
+        cap = @options[:initial].to_f
+        data = Wurk::Limiter.redis { |c| c.call('HMGET', state_key, 'points', 'last') }
+        stored = data[0]
+        return cap if stored.nil?
+
+        last = (data[1] || ::Time.now.to_f).to_f
+        elapsed = [::Time.now.to_f - last, 0.0].max
+        [cap, stored.to_f + (elapsed * @options[:refill].to_f)].min
+      end
+
+      # used = points consumed (cap − available); limit = the cap; reset_at =
+      # when the bucket refills to full, or nil when already full (#16).
+      def status
+        cap = @options[:initial].to_f
+        available = size
+        used = cap - available
+        refill = @options[:refill].to_f
+        reset_at = available < cap && refill.positive? ? ::Time.now.to_f + ((cap - available) / refill) : nil
+        build_status(used: used, limit: cap, reset_at: reset_at)
+      end
+
+      def within_limit(estimate:, &block)
+        raise ArgumentError, 'block required' unless block
+        raise ArgumentError, 'estimate must be positive' if estimate <= 0
+
+        ok, _remaining = acquire(estimate)
+        raise OverLimit, self unless ok.to_i == 1
+
+        handle = Handle.new(self, estimate)
+        block.call(handle)
+      end
+
+      protected
+
+      def state_keys
+        [state_key]
+      end
+
+      private
+
+      def state_key
+        "lmtr-p:#{@name}"
+      end
+
+      def acquire(estimate)
+        lua(:limiter_points_acquire,
+            keys: [state_key],
+            argv: [@options[:initial], @options[:refill], estimate, ttl])
+      end
+
+      def refund(delta)
+        lua(:limiter_points_refund,
+            keys: [state_key],
+            argv: [delta, @options[:initial], ttl]).to_f
+      end
+    end
+  end
+end

data/lib/wurk/limiter/server_middleware.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Wurk
+  module Limiter
+    # Catches OverLimit (and any class registered in `Limiter.config.errors`),
+    # bumps `job['overrated']`, and decides what to do next:
+    #
+    #   * reschedule disabled (`reschedule: 0`) → re-raise so the normal
+    #     retry/dead pipeline handles it (spec §1.2/§1.4 behaviour).
+    #   * still under the cap → reschedule onto the same queue at
+    #     `Time.now + backoff` via `Client.push`.
+    #   * cap reached (`overrated >= reschedule`, default 20) → **poison
+    #     brake** (#16): a job that's still rate-limited after N reschedules
+    #     is saturating the limiter, so instead of dumping it into another
+    #     25× retry loop we route it straight to the dead set tagged
+    #     `rate_limited`, bumping `jobs.rate_limited` and firing death
+    #     handlers. Bounded: termination at exactly `reschedule` attempts.
+    class ServerMiddleware
+      include Wurk::Middleware::ServerMiddleware
+
+      DEAD_REASON = 'rate_limited'
+
+      def call(_worker, job, _queue)
+        yield
+      rescue StandardError => e
+        raise unless over_limit?(e)
+
+        handle_over_limit(job, e)
+      end
+
+      private
+
+      def over_limit?(exc)
+        Wurk::Limiter.config.errors.any? { |k| exc.is_a?(k) }
+      end
+
+      def handle_over_limit(job, exc)
+        job['overrated'] = job.fetch('overrated', 0).to_i + 1
+        limiter = exc.respond_to?(:limiter) ? exc.limiter : nil
+        exc.job = job if exc.respond_to?(:job=)
+        cap = reschedule_cap(limiter)
+
+        raise exc if cap.zero? # rescheduling disabled → normal retry/dead pipeline
+        return route_to_dead(job, exc) if job['overrated'] >= cap
+
+        reschedule(job, exc, limiter)
+      end
+
+      # nil (concurrent/leaky/points never set it) → the default 20.
+      def reschedule_cap(limiter)
+        return DEFAULT_RESCHEDULE unless limiter
+
+        cap = limiter.options[:reschedule]
+        cap.nil? ? DEFAULT_RESCHEDULE : cap
+      end
+
+      def reschedule(job, exc, limiter)
+        backoff_proc = (limiter && limiter.options[:backoff]) || Wurk::Limiter.config.backoff
+        delay = backoff_proc.call(limiter, job, exc).to_f
+        Wurk::Client.new.push(job.merge('at' => ::Time.now.to_f + delay))
+      end
+
+      # Poison brake: stamp a clear reason, drop the job in the dead set, and
+      # ACK by returning normally (no re-raise) so it isn't also retried.
+      def route_to_dead(job, exc)
+        record = job.merge(
+          'error_class' => exc.class.name,
+          'error_message' => "#{DEAD_REASON}: #{exc.message} (overrated=#{job['overrated']})",
+          'failed_at' => ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+        )
+        Wurk::Metrics::Statsd.increment('jobs.rate_limited', tags: ["worker:#{job['class']}"])
+        Wurk::DeadSet.new.kill(Wurk.dump_json(record), ex: exc)
+        nil
+      end
+    end
+  end
+end

data/lib/wurk/limiter/unlimited.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'points'
+
+module Wurk
+  module Limiter
+    # No-op for the tests + bypass scenarios documented in §1.8. The
+    # within_limit block runs unconditionally and the introspection
+    # methods all return zeros so dashboards render predictably.
+    class Unlimited
+      def name = 'unlimited'
+      def type = :unlimited
+      def options = {}
+      def size = 0
+      def fingerprint = Digest::SHA256.hexdigest('unlimited')
+      def reset = nil
+      def delete = nil
+
+      # Uniform status shape (#16): no limit, always available.
+      def status
+        { used: 0, limit: nil, reset_at: nil, available?: true }
+      end
+
+      # Accept all the kwargs the other limiters take so a worker can swap
+      # `limiter = Sidekiq::Limiter.unlimited` in tests without touching
+      # call sites. `points`-style callers pass an `estimate:` and expect a
+      # `|handle|` block param — we yield a zero-cost handle just in case.
+      def within_limit(**_kwargs, &block)
+        raise ArgumentError, 'block required' unless block
+
+        if block.arity.zero?
+          block.call
+        else
+          block.call(Points::Handle.new(self, 0))
+        end
+      end
+
+      private
+
+      # Points::Handle#points_used calls `refund` on the limiter; without this
+      # no-op an Unlimited swap-in would raise NoMethodError the moment user
+      # code records actual usage. Drop-in contract trumps purity.
+      def refund(_delta)
+        0.0
+      end
+    end
+  end
+end

data/lib/wurk/limiter/window.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Wurk
+  module Limiter
+    # Sliding window via ZSET of timestamps. Accepts symbolic units or a
+    # raw Integer (in seconds). Used-units expand to N ZADDs in the Lua
+    # script so multi-charge calls remain atomic.
+    class Window < Base
+      WAIT_SLEEP = 0.5
+
+      def type = :window
+
+      def initialize(name, **options)
+        # Symbol or raw Integer (spec §1.2: window accepts both).
+        Limiter.interval_seconds(options[:interval], allow_integer: true)
+        super
+      end
+
+      def size
+        cutoff = ::Time.now.to_f - interval_seconds
+        Wurk::Limiter.redis do |c|
+          c.call('ZREMRANGEBYSCORE', state_key, '-inf', "(#{cutoff}")
+          c.call('ZCARD', state_key).to_i
+        end
+      end
+
+      # used = entries still inside the window; limit = count; reset_at =
+      # when the oldest entry slides out (freeing a slot), or nil when
+      # idle (#16).
+      def status
+        build_status(used: size, limit: @options[:count], reset_at: oldest_expiry)
+      end
+
+      def within_limit(used: 1, &block)
+        raise ArgumentError, 'block required' unless block
+
+        deadline = ::Time.now.to_f + @options[:wait_timeout]
+        loop do
+          ok, _current, _oldest = acquire(used)
+          return block.call if ok.to_i == 1
+
+          remaining = deadline - ::Time.now.to_f
+          raise OverLimit, self if remaining <= 0
+
+          sleep [remaining, WAIT_SLEEP].min
+        end
+      end
+
+      protected
+
+      def state_keys
+        [state_key]
+      end
+
+      private
+
+      def state_key
+        "lmtr-w:#{@name}"
+      end
+
+      # Oldest timestamp + interval = the moment it leaves the window.
+      def oldest_expiry
+        row = Wurk::Limiter.redis { |c| c.call('ZRANGE', state_key, 0, 0, 'WITHSCORES') }
+        row && !row.empty? ? row[1].to_f + interval_seconds : nil
+      end
+
+      def interval_seconds
+        @interval_seconds ||= Limiter.interval_seconds(@options[:interval], allow_integer: true)
+      end
+
+      def acquire(used)
+        lua(:limiter_window_acquire,
+            keys: [state_key],
+            argv: [@options[:count], interval_seconds, used, ttl, random_id])
+      end
+    end
+  end
+end

data/lib/wurk/limiter.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'digest'
+require 'securerandom'
+require_relative 'lua'
+
+module Wurk
+  # Sidekiq Enterprise rate limiters: concurrent, bucket, window, leaky,
+  # points, unlimited. Lua-backed; all timing inside Lua is from TIME so
+  # clock skew across hosts doesn't matter inside one Redis. Spec:
+  # docs/target/sidekiq-ent.md §1.
+  #
+  # Layout (one file per type under `lib/wurk/limiter/`):
+  #   * `Limiter::Base` owns the metadata write (lmtr:{name}) + the global
+  #     `lmtr-list` registration so the Web UI can list every limiter, and
+  #     the uniform `status` shape.
+  #   * Per-type subclasses (Concurrent / Bucket / Window / Leaky / Points)
+  #     own their acquire/wait loop. Each delegates the atomic step to a
+  #     Lua script in `lib/wurk/lua/limiter_*.lua`.
+  #   * `Unlimited` is a no-op stub for tests and the `unlimited(*)`
+  #     constructor — same `within_limit` surface, never raises.
+  #   * `ServerMiddleware` catches OverLimit, reschedules, and applies the
+  #     poison brake.
+  #
+  # Wire-compat: every key uses the `lmtr-...:` prefix family from §1.7
+  # and the limiter is added to the shared `lmtr-list` SET.
+  module Limiter
+    DEFAULT_TTL = 90 * 24 * 3600
+    DEFAULT_WAIT_TIMEOUT = 5
+    DEFAULT_LOCK_TIMEOUT = 30
+    DEFAULT_RESCHEDULE = 20
+    DEFAULT_BACKOFF = lambda do |_limiter, job, _exc|
+      overrated = job.is_a?(Hash) ? job.fetch('overrated', 0).to_i : 0
+      (300 * overrated) + rand(300) + 1
+    end
+
+    NAME_PATTERN = /\A[\w\-:.\#@]+\z/
+
+    LIST_KEY = 'lmtr-list'
+
+    # Server middleware catches OverLimit, increments `job['overrated']`, and
+    # reschedules onto the same queue with `Time.now + backoff`. The
+    # `#limiter` attr lets the middleware reach the per-limiter backoff
+    # proc + reschedule cap. `#job` is set by the middleware just before the
+    # re-raise so error_handlers can see which job was in flight.
+    class OverLimit < StandardError
+      attr_reader :limiter
+      attr_accessor :job
+
+      def initialize(limiter, job = nil, msg = nil)
+        @limiter = limiter
+        @job = job
+        super(msg || "limit '#{limiter.name}' (#{limiter.type}) reached")
+      end
+    end
+
+    # Global config. Sidekiq Enterprise documents three knobs (§1.6):
+    # `backoff` (Proc), `redis` (a Hash that builds a dedicated pool), and
+    # `errors` (Array of exception classes the middleware also treats as
+    # OverLimit). All three are mutable and re-read on every push/perform.
+    class Config
+      attr_accessor :backoff, :errors
+      attr_reader :redis
+
+      def initialize
+        @backoff = DEFAULT_BACKOFF
+        @errors = [OverLimit]
+        @redis = nil
+        @redis_pool = nil
+      end
+
+      # Accept either a Hash (the documented Sidekiq Ent shape — `{ size:,
+      # url: }`) or an already-built `RedisPool`. The first redis read
+      # lazily materializes the pool; per-fork safety is the caller's
+      # responsibility (same contract as Wurk.redis_pool).
+      def redis=(value)
+        @redis = value
+        @redis_pool = nil
+      end
+
+      def pool
+        return nil if @redis.nil?
+
+        @pool ||= case @redis
+                  when Wurk::RedisPool then @redis
+                  when Hash
+                    Wurk::RedisPool.new(
+                      size: @redis[:size] || 10,
+                      url: @redis[:url] || Wurk::RedisPool::DEFAULT_URL,
+                      timeout: @redis[:timeout] || Wurk::RedisPool::DEFAULT_TIMEOUT,
+                      name: 'limiter'
+                    )
+                  else
+                    raise ArgumentError, "Limiter.config.redis must be Hash or RedisPool, got #{@redis.class}"
+                  end
+      end
+    end
+
+    # `:second :minute :hour :day` symbols → seconds. Window also accepts
+    # a raw Integer; bucket does not (boundary semantics require a unit).
+    INTERVAL_UNITS = {
+      second: 1,
+      minute: 60,
+      hour: 3600,
+      day: 86_400
+    }.freeze
+
+    # Type string (as stored in the `lmtr:{name}` meta hash) → subclass.
+    # Drives `build` for dashboard introspection.
+    TYPE_CLASSES = {
+      'concurrent' => 'Concurrent',
+      'bucket' => 'Bucket',
+      'window' => 'Window',
+      'leaky' => 'Leaky',
+      'points' => 'Points'
+    }.freeze
+
+    class << self
+      def configure
+        yield config
+      end
+
+      def config
+        @config ||= Config.new
+      end
+
+      # Test helper: blow away config + cached pool so a test that mutates
+      # `config.backoff` doesn't leak into the next one. Not part of the
+      # public Sidekiq surface.
+      def reset_config!
+        @config = nil
+      end
+
+      # Redis access: caller-supplied pool (Limiter.configure.redis = …) wins,
+      # else fall back to the default Wurk pool. This is the same hierarchy
+      # Sidekiq Ent documents — dedicated rate-limiter pool is opt-in.
+      def redis(&)
+        pool = config.pool || Wurk.redis_pool
+        pool.with(&)
+      end
+
+      def concurrent(name, limit, wait_timeout: DEFAULT_WAIT_TIMEOUT, lock_timeout: DEFAULT_LOCK_TIMEOUT,
+                     policy: :raise, backoff: nil, ttl: DEFAULT_TTL)
+        Concurrent.new(name,
+                       limit: limit,
+                       wait_timeout: wait_timeout,
+                       lock_timeout: lock_timeout,
+                       policy: policy,
+                       backoff: backoff,
+                       ttl: ttl)
+      end
+
+      def bucket(name, count, interval, wait_timeout: DEFAULT_WAIT_TIMEOUT, backoff: nil,
+                 ttl: DEFAULT_TTL, reschedule: DEFAULT_RESCHEDULE)
+        Bucket.new(name,
+                   count: count,
+                   interval: interval,
+                   wait_timeout: wait_timeout,
+                   backoff: backoff,
+                   ttl: ttl,
+                   reschedule: reschedule)
+      end
+
+      def window(name, count, interval, wait_timeout: DEFAULT_WAIT_TIMEOUT, backoff: nil,
+                 ttl: DEFAULT_TTL, reschedule: DEFAULT_RESCHEDULE)
+        Window.new(name,
+                   count: count,
+                   interval: interval,
+                   wait_timeout: wait_timeout,
+                   backoff: backoff,
+                   ttl: ttl,
+                   reschedule: reschedule)
+      end
+
+      def leaky(name, bucket_size, drain, wait_timeout: DEFAULT_WAIT_TIMEOUT, backoff: nil, ttl: DEFAULT_TTL)
+        Leaky.new(name,
+                  bucket_size: bucket_size,
+                  drain: drain,
+                  wait_timeout: wait_timeout,
+                  backoff: backoff,
+                  ttl: ttl)
+      end
+
+      def points(name, initial_points, refill_per_second, backoff: nil, ttl: DEFAULT_TTL)
+        Points.new(name,
+                   initial: initial_points,
+                   refill: refill_per_second,
+                   backoff: backoff,
+                   ttl: ttl)
+      end
+
+      def unlimited(*_args, **_opts)
+        Unlimited.new
+      end
+
+      # Reconstruct a limiter from its persisted metadata for read-only
+      # introspection (the dashboard `status` column). `register: false`
+      # keeps the GET side-effect-free. Returns nil for an unknown type.
+      def build(name, type, options, register: false)
+        return Unlimited.new if type.to_s == 'unlimited'
+
+        klass_name = TYPE_CLASSES[type.to_s]
+        return nil unless klass_name
+
+        const_get(klass_name).new(name, register: register, **coerce_build_options(options))
+      end
+
+      def interval_seconds(interval, allow_integer:)
+        interval = interval.to_sym if interval.is_a?(String) && INTERVAL_UNITS.key?(interval.to_sym)
+        case interval
+        when Symbol
+          INTERVAL_UNITS.fetch(interval) do
+            raise ArgumentError, "interval must be one of #{INTERVAL_UNITS.keys.inspect} (got #{interval.inspect})"
+          end
+        when Integer
+          unless allow_integer
+            raise ArgumentError, "interval must be a Symbol (got Integer); use #{INTERVAL_UNITS.keys.inspect}"
+          end
+
+          interval
+        else
+          raise ArgumentError, "interval must be Symbol or Integer (got #{interval.class})"
+        end
+      end
+
+      private
+
+      # Stored options round-trip through JSON, so symbol keys arrive as
+      # strings and unit symbols (`:minute`) as `"minute"`. Restore both so a
+      # rebuilt limiter validates the same as a freshly-constructed one.
+      def coerce_build_options(options)
+        opts = options.transform_keys(&:to_sym)
+        %i[interval drain].each do |k|
+          v = opts[k]
+          opts[k] = v.to_sym if v.is_a?(String) && INTERVAL_UNITS.key?(v.to_sym)
+        end
+        opts
+      end
+    end
+  end
+end
+
+require_relative 'limiter/base'
+require_relative 'limiter/concurrent'
+require_relative 'limiter/bucket'
+require_relative 'limiter/window'
+require_relative 'limiter/leaky'
+require_relative 'limiter/points'
+require_relative 'limiter/unlimited'
+require_relative 'middleware'
+require_relative 'limiter/server_middleware'
+# Server-middleware registration happens in wurk.rb after the Wurk
+# `class << self` block defines `Wurk.configuration` — limiter.rb
+# loads earlier than that, so trying to call it here would NoMethodError.

data/lib/wurk/logger.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'time'
+require 'json'
+
+module Wurk
+  # Wurk's stdlib-compatible ::Logger subclass. The point of subclassing
+  # (rather than configuring a vanilla ::Logger) is to ship default
+  # formatters that read the thread-local Wurk::Context so every line
+  # carries jid/bid/tags/elapsed without callers threading the hash through.
+  #
+  # Formatter selection at boot:
+  #   - ENV["DYNO"] set        → Formatters::WithoutTimestamp (Heroku already prefixes)
+  #   - otherwise              → Formatters::Pretty
+  # Switch to Formatters::JSON manually for log aggregators that want NDJSON.
+  #
+  # Spec: docs/target/sidekiq-free.md §29.
+  class Logger < ::Logger
+    module Formatters
+      class Base < ::Logger::Formatter
+        SEVERITY_COLORS = {
+          'DEBUG' => "\e[1;32mDEBUG\e[0m",
+          'INFO' => "\e[1;34mINFO \e[0m",
+          'WARN' => "\e[1;33mWARN \e[0m",
+          'ERROR' => "\e[1;31mERROR\e[0m",
+          'FATAL' => "\e[1;35mFATAL\e[0m"
+        }.freeze
+
+        def tid
+          Thread.current[:wurk_tid] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+        end
+
+        def format_context(ctxt = Wurk::Context.current)
+          return '' if ctxt.empty?
+
+          " #{ctxt.map { |k, v| v.is_a?(Array) ? "#{k}=#{v.join(',')}" : "#{k}=#{v}" }.join(' ')}"
+        end
+      end
+
+      class Pretty < Base
+        def call(severity, time, _program_name, message)
+          "#{SEVERITY_COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} " \
+            "tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class WithoutTimestamp < Pretty
+        def call(severity, _time, _program_name, message)
+          "#{SEVERITY_COLORS[severity]} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class JSON < Base
+        def call(severity, time, _program_name, message)
+          hash = {
+            ts: time.utc.iso8601(3),
+            pid: ::Process.pid,
+            tid: tid,
+            lvl: severity,
+            msg: message
+          }
+          ctx = Wurk::Context.current
+          hash[:ctx] = ctx unless ctx.empty?
+          "#{::JSON.generate(hash)}\n"
+        end
+      end
+    end
+
+    def initialize(*, **)
+      super
+      self.formatter = default_formatter
+    end
+
+    private
+
+    def default_formatter
+      ENV['DYNO'] ? Formatters::WithoutTimestamp.new : Formatters::Pretty.new
+    end
+  end
+end

data/lib/wurk/lua/loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Wurk
+  module Lua
+    # EVALSHA wrapper with `NOSCRIPT` recovery. The SHA1 of each script
+    # source is precomputed in `Wurk::Lua::SHAS`, so the first call to
+    # `eval_cached` after a fork has a fast path: a single EVALSHA, no
+    # per-pool bookkeeping. If the script cache was flushed (manual
+    # `SCRIPT FLUSH`, replica failover, OOM eviction), `EVALSHA` returns
+    # `NOSCRIPT` — we then `SCRIPT LOAD` once and retry exactly once.
+    #
+    # Spec: docs/target/sidekiq-free.md §20 (Lua script caching).
+    class Loader
+      NOSCRIPT_PREFIX = 'NOSCRIPT'
+
+      class << self
+        # Eagerly upload every registered script to the given connection.
+        # Idempotent on the Redis side: `SCRIPT LOAD` of the same source
+        # returns the same SHA regardless of how often it's called.
+        # Manager calls this once per child after the post-fork reconnect.
+        def script_load_all(redis)
+          SCRIPTS.each_value { |src| redis.call('SCRIPT', 'LOAD', src) }
+        end
+
+        # @param redis [RedisClient] a single connection (not a pool)
+        # @param name [Symbol] key into Wurk::Lua::SCRIPTS
+        # @param keys [Array<String>] EVALSHA KEYS
+        # @param argv [Array] EVALSHA ARGV (coerced to strings by Redis)
+        # @return Lua script return value
+        def eval_cached(redis, name, keys:, argv:)
+          src = SCRIPTS.fetch(name) { raise ArgumentError, "unknown Lua script: #{name.inspect}" }
+          sha = SHAS.fetch(name)
+          evalsha(redis, sha, keys, argv)
+        rescue RedisClient::CommandError => e
+          raise unless noscript?(e)
+
+          redis.call('SCRIPT', 'LOAD', src)
+          evalsha(redis, sha, keys, argv)
+        end
+
+        private
+
+        def evalsha(redis, sha, keys, argv)
+          redis.call('EVALSHA', sha, keys.size, *keys, *argv)
+        end
+
+        def noscript?(err)
+          err.message.to_s.start_with?(NOSCRIPT_PREFIX)
+        end
+      end
+    end
+  end
+end