freddy 1.5.0 → 2.1.0

data/lib/freddy/producers.rb

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

data/lib/freddy/request_manager.rb

@@ -3,7 +3,7 @@
 class Freddy
   class RequestManager
     def initialize(logger)
-      @requests = ConcurrentHash.new
+      @requests = {}
       @logger = logger
     end
 
@@ -22,13 +22,5 @@ class Freddy
     def delete(correlation_id)
       @requests.delete(correlation_id)
     end
-
-    class ConcurrentHash < Hash
-      # CRuby hash does not need any locks. Only adding when using JRuby.
-      if RUBY_PLATFORM == 'java'
-        require 'jruby/synchronized'
-        include JRuby::Synchronized
-      end
-    end
   end
 end

data/lib/freddy/tracing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Freddy
+  module Tracing
+    # NOTE: Make sure you finish the span youself.
+    def self.span_for_produce(exchange, routing_key, payload, correlation_id: nil, timeout_in_seconds: nil)
+      destination = exchange.name
+      destination_kind = exchange.type == :direct ? 'queue' : 'topic'
+
+      attributes = {
+        'payload.type' => (payload[:type] || 'unknown').to_s,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_SYSTEM => 'rabbitmq',
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_RABBITMQ_ROUTING_KEY => routing_key,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION => destination,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION_KIND => destination_kind,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_OPERATION => 'send'
+      }
+
+      attributes['freddy.timeout_in_seconds'] = timeout_in_seconds if timeout_in_seconds
+
+      if correlation_id
+        attributes[OpenTelemetry::SemanticConventions::Trace::MESSAGING_CONVERSATION_ID] = correlation_id
+      end
+
+      Freddy.tracer.start_span(
+        ".#{routing_key} send",
+        kind: OpenTelemetry::Trace::SpanKind::PRODUCER,
+        attributes: attributes
+      )
+    end
+
+    def self.inject_tracing_information_to_properties!(properties)
+      properties[:headers] ||= {}
+      OpenTelemetry.propagation.inject(properties[:headers])
+    end
+  end
+end

data/lib/freddy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Freddy
+  VERSION = '2.1.0'
+end

data/lib/freddy.rb

@@ -3,9 +3,11 @@
 require 'json'
 require 'thread/pool'
 require 'securerandom'
-require 'opentracing'
+require 'opentelemetry'
+require 'opentelemetry/semantic_conventions'
+require_relative './freddy/version'
 
-Dir[File.dirname(__FILE__) + '/freddy/*.rb'].each(&method(:require))
+Dir["#{File.dirname(__FILE__)}/freddy/*.rb"].sort.each(&method(:require))
 
 class Freddy
   FREDDY_TOPIC_EXCHANGE_NAME = 'freddy-topic'
@@ -26,22 +28,15 @@ class Freddy
   # @return [Freddy]
   #
   # @example
-  #   Freddy.build(Logger.new(STDOUT), user: 'thumper', pass: 'howdy')
-  def self.build(logger = Logger.new(STDOUT), max_concurrency: DEFAULT_MAX_CONCURRENCY, **config)
-    OpenTracing.global_tracer ||= OpenTracing::Tracer.new
-
+  #   Freddy.build(Logger.new($stdout), user: 'thumper', pass: 'howdy')
+  def self.build(logger = Logger.new($stdout), max_concurrency: DEFAULT_MAX_CONCURRENCY, **config)
     connection = Adapters.determine.connect(config)
     new(connection, logger, max_concurrency)
   end
 
-  # @deprecated Use {OpenTracing.active_span} instead
-  def self.trace
-    OpenTracing.active_span
-  end
-
-  # @deprecated Use OpenTracing ScopeManager instead
-  def self.trace=(trace)
-    OpenTracing.scope_manager.activate(trace) if OpenTracing.active_span != trace
+  # @private
+  def self.tracer
+    @tracer ||= OpenTelemetry.tracer_provider.tracer('freddy', Freddy::VERSION)
   end
 
   def initialize(connection, logger, max_concurrency)
@@ -70,7 +65,7 @@ class Freddy
   #   Received message as a ruby hash with symbolized keys
   # @yieldparam [#success, #error] handler
   #   Handler for responding to messages. Use handler#success for successful
-  #   respone and handler#error for error response.
+  #   response and handler#error for error response.
   #
   # @return [#shutdown]
   #
@@ -104,13 +99,22 @@ class Freddy
   # consuming them. It is useful for general messages that two or more clients
   # are interested.
   #
-  # @param [String] pattern
+  # @param [String] pattern_or_patterns
   #   the destination pattern. Use `#` wildcard for matching 0 or more words.
   #   Use `*` to match exactly one word.
   # @param [Hash] options
   # @option options [String] :group
   #   only one of the listeners in given group will receive a message. All
   #   listeners will receive a message if the group is not specified.
