beaneater 1.1.3 → 1.2.0

data/lib/beaneater/connection.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'socket'
+require 'io/wait'
+require 'monitor'
 
 class Beaneater
   # Represents a connection to a beanstalkd instance.
@@ -11,6 +15,15 @@ class Beaneater
     # Default retry interval
     DEFAULT_RETRY_INTERVAL = 1
 
+    # Fields of the stats responses that are text even when they look numeric
+    # (a tube named "1.12", a server id made only of digits). beanstalkd 1.13
+    # quotes most of these, 1.12 does not.
+    STRING_STAT_FIELDS = {
+      'stats'      => %w(version id hostname os platform),
+      'stats-job'  => %w(tube state),
+      'stats-tube' => %w(name)
+    }.freeze
+
     # @!attribute address
     #   @return [String] returns Beanstalkd server address
     #   @example
@@ -50,7 +63,10 @@ class Beaneater
     #
     def initialize(address)
       @address = address || _host_from_env || Beaneater.configuration.beanstalkd_url
-      @mutex = Mutex.new
+      # Held for each attempt at a command (reconnecting and restoring the tubes included), not
+      # across the pauses between attempts. Reentrant: a job_parser that uses this client runs
+      # while its command holds the lock.
+      @mutex = Monitor.new
       @tube_used = 'default'
       @tubes_watched = ['default']
 
@@ -70,16 +86,27 @@ class Beaneater
     #   @conn.transmit('stats')
     #
     def transmit(command, **options)
-      _with_retry(**options.slice(:retry_interval, :init)) do
-        @mutex.synchronize do
-          _raise_not_connected! unless connection
-
-          command = command.force_encoding('ASCII-8BIT') if command.respond_to?(:force_encoding)
-          connection.write(command.to_s + "\r\n")
-          res = connection.readline
-          parse_response(command, res)
-        end
+      state = {
+        :retry_interval => options[:retry_interval] || DEFAULT_RETRY_INTERVAL, # nil too
+        :init           => options.fetch(:init, true),
+        :reconnects     => 0,
+        :connect_tries  => MAX_RETRIES,
+        :draining_tries => MAX_RETRIES,
+        :connecting     => false
+      }
+      reentrant = @mutex.mon_owned?
+      loop do
+        done, value = @mutex.synchronize { _attempt(command, state) }
+        return value if done
+        # Pause before the next attempt with the lock released, so other threads go on and
+        # Timeout or Thread#raise can stop this one. A reentrant call (from a job_parser) still
+        # holds its outer command's lock here.
+        sleep(value)
       end
+    ensure
+      # #close during a command (from its job_parser, a signal handler or another thread) only
+      # shut the socket down; close it once the command is over and nothing waits on it
+      @mutex.synchronize { _drop_connection if @closed && @connection } if @closed && !reentrant
     end
 
     # Close connection with beanstalkd server.
@@ -88,10 +115,31 @@ class Beaneater
     #  @conn.close
     #
     def close
-      if @connection
-        @connection.close
-        @connection = nil
+      @closed = true
+      socket = @connection
+      if @mutex.mon_locked? && @connection_pid == Process.pid
+        # A thread (this one or another) is inside a command and may be waiting on the socket.
+        # IO#close from a signal handler while any thread waits on that IO can crash Ruby 3.3
+        # and 3.4 (segfault in IO#wait_readable) or raise ThreadError. Shut it down instead:
+        # the wait ends with end-of-file, the command raises NotConnected, and its transmit
+        # closes the socket on its way out. Only in the process that opened the connection: a
+        # child forked during a command inherits the held lock, and shutting down would cut
+        # the parent's connection; the child just closes its own copy below.
+        socket.shutdown(Socket::SHUT_RDWR) if socket && !socket.closed?
+      else
+        # ceiling: a thread can take the lock between the check above and this close and start
+        # waiting on the socket. A close from a signal handler then raises ThreadError on Ruby
+        # 3.3 and 3.4 (ignored below); the waiting thread gets a TypeError from Ruby, and Ruby
+        # keeps the fd open (and the server that connection's pending command) until garbage
+        # collection. On 3.1, 3.2 and 4.0, and from a plain thread, the waiter gets IOError.
+        # Closing under the lock would shut the window, but a signal handler cannot wait for
+        # the lock.
+        _drop_connection
       end
