freddy-jruby 1.0.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7a6fe168fade15285ff62a57414a7f67efb3534
-  data.tar.gz: 47c18f83c774fa3f37841f231ab8ec78c59aa3cb
+  metadata.gz: 3ef47a37bd23d9834cd4d639e0ea0455f5a2c5ad
+  data.tar.gz: 7a778b7dfa7e473a6ea27d848e67df2c662cf249
 SHA512:
-  metadata.gz: 00fe0fe90d0026846bb90787b9bc7d4caf7f778d975b28ab65d1fb8ed79df4b01d03a76404e6c501f131ac88d9d7ecc71c8ce62698d3fe2cf10dce5876a5d9d2
-  data.tar.gz: 36e5b3b91f48020d01ff263cb7ddf0344c2a9523c4a29b458f5fc801a530a274eeb82401831ae7a36a0634cb8a8e8eba4315fb5a3d80f97af3da3bd3ddbcf2f1
+  metadata.gz: 0fe89c5b20d04b4315937406452315f44516ae6ca1b250b7b11362e1ec5edfcb83ed7ffc0e654dab23735caf37490b311ecd87430f8fc4c9e2bbbb9b85c9a72d
+  data.tar.gz: 9e79d8a97a65c7f7077b90e9577a39ec0238edcff0afb0d97e82c3c99fac304faf154fc822fee1d3042d4600c1a825c69bca9dab998ec295383dee7bddabce89

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - 2.1.0
-  - jruby-9.0.4.0
+  - 2.4.1
+  - jruby-9.1.5.0
 addons:
   code_climate:
     repo_token: 1f3842b985fdeff6a36168165d491ca5f444667e9381a85c899a61706a9dd285

data/Gemfile

@@ -4,5 +4,6 @@ gem 'rspec'
 gem 'pry'
 gem 'codeclimate-test-reporter'
 gem 'hamster', '~> 3.0'
+gem 'logasm-tracer', '0.2.2'
 
 gemspec

data/README.md

