[OpenTracing] Span and SpanContext implementation

lib/ddtrace/opentracer.rb

@@ -4,7 +4,7 @@ module OpenTracer
     module_function
 
     def supported?
-      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0')
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1')
     end
 
     def load_opentracer

lib/ddtrace/opentracer/span.rb

@@ -1,6 +1,83 @@
 module Datadog
   module OpenTracer
+    # OpenTracing adapter for Datadog::Span
     class Span < ::OpenTracing::Span
+      attr_reader \
+        :datadog_span
+
+      def initialize(datadog_span:, span_context:)
+        @datadog_span = datadog_span
+        @span_context = span_context
+      end
+
+      # Set the name of the operation
+      #
+      # @param [String] name
+      def operation_name=(name)
+        datadog_span.name = name
+      end
+
+      # Span Context
+      #
+      # @return [SpanContext]
+      def context
+        @span_context
+      end
+
+      # Set a tag value on this span
+      # @param key [String] the key of the tag
+      # @param value [String, Numeric, Boolean] the value of the tag. If it's not
+      # a String, Numeric, or Boolean it will be encoded with to_s
+      def set_tag(key, value)
+        tap { datadog_span.set_tag(key, value) }
+      end
+
+      # Set a baggage item on the span
+      # @param key [String] the key of the baggage item
+      # @param value [String] the value of the baggage item
+      def set_baggage_item(key, value)
+        tap { context.baggage[key] = value }
+      end
+
+      # Get a baggage item
+      # @param key [String] the key of the baggage item
+      # @return [String] value of the baggage item
+      def get_baggage_item(key)
+        context.baggage[key]
+      end
+
+      # @deprecated Use {#log_kv} instead.
+      # Reason: event is an optional standard log field defined in spec and not required.  Also,
+      # method name {#log_kv} is more consistent with other language implementations such as Python and Go.
+      #
+      # Add a log entry to this span
+      # @param event [String] event name for the log
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log(event: nil, timestamp: Time.now, **fields)
+        super # Log deprecation warning
+
+        # If the fields specify an error
+        if fields.key?(:'error.object')
+          datadog_span.set_error(fields[:'error.object'])
+        end
+      end
+
+      # Add a log entry to this span
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log_kv(timestamp: Time.now, **fields)
+        # If the fields specify an error
+        if fields.key?(:'error.object')
+          datadog_span.set_error(fields[:'error.object'])
+        end
+      end
+
+      # Finish the {Span}
+      # @param end_time [Time] custom end time, if not now
+      def finish(end_time: Time.now)
+        datadog_span.finish(end_time)
+      end
     end
   end
 end

lib/ddtrace/opentracer/span_context.rb

@@ -1,6 +1,11 @@
 module Datadog
   module OpenTracer
+    # OpenTracing adapter for SpanContext
     class SpanContext < ::OpenTracing::SpanContext
+      def initialize(baggage: {})
+        super
+        @baggage = baggage
+      end
     end
   end
 end

spec/ddtrace/opentracer/span_context_spec.rb

@@ -9,13 +9,14 @@
 
     subject(:span_context) { described_class.new }
 
-    it { is_expected.to have_attributes(baggage: nil) }
+    it { is_expected.to have_attributes(baggage: {}) }
 
     describe '#initialize' do
       context 'given baggage' do
         subject(:span_context) { described_class.new(baggage: baggage) }
         let(:baggage) { { account_id: '1234' } }
         it { is_expected.to be_a_kind_of(described_class) }
+        it { expect(span_context.baggage).to be(baggage) }
       end
     end
   end

spec/ddtrace/opentracer/span_spec.rb

@@ -7,38 +7,52 @@
   RSpec.describe Datadog::OpenTracer::Span do
     include_context 'OpenTracing helpers'
 
-    subject(:span) { described_class.new }
+    subject(:span) { described_class.new(datadog_span: datadog_span, span_context: span_context) }
+    let(:datadog_span) { instance_double(Datadog::Span) }
+    let(:span_context) { instance_double(Datadog::OpenTracer::SpanContext) }
 
     describe '#operation_name=' do
       subject(:result) { span.operation_name = name }
       let(:name) { 'execute_job' }
 
+      before(:each) { expect(datadog_span).to receive(:name=).with(name).and_return(name) }
       it { expect(result).to eq(name) }
     end
 
     describe '#context' do
       subject(:context) { span.context }
-      it { is_expected.to be(OpenTracing::SpanContext::NOOP_INSTANCE) }
+      it { is_expected.to be(span_context) }
     end
 
     describe '#set_tag' do
       subject(:result) { span.set_tag(key, value) }
       let(:key) { 'account_id' }
       let(:value) { '1234' }
+      before(:each) { expect(datadog_span).to receive(:set_tag).with(key, value) }
       it { is_expected.to be(span) }
     end
 
     describe '#set_baggage_item' do
       subject(:result) { span.set_baggage_item(key, value) }
       let(:key) { 'account_id' }
       let(:value) { '1234' }
+      let(:baggage) { instance_double(Hash) }
+
+      before(:each) do
+        allow(span_context).to receive(:baggage).and_return(baggage)
+        expect(baggage).to receive(:[]=).with(key, value)
+      end
+
       it { is_expected.to be(span) }
     end
 
     describe '#get_baggage_item' do
       subject(:result) { span.get_baggage_item(key) }
       let(:key) { 'account_id' }
-      it { is_expected.to be nil }
+      let(:value) { '1234' }
+      let(:baggage) { { key => value } }
+      before(:each) { allow(span_context).to receive(:baggage).and_return(baggage) }
+      it { is_expected.to be(value) }
     end
 
     describe '#log' do
@@ -47,23 +61,30 @@
       let(:timestamp) { Time.now }
       let(:fields) { { time_started: Time.now, account_id: '1234' } }
 
-      before(:each) do
+      # Expect a deprecation warning to be output.
+      it do
         expect { log }.to output("Span#log is deprecated.  Please use Span#log_kv instead.\n").to_stderr
       end
-
-      it { is_expected.to be nil }
     end
 
     describe '#log_kv' do
       subject(:log_kv) { span.log_kv(timestamp: timestamp, **fields) }
       let(:timestamp) { Time.now }
-      let(:fields) { { time_started: Time.now, account_id: '1234' } }
 
-      before(:each) do
-        expect { log_kv }.to_not output.to_stderr
+      context 'when given arbitrary key/value pairs' do
+        let(:fields) { { time_started: Time.now, account_id: '1234' } }
+        # We don't expect this to do anything right now.
+        it { is_expected.to be nil }
       end
 
-      it { is_expected.to be nil }
+      context 'when given an \'error.object\'' do
+        let(:fields) { { :'error.object' => error_object } }
+        let(:error_object) { instance_double(StandardError) }
+
+        before(:each) { expect(datadog_span).to receive(:set_error).with(error_object) }
+
+        it { is_expected.to be nil }
+      end
     end
   end
 end