sidekiq 8.0.2 → 8.1.0

data/lib/sidekiq/job/iterable.rb

@@ -32,8 +32,14 @@ module Sidekiq
         @_runtime = 0
         @_args = nil
         @_cancelled = nil
+        @current_object = nil
       end
 
+      # Access to the current object while iterating.
+      # This value is not reset so the latest element is
+      # explicitly available to cleanup/complete callbacks.
+      attr_reader :current_object
+
       def arguments
         @_args
       end
@@ -49,7 +55,7 @@ module Sidekiq
       def cancel!
         return @_cancelled if cancelled?
 
-        key = "it-#{jid}"
+        key = iteration_key
         _, result, _ = Sidekiq.redis do |c|
           c.pipelined do |p|
             p.hsetnx(key, "cancelled", Time.now.to_i)
@@ -137,7 +143,7 @@ module Sidekiq
         fetch_previous_iteration_state
 
         @_executions += 1
-        @_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        @_start_time = mono_now
 
         enumerator = build_enumerator(*args, cursor: @_cursor)
         unless enumerator
@@ -171,7 +177,7 @@ module Sidekiq
       private
 
       def is_cancelled?
-        @_cancelled = Sidekiq.redis { |c| c.hget("it-#{jid}", "cancelled") }
+        @_cancelled = Sidekiq.redis { |c| c.hget(iteration_key, "cancelled") }
       end
 
       def fetch_previous_iteration_state
@@ -198,16 +204,17 @@ module Sidekiq
 
         time_limit = Sidekiq.default_configuration[:timeout]
         found_record = false
-        state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        state_flushed_at = mono_now
 
         enumerator.each do |object, cursor|
           found_record = true
           @_cursor = cursor
+          @current_object = object
 
-          is_interrupted = interrupted?
-          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - state_flushed_at >= STATE_FLUSH_INTERVAL || is_interrupted
+          interrupt_job = interrupted? || should_interrupt?
+          if mono_now - state_flushed_at >= STATE_FLUSH_INTERVAL || interrupt_job
             _, _, cancelled = flush_state
-            state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            state_flushed_at = mono_now
             if cancelled
               @_cancelled = true
               on_cancel
@@ -216,11 +223,14 @@ module Sidekiq
             end
           end
 
-          return false if is_interrupted
+          return false if interrupt_job
 
-          verify_iteration_time(time_limit, object) do
+          verify_iteration_time(time_limit) do
             around_iteration do
               each_iteration(object, *arguments)
+            rescue Exception
+              flush_state
+              raise
             end
           end
         end
@@ -228,16 +238,16 @@ module Sidekiq
         logger.debug("Enumerator found nothing to iterate!") unless found_record
         true
       ensure
-        @_runtime += (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @_start_time)
+        @_runtime += (mono_now - @_start_time)
       end
 
-      def verify_iteration_time(time_limit, object)
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      def verify_iteration_time(time_limit)
+        start = mono_now
         yield
-        finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        finish = mono_now
         total = finish - start
         if total > time_limit
-          logger.warn { "Iteration took longer (%.2f) than Sidekiq's shutdown timeout (%d) when processing `%s`. This can lead to job processing problems during deploys" % [total, time_limit, object] }
+          logger.warn { "Iteration took longer (%.2f) than Sidekiq's shutdown timeout (%d). This can lead to job processing problems during deploys" % [total, time_limit] }
         end
       end
 
@@ -263,6 +273,11 @@ module Sidekiq
         end
       end
 