+    rescue ThreadError
+      nil # IO#close refused in a signal handler (see the ceiling above)
+    rescue SystemCallError, IOError
+      nil # already disconnected, or closed by another thread meanwhile
     end
 
     # Returns string representation of job.
@@ -127,7 +175,17 @@ class Beaneater
       match = address.split(':')
       @host, @port = match[0], Integer(match[1] || DEFAULT_PORT)
 
-      @connection = TCPSocket.new @host, @port
+      tcp_opts = { connect_timeout: config.connect_timeout, resolv_timeout: config.resolv_timeout }.compact
+
+      socket = if RUBY_VERSION >= "3.0" && tcp_opts.any?
+        TCPSocket.new(@host, @port, **tcp_opts)
+      else
+        TCPSocket.new(@host, @port)
+      end
+
+      @read_buffer = String.new # binary; bytes read but not yet consumed
+      @connection = socket
+      @connection_pid = Process.pid # a forked child shares the socket; see #close
     end
 
     # Parses the response and returns the useful beanstalk response.
@@ -149,15 +207,17 @@ class Beaneater
       body = nil
       if ['OK','FOUND', 'RESERVED'].include?(status)
         bytes_size = body_values[-1].to_i
-        raw_body = connection.read(bytes_size)
+        raw_body = _read_bytes(bytes_size, cmd)
+        # Consume the trailing CRLF before parsing, so a parser that raises
+        # leaves the stream at the start of the next reply.
+        crlf = _read_bytes(2, cmd) # \r\n
+        raise ExpectedCrlfError.new('EXPECTED_CRLF', cmd) if crlf != "\r\n"
+        @reply_read = true
         body = if status == 'OK'
-          psych_v4_valid_body = raw_body.gsub(/^(.*?): (.*)$/) { "#{$1}: #{$2.gsub(/[\:\-\~]/, '_')}" }
-          YAML.load(psych_v4_valid_body)
+          parse_yaml_body(cmd, raw_body)
         else
-          config.job_parser.call(raw_body)
+          _parse_job(status, body_values[1], raw_body)
         end
-        crlf = connection.read(2) # \r\n
-        raise ExpectedCrlfError.new('EXPECTED_CRLF', cmd) if crlf != "\r\n"
       end
       id = body_values[1]
       response = { :status => status }
@@ -166,6 +226,57 @@ class Beaneater
       response
     end
 
+    # Parses the YAML body of an OK response (stats, stats-job, stats-tube,
+    # list-tubes, list-tubes-watched). beanstalkd emits only a "---" line
+    # followed by "key: value" lines or "- item" lines, so the body is parsed
+    # directly rather than through a YAML loader, which would turn tube names
+    # such as "2022-09-30", "1.12" or "true" into dates, numbers or booleans.
+    #
+    # @param [String] cmd Beanstalk command transmitted
+    # @param [String] raw_body Response body
+    # @return [Hash{String => String, Integer, Float, Boolean}, Array<String>] Parsed body
+    # @example
+    #  parse_yaml_body("stats-job 1", "---\nid: 1\ntube: email-jobs\n")
+    #   # => { "id" => 1, "tube" => "email-jobs" }
+    #
+    def parse_yaml_body(cmd, raw_body)
+      lines = raw_body.dup.force_encoding(Encoding::UTF_8).each_line.map(&:chomp)
+      lines.shift if lines.first == '---'
+      if lines.first && lines.first.start_with?('- ')
+        lines.map { |line| _stat_value(line[2..-1], true) }
+      else
+        text_fields = STRING_STAT_FIELDS[cmd.to_s.split(' ').first] || []
+        lines.each_with_object({}) do |line, hash|
+          key, value = line.split(': ', 2)
+          hash[key] = _stat_value(value.to_s, text_fields.include?(key)) unless key.to_s.empty?
+        end
+      end
+    end
+
+    # Runs the job_parser on a job's body. If it raises for a job this connection has just
+    # reserved, a copy of the parser's exception is raised instead (same class, message,
+    # backtrace and cause, so `rescue JSON::ParserError` still works), tagged with
+    # Beaneater::JobParseFailure, which gives the job's id: Jobs#process! uses it to bury the job
+    # instead of leaving it reserved until its TTR. A copy, so that an exception the parser
+    # froze or raises again later is never changed or tagged with an old id.
+    def _parse_job(status, id, raw_body)
+      config.job_parser.call(raw_body)
+    rescue StandardError => ex
+      raise unless status == 'RESERVED'
+      begin
+        tagged = ex.clone(:freeze => false)
+        tagged.extend(JobParseFailure)
+        tagged.job_id = id
+        cause = ex.cause
+      rescue StandardError
+        tagged = nil # it can't be copied (an initialize_clone or initialize_copy of its own)
+      end
+      # Re-raised out here, where $! is still ex: raised inside the rescue above, a frozen ex
+      # would get the copying error as its cause and fail with "circular causes".
+      raise ex unless tagged
+      raise tagged, :cause => (cause if cause.is_a?(Exception))
+    end
+
     # Returns configuration options for beaneater
     #
     # @return [Beaneater::Configuration] configuration object
