freddy 1.5.0 → 2.1.0

data/lib/freddy/consumers/response_consumer.rb

@@ -7,11 +7,9 @@ class Freddy
         @logger = logger
       end
 
-      def consume(_channel, queue)
+      def consume(_channel, queue, &block)
         @logger.debug "Consuming messages on #{queue.name}"
-        queue.subscribe do |delivery|
-          yield(delivery)
-        end
+        queue.subscribe(&block)
       end
     end
   end

data/lib/freddy/consumers/tap_into_consumer.rb

@@ -7,11 +7,13 @@ class Freddy
         new(*attrs).consume(&block)
       end
 
-      def initialize(thread_pool:, pattern:, channel:, options:)
+      def initialize(thread_pool:, patterns:, channel:, options:)
         @consume_thread_pool = thread_pool
-        @pattern = pattern
+        @patterns = patterns
         @channel = channel
         @options = options
+
+        raise 'Do not use durable queues without specifying a group' if durable? && !group
       end
 
       def consume(&block)
@@ -28,38 +30,52 @@ class Freddy
 
       def create_queue
         topic_exchange = @channel.topic(Freddy::FREDDY_TOPIC_EXCHANGE_NAME)
-        group = @options.fetch(:group, nil)
-
-        if group
-          @channel
-            .queue("groups.#{group}")
-            .bind(topic_exchange, routing_key: @pattern)
-        else
-          @channel
-            .queue('', exclusive: true)
-            .bind(topic_exchange, routing_key: @pattern)
+
+        queue =
+          if group
+            @channel.queue("groups.#{group}", durable: durable?)
+          else
+            @channel.queue('', exclusive: true)
+          end
+
+        @patterns.each do |pattern|
+          queue.bind(topic_exchange, routing_key: pattern)
         end
+
+        queue
       end
 
       def process_message(_queue, delivery)
         @consume_thread_pool.process do
-          begin
-            scope = delivery.build_trace("freddy:observe:#{@pattern}",
-                                         tags: {
-                                           'message_bus.destination' => @pattern,
-                                           'message_bus.correlation_id' => delivery.correlation_id,
-                                           'component' => 'freddy',
-                                           'span.kind' => 'consumer' # Message Bus
-                                         },
-                                         force_follows_from: true)
-
+          delivery.in_span(force_follows_from: true) do
             yield delivery.payload, delivery.routing_key
-          ensure
-            @channel.acknowledge(delivery.tag, false)
-            scope.close
+            @channel.acknowledge(delivery.tag)
+          end
+        rescue StandardError
+          case on_exception
+          when :reject
+            @channel.reject(delivery.tag)
+          when :requeue
+            @channel.reject(delivery.tag, true)
+          else
+            @channel.acknowledge(delivery.tag)
           end
+
+          raise
         end
       end
+
+      def group
+        @options.fetch(:group, nil)
+      end
+
+      def durable?
+        @options.fetch(:durable, false)
+      end
+
+      def on_exception
+        @options.fetch(:on_exception, :ack)
+      end
     end
   end
 end

data/lib/freddy/consumers.rb

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

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/encoding.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+class Freddy
+  class Encoding
+    ZLIB_CONTENT_ENCODING = 'zlib'
+
+    def self.compress(data, encoding)
+      case encoding
+      when ZLIB_CONTENT_ENCODING
+        ::Zlib::Deflate.deflate(data)
+      else
+        data
+      end
+    end
+
+    def self.uncompress(data, encoding)
+      case encoding
+      when ZLIB_CONTENT_ENCODING
+        ::Zlib::Inflate.inflate(data)
+      else
+        data
+      end
+    end
+  end
+end

data/lib/freddy/payload.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-begin
-  require 'oj'
-rescue LoadError
-  require 'symbolizer'
-  require 'json'
-end
+require 'oj'
 
 class Freddy
   class Payload
-    def self.parse(payload)
+    def self.parse(payload, encoding)
       return {} if payload == 'null'
 
+      payload = Freddy::Encoding.uncompress(payload, encoding)
       json_handler.parse(payload)
     end
 
@@ -20,7 +16,7 @@ class Freddy
     end
 
     def self.json_handler
-      @json_handler ||= defined?(Oj) ? OjAdapter : JsonAdapter
+      @json_handler ||= OjAdapter
     end
 
     class OjAdapter
@@ -35,31 +31,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/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,20 +11,19 @@ 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))
-        json_payload = Payload.dump(payload)
+        Tracing.inject_tracing_information_to_properties!(properties)
+
+        json_payload = Freddy::Encoding.compress(
+          Payload.dump(payload),
+          properties[:content_encoding]
+        )
 
         # Connection adapters handle thread safety for #publish themselves. No
         # need to lock these.
@@ -33,8 +32,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