freddy 1.4.1 → 1.4.2

data/lib/freddy/producers.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 Dir[File.dirname(__FILE__) + '/producers/*.rb'].each(&method(:require))

data/lib/freddy/producers/reply_producer.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Freddy
   module Producers
     class ReplyProducer
-      CONTENT_TYPE = 'application/json'.freeze
+      CONTENT_TYPE = 'application/json'
 
       def initialize(channel, logger)
         @logger = logger
@@ -9,11 +11,9 @@ class Freddy
       end
 
       def produce(destination, payload, properties)
-        OpenTracing.active_span.log_kv(
-          event: 'Sending response',
-          queue: destination,
-          payload: payload
-        )
+        if (span = OpenTracing.active_span)
+          span.set_tag('message_bus.destination', destination)
+        end
 
         properties = properties.merge(
           routing_key: destination,

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Freddy
   module Producers
     class SendAndForgetProducer
-      CONTENT_TYPE = 'application/json'.freeze
+      CONTENT_TYPE = 'application/json'
 
       def initialize(channel, logger)
         @logger = logger
@@ -11,13 +13,11 @@ class Freddy
 
       def produce(destination, payload, properties)
         span = OpenTracing.start_span("freddy:notify:#{destination}",
-          tags: {
-            'message_bus.destination': destination,
-            'component': 'freddy',
-            'span.kind': 'producer' # Message Bus
-          }
-        )
-        span.log_kv event: 'Sending message', payload: payload
+                                      tags: {
+                                        'message_bus.destination' => destination,
+                                        'component' => 'freddy',
+                                        'span.kind' => 'producer' # Message Bus
+                                      })
 
         properties = properties.merge(
           routing_key: destination,

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Freddy
   module Producers
     class SendAndWaitResponseProducer
-      CONTENT_TYPE = 'application/json'.freeze
+      CONTENT_TYPE = 'application/json'
 
       def initialize(channel, logger)
         @logger = logger
@@ -16,36 +18,36 @@ class Freddy
           @request_manager.no_route(correlation_id)
         end
 
-        @response_queue = @channel.queue("", exclusive: true)
+        @response_queue = @channel.queue('', exclusive: true)
 
         @response_consumer = Consumers::ResponseConsumer.new(@logger)
         @response_consumer.consume(@channel, @response_queue, &method(:handle_response))
       end
 
       def produce(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties)
-        span = OpenTracing.start_span("freddy:request:#{destination}",
-          tags: {
-            'component': 'freddy',
-            'span.kind': 'client', # RPC
-            'payload.type': payload[:type] || 'unknown'
-          }
-        )
-
         correlation_id = SecureRandom.uuid
 
+        span = OpenTracing.start_span("freddy:request:#{destination}",
+                                      tags: {
+                                        'component' => 'freddy',
+                                        'span.kind' => 'client', # RPC
+                                        'payload.type' => payload[:type] || 'unknown',
+                                        'message_bus.destination' => destination,
+                                        'message_bus.response_queue' => @response_queue.name,
+                                        'message_bus.correlation_id' => correlation_id,
+                                        'freddy.timeout_in_seconds' => timeout_in_seconds
+                                      })
+
         container = SyncResponseContainer.new(
           on_timeout(correlation_id, destination, timeout_in_seconds, span)
         )
 
         @request_manager.store(correlation_id,
-          callback: container,
-          trace: span,
-          destination: destination
-        )
+                               callback: container,
+                               span: span,
+                               destination: destination)
 
-        if delete_on_timeout
-          properties[:expiration] = (timeout_in_seconds * 1000).to_i
-        end
+        properties[:expiration] = (timeout_in_seconds * 1000).to_i if delete_on_timeout
 
         properties = properties.merge(
           routing_key: destination, content_type: CONTENT_TYPE,
@@ -55,13 +57,6 @@ class Freddy
         OpenTracing.global_tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, TraceCarrier.new(properties))
         json_payload = Payload.dump(payload)
 
-        span.log_kv(
-          event: 'Publishing request',
-          payload: payload,
-          response_queue: @response_queue.name,
-          correlation_id: correlation_id
-        )
-
         # Connection adapters handle thread safety for #publish themselves. No
         # need to lock these.
         @topic_exchange.publish json_payload, properties.dup
