sneakers 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e8f7e984a402f29c32f62b919a5ba0be9db25c1
-  data.tar.gz: 9502698889301eacdfa4fa94d9b7ae575e407ca7
+  metadata.gz: c52a398aecf272a36fcb3431f7b242a0d36dc0d1
+  data.tar.gz: c5974b0f7823f4d1e91c99d88adc3bbe50a2e572
 SHA512:
-  metadata.gz: 842cabff8a0f3c2375533061b32a665d9e81102e53fee32eceb96f14d3126c78499a29e80efb0f247b10ed4de9fdb52f8aea57e7ccf65a7641ac020a28ab804c
-  data.tar.gz: 17e5b565b4162c7bbf4ddeffc8801309291c00684fe1c13914b0bae64bc81dce50772ce9874971cdabee462afe506a10b99f751636fc38d0ddc8e13080813ad9
+  metadata.gz: 85bc282b42260ebb6a08fdab01fc2396a30450f3cabb93bed27ccac801bc216e5e139613349cfb874a9c5c2a453234591759671de64c9f7654ddd5076384f746
+  data.tar.gz: 06fd1978121e6e59971152fd202e1cb2d5b13225d0f08f75583a5d021b0cfb8d52768102a007cef7d1dc191ed9264505a9e4157987054bc9631ee3eaaf749605

data/.travis.yml

@@ -5,8 +5,10 @@ sudo: false
 cache: bundler
 language: ruby
 rvm:
-- ruby-head
-- 2.2.5
+  - ruby-head
+  - "2.4.1"
+  - "2.3.4"
+  - "2.2.7"
 matrix:
   include:
     - rvm: 2.2.5

data/examples/newrelic_metrics_worker.rb

@@ -25,8 +25,8 @@ class MetricsWorker
     logger.info "FOUND <#{title}>"
     ack!
   end
-  
-  add_transaction_tracer :work, name: 'MetricsWorker', params: 'args[0]'
+
+  add_transaction_tracer :work, name: 'MetricsWorker', params: 'args[0]', category: :task
 
   private
 
@@ -36,10 +36,5 @@ class MetricsWorker
   end
 end
 
-
 r = Sneakers::Runner.new([ MetricsWorker ])
 r.run
-
-
-
-

data/lib/sneakers.rb

@@ -1,5 +1,5 @@
-require "sneakers/version"
-require 'thread/pool'
+require 'sneakers/version'
+require 'concurrent/executors'
 require 'bunny'
 require 'logger'
 require 'serverengine'
@@ -17,6 +17,7 @@ require 'sneakers/support/production_formatter'
 require 'sneakers/concerns/logging'
 require 'sneakers/concerns/metrics'
 require 'sneakers/handlers/oneshot'
+require 'sneakers/content_type'
 require 'sneakers/worker'
 require 'sneakers/publisher'
 

data/lib/sneakers/content_type.rb

@@ -0,0 +1,47 @@
+module Sneakers
+  class ContentType
+    def self.register(content_type: nil, serializer: nil, deserializer: nil)
+      # This can be removed when support is dropped for ruby 2.0 and replaced
+      # by a keyword arg with no default value
+      fail ArgumentError, 'missing keyword: content_type' if content_type.nil?
+      fail ArgumentError, 'missing keyword: serializer' if serializer.nil?
+      fail ArgumentError, 'missing keyword: deserializer' if deserializer.nil?
+
+      fail ArgumentError, "#{content_type} serializer must be a proc" unless serializer.is_a? Proc
+      fail ArgumentError, "#{content_type} deserializer must be a proc" unless deserializer.is_a? Proc
+
+      fail ArgumentError, "#{content_type} serializer must accept one argument, the payload" unless serializer.arity == 1
+      fail ArgumentError, "#{content_type} deserializer must accept one argument, the payload" unless deserializer.arity == 1
+      @_types[content_type] = new(serializer, deserializer)
+    end
+
+    def self.serialize(payload, content_type)
+      return payload unless content_type
+      @_types[content_type].serializer.(payload)
+    end
+
+    def self.deserialize(payload, content_type)
+      return payload unless content_type
+      @_types[content_type].deserializer.(payload)
+    end
+
+    def self.reset!
+      @_types = Hash.new(
+        new(passthrough, passthrough)
+      )
+    end
+
+    def self.passthrough
+      ->(payload) { payload }
+    end
+
+    def initialize(serializer, deserializer)
+      @serializer = serializer
+      @deserializer = deserializer
+    end
+
+    attr_reader :serializer, :deserializer
+
+    reset!
+  end
+end