+      def should_interrupt?
+        max_iteration_runtime = Sidekiq.default_configuration[:max_iteration_runtime]
+        max_iteration_runtime && (mono_now - @_start_time > max_iteration_runtime)
+      end
+
       def flush_state
         key = iteration_key
         state = {
@@ -298,6 +313,10 @@ module Sidekiq
           raise "Unexpected thrown value: #{completed.inspect}"
         end
       end
+
+      def mono_now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
     end
   end
 end

data/lib/sidekiq/job.rb

@@ -226,6 +226,8 @@ module Sidekiq
         end
         return nil unless result
 
+        verify_json(item)
+
         # round-trip the payload via JSON
         msg = Sidekiq.load_json(Sidekiq.dump_json(item))
 
@@ -248,9 +250,9 @@ module Sidekiq
       end
       alias_method :perform_sync, :perform_inline
 
-      def perform_bulk(args, batch_size: 1_000)
+      def perform_bulk(args, **options)
         client = @klass.build_client
-        client.push_bulk(@opts.merge("class" => @klass, "args" => args, :batch_size => batch_size))
+        client.push_bulk(@opts.merge({"class" => @klass, "args" => args}, options))
       end
 
       # +interval+ must be a timestamp, numeric or something that acts

data/lib/sidekiq/job_logger.rb

@@ -27,10 +27,12 @@ module Sidekiq
       # attribute to expose the underlying thing.
       h = {
         jid: job_hash["jid"],
-        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+        class: job_hash["wrapped"] || job_hash["class"]
       }
-      h[:bid] = job_hash["bid"] if job_hash.has_key?("bid")
-      h[:tags] = job_hash["tags"] if job_hash.has_key?("tags")
+
+      @config[:logged_job_attributes].each do |attr|
+        h[attr.to_sym] = job_hash[attr] if job_hash.has_key?(attr)
+      end
 
       Thread.current[:sidekiq_context] = h
       level = job_hash["log_level"]

data/lib/sidekiq/job_retry.rb

@@ -178,15 +178,21 @@ module Sidekiq
         msg["error_backtrace"] = compress_backtrace(lines)
       end
 
-      return retries_exhausted(jobinst, msg, exception) if count >= max_retry_attempts
-
+      # retry_for and retry are mutually exclusive - if retry_for is set,
+      # we exclusively use duration-based retry logic and ignore count-based logic
       rf = msg["retry_for"]
-      return retries_exhausted(jobinst, msg, exception) if rf && (time_for(msg["failed_at"]) + rf) < Time.now
+      if rf
+        return retries_exhausted(jobinst, msg, exception) if (time_for(msg["failed_at"]) + rf) < Time.now
+      elsif count >= max_retry_attempts
+        return retries_exhausted(jobinst, msg, exception)
+      end
 
       strategy, delay = delay_for(jobinst, count, exception, msg)
       case strategy
       when :discard
-        return # poof!
+        msg["discarded_at"] = now_ms
+
+        return run_death_handlers(msg, exception)
       when :kill
         return retries_exhausted(jobinst, msg, exception)
       end
@@ -255,13 +261,22 @@ module Sidekiq
         handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
       end
 
-      return if rv == :discard # poof!
-      send_to_morgue(msg) unless msg["dead"] == false
+      discarded = msg["dead"] == false || rv == :discard
+
+      if discarded
+        msg["discarded_at"] = now_ms
+      else
+        send_to_morgue(msg)
+      end
+
+      run_death_handlers(msg, exception)
+    end
 
+    def run_death_handlers(job, exception)
       @capsule.config.death_handlers.each do |handler|
-        handler.call(msg, exception)
+        handler.call(job, exception)
       rescue => e
-        handle_exception(e, {context: "Error calling death handler", job: msg})
+        handle_exception(e, {context: "Error calling death handler", job: job})
       end
     end
 

data/lib/sidekiq/launcher.rb

@@ -142,6 +142,12 @@ module Sidekiq
       key = identity
       fails = procd = 0
 
+      idle_timeout = config[:redis_idle_timeout]
+      if idle_timeout
+        config.capsules.each_value { |cap| cap.local_redis_pool.reap(idle_seconds: idle_timeout, &:close) }
+        config.local_redis_pool.reap(idle_seconds: idle_timeout, &:close)
+      end
+
       begin
         flush_stats
 
@@ -214,11 +220,11 @@ module Sidekiq
       # Log a warning if it's a disaster.
       if RTT_READINGS.all? { |x| x > RTT_WARNING_LEVEL }
         logger.warn <<~EOM
-          Your Redis network connection is performing extremely poorly.
+          Your Redis network connection appears to be performing poorly.
           Last RTT readings were #{RTT_READINGS.buffer.inspect}, ideally these should be < 1000.
-          Ensure Redis is running in the same AZ or datacenter as Sidekiq.
-          If these values are close to 100,000, that means your Sidekiq process may be
-          CPU-saturated; reduce your concurrency and/or see https://github.com/sidekiq/sidekiq/discussions/5039
+          Ensure Redis is running in the same AZ or datacenter as Sidekiq and that
+          your Sidekiq process is not CPU-saturated; reduce your concurrency and/or
+          see https://github.com/sidekiq/sidekiq/discussions/5039
         EOM
         RTT_READINGS.reset
       end
@@ -252,8 +258,15 @@ module Sidekiq
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
         "concurrency" => @config.total_concurrency,
+        "capsules" => @config.capsules.each_with_object({}) { |(name, cap), memo|
+          memo[name] = cap.to_h
+        },
+        #####
+        # TODO deprecated, remove in 9.0
+        # This data is now found in the `capsules` element above
         "queues" => @config.capsules.values.flat_map { |cap| cap.queues }.uniq,
-        "weights" => to_weights,
+        "weights" => @config.capsules.values.map(&:weights),
+        #####
         "labels" => @config[:labels].to_a,
         "identity" => identity,
         "version" => Sidekiq::VERSION,
@@ -261,10 +274,6 @@ module Sidekiq
       }
     end
 