@@ -175,57 +286,111 @@ class Beaneater
 
     private
 
+    # Sends one command and reads its whole reply, without retrying.
+    def _exchange(command)
+      completed = false
+      outer_reply_read = @reply_read # a job_parser that uses this client runs an _exchange inside ours
+      @reply_read = false # set by parse_response once the whole reply is off the socket
+      unless connection
+        _raise_not_connected! if @closed
+        raise Errno::ENOTCONN # _attempt reconnects and restores the tubes first
+      end
+
+      command = command.dup.force_encoding('ASCII-8BIT') if command.respond_to?(:force_encoding)
+      read_window = _read_window(command) # checked before anything is written
+      _write(command.to_s + "\r\n", command)
+      @read_deadline = _deadline_in(read_window) # bounds the status line and the body read in parse_response
+      res = _read_line(command)
+      response = parse_response(command, res)
+      completed = true
+      response
+    rescue UnexpectedResponse => ex
+      # an error status line is the whole reply, so the stream is still in step
+      completed = !ex.is_a?(ExpectedCrlfError)
+      raise
+    ensure
+      # Interrupted between the write and the end of the reply (Timeout, Interrupt, an I/O
+      # error): the rest of the reply may still arrive, so drop the socket rather than let the
+      # next command read it. The next command reconnects. Once the whole reply has been read
+      # (a job_parser that raised, say) the stream is in step: keep the socket, and with it the
+      # jobs this connection has reserved.
+      _drop_connection unless completed || @reply_read
+      @reply_read = outer_reply_read
+    end
+
+    # Restores the watched and used tubes on a new connection. Sent with _exchange, not transmit:
+    # a failure here must go back to the _attempt that is reconnecting, which starts over.
     def _initialize_tubes
       if @tubes_watched != ['default']
         tubes_watched.each do |t|
-          transmit("watch #{t}", init: false)
+          _exchange("watch #{t}")
         end
 
-        transmit("ignore default", init: false)
+        _exchange("ignore default") unless tubes_watched.include?('default')
       end
 
-      transmit("use #{tube_used}", init: false) if @tube_used != 'default'
+      _exchange("use #{tube_used}") if @tube_used != 'default'
     end
 