@@ -135,6 +135,41 @@ The following operations are supported:
 responder_handler.shutdown
 ```
 
+## Request Tracing
+
+Freddy supports [OpenTracing API|https://github.com/opentracing/opentracing-ruby]. You must set a global tracer which then freddy will use:
+```ruby
+OpenTracing.global_tracing = MyTracerImplementation.new(...)
+```
+
+For example you can use [Logasm::Tracer](https://github.com/salemove/logasm-tracer) which will log all incoming and outgoing requests with trace ID, parent ID and span ID.
+
+Current trace can be accessed through a thread-local variable `Freddy.trace`. Calling `deliver` or `deliver_with_response` will pass trace context to down-stream services.
+
+Accessing trace information when using Logasm::Tracer implementation:
+
+```ruby
+freddy1 = Freddy.build
+freddy1.respond_do('service1') do |payload, msg_handler|
+  puts "Trace id: #{Freddy.trace.context.trace_id}"
+  puts "Span id: #{Freddy.trace.context.span_id}"
+
+  freddy1.deliver('service2', {})
+end
+
+freddy2 = Freddy.build
+freddy2.tap_into('service2') do |payload|
+  puts "Has same trace_id as the request in service1: #{Freddy.trace.context.trace_id}"
+  puts "Has service1 request span id as parent id: #{Freddy.trace.context.parent_id}"
+  puts "Has its own generated span id: #{Freddy.trace.context.span_id}"
+end
+```
+
+In case you already have an ongoing OpenTracing span (e.g. provided by REST API) then you can pass the trace information to Freddy by doing:
+```ruby
+  Freddy.trace = trace_span
+```
+The `trace_span` must implement OpenTracing::Span interface.
 
 ## Notes about concurrency
 

data/freddy.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   else
     spec.name          = "freddy"
   end
-  spec.version       = '1.0.0'
+  spec.version       = '1.3.2'
   spec.authors       = ["Salemove TechMovers"]
   spec.email         = ["techmovers@salemove.com"]
   spec.description   = %q{Messaging API}
@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   end
 
   spec.add_dependency "thread", "~> 0.1"
+  spec.add_dependency "opentracing", "~> 0.3"
 end

data/lib/freddy.rb

@@ -1,6 +1,7 @@
 require 'json'
 require 'thread/pool'
 require 'securerandom'
+require 'opentracing'
 
 Dir[File.dirname(__FILE__) + '/freddy/*.rb'].each(&method(:require))
 
@@ -25,11 +26,20 @@ class Freddy
   # @example
   #   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)
+    OpenTracing.global_tracer ||= OpenTracing::Tracer.new
 
+    connection = Adapters.determine.connect(config)
     new(connection, logger, max_concurrency)
   end
 
+  def self.trace
+    Thread.current[:freddy_trace]
+  end
+
+  def self.trace=(trace)
+    Thread.current[:freddy_trace] = trace
+  end
+
   def initialize(connection, logger, max_concurrency)
     @connection = connection
     @logger = logger
@@ -76,7 +86,6 @@ class Freddy
     handler_adapter_factory = MessageHandlerAdapters::Factory.new(producer)
 
     Consumers::RespondToConsumer.consume(
-      logger: @logger,
       thread_pool: Thread.pool(@prefetch_buffer_size),
       destination: destination,
       channel: channel,
@@ -111,7 +120,6 @@ class Freddy
     @logger.debug "Tapping into messages that match #{pattern}"
 
     Consumers::TapIntoConsumer.consume(
-      logger: @logger,
       thread_pool: Thread.pool(@prefetch_buffer_size),
       pattern: pattern,
       channel: @connection.create_channel(prefetch: @prefetch_buffer_size),

data/lib/freddy/consumers.rb

@@ -1,14 +1 @@
-class Freddy
-  module Consumers
-    def self.log_receive_event(logger, queue_name, delivery)
-      logger.debug(
-        message: 'Received message',
-        queue: queue_name,
-        payload: delivery.payload,
-        correlation_id: delivery.correlation_id
-      )
-    end
-  end
-end
-
 Dir[File.dirname(__FILE__) + '/consumers/*.rb'].each(&method(:require))

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -5,8 +5,7 @@ class Freddy
         new(*attrs).consume(&block)
       end
 
-      def initialize(logger:, thread_pool:, destination:, channel:, handler_adapter_factory:)
-        @logger = logger
+      def initialize(thread_pool:, destination:, channel:, handler_adapter_factory:)
         @consume_thread_pool = thread_pool
         @destination = destination
         @channel = channel
@@ -15,8 +14,6 @@ class Freddy
 
       def consume(&block)
         consumer = consume_from_destination do |delivery|
-          Consumers.log_receive_event(@logger, @destination, delivery)
-
           adapter = @handler_adapter_factory.for(delivery)
 
           msg_handler = MessageHandler.new(adapter, delivery)
@@ -37,9 +34,25 @@ class Freddy
       def process_message(delivery, &block)
         @consume_thread_pool.process do
           begin
+            Freddy.trace = delivery.build_trace("freddy:respond:#{@destination}",
+              tags: {
+                'peer.address': "#{@destination}:#{delivery.payload[:type]}",
+                'component': 'freddy',
+                'span.kind': 'server' # RPC
+              }
+            )
+            Freddy.trace.log(
+              event: 'Received message through respond_to',
+              queue: @destination,
+              payload: delivery.payload,
+              correlation_id: delivery.correlation_id
+            )
+
             block.call(delivery)
           ensure
             @channel.acknowledge(delivery.tag, false)
+            Freddy.trace.finish
+            Freddy.trace = nil
           end
         end
       end

data/lib/freddy/consumers/response_consumer.rb

@@ -8,16 +8,9 @@ class Freddy
       def consume(channel, queue, &block)
         @logger.debug "Consuming messages on #{queue.name}"
         queue.subscribe do |delivery|
-          process_message(channel, queue, delivery, &block)
+          block.call(delivery)
         end
       end
-
-      private
-
-      def process_message(channel, queue, delivery, &block)
-        Consumers.log_receive_event(@logger, queue.name, delivery)
-        block.call(delivery)
-      end
     end
   end
 end

data/lib/freddy/consumers/tap_into_consumer.rb

@@ -5,8 +5,7 @@ class Freddy
         new(*attrs).consume(&block)
       end
 
-      def initialize(logger:, thread_pool:, pattern:, channel:, options:)
-        @logger = logger
+      def initialize(thread_pool:, pattern:, channel:, options:)
         @consume_thread_pool = thread_pool
         @pattern = pattern
         @channel = channel
@@ -43,10 +42,25 @@ class Freddy
       def process_message(queue, delivery, &block)
         @consume_thread_pool.process do
           begin
-            Consumers.log_receive_event(@logger, queue.name, delivery)
+            Freddy.trace = delivery.build_trace("freddy:observe:#{@pattern}",
+              tags: {
+                'message_bus.destination': @pattern,
+                'component': 'freddy',
+                'span.kind': 'consumer' # Message Bus
+              },
+              force_follows_from: true
+            )
+            Freddy.trace.log(
+              event: 'Received message through tap_into',
+              payload: delivery.payload,
+              correlation_id: delivery.correlation_id
+            )
+
             block.call delivery.payload, delivery.routing_key
           ensure
             @channel.acknowledge(delivery.tag, false)
+            Freddy.trace.finish
+            Freddy.trace = nil
           end
         end
       end

data/lib/freddy/delivery.rb

@@ -20,5 +20,26 @@ class Freddy
     def reply_to
       @metadata.reply_to
     end
+
+    def build_trace(operation_name, tags: {}, force_follows_from: false)
+      carrier = TraceCarrier.new(@metadata)
+      parent =
+        if expecting_response? && !force_follows_from
+          OpenTracing.global_tracer.extract(OpenTracing::FORMAT_TEXT_MAP, carrier)
+        else
+          nil
+        end
+
+      # Creating a child span when the message sender is expecting a response.
+      # Otherwise creating a new trace because the OpenTracing client does not
+      # support FollowsFrom yet.
+      OpenTracing.start_span(operation_name, child_of: parent, tags: tags)
+    end
+
+    private
+
+    def expecting_response?
+      type == 'request'
+    end
   end
 end

data/lib/freddy/payload.rb

@@ -22,12 +22,15 @@ class Freddy
     end
 
     class OjAdapter
+      PARSE_OPTIONS = { symbol_keys: true }
+      DUMP_OPTIONS = { mode: :compat, time_format: :xmlschema, second_precision: 6 }
+
       def self.parse(payload)
-        Oj.strict_load(payload, symbol_keys: true)
+        Oj.strict_load(payload, PARSE_OPTIONS)
       end
 
       def self.dump(payload)
-        Oj.dump(payload, mode: :compat, time_format: :xmlschema)
+        Oj.dump(payload, DUMP_OPTIONS)
       end
     end
 

data/lib/freddy/producers.rb

@@ -1,9 +1 @@
-class Freddy
-  module Producers
-    def self.log_send_event(logger, payload, destination)
-      logger.debug message: 'Sending message', queue: destination, payload: payload
-    end
-  end
-end
-
 Dir[File.dirname(__FILE__) + '/producers/*.rb'].each(&method(:require))

data/lib/freddy/producers/reply_producer.rb

@@ -9,10 +9,11 @@ class Freddy
       end
 
       def produce(destination, payload, properties)
-        Producers.log_send_event(@logger, payload, destination)
+        Freddy.trace.log event: 'Sending response', queue: destination, payload: payload
 
         properties = properties.merge(
-          routing_key: destination, content_type: CONTENT_TYPE
+          routing_key: destination,
+          content_type: CONTENT_TYPE
         )
 
         @exchange.publish Payload.dump(payload), properties

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -10,15 +10,33 @@ class Freddy
       end
 
       def produce(destination, payload, properties)
-        Producers.log_send_event(@logger, payload, destination)
+        span = OpenTracing.start_span("freddy:notify:#{destination}",
+          child_of: Freddy.trace,
+          tags: {
+            'message_bus.destination': destination,
+            'component': 'freddy',
+            'span.kind': 'producer' # Message Bus
+          }
+        )
+        span.log event: 'Sending message', payload: payload
 
-        properties = properties.merge(routing_key: destination, content_type: CONTENT_TYPE)
+        properties = properties.merge(
+          routing_key: destination,
+          content_type: CONTENT_TYPE
+        )
+        OpenTracing.global_tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, TraceCarrier.new(properties))
         json_payload = Payload.dump(payload)
 
         # 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
+      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
   end

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -23,14 +23,24 @@ class Freddy
       end
 
       def produce(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties)
+        span = OpenTracing.start_span("freddy:request:#{destination}",
+          child_of: Freddy.trace,
+          tags: {
+            'component': 'freddy',
+            'span.kind': 'client', # RPC
+            'payload.type': payload[:type]
+          }
+        )
+
         correlation_id = SecureRandom.uuid
 
         container = SyncResponseContainer.new(
-          on_timeout(correlation_id, destination, timeout_in_seconds)
+          on_timeout(correlation_id, destination, timeout_in_seconds, span)
         )
 
         @request_manager.store(correlation_id,
           callback: container,
+          trace: span,
           destination: destination
         )
 
@@ -43,11 +53,11 @@ class Freddy
           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)
 
-        @logger.debug(
-          message: 'Publishing request',
-          queue: destination,
+        span.log(
+          event: 'Publishing request',
           payload: payload,
           response_queue: @response_queue.name,
           correlation_id: correlation_id
@@ -77,14 +87,17 @@ class Freddy
         @logger.debug "Got response for request to #{request[:destination]} "\
                       "with correlation_id #{delivery.correlation_id}"
         request[:callback].call(delivery.payload, delivery)
+      ensure
+        request[:trace].finish
       end
 
-      def on_timeout(correlation_id, destination, timeout_in_seconds)
+      def on_timeout(correlation_id, destination, timeout_in_seconds, trace)
         Proc.new do
           @logger.warn "Request timed out waiting response from #{destination}"\
                        ", correlation id #{correlation_id}"
 
           @request_manager.delete(correlation_id)
+          trace.finish
         end
       end
     end

data/lib/freddy/trace_carrier.rb

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

data/spec/freddy/consumers/respond_to_consumer_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 describe Freddy::Consumers::RespondToConsumer do
   let(:consumer) do
     described_class.new(
-      logger: logger,
       thread_pool: thread_pool,
       destination: destination,
       channel: channel,

data/spec/freddy/trace_carrier_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Freddy::TraceCarrier do
+  subject(:carrier) { described_class.new(properties) }
+
+  context 'when adding trace information' do
+    let(:properties) { {x: 'y'} }
+    let(:key_name) { 'some-key' }
+    let(:key_value) { 'some-key' }
+
+    it 'adds a header with x-trace- prefix' do
+      carrier[key_name] = key_value
+      expect(properties[:headers]["x-trace-#{key_name}"]).to eq(key_value)
+    end
+  end
+
+  context 'when extracting trace information' do
+    let(:key_name) { 'some-key' }
+    let(:serialized_key_name) { "x-trace-#{key_name}" }
+    let(:key_value) { 'some-key' }
+
+    let(:properties) do
+      double(headers: {serialized_key_name => key_value})
+    end
+
+    it 'extracts a header with x-trace- prefix' do
+      expect(carrier[key_name]).to eq(key_value)
+    end
+  end
+
+  describe '#each' do
+    context 'when headers are present' do
+      let(:properties) do
+        double(
+          headers: {
+            "x-trace-key1" => "value1",
+            "x-trace-key2" => "value2",
+            "other-key" => "value3"
+          }
+        )
+      end
+
+      it 'iterates over keys starting with x-trace- prefix' do
+        expect(carrier.each.count).to eq(2)
+      end
+    end
+
+    context 'when no headers' do
+      let(:properties) { double(headers: nil) }
+
+      it 'iterates over an empty list' do
+        expect(carrier.each.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/integration/logging_spec.rb

@@ -1,44 +1,101 @@
 require 'spec_helper'
+require 'logasm/tracer'
 
-describe 'Logging' do
-  let(:freddy1) { Freddy.build(logger1, config) }
-  let(:freddy2) { Freddy.build(logger2, config) }
+describe 'Logging with Logasm::Tracer' do
+  let(:logger) { ArrayLogger.new }
+  let(:tracer) { Logasm::Tracer.new(logger) }
 
-  let(:logger1) { spy('logger1') }
-  let(:logger2) { spy('logger2') }
+  before { OpenTracing.global_tracer = tracer }
+  after { OpenTracing.global_tracer = nil }
 
-  let(:destination) { random_destination }
-  let(:payload)     { {pay: 'load'} }
+  context 'when receiving an untraced request' do
+    let(:freddy) { Freddy.build(spy, config) }
+    let(:destination) { random_destination }
 
-  after { [freddy1, freddy2].each(&:close) }
-
-  before do
-    freddy1.respond_to destination do |payload, msg_handler|
-      msg_handler.success
+    before do
+      freddy.respond_to(destination) do |payload, msg_handler|
+        sleep 0.1 # emulate some processing
+        msg_handler.success({})
+      end
     end
 
-    freddy2.deliver_with_response(destination, payload) { }
-    default_sleep
-  end
+    after { freddy.close }
+
+    it 'generates a trace' do
+      freddy.deliver_with_response(destination, {})
+
+      expect(logger.calls.map(&:first)).to eq([
+        # Initiator
+        "Span [freddy:request:#{destination}] started",
+        "Span [freddy:request:#{destination}] Publishing request",
+
+        # Service
+        "Span [freddy:respond:#{destination}] started",
+        "Span [freddy:respond:#{destination}] Received message through respond_to",
+        "Span [freddy:respond:#{destination}] Sending response",
+        "Span [freddy:respond:#{destination}] finished",
 
-  it 'logs all consumed messages' do
-    expect(logger1).to have_received(:info).with(/Listening for requests on \S+/)
-    expect(logger1).to have_received(:debug).with(
-      message: 'Received message',
-      queue: destination,
-      payload: payload,
-      correlation_id: anything
-    )
+        # Initiator
+        "Span [freddy:request:#{destination}] finished"
+      ])
+    end
   end
 
-  it 'logs all produced messages' do
-    expect(logger2).to have_received(:debug).with(/Consuming messages on \S+/)
-    expect(logger2).to have_received(:debug).with(
-      message: 'Publishing request',
-      queue: destination,
-      payload: payload,
-      response_queue: anything,
-      correlation_id: anything
-    )
+  context 'when receiving a traced request' do
+    let(:freddy) { Freddy.build(spy, config) }
+    let(:freddy2) { Freddy.build(spy, config) }
+
+    let(:destination) { random_destination }
+    let(:destination2) { random_destination }
+
+    before do
+      freddy.respond_to(destination) do |payload, msg_handler|
+        sleep 0.1 # emulate some processing
+        msg_handler.success({
+          trace_initiator: {},
+          current_receiver: freddy.deliver_with_response(destination2, {})
+        })
+      end
+
+      freddy2.respond_to(destination2) do |payload, msg_handler|
+        sleep 0.1 # emulate some processing
+        msg_handler.success({})
+      end
+    end
+
+    after do
+      freddy.close
+      freddy2.close
+    end
+
+    it 'generates a trace' do
+      freddy.deliver_with_response(destination, {})
+
+      expect(logger.calls.map(&:first)).to eq([
+        # Initiator
+        "Span [freddy:request:#{destination}] started",
+        "Span [freddy:request:#{destination}] Publishing request",
+
+        # Service 1
+        "Span [freddy:respond:#{destination}] started",
+        "Span [freddy:respond:#{destination}] Received message through respond_to",
+        "Span [freddy:request:#{destination2}] started",
+        "Span [freddy:request:#{destination2}] Publishing request",
+
+        # Service 2
+        "Span [freddy:respond:#{destination2}] started",
+        "Span [freddy:respond:#{destination2}] Received message through respond_to",
+        "Span [freddy:respond:#{destination2}] Sending response",
+        "Span [freddy:respond:#{destination2}] finished",
+
+        # Service 1
+        "Span [freddy:request:#{destination2}] finished",
+        "Span [freddy:respond:#{destination}] Sending response",
+        "Span [freddy:respond:#{destination}] finished",
+
+        # Initiator
+        "Span [freddy:request:#{destination}] finished"
+      ])
+    end
   end
 end

data/spec/integration/tracing_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'logasm/tracer'
+
+describe 'Tracing' do
+  let(:tracer) { Logasm::Tracer.new(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) }
+
+    let(:destination) { random_destination }
+    let(:destination2) { random_destination }
+
+    before do
+      freddy.respond_to(destination) do |payload, msg_handler|
+        msg_handler.success({
+          trace_initiator: {
+            trace_id: Freddy.trace.context.trace_id,
+            parent_id: Freddy.trace.context.parent_id,
+            span_id: Freddy.trace.context.span_id
+          },
+          current_receiver: freddy.deliver_with_response(destination2, {})
+        })
+      end
+
+      freddy2.respond_to(destination2) do |payload, msg_handler|
+        msg_handler.success({
+          trace_id: Freddy.trace.context.trace_id,
+          parent_id: Freddy.trace.context.parent_id,
+          span_id: Freddy.trace.context.span_id
+        })
+      end
+    end
+
+    after do
+      freddy.close
+      freddy2.close
+    end
+
+    it 'has trace_id from the trace initiator' do
+      response = freddy.deliver_with_response(destination, {})
+      trace_initiator = response.fetch(:trace_initiator)
+      current_receiver = response.fetch(:current_receiver)
+      expect(trace_initiator.fetch(:trace_id)).to eq(current_receiver.fetch(:trace_id))
+    end
+
+    it 'has parent_id' do
+      response = freddy.deliver_with_response(destination, {})
+      current_receiver = response.fetch(:current_receiver)
+      expect(current_receiver.fetch(:parent_id)).to_not be_nil
+    end
+
+    it 'has generated span_id' do
+      response = freddy.deliver_with_response(destination, {})
+      trace_initiator = response.fetch(:trace_initiator)
+      current_receiver = response.fetch(:current_receiver)
+      expect(current_receiver.fetch(:span_id)).to_not be_nil
+      expect(current_receiver.fetch(:span_id)).to_not eq(trace_initiator.fetch(:span_id))
+    end
+  end
+
+  context 'when receiving a nested traced request' do
+    let(:freddy) { Freddy.build(logger, config) }
+    let(:freddy2) { Freddy.build(logger, config) }
+    let(:freddy3) { Freddy.build(logger, config) }
+
+    let(:destination) { random_destination }
+    let(:destination2) { random_destination }
+    let(:destination3) { random_destination }
+
+    before do
+      freddy.respond_to(destination) do |payload, msg_handler|
+        msg_handler.success({
+          trace_initiator: {
+            trace_id: Freddy.trace.context.trace_id,
+            parent_id: Freddy.trace.context.parent_id,
+            span_id: Freddy.trace.context.span_id
+          }
+        }.merge(freddy.deliver_with_response(destination2, {})))
+      end
+
+      freddy2.respond_to(destination2) do |payload, msg_handler|
+        msg_handler.success({
+          previous_receiver: {
+            trace_id: Freddy.trace.context.trace_id,
+            parent_id: Freddy.trace.context.parent_id,
+            span_id: Freddy.trace.context.span_id
+          },
+          current_receiver: freddy2.deliver_with_response(destination3, {})
+        })
+      end
+
+      freddy3.respond_to(destination3) do |payload, msg_handler|
+        msg_handler.success({
+          trace_id: Freddy.trace.context.trace_id,
+          parent_id: Freddy.trace.context.parent_id,
+          span_id: Freddy.trace.context.span_id
+        })
+      end
+    end
+
+    after do
+      freddy.close
+      freddy2.close
+      freddy3.close
+    end
+
+    it 'has trace_id from the trace initiator' do
+      response = freddy.deliver_with_response(destination, {})
+      trace_initiator = response.fetch(:trace_initiator)
+      current_receiver = response.fetch(:current_receiver)
+      expect(trace_initiator.fetch(:trace_id)).to eq(current_receiver.fetch(:trace_id))
+    end
+
+    it 'has parent_id' do
+      response = freddy.deliver_with_response(destination, {})
+      current_receiver = response.fetch(:current_receiver)
+      expect(current_receiver.fetch(:parent_id)).to_not be_nil
+    end
+
+    it 'has generated span_id' do
+      response = freddy.deliver_with_response(destination, {})
+      previous_receiver = response.fetch(:previous_receiver)
+      current_receiver = response.fetch(:current_receiver)
+      expect(current_receiver.fetch(:span_id)).to_not be_nil
+      expect(current_receiver.fetch(:span_id)).to_not eq(previous_receiver.fetch(:span_id))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -22,6 +22,10 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
+
+  config.before do
+    OpenTracing.global_tracer ||= OpenTracing::Tracer.new
+  end
 end
 
 def random_destination
@@ -61,3 +65,15 @@ def spawn_echo_responder(freddy, queue_name)
     msg_handler.success(payload)
   end
 end
+
+class ArrayLogger
+  attr_accessor :calls
+
+  def initialize
+    @calls = []
+  end
+
+  def info(*args)
+    @calls << args
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy-jruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Salemove TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-01-30 00:00:00.000000000 Z
+date: 2018-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  name: opentracing
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: Messaging API
 email:
 - techmovers@salemove.com
@@ -120,6 +134,7 @@ files:
 - lib/freddy/responder_handler.rb
 - lib/freddy/sync_response_container.rb
 - lib/freddy/timeout_error.rb
+- lib/freddy/trace_carrier.rb
 - spec/freddy/consumers/respond_to_consumer_spec.rb
 - spec/freddy/error_response_spec.rb
 - spec/freddy/freddy_spec.rb
@@ -127,10 +142,12 @@ files:
 - spec/freddy/payload_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
+- spec/freddy/trace_carrier_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb
 - spec/integration/tap_into_with_group_spec.rb
+- spec/integration/tracing_spec.rb
 - spec/spec_helper.rb
 homepage:
 licenses:
@@ -152,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.8
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response
@@ -164,8 +181,10 @@ test_files:
 - spec/freddy/payload_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
+- spec/freddy/trace_carrier_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb
 - spec/integration/tap_into_with_group_spec.rb
+- spec/integration/tracing_spec.rb
 - spec/spec_helper.rb