-    def to_weights
-      @config.capsules.values.map(&:weights)
-    end
-
     def to_json
       # this data changes infrequently so dump it to a string
       # now so we don't need to dump it every heartbeat.

data/lib/sidekiq/loader.rb

@@ -0,0 +1,57 @@
+module Sidekiq
+  require "sidekiq/component"
+
+  class Loader
+    include Sidekiq::Component
+
+    def initialize(cfg = Sidekiq.default_configuration)
+      @config = cfg
+      @load_hooks = Hash.new { |h, k| h[k] = [] }
+      @loaded = Set.new
+      @lock = Mutex.new
+    end
+
+    # Declares a block that will be executed when a Sidekiq component is fully
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
+    #
+    #   Sidekiq.loader.on_load(:api) do
+    #     # extend the sidekiq API
+    #   end
+    #
+    def on_load(name, &block)
+      # we don't want to hold the lock while calling the block
+      to_run = nil
+
+      @lock.synchronize do
+        if @loaded.include?(name)
+          to_run = block
+        else
+          @load_hooks[name] << block
+        end
+      end
+
+      to_run&.call
+      nil
+    end
+
+    # Executes all blocks registered to +name+ via on_load.
+    #
+    #   Sidekiq.loader.run_load_hooks(:api)
+    #
+    # In the case of the above example, it will execute all hooks registered for +:api+.
+    #
+    def run_load_hooks(name)
+      hks = @lock.synchronize do
+        @loaded << name
+        @load_hooks.delete(name)
+      end
+
+      hks&.each do |blk|
+        blk.call
+      rescue => ex
+        handle_exception(ex, hook: name)
+      end
+    end
+  end
+end

data/lib/sidekiq/logger.rb

@@ -24,14 +24,15 @@ module Sidekiq
 
   class Logger < ::Logger
     module Formatters
-      COLORS = {
-        "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
-        "INFO" => "\e[1;34mINFO \e[0m", # blue
-        "WARN" => "\e[1;33mWARN \e[0m", # yellow
-        "ERROR" => "\e[1;31mERROR\e[0m", # red
-        "FATAL" => "\e[1;35mFATAL\e[0m" # pink
-      }
       class Base < ::Logger::Formatter