@@ -73,11 +68,11 @@ class Freddy
       def handle_response(delivery)
         correlation_id = delivery.correlation_id
 
-        if request = @request_manager.delete(correlation_id)
+        if (request = @request_manager.delete(correlation_id))
           process_response(request, delivery)
         else
           message = "Got rpc response for correlation_id #{correlation_id} "\
-                    "but there is no requester"
+                    'but there is no requester'
           @logger.warn message
         end
       end
@@ -86,17 +81,30 @@ class Freddy
         @logger.debug "Got response for request to #{request[:destination]} "\
                       "with correlation_id #{delivery.correlation_id}"
         request[:callback].call(delivery.payload, delivery)
+      rescue InvalidRequestError => e
+        request[:span].set_tag('error', true)
+        request[:span].log_kv(
+          event: 'invalid request',
+          message: e.message,
+          'error.object': e
+        )
+        raise e
       ensure
-        request[:trace].finish
+        request[:span].finish
       end
 
-      def on_timeout(correlation_id, destination, timeout_in_seconds, trace)
-        Proc.new do
+      def on_timeout(correlation_id, destination, timeout_in_seconds, span)
+        proc do
           @logger.warn "Request timed out waiting response from #{destination}"\
-                       ", correlation id #{correlation_id}"
+                       ", correlation id #{correlation_id}, timeout #{timeout_in_seconds}s"
 
           @request_manager.delete(correlation_id)
-          trace.finish
+          span.set_tag('error', true)
+          span.log_kv(
+            event: 'timed out',
+            message: "Timed out waiting response from #{destination}"
+          )
+          span.finish
         end
       end
     end

data/lib/freddy/request_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Freddy
   class RequestManager
     def initialize(logger)
@@ -6,10 +8,11 @@ class Freddy
     end
 
     def no_route(correlation_id)
-      if request = @requests[correlation_id]
-        delete(correlation_id)
-        request[:callback].call({error: 'Specified queue does not exist'}, nil)
-      end
+      request = @requests[correlation_id]
+      return unless request
+
+      delete(correlation_id)
+      request[:callback].call({ error: 'Specified queue does not exist' }, nil)
     end
 
     def store(correlation_id, opts)

data/lib/freddy/responder_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Freddy
   class ResponderHandler
     def initialize(consumer, consume_thread_pool)

data/lib/freddy/sync_response_container.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'timeout'
 
 class Freddy
@@ -9,9 +11,7 @@ class Freddy
     end
 
     def call(response, delivery)
-      if response.nil?
-        raise StandardError, 'unexpected nil value for response'
-      end
+      raise StandardError, 'unexpected nil value for response' if response.nil?
 
       @response = response
       @delivery = delivery
@@ -28,7 +28,7 @@ class Freddy
           message: 'Timed out waiting for response'
         )
       elsif !@delivery || @delivery.type == 'error'
-        raise InvalidRequestError.new(@response)
+        raise InvalidRequestError, @response
       else
         @response
       end

data/lib/freddy/timeout_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'error_response'
 
 class Freddy

data/lib/freddy/trace_carrier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Freddy
   # Carrier for rabbitmq following OpenTracing API
   # See https://github.com/opentracing/opentracing-ruby/blob/master/lib/opentracing/carrier.rb
@@ -18,8 +20,8 @@ class Freddy
     def each(&block)
       Hash[
         (@properties.headers || {})
-          .select {|key, _| key =~ /^x-trace/}
-          .map {|key, value| [key.sub(/x-trace-/, ''), value]}
+        .select { |key, _| key =~ /^x-trace/ }
+        .map { |key, value| [key.sub(/x-trace-/, ''), value] }
       ].each(&block)
     end
   end

data/spec/freddy/consumers/respond_to_consumer_spec.rb

@@ -12,7 +12,7 @@ describe Freddy::Consumers::RespondToConsumer do
 
   let(:connection) { Freddy::Adapters.determine.connect(config) }
   let(:destination) { random_destination }
-  let(:payload) { {pay: 'load'} }
+  let(:payload) { { pay: 'load' } }
   let(:msg_handler_adapter_factory) { double(for: msg_handler_adapter) }
   let(:msg_handler_adapter) { Freddy::MessageHandlerAdapters::NoOpHandler.new }
   let(:prefetch_buffer_size) { 2 }