-    # Wrapper method for capturing certain failures and retry the payload block
-    #
-    # @param [Proc] block The command to execute.
-    # @param [Integer] retry_interval The time to wait before the next retry
-    # @param [Integer] tries The maximum number of tries in draining mode
-    # @return [Object] Result of the block passed
-    #
-    def _with_retry(retry_interval: DEFAULT_RETRY_INTERVAL, init: true, tries: MAX_RETRIES, &block)
-      yield
-    rescue EOFError, Errno::ECONNRESET, Errno::EPIPE,
-      Errno::ECONNREFUSED => ex
-      _reconnect(ex, retry_interval)
-      _initialize_tubes if init
-      retry
+    # One attempt at a command, made holding the lock: reconnect (and restore the tubes) if the
+    # connection is gone, then send the command. Returns [true, response], or [false, seconds]
+    # to pause and try again. state carries the retry counts across attempts.
+    def _attempt(command, state)
+      if connection
+        state[:connecting] = false # another thread may have reconnected during our pause
+      else
+        _raise_not_connected! if @closed
+        unless state[:connecting] # a new reconnect, not the next try of one in progress
+          state[:reconnects] += 1
+          # something accepts connections but drops every command (a proxy with no backend):
+          # give up rather than reconnect in a tight loop
+          _raise_not_connected! if state[:reconnects] > MAX_RETRIES
+          state[:connecting] = true
+          state[:connect_tries] = MAX_RETRIES
+        end
+        begin
+          establish_connection
+        rescue SystemCallError, SocketError, IOError
+          state[:connect_tries] -= 1
+          _raise_not_connected! if state[:connect_tries].zero?
+          return [false, state[:retry_interval]]
+        end
+        state[:connecting] = false
+        if @closed # #close ran while connecting
+          _drop_connection
+          _raise_not_connected!
+        end
+        if state[:init]
+          begin
+            _initialize_tubes
+          rescue Exception
+            # never leave a half-restored connection watching the wrong tubes: drop it, so a
+            # lost connection reconnects and restores again below, and anything else makes the
+            # next command start over
+            _drop_connection
+            raise
+          end
+        end
+      end
+      [true, _exchange(command)]
+    rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED, Errno::ENOTCONN
+      _drop_connection
+      retry # reconnects at once, still holding the lock
     rescue Beaneater::DrainingError
-      tries -= 1
-      if tries.zero?
-        close
+      state[:draining_tries] -= 1
+      if state[:draining_tries].zero?
+        _drop_connection
         raise
       end
-      sleep(retry_interval)
-      retry
+      [false, state[:retry_interval]]
     end
 
-    # Tries to re-establish connection to the beanstalkd
-    #
-    # @param [Exception] original_exception The exception caused the retry
-    # @param [Integer] retry_interval The time to wait before the next reconnect
-    # @param [Integer] tries The maximum number of attempts to reconnect
-    def _reconnect(original_exception, retry_interval, tries=MAX_RETRIES)
-      close
-      establish_connection
-    rescue Errno::ECONNREFUSED
-      tries -= 1
-      if tries.zero?
-        _raise_not_connected!
-      end
-      sleep(retry_interval || DEFAULT_RETRY_INTERVAL)
-      retry
+    # Closes the socket without marking the connection closed, so the next command reconnects.
+    # Only #close is final.
+    def _drop_connection
+      socket, @connection = @connection, nil
+      @read_buffer = String.new
+      socket.close if socket
     end
 
     # The host provided by BEANSTALKD_URL environment variable, if available.
@@ -239,6 +404,99 @@ class Beaneater
       ENV['BEANSTALKD_URL'].respond_to?(:length) && ENV['BEANSTALKD_URL'].length > 0 && ENV['BEANSTALKD_URL'].strip
     end
 