+        COLORS = {
+          "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
+          "INFO" => "\e[1;34mINFO \e[0m", # blue
+          "WARN" => "\e[1;33mWARN \e[0m", # yellow
+          "ERROR" => "\e[1;31mERROR\e[0m", # red
+          "FATAL" => "\e[1;35mFATAL\e[0m" # pink
+        }
+
         def tid
           Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
         end
@@ -50,13 +51,19 @@ module Sidekiq
 
       class Pretty < Base
         def call(severity, time, program_name, message)
-          "#{Formatters::COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+          "#{COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class Plain < Base
+        def call(severity, time, program_name, message)
+          "#{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)
-          "#{Formatters::COLORS[severity]} pid=#{::Process.pid} tid=#{tid} #{format_context}: #{message}\n"
+          "#{COLORS[severity]} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 

data/lib/sidekiq/metrics/tracking.rb

@@ -147,4 +147,7 @@ Sidekiq.configure_server do |config|
   config.on(:beat) do
     exec.flush
   end
+  config.on(:exit) do
+    exec.flush
+  end
 end

data/lib/sidekiq/middleware/current_attributes.rb

@@ -50,7 +50,7 @@ module Sidekiq
         @cattrs = cattrs
       end
 
-      def call(_, job, _, &block)
+      def call(_, job, *, &block)
         klass_attrs = {}
 
         @cattrs.each do |(key, strklass)|
@@ -71,11 +71,14 @@ module Sidekiq
         retried = false
 
         begin
+          set_succeeded = false
           klass.set(attrs) do
+            set_succeeded = true
             wrap(klass_attrs, &block)
           end
         rescue NoMethodError
-          raise if retried
+          # Don't retry if the no method error didn't come from current attributes
+          raise if retried || set_succeeded
 
           # It is possible that the `CurrentAttributes` definition
           # was changed before the job started processing.
@@ -90,6 +93,7 @@ module Sidekiq
       def persist(klass_or_array, config = Sidekiq.default_configuration)
         cattrs = build_cattrs_hash(klass_or_array)
 
+        config.client_middleware.prepend Load, cattrs
         config.client_middleware.add Save, cattrs
         config.server_middleware.prepend Load, cattrs
       end

data/lib/sidekiq/middleware/i18n.rb

@@ -11,6 +11,7 @@ module Sidekiq::Middleware::I18n
   # to be sent to Sidekiq.
   class Client
     include Sidekiq::ClientMiddleware
+
     def call(_jobclass, job, _queue, _redis)
       job["locale"] ||= I18n.locale
       yield
@@ -20,6 +21,7 @@ module Sidekiq::Middleware::I18n
   # Pull the msg locale out and set the current thread to use it.
   class Server
     include Sidekiq::ServerMiddleware
+
     def call(_jobclass, job, _queue, &block)
       I18n.with_locale(job.fetch("locale", I18n.default_locale), &block)
     end

data/lib/sidekiq/monitor.rb

@@ -49,14 +49,10 @@ class Sidekiq::Monitor
       puts "---- Processes (#{process_set.size}) ----"
       process_set.each_with_index do |process, index|
         # Keep compatibility with legacy versions since we don't want to break sidekiqmon during rolling upgrades or downgrades.
-        #
-        # Before:
-        #   ["default", "critical"]
-        #
-        # After:
-        #   {"default" => 1, "critical" => 10}
         queues =
-          if process["weights"]
+          if process["capsules"] # 8.0.6+
+            process["capsules"].values.map { |x| x["weights"].keys.join(", ") }
+          elsif process["weights"]
             process["weights"].sort_by { |queue| queue[0] }.map { |capsule| capsule.map { |name, weight| (weight > 0) ? "#{name}: #{weight}" : name }.join(", ") }
           else
             process["queues"].sort