data/lib/sneakers/handlers/maxretry.rb

@@ -135,7 +135,7 @@ module Sneakers
             "#{log_prefix} msg=failing, retry_count=#{num_attempts}, reason=#{reason}"
           end
           data = {
-            error: reason,
+            error: reason.to_s,
             num_attempts: num_attempts,
             failed_at: Time.now.iso8601,
             payload: Base64.encode64(msg.to_s),

data/lib/sneakers/publisher.rb

@@ -12,7 +12,7 @@ module Sneakers
       to_queue = options.delete(:to_queue)
       options[:routing_key] ||= to_queue
       Sneakers.logger.info {"publishing <#{msg}> to [#{options[:routing_key]}]"}
-      @exchange.publish(msg, options)
+      @exchange.publish(ContentType.serialize(msg, options[:content_type]), options)
     end
 
 
@@ -34,8 +34,10 @@ module Sneakers
     end
 
     def create_bunny_connection
-      Bunny.new(@opts[:amqp], :vhost => @opts[:vhost], :heartbeat => @opts[:heartbeat], :logger => Sneakers::logger)
+      Bunny.new(@opts[:amqp], :vhost => @opts[:vhost],
+                              :heartbeat => @opts[:heartbeat],
+                              :properties => @opts.fetch(:properties, {}),
+                              :logger => Sneakers::logger)
     end
   end
 end
-

data/lib/sneakers/queue.rb

@@ -56,13 +56,26 @@ class Sneakers::Queue
   end
 
   def unsubscribe
-    # XXX can we cancel bunny and channel too?
-    @consumer.cancel if @consumer
-    @consumer = nil
+    return unless @consumer
+
+    # TODO: should we simply close the channel here?
+    Sneakers.logger.info("Queue: will try to cancel consumer #{@consumer.inspect}")
+    cancel_ok = @consumer.cancel
+    if cancel_ok
+      Sneakers.logger.info "Queue: consumer #{cancel_ok.consumer_tag} cancelled"
+      @consumer = nil
+    else
+      Sneakers.logger.warn "Queue: could not cancel consumer #{@consumer.inspect}"
+      sleep(1)
+      unsubscribe
+    end
   end
 
   def create_bunny_connection
-    Bunny.new(@opts[:amqp], :vhost => @opts[:vhost], :heartbeat => @opts[:heartbeat], :logger => Sneakers::logger)
+    Bunny.new(@opts[:amqp], :vhost => @opts[:vhost],
+                            :heartbeat => @opts[:heartbeat],
+                            :properties => @opts.fetch(:properties, {}),
+                            :logger => Sneakers::logger)
   end
   private :create_bunny_connection
 end

data/lib/sneakers/spawner.rb

@@ -8,6 +8,7 @@ module Sneakers
       unless File.exists?(worker_group_config_file)
         puts "No worker group file found."
         puts "Specify via ENV 'WORKER_GROUP_CONFIG' or by convention ./config/sneaker_worker_groups.yml"
+        Kernel.exit(1)
       end
       @pids = []
       @exec_string = "bundle exec rake sneakers:run"

data/lib/sneakers/version.rb

@@ -1,3 +1,3 @@
 module Sneakers
-  VERSION = "2.5.0"
+  VERSION = "2.6.0"
 end

data/lib/sneakers/worker.rb

@@ -19,8 +19,9 @@ module Sneakers
 
       @should_ack =  opts[:ack]
       @timeout_after = opts[:timeout_job_after]
-      @pool = pool || Thread.pool(opts[:threads]) # XXX config threads
+      @pool = pool || Concurrent::FixedThreadPool.new(opts[:threads])
       @call_with_params = respond_to?(:work_with_params)
+      @content_type = opts[:content_type]
 
       @queue = queue || Sneakers::Queue.new(
         queue_name,
@@ -39,13 +40,13 @@ module Sneakers
       to_queue = opts.delete(:to_queue)
       opts[:routing_key] ||= to_queue
       return unless opts[:routing_key]
-      @queue.exchange.publish(msg, opts)
+      @queue.exchange.publish(Sneakers::ContentType.serialize(msg, opts[:content_type]), opts)
     end
 
     def do_work(delivery_info, metadata, msg, handler)
       worker_trace "Working off: #{msg.inspect}"
 
-      @pool.process do
+      @pool.post do
         res = nil
         error = nil
 
@@ -53,10 +54,11 @@ module Sneakers
           metrics.increment("work.#{self.class.name}.started")
           Timeout.timeout(@timeout_after, WorkerTimeout) do
             metrics.timing("work.#{self.class.name}.time") do
+              deserialized_msg = ContentType.deserialize(msg, @content_type || metadata && metadata[:content_type])
               if @call_with_params
-                res = work_with_params(msg, delivery_info, metadata)
+                res = work_with_params(deserialized_msg, delivery_info, metadata)
               else
-                res = work(msg)
+                res = work(deserialized_msg)
               end
             end
           end
@@ -91,14 +93,15 @@ module Sneakers
         end
 
         metrics.increment("work.#{self.class.name}.ended")
-      end #process
+      end #post
     end
 
     def stop
-      worker_trace "Stopping worker: shutting down thread pool."
-      @pool.shutdown
       worker_trace "Stopping worker: unsubscribing."
       @queue.unsubscribe
+      worker_trace "Stopping worker: shutting down thread pool."
+      @pool.shutdown
+      @pool.wait_for_termination
       worker_trace "Stopping worker: I'm gone."
     end
 
@@ -135,6 +138,7 @@ module Sneakers
 
       def enqueue(msg, opts={})
         opts[:routing_key] ||= @queue_opts[:routing_key]
+        opts[:content_type] ||= @queue_opts[:content_type]
         opts[:to_queue] ||= @queue_name
 
         publisher.publish(msg, opts)

data/lib/sneakers/workergroup.rb

@@ -21,7 +21,7 @@ module Sneakers
 
       # Allocate single thread pool if share_threads is set. This improves load balancing
       # when used with many workers.
-      pool = config[:share_threads] ? Thread.pool(config[:threads]) : nil
+      pool = config[:share_threads] ? Concurrent::FixedThreadPool.new(config[:threads]) : nil
 
       worker_classes = config[:worker_classes]
 
@@ -29,7 +29,13 @@ module Sneakers
         worker_classes = worker_classes.call
       end
 
-      @workers = worker_classes.map{|w| w.new(nil, pool) }
+      # if we don't provide a connection to a worker,
+      # the queue used in the worker will create a new one
+      # so if we want to have a shared bunny connection for the workers
+      # we must create it here
+      bunny_connection = create_connection_or_nil
+
+      @workers = worker_classes.map{|w| w.new(nil, pool, {connection: bunny_connection}) }
       # if more than one worker this should be per worker
       # accumulate clients and consumers as well
       @workers.each do |worker|
@@ -52,5 +58,13 @@ module Sneakers
       @stop_flag.set!
     end
 
+    def create_bunny_connection
+      Bunny.new(Sneakers::CONFIG[:amqp], :vhost => Sneakers::CONFIG[:vhost], :heartbeat => Sneakers::CONFIG[:heartbeat], :logger => Sneakers::logger)
+    end
+
+    def create_connection_or_nil
+      config[:share_bunny_connection] ? create_bunny_connection : nil
+    end
+    private :create_bunny_connection, :create_connection_or_nil
   end
 end

data/sneakers.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |gem|
   gem.description   = %q( Fast background processing framework for Ruby and RabbitMQ )
   gem.summary       = %q( Fast background processing framework for Ruby and RabbitMQ )
   gem.homepage      = 'http://sneakers.io'
+  gem.license       = 'MIT'
   gem.required_ruby_version = Gem::Requirement.new(">= 2.0")
 
   gem.files         = `git ls-files`.split($/).reject { |f| f == 'Gemfile.lock' }
@@ -18,8 +19,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
   gem.require_paths = ['lib']
   gem.add_dependency 'serverengine', '~> 1.5.11'
-  gem.add_dependency 'bunny', '~> 2.6.4'
-  gem.add_dependency 'thread', '~> 0.1.7'
+  gem.add_dependency 'bunny', '~> 2.7.0'
+  gem.add_dependency 'concurrent-ruby', '~> 1.0'
   gem.add_dependency 'thor'
 
   # for integration environment (see .travis.yml and integration_spec)

data/spec/sneakers/content_type_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'sneakers/content_type'
+require 'base64'
+
+describe Sneakers::ContentType do
+  after do
+    Sneakers::ContentType.reset!
+  end
+
+  describe '.deserialize' do
+    it 'uses the given deserializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(_) {},
+        deserializer: ->(payload) { JSON.parse(payload) },
+      )
+
+      Sneakers::ContentType.deserialize('{"foo":"bar"}', 'application/json').must_equal('foo' => 'bar')
+    end
+  end
+
+  describe '.serialize' do
+     it 'uses the given serializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(payload) { JSON.dump(payload) },
+        deserializer: ->(_) {},
+      )
+
+      Sneakers::ContentType.serialize({ 'foo' => 'bar' }, 'application/json').must_equal('{"foo":"bar"}')
+    end
+
+    it 'passes the payload through by default' do
+      payload = "just some text"
+      Sneakers::ContentType.serialize(payload, 'unknown/type').must_equal(payload)
+      Sneakers::ContentType.deserialize(payload, 'unknown/type').must_equal(payload)
+      Sneakers::ContentType.serialize(payload, nil).must_equal(payload)
+      Sneakers::ContentType.deserialize(payload, nil).must_equal(payload)
+    end
+
+    it 'passes the payload through if type not found' do
+      Sneakers::ContentType.register(content_type: 'found/type', serializer: ->(_) {}, deserializer: ->(_) {})
+      payload = "just some text"
+
+      Sneakers::ContentType.serialize(payload, 'unknown/type').must_equal(payload)
+      Sneakers::ContentType.deserialize(payload, 'unknown/type').must_equal(payload)
+    end
+  end
+
+  describe '.register' do
+    it 'provides a mechnism to register a given type' do
+      Sneakers::ContentType.register(
+        content_type: 'text/base64',
+        serializer: ->(payload) { Base64.encode64(payload) },
+        deserializer: ->(payload) { Base64.decode64(payload) },
+      )
+
+      ct = Sneakers::ContentType
+      ct.deserialize(ct.serialize('hello world', 'text/base64'), 'text/base64').must_equal('hello world')
+    end
+
+    it 'requires a content type' do
+      proc { Sneakers::ContentType.register(serializer: -> { }, deserializer: -> { }) }.must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to be present' do
+      proc { Sneakers::ContentType.register(content_type: 'foo', deserializer: -> { }) }.must_raise ArgumentError
+      proc { Sneakers::ContentType.register(content_type: 'foo', serializer: -> { }) }.must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to be a proc' do
+      proc { Sneakers::ContentType.register(content_type: 'foo', serializer: 'not a proc', deserializer: ->(_) { }) }.must_raise ArgumentError
+      proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_) {}, deserializer: 'not a proc' ) }.must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to have the correct arity' do
+      proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_,_) {}, deserializer: ->(_) {}) }.must_raise ArgumentError
+      proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_) {}, deserializer: ->() {} ) }.must_raise ArgumentError
+    end
+  end
+end

