instana 1.9.7 → 1.10.0.slimfast

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 556dea91963ad3942c67bd242df34c6121623f74055a09e88891adbabe7aff5a
-  data.tar.gz: 2de597f123eaf230c7cf6733efe8d4622e59300b69597478c99fe878d665849e
+  metadata.gz: 636d84b9e35dfd6f03f1186ecda22b22b96105725007ca2f48dccc41198782f7
+  data.tar.gz: 16842c4bacc3cac2c347babee2653fbfd3462fb0ee466b5317d22167465088ab
 SHA512:
-  metadata.gz: 14a5cfc91e47192e928eb6fc407ad0dc5788f8471c593fcfdc34617c9e20f58c7509e3ffaa6eecc4a004f5c9af58d6af9adb9be71794c3bd14cce3ecd110370d
-  data.tar.gz: a3b2301b94d016965d054b66c383edd8823b340390114a1f011a1874281a61e19bd4c0be0aca7ce40f7ced5c36fa2f265e3c67f81bd7bbe836335e8914fbdd25
+  metadata.gz: e30db43f11f5b3574405ef02ce18c1bb755bad5b0b5e28bd3f8d5a74846b9feeb08e0541f66a74bb174cb4c01be889ab896a34b988d26ab93577f4de2561c34a
+  data.tar.gz: 2cc0b8257cdb95df46fa3955c081a12188d7abf4f0a639929f50264b94961fa61bb9de4f092cf04d0144c985d4a871084114aaad14ad1b7671dea908b4a3bd43

data/lib/instana/agent.rb

@@ -167,8 +167,8 @@ module Instana
         @timers.wait
       end
     rescue Exception => e