+    # Converts one value of a stats or list response to its Ruby type:
+    # quoted values and text fields stay Strings, whole numbers become
+    # Integers, decimals Floats, and true/false Booleans.
+    def _stat_value(value, text)
+      if value.length >= 2 && value.start_with?('"') && value.end_with?('"')
+        value[1..-2]
+      elsif text
+        value
+      elsif value =~ /\A-?\d+\z/
+        value.to_i
+      elsif value =~ /\A-?\d+\.\d+\z/
+        value.to_f
+      elsif value == 'true' || value == 'false'
+        value == 'true'
+      else
+        value
+      end
+    end
+
+    # Writes data to the socket, waiting at most write_timeout seconds.
+    #
+    # Ruby waits on its sockets itself, so the socket-level SO_SNDTIMEO and
+    # SO_RCVTIMEO options have no effect; the deadlines are kept here instead.
+    def _write(data, cmd)
+      deadline = _deadline_in(config.write_timeout && Float(config.write_timeout))
+      until data.empty?
+        written = connection.write_nonblock(data, exception: false)
+        if written == :wait_writable
+          _wait_for(:write, deadline, cmd)
+        else
+          data = data.byteslice(written..-1)
+        end
+      end
+    end
+
+    # Returns how many seconds the reply to cmd may take once it is written, or
+    # nil to wait without limit. reserve-with-timeout gets its own timeout on top
+    # of read_timeout; a plain reserve blocks until a job arrives, by design.
+    # Timeouts may be given as numeric strings (from ENV, say).
+    def _read_window(cmd)
+      return nil if config.read_timeout.nil? || cmd =~ /\Areserve\s*\z/
+      extra = cmd =~ /\Areserve-with-timeout (\d+)/ ? $1.to_i : 0
+      Float(config.read_timeout) + extra
+    end
+
+    # Reads one reply line (the status line), without its line ending.
+    def _read_line(cmd)
+      until (eol = @read_buffer.index("\n"))
+        _fill_read_buffer(cmd)
+      end
+      @read_buffer.slice!(0, eol + 1)
+    end
+
+    # Reads exactly size bytes of a reply body.
+    def _read_bytes(size, cmd)
+      _fill_read_buffer(cmd) while @read_buffer.bytesize < size
+      @read_buffer.slice!(0, size)
+    end
+
+    # Waits until the socket has data (up to the reply's deadline) and appends
+    # what is available to the read buffer.
+    def _fill_read_buffer(cmd)
+      _wait_for(:read, @read_deadline, cmd)
+      @read_buffer << connection.readpartial(16_384)
+    end
+
+    # Waits for the socket to become readable or writable before deadline.
+    # On timeout the connection is dropped (the next command reconnects): a late
+    # reply would otherwise be read as the answer to the next command.
+    #
+    # @raise [Beaneater::SocketTimeout] The deadline passed.
+    def _wait_for(direction, deadline, cmd)
+      # Past the deadline this still polls once (timeout 0): data that is already there is
+      # not a timeout.
+      remaining = deadline && [deadline - _now, 0].max
+      # IO#wait_* rather than IO.select: a thread waiting here is woken by end-of-file when
+      # #close shuts the socket down (its command then raises NotConnected).
+      ready = direction == :read ? connection.wait_readable(remaining) : connection.wait_writable(remaining)
+      return if ready
+
+      _drop_connection
+      action = direction == :read ? 'waiting for the reply to' : 'writing'
+      raise SocketTimeout, "Timed out #{action} '#{cmd.to_s.split("\r\n").first}' on beanstalk '#{@host}:#{@port}'; the next command reconnects"
+    end
+
+    def _deadline_in(seconds)
+      seconds && _now + seconds
+    end
+
+    def _now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     # Raises an error to be triggered when the connection has failed
     # @raise [Beaneater::NotConnected] Beanstalkd is no longer connected
     def _raise_not_connected!

data/lib/beaneater/errors.rb

@@ -1,6 +1,22 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Raises when a beanstalkd instance is no longer accessible.
   class NotConnected < RuntimeError; end
+  # Raises when beanstalkd does not answer within the configured read_timeout,
+  # or a command cannot be written within write_timeout. The connection is
+  # closed, since a late reply would otherwise be read as the answer to the
+  # next command. Not to be confused with {TimedOutError}, which is
+  # beanstalkd's own TIMED_OUT reply to reserve-with-timeout.
+  class SocketTimeout < NotConnected; end
+  # Added to a copy of the exception a job_parser raises for a job just reserved. The copy
+  # keeps the exception's class (JSON::ParserError, say), message, backtrace and cause; #job_id
+  # names the job, still reserved by this connection, so the caller can bury, release or
+  # delete it.
+  module JobParseFailure
+    # @return [String] id of the reserved job whose body the parser rejected
+    attr_accessor :job_id
+  end
   # Raises when the tube name specified is invalid.
   class InvalidTubeName < RuntimeError; end
   # Raises when a job has not been reserved properly.

data/lib/beaneater/job/collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Exception to stop processing jobs during a `process!` loop.
   # Simply `raise AbortProcessingError` in any job process handler to stop the processing loop.
@@ -109,7 +111,20 @@ class Beaneater
       client.tubes.watch!(*processors.keys)
       while !stop? do
         begin
