Preliminary error recording

api/lib/opentelemetry/trace/span.rb

@@ -89,6 +89,14 @@ def add_event(name: nil, attributes: nil, timestamp: nil)
         self
       end
 
+      # Record an error during the execution of this span. Multiple errors
+      # can be recorded on a span.
+      #
+      # @param [Exception] error The error to recorded
+      #
+      # @return [void]
+      def record_error(error); end
+
       # Sets the Status to the Span
       #
       # If used, this will override the default Span status. Default is OK.

api/lib/opentelemetry/trace/tracer.rb

@@ -43,10 +43,17 @@ def active_span_context(context = nil)
       #
       #   OpenTelemetry.tracer.with_span(OpenTelemetry.tracer.start_span('do-the-thing')) do ... end
       #
-      # On exit, the Span that was active before calling this method will be reactivated.
+      # On exit, the Span that was active before calling this method will be reactivated. If an
+      # exception occurs during the execution of the provided block, it will be recorded on the
+      # span and reraised.
       def in_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil, sampling_hint: nil, with_parent: nil, with_parent_context: nil)
         span = start_span(name, attributes: attributes, links: links, start_timestamp: start_timestamp, kind: kind, sampling_hint: sampling_hint, with_parent: with_parent, with_parent_context: with_parent_context)
         with_span(span) { |s| yield s }
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        span.record_error(e)
+        span.status = Status.new(Status::UNKNOWN_ERROR,
+                                 description: "Unhandled exception of type: #{e.class}")
+        raise e
       ensure
         span.finish
       end

api/test/opentelemetry/trace/span_test.rb

@@ -48,6 +48,12 @@
     end
   end
 
+  describe '#record_error' do
+    it 'returns nil' do
+      _(span.record_error(StandardError.new('oops'))).must_be_nil
+    end
+  end
+
   describe '#finish' do
     it 'returns self' do
       _(span.finish).must_equal(span)

sdk/lib/opentelemetry/sdk/trace/span.rb

@@ -107,6 +107,7 @@ def set_attribute(key, value)
         def add_event(name: nil, attributes: nil, timestamp: nil)
           super
           event = block_given? ? yield : OpenTelemetry::Trace::Event.new(name: name, attributes: attributes, timestamp: timestamp || Time.now)
+
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling add_event on an ended Span.')
@@ -119,6 +120,21 @@ def add_event(name: nil, attributes: nil, timestamp: nil)
           self
         end
 
+        # Record an error during the execution of this span. Multiple errors
+        # can be recorded on a span.
+        #
+        # @param [Exception] error The error to be recorded
+        #
+        # @return [void]
+        def record_error(error)
+          add_event(name: 'error',
+                    attributes: {
+                      'error.type' => error.class.to_s,
+                      'error.message' => error.message,
+                      'error.stack' => error.backtrace.join("\n")
+                    })
+        end
+
         # Sets the Status to the Span
         #
         # If used, this will override the default Span status. Default is OK.

sdk/test/opentelemetry/sdk/trace/span_test.rb

@@ -131,6 +131,49 @@
     end
   end
 
+  describe '#record_error' do
+    let(:trace_config) do
+      TraceConfig.new(
+        max_attributes_count: 10,
+        max_events_count: 5,
+        max_attributes_per_event: 10
+      )
+    end
+
+    let(:error) do
+      begin
+        raise 'oops'
+      rescue StandardError => e
+        e
+      end
+    end
+
+    it 'records error as an event' do
+      span.record_error(error)
+      events = span.events
+      _(events.size).must_equal(1)
+
+      ev = events[0]
+
+      _(ev.name).must_equal('error')
+      _(ev.attributes['error.type']).must_equal(error.class.to_s)
+      _(ev.attributes['error.message']).must_equal(error.message)
+      _(ev.attributes['error.stack']).must_equal(error.backtrace.join("\n"))
+    end
+
+    it 'records multiple errors' do
+      3.times { span.record_error(error) }
+      events = span.events
+      _(events.size).must_equal(3)
+
+      events.each do |ev|
+        _(ev.attributes['error.type']).must_equal(error.class.to_s)
+        _(ev.attributes['error.message']).must_equal(error.message)
+        _(ev.attributes['error.stack']).must_equal(error.backtrace.join("\n"))
+      end
+    end
+  end
+
   describe '#status=' do
     it 'sets the status' do
       span.status = Status.new(1, description: 'cancelled')

sdk/test/opentelemetry/sdk/trace/tracer_test.rb

@@ -283,6 +283,25 @@
     end
   end
 
+  describe '#in_span' do
+    it 'records and reraises exceptions' do
+      span = nil
+      _(proc do
+        tracer.in_span('op') do |s|
+          span = s
+          raise 'this is fine'
+        end
+      end).must_raise(RuntimeError)
+
+      _(span.events.size).must_equal(1)
+
+      _(span.events[0].name).must_equal('error')
+      _(span.events[0].attributes['error.message']).must_equal('this is fine')
+      _(span.status.canonical_code).must_equal(OpenTelemetry::Trace::Status::UNKNOWN_ERROR)
+      _(span.status.description).must_equal('Unhandled exception of type: RuntimeError')
+    end
+  end
+
   def activate_trace_config(trace_config)
     tracer_factory.active_trace_config = trace_config
   end