+  # @option options [Boolean] :durable
+  #   Should the consumer queue be durable? Default is `false`. This option can
+  #   be used only in combination with option `:group`.
+  # @option options [Boolean] :on_exception
+  #   Defines consumer's behaviour when the callback fails to process a message
+  #   and raises an exception. Can be one of `:ack`, `:reject` or `:requeue`.
+  #   `:ack` simply acknowledges the message and re-raises the exception. `:reject`
+  #   rejects the message without requeueing it. `:requeue` rejects the message with
+  #   `requeue` flag.
   #
   # @yield [message] Yields received message to the block
   #
@@ -120,12 +124,12 @@ class Freddy
   #   freddy.tap_into 'notifications.*' do |message|
   #     puts "Notification showed #{message.inspect}"
   #   end
-  def tap_into(pattern, options = {}, &callback)
-    @logger.debug "Tapping into messages that match #{pattern}"
+  def tap_into(pattern_or_patterns, options = {}, &callback)
+    @logger.debug "Tapping into messages that match #{pattern_or_patterns}"
 
     Consumers::TapIntoConsumer.consume(
       thread_pool: Thread.pool(@prefetch_buffer_size),
-      pattern: pattern,
+      patterns: Array(pattern_or_patterns),
       channel: @connection.create_channel(prefetch: @prefetch_buffer_size),
       options: options,
       &callback
@@ -148,15 +152,18 @@ class Freddy
   # @option options [Integer] :timeout (0)
   #   discards the message after given seconds if nobody consumes it. Message
   #   won't be discarded if timeout it set to 0 (default).
-  #
+  # @option options [String] :compress (nil)
+  #   - 'zlib' - compresses the payload with zlib
   # @return [void]
   #
   # @example
   #   freddy.deliver 'Metrics', user_id: 5, metric: 'signed_in'
   def deliver(destination, payload, options = {})
     timeout = options.fetch(:timeout, 0)
+    compression_algorithm = options.fetch(:compress, nil)
     opts = {}
     opts[:expiration] = (timeout * 1000).to_i if timeout.positive?
+    opts[:content_encoding] = compression_algorithm if compression_algorithm
 
     @send_and_forget_producer.produce(destination, payload, opts)
   end

data/spec/.rubocop.yml

@@ -0,0 +1,26 @@
+require: rubocop-rspec
+inherit_from: ../.rubocop.yml
+
+RSpec/ExampleLength:
+  Enabled: no
+
+RSpec/MultipleExpectations:
+  Enabled: no
+
+RSpec/MessageSpies:
+  Enabled: no
+
+RSpec/VerifiedDoubles:
+  Enabled: no
+
+RSpec/InstanceVariable:
+  Enabled: no
+
+RSpec/NestedGroups:
+  Enabled: no
+
+RSpec/DescribeClass:
+  Enabled: no
+
+RSpec/MultipleMemoizedHelpers:
+  Enabled: no

data/spec/freddy/error_response_spec.rb

@@ -13,10 +13,10 @@ describe Freddy::ErrorResponse do
     end
 
     describe '#message' do
-      subject { error.message }
+      subject(:message) { error.message }
 
       it 'uses error type as a message' do
-        is_expected.to eq('SomeError')
+        expect(message).to eq('SomeError')
       end
     end
   end
@@ -31,10 +31,10 @@ describe Freddy::ErrorResponse do
     end
 
     describe '#message' do
-      subject { error.message }
+      subject(:message) { error.message }
 
       it 'uses error type as a message' do
-        is_expected.to eq('SomeError: extra info')
+        expect(message).to eq('SomeError: extra info')
       end
     end
   end
@@ -49,10 +49,10 @@ describe Freddy::ErrorResponse do
     end
 
     describe '#message' do
-      subject { error.message }
+      subject(:message) { error.message }
 
       it 'uses default error message as a message' do
-        is_expected.to eq('Use #response to get the error response')
+        expect(message).to eq('Use #response to get the error response')
       end
     end
   end

data/spec/freddy/freddy_spec.rb

@@ -49,6 +49,29 @@ describe Freddy do
         expect(processed_after_timeout).to be(true)
       end
     end
+
+    context 'with compress' do
+      it 'compresses the payload' do
+        expect(Freddy::Encoding).to receive(:compress).with(anything, 'zlib').and_call_original
+
+        freddy.tap_into(destination) { |msg| @tapped_message = msg }
+        freddy.deliver(destination, payload, compress: 'zlib')
+        default_sleep
+
+        wait_for { @tapped_message }
+        expect(@tapped_message).to eq(payload)
+      end
+    end
+
+    context 'without compress' do
+      it 'does not compress the payload' do
+        freddy.tap_into(destination) { |msg| @tapped_message = msg }
+        deliver
+
+        wait_for { @tapped_message }
+        expect(@tapped_message).to eq(payload)
+      end
+    end
   end
 
   context 'when making a synchronized request' do

data/spec/freddy/payload_spec.rb

@@ -2,19 +2,28 @@ require 'spec_helper'
 
 describe Freddy::Payload do
   describe '#dump' do
-    it 'serializes time objects as iso8601 format strings' do
-      expect(dump(time: Time.utc(2016, 1, 4, 20, 18)))
-        .to eq('{"time":"2016-01-04T20:18:00Z"}')
-    end
-
-    it 'serializes time objects in an array as iso8601 format strings' do
-      expect(dump(time: [Time.utc(2016, 1, 4, 20, 18)]))
-        .to eq('{"time":["2016-01-04T20:18:00Z"]}')
-    end
-
-    it 'serializes time objects in a nested hash as iso8601 format strings' do
-      expect(dump(x: { time: Time.utc(2016, 1, 4, 20, 18) }))
-        .to eq('{"x":{"time":"2016-01-04T20:18:00Z"}}')
+    context 'with a given Ruby engine' do
+      let(:ts) do
+        RUBY_ENGINE == 'jruby' ? '{"time":"2016-01-04T20:18:00Z"}' : '{"time":"2016-01-04T20:18:00.000000Z"}'
+      end
+      let(:ts_array) do
+        RUBY_ENGINE == 'jruby' ? '{"time":["2016-01-04T20:18:00Z"]}' : '{"time":["2016-01-04T20:18:00.000000Z"]}'
+      end
+
+      it 'serializes time objects as iso8601 format strings' do
+        expect(dump(time: Time.utc(2016, 1, 4, 20, 18)))
+          .to eq(ts)
+      end
+
+      it 'serializes time objects in an array as iso8601 format strings' do
+        expect(dump(time: [Time.utc(2016, 1, 4, 20, 18)]))
+          .to eq(ts_array)
+      end
+
+      it 'serializes time objects in a nested hash as iso8601 format strings' do
+        expect(dump(x: { time: Time.utc(2016, 1, 4, 20, 18) }))
+          .to eq("{\"x\":#{ts}}")
+      end
     end
 
     it 'serializes date objects as iso8601 format strings' do
@@ -33,17 +42,17 @@ describe Freddy::Payload do
     end
 
     it 'serializes datetime objects as iso8601 format strings' do
-      expect(dump(datetime: DateTime.new(2016, 1, 4, 20, 18))) # rubocop:disable Style/DateTime
+      expect(dump(datetime: DateTime.new(2016, 1, 4, 20, 18)))
         .to eq('{"datetime":"2016-01-04T20:18:00+00:00"}')
     end
 
     it 'serializes datetime objects in an array as iso8601 format strings' do
-      expect(dump(datetime: [DateTime.new(2016, 1, 4, 20, 18)])) # rubocop:disable Style/DateTime
+      expect(dump(datetime: [DateTime.new(2016, 1, 4, 20, 18)]))
         .to eq('{"datetime":["2016-01-04T20:18:00+00:00"]}')
     end
 
     it 'serializes datetime objects in a nested hash as iso8601 format strings' do
-      expect(dump(x: { datetime: DateTime.new(2016, 1, 4, 20, 18) })) # rubocop:disable Style/DateTime
+      expect(dump(x: { datetime: DateTime.new(2016, 1, 4, 20, 18) }))
         .to eq('{"x":{"datetime":"2016-01-04T20:18:00+00:00"}}')
     end
 

data/spec/integration/concurrency_spec.rb

@@ -10,21 +10,17 @@ describe 'Concurrency' do
 
   it 'supports multiple requests in #respond_to' do
     freddy1.respond_to 'Concurrency1' do |_payload, msg_handler|
-      begin
-        freddy1.deliver_with_response 'Concurrency2', msg: 'noop'
-        result2 = freddy1.deliver_with_response 'Concurrency3', msg: 'noop'
-        msg_handler.success(result2)
-      rescue Freddy::InvalidRequestError => e
-        msg_handler.error(e.response)
-      end
+      freddy1.deliver_with_response 'Concurrency2', msg: 'noop'
+      result2 = freddy1.deliver_with_response 'Concurrency3', msg: 'noop'
+      msg_handler.success(result2)
+    rescue Freddy::InvalidRequestError => e
+      msg_handler.error(e.response)
     end
 
     freddy2.respond_to 'Concurrency2' do |_payload, msg_handler|
-      begin
-        msg_handler.success(from: 'Concurrency2')
-      rescue Freddy::InvalidRequestError => e
-        msg_handler.error(e.response)
-      end
+      msg_handler.success(from: 'Concurrency2')
+    rescue Freddy::InvalidRequestError => e
+      msg_handler.error(e.response)
     end
 
     freddy3.respond_to 'Concurrency3' do |_payload, msg_handler|

data/spec/integration/tap_into_with_group_spec.rb

@@ -10,6 +10,11 @@ describe 'Tapping into with group identifier' do
 
   after { [deliverer, responder1, responder2].each(&:close) }
 
+  it 'raises an exception if option :durable is provided without group' do
+    expect { responder1.tap_into(destination, durable: true) }
+      .to raise_error(RuntimeError)
+  end
+
   it 'receives a message once' do
     msg_counter = Hamster::MutableSet[]
 
@@ -21,4 +26,33 @@ describe 'Tapping into with group identifier' do
     default_sleep
     expect(msg_counter.count).to eq(1)
   end
+
+  it 'can requeue message on exception' do
+    counter = 0
+
+    responder1.tap_into(destination, group: arbitrary_id, on_exception: :requeue) do
+      counter += 1
+      raise 'error' if counter == 1
+    end
+
+    deliverer.deliver(destination, {})
+
+    wait_for { counter == 2 }
+    expect(counter).to eq(2)
+  end
+
+  it 'taps into multiple topics' do
+    destination2 = random_destination
+    counter = 0
+
+    responder1.tap_into([destination, destination2], group: arbitrary_id) do
+      counter += 1
+    end
+
+    deliverer.deliver(destination, {})
+    deliverer.deliver(destination2, {})
+
+    wait_for { counter == 2 }
+    expect(counter).to eq(2)
+  end
 end

data/spec/integration/tracing_spec.rb

@@ -1,13 +1,8 @@
 require 'spec_helper'
-require 'opentracing_test_tracer'
 
 describe 'Tracing' do
-  let(:tracer) { OpenTracingTestTracer.build(logger: logger) }
   let(:logger) { spy }
 
-  before { OpenTracing.global_tracer = tracer }
-  after { OpenTracing.global_tracer = nil }
-
   context 'when receiving a traced request' do
     let(:freddy) { Freddy.build(logger, config) }
     let(:freddy2) { Freddy.build(logger, config) }
@@ -18,21 +13,13 @@ describe 'Tracing' do
     before do
       freddy.respond_to(destination) do |_payload, msg_handler|
         msg_handler.success(
-          trace_initiator: {
-            trace_id: active_span.context.trace_id,
-            parent_id: active_span.context.parent_id,
-            span_id: active_span.context.span_id
-          },
+          trace_initiator: current_span_attributes,
           current_receiver: freddy.deliver_with_response(destination2, {})
         )
       end
 
       freddy2.respond_to(destination2) do |_payload, msg_handler|
-        msg_handler.success(
-          trace_id: active_span.context.trace_id,
-          parent_id: active_span.context.parent_id,
-          span_id: active_span.context.span_id
-        )
+        msg_handler.success(current_span_attributes)
       end
     end
 
@@ -75,31 +62,19 @@ describe 'Tracing' do
     before do
       freddy.respond_to(destination) do |_payload, msg_handler|
         msg_handler.success({
-          trace_initiator: {
-            trace_id: active_span.context.trace_id,
-            parent_id: active_span.context.parent_id,
-            span_id: active_span.context.span_id
-          }
+          trace_initiator: current_span_attributes
         }.merge(freddy.deliver_with_response(destination2, {})))
       end
 
       freddy2.respond_to(destination2) do |_payload, msg_handler|
         msg_handler.success(
-          previous_receiver: {
-            trace_id: active_span.context.trace_id,
-            parent_id: active_span.context.parent_id,
-            span_id: active_span.context.span_id
-          },
+          previous_receiver: current_span_attributes,
           current_receiver: freddy2.deliver_with_response(destination3, {})
         )
       end
 
       freddy3.respond_to(destination3) do |_payload, msg_handler|
-        msg_handler.success(
-          trace_id: active_span.context.trace_id,
-          parent_id: active_span.context.parent_id,
-          span_id: active_span.context.span_id
-        )
+        msg_handler.success(current_span_attributes)
       end
     end
 
@@ -131,7 +106,15 @@ describe 'Tracing' do
     end
   end
 
-  def active_span
-    OpenTracing.active_span
+  def current_span_attributes
+    {
+      trace_id: current_span.context.trace_id,
+      parent_id: current_span.parent_span_id,
+      span_id: current_span.context.span_id
+    }
+  end
+
+  def current_span
+    OpenTelemetry::Trace.current_span
   end
 end