-          @current_job = client.tubes.reserve(reserve_timeout)
+          @current_job = nil # never take an earlier iteration's job for this one
+          begin
+            @current_job = client.tubes.reserve(reserve_timeout)
+          rescue Beaneater::JobParseFailure => ex
+            # The job_parser rejected the job just reserved, so there was no job to handle: it is
+            # ours to bury (the ensure below does), whatever the parser raised, rather than leave
+            # it reserved to be released and fail again when its TTR runs out.
+            # ceiling: a parser exception that can't be copied is raised untagged, so process!
+            # can't tell which job it came from; the job stays reserved, and near its TTR process!
+            # keeps reserving (DEADLINE_SOON) until beanstalkd releases it, then fails on it again.
+            # Upgrade path: have the connection record the id of the job whose parse failed.
+            @current_job = Job.new(client, :id => ex.job_id, :status => 'RESERVED')
+            raise
+          end
           processor = processors[@current_job.tube]
           begin
             processor[:block].call(@current_job)
@@ -122,14 +137,37 @@ class Beaneater
         rescue AbortProcessingError
           break
         rescue Beaneater::JobNotReserved, Beaneater::NotFoundError, Beaneater::TimedOutError
-          retry
-        rescue StandardError # handles unspecified errors
-          @current_job.bury if @current_job
+          # No job yet (reserve timed out), or the job is gone (its handler deleted or released
+          # it, or its TTR ran out). If a handler or the job_parser raised this with the job still
+          # reserved, the ensure buries that job like any failure; then the loop goes on.
+          nil
+        rescue Beaneater::NotConnected
+          # Only when this client's own connection is gone (reconnecting failed, or it was
+          # closed): the server releases a job reserved on it. A NotConnected from a handler that
+          # uses another client is a failed job like any other, buried by the ensure below.
+          unless client.connection.connection
+            @current_job = nil
+            raise
+          end
+        rescue StandardError # handles unspecified errors: the ensure below buries the job
         ensure # bury if still reserved
-          @current_job.bury if @current_job && @current_job.exists? && @current_job.reserved?
-          @current_job = nil
+          begin
+            bury_if_reserved(@current_job)
+          ensure
+            @current_job = nil # even when burying fails, so no later loop sees this job
+          end
         end
       end
     end # process!
+
+    private
+
+    # Buries a job this worker still holds. NOT_FOUND means it no longer holds it (the handler
+    # deleted it, or its TTR ran out and the server released it), so there is nothing to bury.
+    def bury_if_reserved(job)
+      job.bury if job && job.exists? && job.reserved?
+    rescue Beaneater::NotFoundError, Beaneater::JobNotReserved
+      nil # gone, or no longer reserved by us by the time bury ran
+    end
   end # Jobs
 end # Beaneater

data/lib/beaneater/job/record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Represents job related commands.
   class Job

data/lib/beaneater/job.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'beaneater/job/record'
 require 'beaneater/job/collection'

data/lib/beaneater/stats/fast_struct.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   #
   # Borrowed from:

data/lib/beaneater/stats/stat_struct.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Represents a stats hash with proper underscored keys
   class StatStruct < FasterOpenStruct
@@ -17,13 +19,18 @@ class Beaneater
 
     # Access value for stat with specified key.
     #
+    # Keys are stored underscored (see {.from_hash}), so hyphenated beanstalkd
+    # names like "current-jobs-ready" are underscored before lookup. This also
+    # avoids defining an invalid, hyphenated method name via method_missing.
+    #
     # @param [String] key Key to fetch from stats.
     # @return [String, Integer] Value for specified stat key.
     # @example
     #  @stats['foo'] # => "bar"
+    #  @stats['current-jobs-ready'] # => 5
     #
     def [](key)
-      self.send(key.to_s)
+      self.send(key.to_s.gsub(/-/, '_'))
     end
 
     # Returns set of keys within this struct

data/lib/beaneater/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'beaneater/stats/fast_struct'
 require 'beaneater/stats/stat_struct'
 

data/lib/beaneater/tube/collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Represents collection of tube related commands.
 

data/lib/beaneater/tube/record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Beanstalk tube which contains jobs which can be inserted, reserved, et al.
   class Tube

data/lib/beaneater/tube.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'beaneater/tube/record'
 require 'beaneater/tube/collection'

data/lib/beaneater/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 class Beaneater
   # Current version of gem.
-  VERSION = "1.1.3"
+  VERSION = "1.2.0"
 end

data/lib/beaneater.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread' unless defined?(Mutex)
 
 %w(version configuration errors connection tube job stats).each do |f|

data/test/beaneater_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', __FILE__)
 
 describe "beanstalk-client" do