data/spec/sneakers/integration_spec.rb

@@ -65,7 +65,7 @@ describe "integration" do
           return
         end
       end
-      
+
       integration_log "failed test. killing off workers."
       Process.kill("TERM", pid)
       sleep 1
@@ -85,6 +85,44 @@ describe "integration" do
       pid
     end
 
+    def any_consumers
+      rmq_addr = compose_or_localhost("rabbitmq")
+      result = false
+      begin
+        admin = RabbitMQ::HTTP::Client.new("http://#{rmq_addr}:15672/", username: "guest", password: "guest")
+        qs = admin.list_queues
+        qs.each do |q|
+          if q.name.start_with? 'integration_'
+            puts "We see #{q.consumers} consumers on #{q.name}"
+            return true if q.consumers > 0
+          end
+        end
+        return false
+      rescue
+        puts "Rabbitmq admin seems to not exist? you better be running this on Travis or Docker. proceeding.\n#{$!}"
+      end
+    end
+
+    it 'should be possible to terminate when queue is full' do
+      job_count = 40000
+
+      pid = start_worker(IntegrationWorker)
+      Process.kill("TERM", pid)
+
+      integration_log "publishing #{job_count} messages..."
+      p = Sneakers::Publisher.new
+      job_count.times do |i|
+        p.publish("m #{i}", to_queue: IntegrationWorker.queue_name)
+      end
+
+      pid = start_worker(IntegrationWorker)
+      any_consumers.must_equal true
+      integration_log "Killing #{pid} now!"
+      Process.kill("TERM", pid)
+      sleep(2)
+      any_consumers.must_equal false
+    end
+
     it 'should pull down 100 jobs from a real queue' do
       job_count = 100
 