@@ -105,7 +101,7 @@ class Sidekiq::Monitor
           out << line
           line = " " * pad
         end
-        line << value + ", "
+        line << value + "; "
       end
       out << line[0..-3]
       out.join("\n")

data/lib/sidekiq/profiler.rb

@@ -11,8 +11,10 @@ module Sidekiq
     }
 
     include Sidekiq::Component
+
     def initialize(config)
       @config = config
+      @vernier_output_dir = ENV.fetch("VERNIER_OUTPUT_DIR") { Dir.tmpdir }
     end
 
     def call(job, &block)
@@ -22,7 +24,6 @@ module Sidekiq
       type = job["class"]
       jid = job["jid"]
       started_at = Time.now
-      options = DEFAULT_OPTIONS.merge((job["profiler_options"] || {}).transform_keys!(&:to_sym))
 
       rundata = {
         started_at: started_at.to_i,
@@ -30,13 +31,17 @@ module Sidekiq
         type: type,
         jid: jid,
         # .gz extension tells Vernier to compress the data
-        filename: "#{token}-#{type}-#{jid}-#{started_at.strftime("%Y%m%d-%H%M%S")}.json.gz"
+        filename: File.join(
+          @vernier_output_dir,
+          "#{token}-#{type}-#{jid}-#{started_at.strftime("%Y%m%d-%H%M%S")}.json.gz"
+        )
       }
+      profiler_options = profiler_options(job, rundata)
 
       require "vernier"
       begin
         a = Time.now
-        rc = Vernier.profile(**options.merge(out: rundata[:filename]), &block)
+        rc = Vernier.profile(**profiler_options, &block)
         b = Time.now
 
         # Failed jobs will raise an exception on previous line and skip this
@@ -55,5 +60,14 @@ module Sidekiq
         FileUtils.rm_f(rundata[:filename])
       end
     end
+
+    private
+
+    def profiler_options(job, rundata)
+      profiler_options = (job["profiler_options"] || {}).transform_keys(&:to_sym)
+      profiler_options[:mode] = profiler_options[:mode].to_sym if profiler_options[:mode]
+
+      DEFAULT_OPTIONS.merge(profiler_options, {out: rundata[:filename]})
+    end
   end
 end

data/lib/sidekiq/rails.rb

@@ -1,84 +1,63 @@
 # frozen_string_literal: true
 
-require "sidekiq/job"
-require "rails"
-
 module Sidekiq
-  module ActiveJob
-    # @api private
-    class Wrapper
-      include Sidekiq::Job
-
-      def perform(job_data)
-        ::ActiveJob::Base.execute(job_data.merge("provider_job_id" => jid))
-      end
-    end
-  end
-
-  class Rails < ::Rails::Engine
-    class Reloader
-      def initialize(app = ::Rails.application)
-        @app = app
-      end
-
-      def call
-        params = (::Rails::VERSION::STRING >= "7.1") ? {source: "job.sidekiq"} : {}
-        @app.reloader.wrap(**params) do
-          yield
+  begin
+    gem "railties", ">= 7.0"
+    require "rails"
+    require "sidekiq/job"
+    require_relative "../active_job/queue_adapters/sidekiq_adapter"
+
+    class Rails < ::Rails::Engine
+      class Reloader
+        def initialize(app = ::Rails.application)
+          @app = app
         end
-      end
 
-      def inspect
-        "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
-      end
+        def call
+          params = (::Rails::VERSION::STRING >= "7.1") ? {source: "job.sidekiq"} : {}
+          @app.reloader.wrap(**params) do
+            yield
+          end
+        end
 
-      def to_hash
-        {app: @app.class.name}
-      end
-    end
+        def inspect
+          "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
+        end
 
