freddy 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55a9bea9337f7d20d2e713bd012ed8f216fef328
-  data.tar.gz: 2c49767c9226fdf1b882cf221cec8ff7726203f9
+  metadata.gz: 780979fe0cb5c2d61b74d2356643695dc3380e1d
+  data.tar.gz: 7778664a870a3b04ea9b0d697445ec2843a4a98a
 SHA512:
-  metadata.gz: 7d3c30c1d5d54c72539821bc465f0887371ee30fdcbed3fa4711ee3b9f65137922025a4aa6956ca862b08b851d5bc8bff2d4aac7279a80250475c45a90e475ab
-  data.tar.gz: 13f606726903475c3619ee4f7dd1d18ebe257cbb48844cb0831cf81809b468eeb7143c4d4519b8cd1e6fa00e9d4703dcf9ce1282ebf70d4867419c85a89f42ae
+  metadata.gz: dd21e0ca6b7140f2096db0062f8793941928bab1f8f23b0c6c6f0e1a5641c2a244a7d624a543fae642d38d1af9f0b4cd6a736d77195d355699ef582135a68c39
+  data.tar.gz: ce44daf3488a6b7805d179f0176fb0b71a2080836526660a5482665a854c6e0bc214ac7a09e7c7fa4b5426a52dd65a2da253c4e3996c69420a275d91a2de56fe

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.0'
 
 gemspec

data/README.md

@@ -137,33 +137,39 @@ responder_handler.shutdown
 
 ## Request Tracing
 
-Freddy helps application developers to implement distributed tracing. Freddy provides trace ID, parent ID and span ID when receiving a request. These can be accessed through a thread-local variable `Freddy.trace`. Calling `deliver` or `deliver_with_response` will pass these IDs to the next service.
+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.id}"
-  puts "Span id: #{Freddy.trace.span_id}"
+  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.id}"
-  puts "Has service1 request span id as parent id: #{Freddy.trace.parent_id}"
-  puts "Has its own generated span id: #{Freddy.trace.span_id}"
+  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 trace IDs (e.g. provided by REST API) then you can set them yourself:
+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 = Freddy::Traces::Trace.new({
-    id: 'YourTraceId',
-    parent_id: 'YourParentId', # Use nil in case this is the root of the trace
-    span_id: 'YourSpanId'
-  })
+  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.1.0'
+  spec.version       = '1.2.0'
   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,13 +26,14 @@ 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] || Traces::NO_TRACE
+    Thread.current[:freddy_trace]
   end
 
   def self.trace=(trace)
@@ -84,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,
@@ -119,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,15 +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,
-        trace: Freddy.trace.to_h
-      )
-    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,10 +34,18 @@ class Freddy
       def process_message(delivery, &block)
         @consume_thread_pool.process do
           begin
-            Freddy.trace = delivery.trace
+            Freddy.trace = delivery.build_trace("freddy:respond:#{@destination}")
+            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

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,11 +42,20 @@ 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.trace
+            Freddy.trace = delivery.build_trace("freddy:observe:#{@pattern}",
+              tags: {queue: @pattern},
+              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

data/lib/freddy/delivery.rb

@@ -1,13 +1,12 @@
 class Freddy
   class Delivery
-    attr_reader :routing_key, :payload, :tag, :trace
+    attr_reader :routing_key, :payload, :tag
 
     def initialize(payload, metadata, routing_key, tag)
       @payload = payload
       @metadata = metadata
       @routing_key = routing_key
       @tag = tag
-      @trace = build_trace(metadata.headers || {})
     end
 
     def correlation_id
@@ -22,17 +21,25 @@ class Freddy
       @metadata.reply_to
     end
 
+    def build_trace(operation_name, tags: {}, force_follows_from: false)
+      carrier = TraceCarrier.new(@metadata)
+      parent =
+        if carrier.has_required_fields? && 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 build_trace(headers)
-      if headers['x-trace-id'] && headers['x-span-id']
-        Traces::Trace.build_from_existing_trace(
-          id: headers['x-trace-id'],
-          parent_id: headers['x-span-id']
-        )
-      else
-        Traces::Trace.build
-      end
+    def expecting_response?
+      type == 'request'
     end
   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, trace: Freddy.trace.to_h
-    end
-  end
-end
-
 Dir[File.dirname(__FILE__) + '/producers/*.rb'].each(&method(:require))

data/lib/freddy/producers/reply_producer.rb

@@ -9,15 +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,
-          headers: {
-            'x-trace-id' => Freddy.trace.id,
-            'x-span-id' => Freddy.trace.span_id
-          }
+          content_type: CONTENT_TYPE
         )
 
         @exchange.publish Payload.dump(payload), properties

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -10,22 +10,29 @@ 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: {queue: destination}
+        )
+        span.log event: 'Sending message', payload: payload
 
         properties = properties.merge(
           routing_key: destination,
-          content_type: CONTENT_TYPE,
-          headers: {
-            'x-trace-id' => Freddy.trace.id,
-            'x-span-id' => Freddy.trace.span_id
-          }
+          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,20 @@ 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: {queue: destination}
+        )
+
         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
         )
 