data/spec/freddy/error_response_spec.rb

@@ -4,55 +4,55 @@ describe Freddy::ErrorResponse do
   subject(:error) { described_class.new(input) }
 
   context 'with an error type' do
-    let(:input) { {error: 'SomeError'} }
+    let(:input) { { error: 'SomeError' } }
 
     describe '#response' do
       subject { error.response }
 
-      it { should eq(input) }
+      it { is_expected.to eq(input) }
     end
 
     describe '#message' do
       subject { error.message }
 
       it 'uses error type as a message' do
-        should eq('SomeError')
+        is_expected.to eq('SomeError')
       end
     end
   end
 
   context 'with an error type and message' do
-    let(:input) { {error: 'SomeError', message: 'extra info'} }
+    let(:input) { { error: 'SomeError', message: 'extra info' } }
 
     describe '#response' do
       subject { error.response }
 
-      it { should eq(input) }
+      it { is_expected.to eq(input) }
     end
 
     describe '#message' do
       subject { error.message }
 
       it 'uses error type as a message' do
-        should eq('SomeError: extra info')
+        is_expected.to eq('SomeError: extra info')
       end
     end
   end
 
   context 'without an error type' do
-    let(:input) { {something: 'else'} }
+    let(:input) { { something: 'else' } }
 
     describe '#response' do
       subject { error.response }
 
-      it { should eq(input) }
+      it { is_expected.to eq(input) }
     end
 
     describe '#message' do
       subject { error.message }
 
       it 'uses default error message as a message' do
-        should eq('Use #response to get the error response')
+        is_expected.to eq('Use #response to get the error response')
       end
     end
   end

data/spec/freddy/freddy_spec.rb

@@ -5,7 +5,7 @@ describe Freddy do
 
   let(:destination)  { random_destination }
   let(:destination2) { random_destination }
-  let(:payload)      { {pay: 'load'} }
+  let(:payload)      { { pay: 'load' } }
 
   after { freddy.close }
 
@@ -18,7 +18,7 @@ describe Freddy do
       it 'removes the message from the queue after the timeout' do
         # Assume that there already is a queue. Otherwise will get an early
         # return.
-        consumer = freddy.respond_to(destination) { }
+        consumer = freddy.respond_to(destination) {}
         consumer.shutdown
 
         freddy.deliver(destination, {}, timeout: 0.1)
@@ -36,7 +36,7 @@ describe Freddy do
       it 'keeps the message in the queue' do
         # Assume that there already is a queue. Otherwise will get an early
         # return.
-        consumer = freddy.respond_to(destination) { }
+        consumer = freddy.respond_to(destination) {}
         consumer.shutdown
 
         freddy.deliver(destination, {})
@@ -53,50 +53,50 @@ describe Freddy do
 
   context 'when making a synchronized request' do
     it 'returns response as soon as possible' do
-      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
-      response = freddy.deliver_with_response(destination, {a: 'b'})
+      respond_to { |_payload, msg_handler| msg_handler.success(res: 'yey') }
+      response = freddy.deliver_with_response(destination, a: 'b')
 
       expect(response).to eq(res: 'yey')
     end
 
     it 'raises an error if the message was errored' do
-      respond_to { |payload, msg_handler| msg_handler.error(error: 'not today') }
+      respond_to { |_payload, msg_handler| msg_handler.error(error: 'not today') }
 
