freddy 1.4.2 → 2.0.0

data/lib/freddy/delivery.rb

@@ -4,11 +4,12 @@ class Freddy
   class Delivery
     attr_reader :routing_key, :payload, :tag
 
-    def initialize(payload, metadata, routing_key, tag)
+    def initialize(payload, metadata, routing_key, tag, exchange)
       @payload = payload
       @metadata = metadata
       @routing_key = routing_key
       @tag = tag
+      @exchange = exchange
     end
 
     def correlation_id
@@ -23,20 +24,52 @@ class Freddy
       @metadata.reply_to
     end
 
-    def build_trace(operation_name, tags: {}, force_follows_from: false)
-      carrier = TraceCarrier.new(@metadata)
-      parent = OpenTracing.global_tracer.extract(OpenTracing::FORMAT_TEXT_MAP, carrier)
-
-      references =
-        if !parent
-          []
-        elsif force_follows_from
-          [OpenTracing::Reference.follows_from(parent)]
-        else
-          [OpenTracing::Reference.child_of(parent)]
+    def in_span(force_follows_from: false, &block)
+      name = "#{@exchange}.#{@routing_key} receive"
+      kind = OpenTelemetry::Trace::SpanKind::CONSUMER
+      producer_context = OpenTelemetry.propagation.extract(@metadata[:headers] || {})
+
+      if force_follows_from
+        producer_span_context = OpenTelemetry::Trace.current_span(producer_context).context
+
+        links = []
+        links << OpenTelemetry::Trace::Link.new(producer_span_context) if producer_span_context.valid?
+
+        # In general we should start a new trace here and just link two traces
+        # together. But Zipkin (which we currently use) doesn't support links.
+        # So even though the root trace could finish before anything here
+        # starts executing, we'll continue with the root trace here as well.
+        OpenTelemetry::Context.with_current(producer_context) do
+          Freddy.tracer.in_span(name, attributes: span_attributes, links: links, kind: kind, &block)
         end
+      else
+        OpenTelemetry::Context.with_current(producer_context) do
+          Freddy.tracer.in_span(name, attributes: span_attributes, kind: kind, &block)
+        end
+      end
+    end
+
+    private
+
+    def span_attributes
+      destination_kind = @exchange == '' ? 'queue' : 'topic'
+
+      attributes = {
+        'payload.type' => (@payload[:type] || 'unknown').to_s,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_SYSTEM => 'rabbitmq',
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION => @exchange,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION_KIND => destination_kind,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_RABBITMQ_ROUTING_KEY => @routing_key,
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_OPERATION => 'receive'
+      }
+
+      # There's no correlation_id when a message was sent using
+      # `Freddy#deliver`.
+      if correlation_id
+        attributes[OpenTelemetry::SemanticConventions::Trace::MESSAGING_CONVERSATION_ID] = correlation_id
+      end
 
-      OpenTracing.start_active_span(operation_name, references: references, tags: tags)
+      attributes
     end
   end
 end

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,12 +15,12 @@ class Freddy
     end
 
     def self.json_handler
-      @json_handler ||= defined?(Oj) ? OjAdapter : JsonAdapter
+      @json_handler ||= OjAdapter
     end
 
     class OjAdapter
       PARSE_OPTIONS = { symbol_keys: true }.freeze
-      DUMP_OPTIONS = { mode: :compat, time_format: :xmlschema, second_precision: 6 }.freeze
+      DUMP_OPTIONS = { mode: :custom, time_format: :xmlschema, second_precision: 6 }.freeze
 
       def self.parse(payload)
         Oj.strict_load(payload, PARSE_OPTIONS)
@@ -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