@@ -95,7 +133,7 @@ describe "integration" do
       job_count.times do |i|
         p.publish("m #{i}", to_queue: IntegrationWorker.queue_name)
       end
-      
+
       assert_all_accounted_for(
          queue: IntegrationWorker.queue_name,
          pid: pid,
@@ -103,8 +141,8 @@ describe "integration" do
          jobs: job_count,
       )
     end
-    
+
   end
 end
-  
+
 

data/spec/sneakers/publisher_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'sneakers'
+require 'serverengine'
 
 describe Sneakers::Publisher do
   let :pub_vars do
@@ -75,6 +76,7 @@ describe Sneakers::Publisher do
         exchange: 'another_exchange',
         exchange_options: { :type => :topic, :arguments => { 'x-arg' => 'value' } },
         log: logger,
+        properties: { key: "value" },
         durable: false)
 
       channel = Object.new
@@ -86,7 +88,7 @@ describe Sneakers::Publisher do
       mock(bunny).start
       mock(bunny).create_channel { channel }
 
-      mock(Bunny).new('amqp://someuser:somepassword@somehost:5672', heartbeat: 1, vhost: '/', logger: logger) { bunny }
+      mock(Bunny).new('amqp://someuser:somepassword@somehost:5672', heartbeat: 1, vhost: '/', logger: logger, properties: { key: "value" }) { bunny }
 
       p = Sneakers::Publisher.new
 