-    # By including the Options module, we allow AJs to directly control sidekiq features
-    # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
-    # AJ retries don't show up in the Sidekiq UI Retries tab, don't save any error data, can't be
-    # manually retried, don't automatically die, etc.
-    #
-    #   class SomeJob < ActiveJob::Base
-    #     queue_as :default
-    #     sidekiq_options retry: 3, backtrace: 10
-    #     def perform
-    #     end
-    #   end
-    initializer "sidekiq.active_job_integration" do
-      ActiveSupport.on_load(:active_job) do
-        require_relative "../active_job/queue_adapters/sidekiq_adapter"
-        include ::Sidekiq::Job::Options unless respond_to?(:sidekiq_options)
+        def to_hash
+          {app: @app.class.name}
+        end
       end
-    end
 
-    initializer "sidekiq.backtrace_cleaner" do
-      Sidekiq.configure_server do |config|
-        config[:backtrace_cleaner] = ->(backtrace) { ::Rails.backtrace_cleaner.clean(backtrace) }
+      initializer "sidekiq.backtrace_cleaner" do
+        Sidekiq.configure_server do |config|
+          config[:backtrace_cleaner] = ->(backtrace) { ::Rails.backtrace_cleaner.clean(backtrace) }
+        end
       end
-    end
-
-    # This hook happens after all initializers are run, just before returning
-    # from config/environment.rb back to sidekiq/cli.rb.
-    #
-    # None of this matters on the client-side, only within the Sidekiq process itself.
-    config.after_initialize do
-      Sidekiq.configure_server do |config|
-        config[:reloader] = Sidekiq::Rails::Reloader.new
 
-        # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
-        # it will appear in the Sidekiq console with all of the job context.
-        unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
-          if ::Rails.logger.respond_to?(:broadcast_to)
-            ::Rails.logger.broadcast_to(config.logger)
-          else
-            ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+      # This hook happens after all initializers are run, just before returning
+      # from config/environment.rb back to sidekiq/cli.rb.
+      #
+      # None of this matters on the client-side, only within the Sidekiq process itself.
+      config.after_initialize do
+        Sidekiq.configure_server do |config|
+          config[:reloader] = Sidekiq::Rails::Reloader.new
+
+          # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
+          # it will appear in the Sidekiq console with all of the job context.
+          unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
+            if ::Rails.logger.respond_to?(:broadcast_to)
+              ::Rails.logger.broadcast_to(config.logger)
+            elsif ::ActiveSupport::Logger.respond_to?(:broadcast)
+              ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+            else
+              ::Rails.logger = ::ActiveSupport::BroadcastLogger.new(::Rails.logger, config.logger)
+            end
           end
         end
       end
     end
+  rescue Gem::LoadError
+    # Rails not available or version requirement not met
   end
 end

data/lib/sidekiq/redis_connection.rb

@@ -23,7 +23,7 @@ module Sidekiq
 
         size = symbolized_options.delete(:size) || 5
         pool_timeout = symbolized_options.delete(:pool_timeout) || 1
-        pool_name = symbolized_options.delete(:pool_name)
+        symbolized_options.delete(:pool_name)
 
         # Default timeout in redis-client is 1 second, which can be too aggressive
         # if the Sidekiq process is CPU-bound. With 10-15 threads and a thread quantum of 100ms,
@@ -33,7 +33,7 @@ module Sidekiq
         symbolized_options[:timeout] ||= 3
 
         redis_config = Sidekiq::RedisClientAdapter.new(symbolized_options)
-        ConnectionPool.new(timeout: pool_timeout, size: size, name: pool_name) do
+        ConnectionPool.new(timeout: pool_timeout, size: size) do
           redis_config.new_client
         end
       end

data/lib/sidekiq/ring_buffer.rb

@@ -6,6 +6,7 @@ module Sidekiq
   class RingBuffer
     include Enumerable
     extend Forwardable
+
     def_delegators :@buf, :[], :each, :size
 
     def initialize(size, default = 0)