@@ -41,21 +47,16 @@ class Freddy
         properties = properties.merge(
           routing_key: destination, content_type: CONTENT_TYPE,
           correlation_id: correlation_id, reply_to: @response_queue.name,
-          mandatory: true, type: 'request',
-          headers: {
-            'x-trace-id' => Freddy.trace.id,
-            'x-span-id' => Freddy.trace.span_id
-          }
+          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,
-          trace: Freddy.trace.to_h
+          correlation_id: correlation_id
         )
 
         # Connection adapters handle thread safety for #publish themselves. No
@@ -82,14 +83,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,30 @@
+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
+
+    def has_required_fields?
+      self['trace-id'] && self['parent-id'] && self['span-id']
+    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,46 +1,98 @@
 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|
+        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,
-      trace: 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,
-      trace: 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|
+        msg_handler.success({
+          trace_initiator: {},
+          current_receiver: freddy.deliver_with_response(destination2, {})
+        })
+      end
+
+      freddy2.respond_to(destination2) do |payload, msg_handler|
+        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

@@ -1,6 +1,13 @@
 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 an untraced request' do
     let(:freddy) { Freddy.build(logger, config) }
     let(:destination) { random_destination }
@@ -8,9 +15,9 @@ describe 'Tracing' do
     before do
       freddy.respond_to(destination) do |payload, msg_handler|
         msg_handler.success({
-          trace_id: Freddy.trace.id,
-          parent_id: Freddy.trace.parent_id,
-          span_id: Freddy.trace.span_id
+          trace_id: Freddy.trace.context.trace_id,
+          parent_id: Freddy.trace.context.parent_id,
+          span_id: Freddy.trace.context.span_id
         })
       end
     end
@@ -44,9 +51,9 @@ describe 'Tracing' do
       freddy.respond_to(destination) do |payload, msg_handler|
         msg_handler.success({
           trace_initiator: {
-            trace_id: Freddy.trace.id,
-            parent_id: Freddy.trace.parent_id,
-            span_id: Freddy.trace.span_id
+            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, {})
         })
@@ -54,9 +61,9 @@ describe 'Tracing' do
 
       freddy2.respond_to(destination2) do |payload, msg_handler|
         msg_handler.success({
-          trace_id: Freddy.trace.id,
-          parent_id: Freddy.trace.parent_id,
-          span_id: Freddy.trace.span_id
+          trace_id: Freddy.trace.context.trace_id,
+          parent_id: Freddy.trace.context.parent_id,
+          span_id: Freddy.trace.context.span_id
         })
       end
     end
@@ -73,11 +80,10 @@ describe 'Tracing' do
       expect(trace_initiator.fetch(:trace_id)).to eq(current_receiver.fetch(:trace_id))
     end
 
-    it 'has request initiator span_id as parent_id' do
+    it 'has parent_id' do
       response = freddy.deliver_with_response(destination, {})
-      trace_initiator = response.fetch(:trace_initiator)
       current_receiver = response.fetch(:current_receiver)
-      expect(trace_initiator.fetch(:span_id)).to eq(current_receiver.fetch(:parent_id))
+      expect(current_receiver.fetch(:parent_id)).to_not be_nil
     end
 
     it 'has generated span_id' do