@@ -122,5 +124,24 @@ describe Sneakers::Publisher do
       p.publish('test msg', my_vars)
       p.instance_variable_get(:@bunny).must_equal existing_session
     end
+
+    it 'should publish using the content type serializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(payload) { JSON.dump(payload) },
+        deserializer: ->(_) {},
+      )
+
+      xchg = Object.new
+      mock(xchg).publish('{"foo":"bar"}', routing_key: 'downloads', content_type: 'application/json')
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish({ 'foo' => 'bar' }, to_queue: 'downloads', content_type: 'application/json')
+
+      Sneakers::ContentType.reset!
+    end
   end
 end

data/spec/sneakers/worker_handlers_spec.rb

@@ -36,12 +36,7 @@ class HandlerTestWorker
   end
 end
 
-class TestPool
-  def process(*args,&block)
-    block.call
-  end
-end
-
+TestPool ||= Concurrent::ImmediateExecutor
 
 describe 'Handlers' do
   let(:channel) { Object.new }

data/spec/sneakers/worker_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'sneakers'
 require 'timeout'
+require 'serverengine'
 
 class DummyWorker
   include Sneakers::Worker
@@ -75,7 +76,16 @@ class PublishingWorker
   end
 end
 
+class JSONPublishingWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => false,
+             :exchange => 'foochange'
 
+  def work(msg)
+    publish msg, :to_queue => 'target', :content_type => 'application/json'
+  end
+end
 
 class LoggingWorker
   include Sneakers::Worker
@@ -87,6 +97,15 @@ class LoggingWorker
   end
 end
 
+class JSONWorker
+  include Sneakers::Worker
+  from_queue 'defaults',
+             :ack => false,
+             :content_type => 'application/json'
+
+  def work(msg)
+  end
+end
 
 class MetricsWorker
   include Sneakers::Worker
@@ -123,11 +142,7 @@ class WithDeprecatedExchangeOptionsWorker
   end
 end
 
-class TestPool
-  def process(*args,&block)
-    block.call
-  end
-end
+TestPool ||= Concurrent::ImmediateExecutor
 
 def with_test_queuefactory(ctx, ack=true, msg=nil, nowork=false)
   qf = Object.new
@@ -164,7 +179,8 @@ describe Sneakers::Worker do
       mock(Sneakers::Publisher).new(DummyWorker.queue_opts) do
         mock(Object.new).publish(message, {
           :routing_key => 'test.routing.key',
-          :to_queue    => 'downloads'
+          :to_queue    => 'downloads',
+          :content_type => nil,
         })
       end
 
