freddy 1.7.0 → 2.0.0

data/lib/freddy/payload.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
-begin
-  require 'oj'
-rescue LoadError
-  require 'symbolizer'
-  require 'json'
-end
+require 'oj'
 
 class Freddy
   class Payload
@@ -20,7 +15,7 @@ class Freddy
     end
 
     def self.json_handler
-      @json_handler ||= defined?(Oj) ? OjAdapter : JsonAdapter
+      @json_handler ||= OjAdapter
     end
 
     class OjAdapter
@@ -35,31 +30,5 @@ class Freddy
         Oj.dump(payload, DUMP_OPTIONS)
       end
     end
-
-    class JsonAdapter
-      def self.parse(payload)
-        # MRI has :symbolize_keys, but JRuby does not. Not adding it at the
-        # moment.
-        Symbolizer.symbolize(JSON.parse(payload))
-      end
-
-      def self.dump(payload)
-        JSON.dump(serialize_time_objects(payload))
-      end
-
-      def self.serialize_time_objects(object)
-        if object.is_a?(Hash)
-          object.reduce({}) do |hash, (key, value)|
-            hash.merge(key => serialize_time_objects(value))
-          end
-        elsif object.is_a?(Array)
-          object.map(&method(:serialize_time_objects))
-        elsif object.is_a?(Time) || object.is_a?(Date)
-          object.iso8601
-        else
-          object
-        end
-      end
-    end
   end
 end

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/producers/reply_producer.rb

@@ -10,17 +10,24 @@ class Freddy
         @exchange = channel.default_exchange
       end
 
-      def produce(destination, payload, properties)
-        if (span = OpenTracing.active_span)
-          span.set_tag('message_bus.destination', destination)
-        end
+      def produce(routing_key, payload, properties)
+        span = Tracing.span_for_produce(
+          @exchange,
+          routing_key,
+          payload,
+          correlation_id: properties[:correlation_id]
+        )
 
         properties = properties.merge(
-          routing_key: destination,
+          routing_key: routing_key,
           content_type: CONTENT_TYPE
         )
+        Tracing.inject_tracing_information_to_properties!(properties)
 
         @exchange.publish Payload.dump(payload), properties
+      ensure
+        # We won't wait for a reply. Just finish the span immediately.
+        span.finish
       end
     end
   end

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -11,19 +11,15 @@ class Freddy
         @topic_exchange = channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
       end
 
-      def produce(destination, payload, properties)
-        span = OpenTracing.start_span("freddy:notify:#{destination}",
-                                      tags: {
-                                        'message_bus.destination' => destination,
-                                        'component' => 'freddy',
-                                        'span.kind' => 'producer' # Message Bus
-                                      })
+      def produce(routing_key, payload, properties)
+        span = Tracing.span_for_produce(@topic_exchange, routing_key, payload)
 
         properties = properties.merge(
-          routing_key: destination,
+          routing_key: routing_key,
           content_type: CONTENT_TYPE
         )
-        OpenTracing.global_tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, TraceCarrier.new(properties))
+        Tracing.inject_tracing_information_to_properties!(properties)
+
         json_payload = Payload.dump(payload)
 
         # Connection adapters handle thread safety for #publish themselves. No
@@ -33,8 +29,6 @@ class Freddy
       ensure
         # We don't know how many listeners there are and we do not know when
         # this message gets processed. Instead we close the span immediately.
-        # Listeners should use FollowsFrom to add trace information.
-        # https://github.com/opentracing/specification/blob/master/specification.md
         span.finish
       end
     end

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -12,7 +12,6 @@ class Freddy
         @request_manager = RequestManager.new(@logger)
 
         @exchange = @channel.default_exchange
-        @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
 
         @channel.on_no_route do |correlation_id|
           @request_manager.no_route(correlation_id)
@@ -24,43 +23,37 @@ class Freddy
         @response_consumer.consume(@channel, @response_queue, &method(:handle_response))
       end
 
-      def produce(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties)
+      def produce(routing_key, payload, timeout_in_seconds:, delete_on_timeout:, **properties)
         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
-                                      })
+        span = Tracing.span_for_produce(
+          @exchange,
+          routing_key,
+          payload,
+          correlation_id: correlation_id, timeout_in_seconds: timeout_in_seconds
+        )
 
         container = SyncResponseContainer.new(
-          on_timeout(correlation_id, destination, timeout_in_seconds, span)
+          on_timeout(correlation_id, routing_key, timeout_in_seconds, span)
         )
 
         @request_manager.store(correlation_id,
                                callback: container,
                                span: span,
-                               destination: destination)
+                               destination: routing_key)
 
         properties[:expiration] = (timeout_in_seconds * 1000).to_i if delete_on_timeout
 
         properties = properties.merge(
-          routing_key: destination, content_type: CONTENT_TYPE,
+          routing_key: routing_key, content_type: CONTENT_TYPE,
           correlation_id: correlation_id, reply_to: @response_queue.name,
           mandatory: true, type: 'request'
         )
-        OpenTracing.global_tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, TraceCarrier.new(properties))
-        json_payload = Payload.dump(payload)
+        Tracing.inject_tracing_information_to_properties!(properties)
 
         # Connection adapters handle thread safety for #publish themselves. No
-        # need to lock these.
-        @topic_exchange.publish json_payload, properties.dup
-        @exchange.publish json_payload, properties.dup
+        # need to lock this.
+        @exchange.publish Payload.dump(payload), properties.dup
 
         container.wait_for_response(timeout_in_seconds)
       end
@@ -82,28 +75,21 @@ class Freddy
                       "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
-        )
+        request[:span].record_exception(e)
+        request[:span].status = OpenTelemetry::Trace::Status.error
         raise e
       ensure
         request[:span].finish
       end
 
-      def on_timeout(correlation_id, destination, timeout_in_seconds, span)
+      def on_timeout(correlation_id, routing_key, timeout_in_seconds, span)
         proc do
-          @logger.warn "Request timed out waiting response from #{destination}"\
+          @logger.warn "Request timed out waiting response from #{routing_key}"\
                        ", correlation id #{correlation_id}, timeout #{timeout_in_seconds}s"
 
           @request_manager.delete(correlation_id)
-          span.set_tag('error', true)
-          span.log_kv(
-            event: 'timed out',
-            message: "Timed out waiting response from #{destination}"
-          )
+          span.add_event('timeout')
+          span.status = OpenTelemetry::Trace::Status.error("Timed out waiting response from #{routing_key}")
           span.finish
         end
       end

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.0.0'
+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/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|