@@ -102,9 +108,9 @@ describe 'Tracing' do
       freddy.respond_to(destination) do |payload, msg_handler|
         msg_handler.success({
           trace_initiator: {
-            trace_id: Freddy.trace.id,
-            parent_id: Freddy.trace.parent_id,
-            span_id: Freddy.trace.span_id
+            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
@@ -112,9 +118,9 @@ describe 'Tracing' do
       freddy2.respond_to(destination2) do |payload, msg_handler|
         msg_handler.success({
           previous_receiver: {
-            trace_id: Freddy.trace.id,
-            parent_id: Freddy.trace.parent_id,
-            span_id: Freddy.trace.span_id
+            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, {})
         })
@@ -122,9 +128,9 @@ describe 'Tracing' do
 
       freddy3.respond_to(destination3) do |payload, msg_handler|
         msg_handler.success({
-          trace_id: Freddy.trace.id,
-          parent_id: Freddy.trace.parent_id,
-          span_id: Freddy.trace.span_id
+          trace_id: Freddy.trace.context.trace_id,
+          parent_id: Freddy.trace.context.parent_id,
+          span_id: Freddy.trace.context.span_id
         })
       end
     end
@@ -142,11 +148,10 @@ describe 'Tracing' do
       expect(trace_initiator.fetch(:trace_id)).to eq(current_receiver.fetch(:trace_id))
     end
 
-    it 'has request initiator span_id as parent_id' do
+    it 'has parent_id' do
       response = freddy.deliver_with_response(destination, {})
-      previous_receiver = response.fetch(:previous_receiver)
       current_receiver = response.fetch(:current_receiver)
-      expect(previous_receiver.fetch(:span_id)).to eq(current_receiver.fetch(:parent_id))
+      expect(current_receiver.fetch(:parent_id)).to_not be_nil
     end
 
     it 'has generated span_id' do

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
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Salemove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-29 00:00:00.000000000 Z
+date: 2017-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: opentracing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: Messaging API
 email:
 - techmovers@salemove.com
@@ -120,7 +134,7 @@ files:
 - lib/freddy/responder_handler.rb
 - lib/freddy/sync_response_container.rb
 - lib/freddy/timeout_error.rb
-- lib/freddy/traces.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
@@ -128,7 +142,7 @@ files:
 - spec/freddy/payload_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
-- spec/freddy/traces/trace_id_spec.rb
+- spec/freddy/trace_carrier_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb
@@ -167,7 +181,7 @@ test_files:
 - spec/freddy/payload_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
-- spec/freddy/traces/trace_id_spec.rb
+- spec/freddy/trace_carrier_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb

data/lib/freddy/traces.rb

@@ -1,40 +0,0 @@
-class Freddy
-  module Traces
-    class Trace
-      def self.build
-        id = TraceId.generate
-        span_id = TraceId.generate
-        new(id: id, parent_id: nil, span_id: span_id)
-      end
-
-      def self.build_from_existing_trace(id:, parent_id:)
-        span_id = TraceId.generate
-        new(id: id, parent_id: parent_id, span_id: span_id)
-      end
-
-      attr_reader :id, :parent_id, :span_id
-
-      def initialize(id:, parent_id:, span_id:)
-        @id = id
-        @parent_id = parent_id
-        @span_id = span_id
-      end
-
-      def to_h
-        {id: @id, parent_id: @parent_id, span_id: @span_id}
-      end
-    end
-
-    module TraceId
-      TRACE_ID_UPPER_BOUND = 2 ** 64
-
-      # Generates 64-bit lower-hex encoded ID. This was chosen to be compatible
-      # with tracing frameworks like zipkin.
-      def self.generate
-        rand(TRACE_ID_UPPER_BOUND).to_s(16)
-      end
-    end
-
-    NO_TRACE = Trace.new(id: nil, parent_id: nil, span_id: nil)
-  end
-end

data/spec/freddy/traces/trace_id_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Freddy::Traces::TraceId do
-  describe '.generate' do
-    it 'generates a trace id' do
-      expect(described_class.generate).to_not be_nil
-    end
-  end
-end