@@ -330,6 +346,38 @@ describe Sneakers::Worker do
       w.do_work(nil, nil, "msg", nil)
     end
 
+    describe 'content type based deserialization' do
+      before do
+        Sneakers::ContentType.register(
+          content_type: 'application/json',
+          serializer: ->(_) {},
+          deserializer: ->(payload) { JSON.parse(payload) },
+        )
+      end
+
+      after do
+        Sneakers::ContentType.reset!
+      end
+
+      it 'should use the registered deserializer if the content type is in the metadata' do
+        w = DummyWorker.new(@queue, TestPool.new)
+        mock(w).work({'foo' => 'bar'}).once
+        w.do_work(nil, { content_type: 'application/json' }, '{"foo":"bar"}', nil)
+      end
+
+      it 'should use the registered deserializer if the content type is in the queue options' do
+        w = JSONWorker.new(@queue, TestPool.new)
+        mock(w).work({'foo' => 'bar'}).once
+        w.do_work(nil, {}, '{"foo":"bar"}', nil)
+      end
+
+      it 'should use the deserializer from the queue options even if the metadata has a different content type' do
+        w = JSONWorker.new(@queue, TestPool.new)
+        mock(w).work({'foo' => 'bar'}).once
+        w.do_work(nil, { content_type: 'not/real' }, '{"foo":"bar"}', nil)
+      end
+    end
+
     it "should catch runtime exceptions from a bad work" do
       w = AcksWorker.new(@queue, TestPool.new)
       mock(w).work("msg").once{ raise "foo" }
@@ -432,6 +480,27 @@ describe Sneakers::Worker do
       mock(@exchange).publish('msg', :routing_key => 'target', :expiration => 1).once
       w.publish 'msg', :to_queue => 'target', :expiration => 1
     end
+
+    describe 'content_type based serialization' do
+      before do
+        Sneakers::ContentType.register(
+          content_type: 'application/json',
+          serializer: ->(payload) { JSON.dump(payload) },
+          deserializer: ->(_) {},
+        )
+      end
+
+      after do
+        Sneakers::ContentType.reset!
+      end
+
+      it 'should be able to publish a message from working context' do
+        w = JSONPublishingWorker.new(@queue, TestPool.new)
+        mock(@exchange).publish('{"foo":"bar"}', :routing_key => 'target', :content_type => 'application/json').once
+        w.do_work(nil, {}, {'foo' => 'bar'}, nil)
+      end
+    end
+
   end
 
 

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ require 'rr'
 
 def compose_or_localhost(key)
   Resolv::DNS.new.getaddress(key)
-rescue 
+rescue
   "localhost"
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sneakers
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Dotan Nahum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-01 00:00:00.000000000 Z
+date: 2017-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serverengine
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.6.4
+        version: 2.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.6.4
+        version: 2.7.0
 - !ruby/object:Gem::Dependency
-  name: thread
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.7
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.7
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -267,6 +267,7 @@ files:
 - lib/sneakers/concerns/logging.rb
 - lib/sneakers/concerns/metrics.rb
 - lib/sneakers/configuration.rb
+- lib/sneakers/content_type.rb
 - lib/sneakers/error_reporter.rb
 - lib/sneakers/errors.rb
 - lib/sneakers/handlers/maxretry.rb
@@ -294,6 +295,7 @@ files:
 - spec/sneakers/concerns/logging_spec.rb
 - spec/sneakers/concerns/metrics_spec.rb
 - spec/sneakers/configuration_spec.rb
+- spec/sneakers/content_type_spec.rb
 - spec/sneakers/integration_spec.rb
 - spec/sneakers/publisher_spec.rb
 - spec/sneakers/queue_spec.rb
@@ -304,7 +306,8 @@ files:
 - spec/sneakers/worker_spec.rb
 - spec/spec_helper.rb
 homepage: http://sneakers.io
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -322,7 +325,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Fast background processing framework for Ruby and RabbitMQ
@@ -333,6 +336,7 @@ test_files:
 - spec/sneakers/concerns/logging_spec.rb
 - spec/sneakers/concerns/metrics_spec.rb
 - spec/sneakers/configuration_spec.rb
+- spec/sneakers/content_type_spec.rb
 - spec/sneakers/integration_spec.rb
 - spec/sneakers/publisher_spec.rb
 - spec/sneakers/queue_spec.rb