-      ::Instana.logger.warn "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      ::Instana.logger.debug e.backtrace.join("\r\n")
+      ::Instana.logger.warn { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      ::Instana.logger.debug { e.backtrace.join("\r\n") }
     ensure
       if @state == :announced
         # Pause the timers so they don't fire while we are
@@ -176,7 +176,7 @@ module Instana
         @collect_timer.pause
         @announce_timer.pause
 
-        ::Instana.logger.debug "#{Thread.current}: Agent exiting. Reporting final #{::Instana.processor.queue_count} trace(s)."
+        ::Instana.logger.debug { "#{Thread.current}: Agent exiting. Reporting final #{::Instana.processor.queue_count} trace(s)." }
         ::Instana.processor.send
       end
     end
@@ -211,7 +211,7 @@ module Instana
       req = Net::HTTP::Put.new(uri)
       req.body = Oj.dump(announce_payload, OJ_OPTIONS)
 
-      ::Instana.logger.debug "Announce: http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{DISCOVERY_PATH} - payload: #{req.body}"
+      ::Instana.logger.debug { "Announce: http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{DISCOVERY_PATH} - payload: #{req.body}" }
 
       response = make_host_agent_request(req)
 
@@ -228,8 +228,8 @@ module Instana
         false
       end
     rescue => e
-      Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n")
+      Instana.logger.info { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      Instana.logger.debug { e.backtrace.join("\r\n") }
       return false
     ensure
       socket.close if socket
@@ -269,8 +269,8 @@ module Instana
       end
       false
     rescue => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n")
+      Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      Instana.logger.debug { e.backtrace.join("\r\n") }
     end
 
     # Accept and report spans to the host agent.
@@ -304,8 +304,8 @@ module Instana
       end
       false
     rescue => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n")
+      Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      Instana.logger.debug { e.backtrace.join("\r\n") }
     end
 
     # Check that the host agent is available and can be contacted.  This will
@@ -328,8 +328,8 @@ module Instana
       end
       false
     rescue => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n") unless ENV.key?('INSTANA_TEST')
+      Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      Instana.logger.debug { e.backtrace.join("\r\n") } unless ENV.key?('INSTANA_TEST')
       return false
     end
 
@@ -342,20 +342,20 @@ module Instana
     def run_discovery
       discovered = {}
 
-      ::Instana.logger.debug "#{__method__}: Running agent discovery..."
+      ::Instana.logger.debug { "#{__method__}: Running agent discovery..." }
 
       # Try default location or manually configured (if so)
       uri = URI.parse("http://#{::Instana.config[:agent_host]}:#{::Instana.config[:agent_port]}/")
       req = Net::HTTP::Get.new(uri)
 
-      ::Instana.logger.debug "#{__method__}: Trying #{::Instana.config[:agent_host]}:#{::Instana.config[:agent_port]}"
+      ::Instana.logger.debug { "#{__method__}: Trying #{::Instana.config[:agent_host]}:#{::Instana.config[:agent_port]}" }
 
       response = make_host_agent_request(req)
 
       if response && (response.code.to_i == 200)
         discovered[:agent_host] = ::Instana.config[:agent_host]
         discovered[:agent_port] = ::Instana.config[:agent_port]
-        ::Instana.logger.debug "#{__method__}: Found #{discovered[:agent_host]}:#{discovered[:agent_port]}"
+        ::Instana.logger.debug { "#{__method__}: Found #{discovered[:agent_host]}:#{discovered[:agent_port]}" }
         return discovered
       end
 
@@ -366,14 +366,14 @@ module Instana
       uri = URI.parse("http://#{@default_gateway}:#{::Instana.config[:agent_port]}/")
       req = Net::HTTP::Get.new(uri)
 
-      ::Instana.logger.debug "#{__method__}: Trying default gateway #{@default_gateway}:#{::Instana.config[:agent_port]}"
+      ::Instana.logger.debug { "#{__method__}: Trying default gateway #{@default_gateway}:#{::Instana.config[:agent_port]}" }
 
       response = make_host_agent_request(req)
 
       if response && (response.code.to_i == 200)
         discovered[:agent_host] = @default_gateway
         discovered[:agent_port] = ::Instana.config[:agent_port]
-        ::Instana.logger.debug "#{__method__}: Found #{discovered[:agent_host]}:#{discovered[:agent_port]}"
+        ::Instana.logger.debug { "#{__method__}: Found #{discovered[:agent_host]}:#{discovered[:agent_port]}" }
         return discovered
       end
 
@@ -434,8 +434,8 @@ module Instana
     rescue Errno::ECONNREFUSED
       return nil
     rescue => e
-      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-      Instana.logger.debug e.backtrace.join("\r\n") unless ENV.key?('INSTANA_TEST')
+      Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      Instana.logger.debug { e.backtrace.join("\r\n") } unless ENV.key?('INSTANA_TEST')
       return nil
     end
   end

data/lib/instana/agent/helpers.rb

@@ -51,8 +51,8 @@ module AgentHelpers
 
     @state == :announced
   rescue => e
-    Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-    Instana.logger.debug e.backtrace.join("\r\n") unless ENV.key?('INSTANA_TEST')
+    Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+    Instana.logger.debug { e.backtrace.join("\r\n") } unless ENV.key?('INSTANA_TEST')
     return false
   end
 end

data/lib/instana/agent/tasks.rb

@@ -42,7 +42,7 @@ module AgentTasks
     make_host_agent_request(req)
 
   rescue StandardError => e
-    Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-    Instana.logger.debug e.backtrace.join("\r\n")
+    Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+    Instana.logger.debug { e.backtrace.join("\r\n") }
   end
 end

data/lib/instana/collectors/gc.rb

@@ -45,7 +45,7 @@ module Instana
         @this_gc
       rescue => e
         ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        ::Instana.logger.debug e.backtrace.join("\r\n")
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
       end
     end
   end

data/lib/instana/collectors/memory.rb

@@ -22,7 +22,7 @@ module Instana
         @this_mem
       rescue => e
         ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        ::Instana.logger.debug e.backtrace.join("\r\n")
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
       end
     end
   end

data/lib/instana/collectors/thread.rb

@@ -18,7 +18,7 @@ module Instana
         @this_count
       rescue => e
         ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        ::Instana.logger.debug e.backtrace.join("\r\n")
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
       end
     end
   end

data/lib/instana/frameworks/instrumentation/mysql2_adapter.rb

@@ -67,7 +67,7 @@ module Instana
 
       def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql) ||
-            ::Instana.tracer.current_span_name?(:activerecord)
+            ::Instana.tracer.current_span[:n] == :activerecord
           return exec_query_without_instana(sql, name, binds, *args)
         end
 

data/lib/instana/frameworks/instrumentation/mysql_adapter.rb

@@ -42,7 +42,7 @@ module Instana
 
       def exec_query_with_instana(sql, name = 'SQL', binds = [], *args)
         if !::Instana.tracer.tracing? || ignore_payload?(name, sql) ||
-            ::Instana.tracer.current_span_name?(:activerecord)
+            ::Instana.tracer.current_span[:n] == :activerecord
           return exec_query_without_instana(sql, name, binds, *args)
         end
 

data/lib/instana/helpers.rb

@@ -16,7 +16,7 @@ module Instana
         ERB.new(EUM_SNIPPET).result
       rescue => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
         return nil
       end
 
@@ -32,7 +32,7 @@ module Instana
         ERB.new(EUM_TEST_SNIPPET).result
       rescue => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
         return nil
       end
     end

data/lib/instana/instrumentation.rb

@@ -14,7 +14,7 @@ if !ENV.key?('INSTANA_DISABLE_AUTO_INSTR') || ENV['INSTANA_DISABLE_AUTO_INSTR']
         require f
       rescue => e
         Instana.logger.error "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
-        Instana.logger.debug e.backtrace.join("\r\n")
+        Instana.logger.debug { e.backtrace.join("\r\n") }
       end
     end
   end

data/lib/instana/instrumentation/excon.rb

@@ -13,13 +13,14 @@ if defined?(::Excon) && ::Instana.config[:excon][:enabled]
           if datum[:pipeline] == true
             # Pass the context along in the datum so we get back on response
             # and can close out the async span
-            datum[:instana_context] = ::Instana.tracer.log_async_entry(:excon, payload)
+            datum[:instana_span] = ::Instana.tracer.log_async_entry(:excon, payload)
+            t_context = datum[:instana_span].context
           else
             ::Instana.tracer.log_entry(:excon, payload)
+            t_context = ::Instana.tracer.context
           end
 
           # Set request headers; encode IDs as hexadecimal strings
-          t_context = ::Instana.tracer.context
           datum[:headers]['X-Instana-T'] = t_context.trace_id_header
           datum[:headers]['X-Instana-S'] = t_context.span_id_header
 
@@ -30,7 +31,7 @@ if defined?(::Excon) && ::Instana.config[:excon][:enabled]
           return @stack.error_call(datum) unless ::Instana.tracer.tracing?
 
           if datum[:pipeline] == true
-            ::Instana.tracer.log_async_error(datum[:error], datum[:instana_context])
+            ::Instana.tracer.log_async_error(datum[:error], datum[:instana_span])
           else
             ::Instana.tracer.log_error(datum[:error])
           end
@@ -38,6 +39,8 @@ if defined?(::Excon) && ::Instana.config[:excon][:enabled]
         end
 
         def response_call(datum)
+          # FIXME: Will connect exceptions call a response?
+          #
           return @stack.response_call(datum) unless ::Instana.tracer.tracing?
 
           result =  @stack.response_call(datum)
@@ -54,8 +57,8 @@ if defined?(::Excon) && ::Instana.config[:excon][:enabled]
           end
 
           if datum[:pipeline] == true
-            # Pickup context of this async span from datum[:instana_id]
-            ::Instana.tracer.log_async_exit(:excon, { :http => {:status => status } }, datum[:instana_context])
+            # Pickup context of this async span from datum[:instana_span]
+            ::Instana.tracer.log_async_exit(:excon, { :http => {:status => status } }, datum[:instana_span])
           else
             ::Instana.tracer.log_exit(:excon, { :http => {:status => status } })
           end

data/lib/instana/instrumentation/rack.rb

@@ -57,8 +57,8 @@ module Instana
 
         # Save the IDs before the trace ends so we can place
         # them in the response headers in the ensure block
-        trace_id = ::Instana.tracer.trace_id
-        span_id = ::Instana.tracer.span_id
+        trace_id = ::Instana.tracer.current_span.trace_id
+        span_id = ::Instana.tracer.current_span.id
       end
 
       [status, headers, response]

data/lib/instana/instrumentation/resque.rb

@@ -17,7 +17,7 @@ module Instana
           kvs[:job] = klass.to_s
           kvs[:queue] = klass.instance_variable_get(:@queue)
         rescue => e
-          Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
         end
 
         { :'resque-client' => kvs }
@@ -77,7 +77,7 @@ module Instana
           kvs[:'resque-worker'][:job] = job.payload['class'].to_s
           kvs[:'resque-worker'][:queue] = job.queue
         rescue => e
-          ::Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if Instana::Config[:verbose]
+          ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" } if Instana::Config[:verbose]
         end
 
         Instana.tracer.start_or_continue_trace(:'resque-worker', kvs) do
@@ -97,7 +97,7 @@ module Instana
           ::Instana.tracer.log_error(exception)
         end
       rescue Exception => e
-        ::Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if Instana::Config[:verbose]
+        ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" } if Instana::Config[:verbose]
       ensure
         fail_without_instana(exception)
       end

data/lib/instana/tracer.rb

@@ -1,5 +1,4 @@
 require "instana/thread_local"
-require "instana/tracing/trace"
 require "instana/tracing/span"
 require "instana/tracing/span_context"
 
@@ -7,7 +6,7 @@ module Instana
   class Tracer
     extend ::Instana::ThreadLocal
 
-    thread_local :current_trace
+    thread_local :current_span
 
     # Support ::Instana::Tracer.xxx call style for the instantiated tracer
     class << self
@@ -35,7 +34,7 @@ module Instana
     #     :span_id the ID of the parent span (must be an unsigned hex-string)
     #     :level specifies data collection level (optional)
     #
-    def start_or_continue_trace(name, kvs = {}, incoming_context = {}, &block)
+    def start_or_continue_trace(name, kvs = {}, incoming_context = nil, &block)
       log_start_or_continue(name, kvs, incoming_context)
       yield
     rescue Exception => e
@@ -75,16 +74,34 @@ module Instana
     #
     # @param name [String] the name of the span to start
     # @param kvs [Hash] list of key values to be reported in the span
-    # @param incoming_context [Hash] specifies the incoming context.  At a
+    # @param incoming_context [SpanContext or Hash] specifies the incoming context.  At a
     #   minimum, it should specify :trace_id and :span_id from the following:
     #     :trace_id the trace ID (must be an unsigned hex-string)
     #     :span_id the ID of the parent span (must be an unsigned hex-string)
     #     :level specifies data collection level (optional)
     #
-    def log_start_or_continue(name, kvs = {}, incoming_context = {})
+    def log_start_or_continue(name, kvs = {}, incoming_context = nil)
       return if !::Instana.agent.ready? || !::Instana.config[:tracing][:enabled]
       ::Instana.logger.debug "#{__method__} passed a block.  Use `start_or_continue` instead!" if block_given?
-      self.current_trace = ::Instana::Trace.new(name, kvs, incoming_context)
+
+      # Handle the potential variations on `incoming_context`
+      if incoming_context
+        if incoming_context.is_a?(Hash)
+          if !incoming_context.empty?
+            parent_context = SpanContext.new(incoming_context[:trace_id], incoming_context[:span_id])
+          end
+        else
+          parent_context = incoming_context
+        end
+      end
+
+      if parent_context
+        self.current_span = Span.new(name, parent_ctx: parent_context)
+      else
+        self.current_span = Span.new(name)
+      end
+      self.current_span.set_tags(kvs) unless kvs.empty?
+      self.current_span
     end
 
     # Will establish a new span as a child of the current span
@@ -93,9 +110,16 @@ module Instana
     # @param name [String] the name of the span to create
     # @param kvs [Hash] list of key values to be reported in the span
     #
-    def log_entry(name, kvs = {})
-      return unless tracing?
-      self.current_trace.new_span(name, kvs)
+    def log_entry(name, kvs = nil, start_time = ::Instana::Util.now_in_ms, child_of = nil)
+      return unless self.current_span || child_of
+
+      if child_of && (child_of.is_a?(::Instana::Span) || child_of.is_a?(::Instana::SpanContext))
+        new_span = Span.new(name, parent_ctx: child_of, start_time: start_time)
+      else
+        new_span = Span.new(name, parent_ctx: self.current_span, start_time: start_time)
+      end
+      new_span.set_tags(kvs) if kvs
+      self.current_span = new_span
     end
 
     # Add info to the current span
@@ -103,8 +127,8 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_info(kvs)
-      return unless tracing?
-      self.current_trace.add_info(kvs)
+      return unless self.current_span
+      self.current_span.set_tags(kvs)
     end
 
     # Add an error to the current span
@@ -112,8 +136,8 @@ module Instana
     # @param e [Exception] Add exception to the current span
     #
     def log_error(e)
-      return unless tracing?
-      self.current_trace.add_error(e)
+      return unless self.current_span
+      self.current_span.add_error(e)
     end
 
     # Closes out the current span
@@ -125,15 +149,22 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_exit(name, kvs = {})
-      return unless tracing?
+      return unless self.current_span
 
       if ENV.key?('INSTANA_DEBUG') || ENV.key?('INSTANA_TEST')
-        unless current_span_name?(name)
-          ::Instana.logger.debug "Span mismatch: Attempt to exit #{name} span but #{current_span.name} is active."
+        unless self.current_span.name == name
+          ::Instana.logger.debug "Span mismatch: Attempt to exit #{name} span but #{self.current_span.name} is active."
         end
       end
 
-      self.current_trace.end_span(kvs)
+      self.current_span.set_tags(kvs)
+      self.current_span.close
+
+      if self.current_span.parent
+        self.current_span = self.current_span.parent
+      else
+        self.current_span = nil
+      end
     end
 
     # Closes out the current span in the current trace
@@ -146,28 +177,17 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_end(name, kvs = {}, end_time = ::Instana::Util.now_in_ms)
-      return unless tracing?
+      return unless self.current_span
 
       if ENV.key?('INSTANA_DEBUG') || ENV.key?('INSTANA_TEST')
-        unless current_span_name?(name)
-          ::Instana.logger.debug "Span mismatch: Attempt to end #{name} span but #{current_span.name} is active."
+        unless self.current_span.name == name
+          ::Instana.logger.debug "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
         end
       end
 
-      self.current_trace.finish(kvs, end_time)
-
-      if ::Instana.agent.ready?
-        if !self.current_trace.has_async? ||
-            (self.current_trace.has_async? && self.current_trace.complete?)
-          Instana.processor.add(self.current_trace)
-        else
-          # This trace still has outstanding/uncompleted asynchronous spans.
-          # Put it in the staging queue until the async span closes out or
-          # 5 minutes has passed.  Whichever comes first.
-          Instana.processor.stage(self.current_trace)
-        end
-      end
-      self.current_trace = nil
+      self.current_span.set_tags(kvs)
+      self.current_span.close(end_time)
+      self.current_span = nil
     end
 
     ###########################################################################
@@ -184,80 +204,40 @@ module Instana
     #   :span_id => 12345
     #
     def log_async_entry(name, kvs)
-      return unless tracing?
-      self.current_trace.new_async_span(name, kvs)
+      return unless self.current_span
+
+      new_span = Span.new(name, parent_ctx: self.current_span)
+      new_span.set_tags(kvs) unless kvs.empty?
+      new_span
     end
 
     # Add info to an asynchronous span
     #
     # @param kvs [Hash] list of key values to be reported in the span
-    # @param span [Span] the span for this Async op (previously returned
-    #   from `log_async_entry`)
+    # @param span [Span] the span for this Async op (previously returned from `log_async_entry`)
     #
     def log_async_info(kvs, span)
-      # Asynchronous spans can persist longer than the parent
-      # trace.  With the trace ID, we check the current trace
-      # but otherwise, we search staged traces.
-
-      if tracing? && self.current_trace.id == span.context.trace_id
-        self.current_trace.add_async_info(kvs, span)
-      else
-        trace = ::Instana.processor.staged_trace(span.context.trace_id)
-        if trace
-          trace.add_async_info(kvs, span)
-        else
-          ::Instana.logger.debug "#{__method__}: Couldn't find staged trace. #{span.inspect}"
-        end
-      end
+      span.set_tags(kvs)
     end
 
     # Add an error to an asynchronous span
     #
     # @param e [Exception] Add exception to the current span
-    # @param span [Span] the span for this Async op (previously returned
-    #   from `log_async_entry`)
+    # @param span [Span] the span for this Async op (previously returned from `log_async_entry`)
     #
     def log_async_error(e, span)
-      # Asynchronous spans can persist longer than the parent
-      # trace.  With the trace ID, we check the current trace
-      # but otherwise, we search staged traces.
-
-      if tracing? && self.current_trace.id == span.context.trace_id
-        self.current_trace.add_async_error(e, span)
-      else
-        trace = ::Instana.processor.staged_trace(span.context.trace_id)
-        if trace
-          trace.add_async_error(e, span)
-        else
-          ::Instana.logger.debug "#{__method__}: Couldn't find staged trace. #{span.inspect}"
-        end
-      end
+      span.add_error(e)
     end
 
     # Closes out an asynchronous span
     #
     # @param name [String] the name of the async span to exit (close out)
-    # @param kvs [Hash] list of key values to be reported in the span
-    # @param span [Span] the span for this Async op (previously returned
-    #   from `log_async_entry`)
+    # @param kvs [Hash] list of additional key/values to be reported in the span (or use {})
+    # @param span [Span] the span for this Async op (previously returned from `log_async_entry`)
     #
     def log_async_exit(_name, kvs, span)
-      # An asynchronous span can end after the current trace has
-      # already completed so we make sure that we end the span
-      # on the right trace.
-
-      if tracing? && self.current_trace.id == span.context.trace_id
-        self.current_trace.end_async_span(kvs, span)
-      else
-        # Different trace from current so find the staged trace
-        # and close out the span on it.
-        trace = ::Instana.processor.staged_trace(span.context.trace_id)
-        if trace
-          trace.end_async_span(kvs, span)
-        else
-          ::Instana.logger.debug "#{__method__}: Couldn't find staged trace. #{span.inspect}"
-        end
-      end
+      span.set_tags(kvs) unless kvs.empty?
+      span.close
     end
 
     ###########################################################################
@@ -274,16 +254,13 @@ module Instana
     # @return [Span]
     #
     def start_span(operation_name, child_of: nil, start_time: ::Instana::Util.now_in_ms, tags: nil)
-      # return unless ::Instana.agent.ready?
-
-      if tracing?
-        span = self.current_trace.new_span(operation_name, tags, start_time, child_of)
+      if child_of && (child_of.is_a?(::Instana::Span) || child_of.is_a?(::Instana::SpanContext))
+        new_span = Span.new(operation_name, parent_ctx: child_of, start_time: start_time)
       else
-        self.current_trace = ::Instana::Trace.new(operation_name, tags, nil, start_time)
-        span = self.current_trace.current_span
+        new_span = Span.new(operation_name, start_time: start_time)
       end
-      span.set_tags(tags)
-      span
+      new_span.set_tags(tags) if tags
+      new_span
     end
 
     # Inject a span into the given carrier
@@ -338,7 +315,7 @@ module Instana
       # The non-nil value of this instance variable
       # indicates if we are currently tracing
       # in this thread or not.
-      self.current_trace ? true : false
+      self.current_span ? true : false
     end
 
     # Indicates if we're tracing and the current span name matches
@@ -349,8 +326,8 @@ module Instana
     # @return [Boolean]
     #
     def tracing_span?(name)
-      if self.current_trace
-        return self.current_trace.current_span.name == name
+      if self.current_span
+        return self.current_span.name == name
       end
       false
     end
@@ -360,8 +337,8 @@ module Instana
     # @return [SpanContext] or nil if not tracing
     #
     def context
-      return nil unless tracing?
-      self.current_trace.current_span.context
+      return unless self.current_span
+      self.current_span.context
     end
 
     # Take the current trace_id and convert it to a header compatible
@@ -370,7 +347,11 @@ module Instana
     # @return [String] a hexadecimal representation of the current trace ID
     #
     def trace_id_header
-      ::Instana::Util.id_to_header(trace_id)
+      if self.current_span
+        self.current_span.context.trace_id_header
+      else
+        ""
+      end
     end
 
     # Take the current span_id and convert it to a header compatible
@@ -379,39 +360,33 @@ module Instana
     # @return [String] a hexadecimal representation of the current span ID
     #
     def span_id_header
-      ::Instana::Util.id_to_header(span_id)
+      if self.current_span
+        self.current_span.context.span_id_header
+      else
+        ""
+      end
     end
 
     # Returns the trace ID for the active trace (if there is one),
     # otherwise nil.
     #
     def trace_id
-      self.current_trace ? self.current_trace.id : nil
+      self.current_span ? self.current_span.id : nil
+      ::Instana.logger.debug("tracer.trace_id will deprecated in a future version.")
     end
 
     # Returns the current [Span] ID for the active trace (if there is one),
     # otherwise nil.
     #
     def span_id
-      self.current_trace  ? current_trace.current_span_id : nil
-    end
-
-    # Helper method to retrieve the currently active span for the active trace.
-    #
-    def current_span
-      self.current_trace ? self.current_trace.current_span : nil
-    end
-
-    # Indicates if the name of the current span matches <candidate>
-    #
-    def current_span_name?(candidate)
-      self.current_trace &&  self.current_trace.current_span.name == candidate.to_sym
+      self.current_span  ? self.current_span.span_id : nil
+      ::Instana.logger.debug("tracer.span_id will deprecated in a future version.")
     end
 
     # Used in the test suite, this resets the tracer to non-tracing state.
     #
     def clear!
-      self.current_trace = nil
+      self.current_span = nil
     end
   end
 end