-      expect {
+      expect do
         freddy.deliver_with_response(destination, payload)
-      }.to raise_error(Freddy::InvalidRequestError) {|error|
+      end.to raise_error(Freddy::InvalidRequestError) { |error|
         expect(error.response).to eq(error: 'not today')
       }
     end
 
     it 'responds to the correct requester' do
-      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
+      respond_to { |_payload, msg_handler| msg_handler.success(res: 'yey') }
 
       response = freddy.deliver_with_response(destination, payload)
       expect(response).to eq(res: 'yey')
 
-      expect {
+      expect do
         freddy.deliver_with_response(destination2, payload)
-      }.to raise_error(Freddy::InvalidRequestError)
+      end.to raise_error(Freddy::InvalidRequestError)
     end
 
     context 'when queue does not exist' do
       it 'gives a no route error' do
-        expect {
-          freddy.deliver_with_response(destination, {a: 'b'}, timeout: 1)
-        }.to raise_error(Freddy::InvalidRequestError) {|error|
+        expect do
+          freddy.deliver_with_response(destination, { a: 'b' }, timeout: 1)
+        end.to raise_error(Freddy::InvalidRequestError) { |error|
           expect(error.response).to eq(error: 'Specified queue does not exist')
         }
       end
     end
 
-    context 'on timeout' do
+    context 'when timeout' do
       it 'gives timeout error' do
-        respond_to { |payload, msg_handler| sleep 0.2 }
+        respond_to { |_payload, _msg_handler| sleep 0.2 }
 
-        expect {
-          freddy.deliver_with_response(destination, {a: 'b'}, timeout: 0.1)
-        }.to raise_error(Freddy::TimeoutError) {|error|
+        expect do
+          freddy.deliver_with_response(destination, { a: 'b' }, timeout: 0.1)
+        end.to raise_error(Freddy::TimeoutError) { |error|
           expect(error.response).to eq(error: 'RequestTimeout', message: 'Timed out waiting for response')
         }
       end
@@ -105,12 +105,12 @@ describe Freddy do
         it 'removes the message from the queue' do
           # Assume that there already is a queue. Otherwise will get an early
           # return.
-          consumer = freddy.respond_to(destination) { }
+          consumer = freddy.respond_to(destination) {}
           consumer.shutdown
 
-          expect {
+          expect do
             freddy.deliver_with_response(destination, {}, timeout: 0.1)
-          }.to raise_error(Freddy::TimeoutError)
+          end.to raise_error(Freddy::TimeoutError)
           default_sleep # to ensure everything is properly cleaned
 
           processed_after_timeout = false
@@ -125,12 +125,12 @@ describe Freddy do
         it 'removes the message from the queue' do
           # Assume that there already is a queue. Otherwise will get an early
           # return.
-          consumer = freddy.respond_to(destination) { }
+          consumer = freddy.respond_to(destination) {}
           consumer.shutdown
 
-          expect {
+          expect do
             freddy.deliver_with_response(destination, {}, timeout: 0.1, delete_on_timeout: false)
-          }.to raise_error(Freddy::TimeoutError)
+          end.to raise_error(Freddy::TimeoutError)
           default_sleep # to ensure everything is properly cleaned
 
           processed_after_timeout = false
@@ -149,7 +149,7 @@ describe Freddy do
     end
 
     it 'receives messages' do
-      tap {|msg| @tapped_message = msg }
+      tap { |msg| @tapped_message = msg }
       deliver
 
       wait_for { @tapped_message }
@@ -157,13 +157,13 @@ describe Freddy do
     end
 
     it 'has the destination' do
-      tap "somebody.*.love" do |message, destination|
+      tap 'somebody.*.love' do |_message, destination|
         @destination = destination
       end
-      deliver "somebody.to.love"
+      deliver 'somebody.to.love'
 
       wait_for { @destination }
-      expect(@destination).to eq("somebody.to.love")
+      expect(@destination).to eq('somebody.to.love')
     end
 
     it "doesn't consume the message" do
@@ -178,28 +178,28 @@ describe Freddy do
       expect(@message_received).to be(true)
     end
 
-    it "allows * wildcard" do
-      tap("somebody.*.love") { @tapped = true }
+    it 'allows * wildcard' do
+      tap('somebody.*.love') { @tapped = true }
 
-      deliver "somebody.to.love"
+      deliver 'somebody.to.love'
 
       wait_for { @tapped }
       expect(@tapped).to be(true)
     end
 
-    it "* matches only one word" do
-      tap("somebody.*.love") { @tapped = true }
+    it '* matches only one word' do
+      tap('somebody.*.love') { @tapped = true }
 
-      deliver "somebody.not.to.love"
+      deliver 'somebody.not.to.love'
 
       default_sleep
       expect(@tapped).to be_falsy
     end
 
-    it "allows # wildcard" do
-      tap("i.#.free") { @tapped = true }
+    it 'allows # wildcard' do
+      tap('i.#.free') { @tapped = true }
 
-      deliver "i.want.to.break.free"
+      deliver 'i.want.to.break.free'
 
       wait_for { @tapped }
       expect(@tapped).to be(true)