instana 1.195.4 → 1.198.0

data/lib/instana/tracer.rb

@@ -1,16 +1,11 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2016
 
-require "instana/thread_local"
 require "instana/tracing/span"
 require "instana/tracing/span_context"
 
 module Instana
   class Tracer
-    extend ::Instana::ThreadLocal
-
-    thread_local :current_span
-
     # Support ::Instana::Tracer.xxx call style for the instantiated tracer
     class << self
       def method_missing(method, *args, &block)
@@ -22,6 +17,22 @@ module Instana
       end
     end
 
+    def initialize(logger: Instana.logger)
+      @current_span = Concurrent::ThreadLocalVar.new
+      @logger = logger
+    end
+
+    # @return [Instana::Span, NilClass] the current active span or nil if we are not tracing
+    def current_span
+      @current_span.value
+    end
+
+    # @param [Instana::Span, NilClas] v the new current span
+    # Set the value of the current span
+    def current_span=(v)
+      @current_span.value = v
+    end
+
     #######################################
     # Tracing blocks API methods
     #######################################
@@ -85,7 +96,6 @@ module Instana
     #
     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?
 
       # Handle the potential variations on `incoming_context`
       if incoming_context
@@ -125,11 +135,11 @@ module Instana
     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 = if child_of.is_a?(::Instana::Span) || child_of.is_a?(::Instana::SpanContext)
+                   Span.new(name, parent_ctx: child_of, start_time: start_time)
+                 else
+                   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
@@ -163,10 +173,8 @@ module Instana
     def log_exit(name, kvs = {})
       return unless self.current_span
 
-      if ENV.key?('INSTANA_DEBUG') || ENV.key?('INSTANA_TEST')
-        unless self.current_span.name == name
-          ::Instana.logger.debug "Span mismatch: Attempt to exit #{name} span but #{self.current_span.name} is active."
-        end
+      if self.current_span.name != name
+        @logger.warn "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
       end
 
       self.current_span.set_tags(kvs)
@@ -191,10 +199,8 @@ module Instana
     def log_end(name, kvs = {}, end_time = ::Instana::Util.now_in_ms)
       return unless self.current_span
 
-      if ENV.key?('INSTANA_DEBUG') || ENV.key?('INSTANA_TEST')
-        unless self.current_span.name == name
-          ::Instana.logger.debug "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
-        end
+      if self.current_span.name != name
+        @logger.warn "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
       end
 
       self.current_span.set_tags(kvs)
@@ -252,88 +258,6 @@ module Instana
       span.close
     end
 
-    ###########################################################################
-    # OpenTracing Support
-    ###########################################################################
-
-    # Start a new span
-    #
-    # @param operation_name [String] The name of the operation represented by the span
-    # @param child_of [Span] A span to be used as the ChildOf reference
-    # @param start_time [Time] the start time of the span
-    # @param tags [Hash] Starting tags for the span
-    #
-    # @return [Span]
-    #
-    def start_span(operation_name, child_of: nil, start_time: ::Instana::Util.now_in_ms, tags: nil)
-      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
-        new_span = Span.new(operation_name, start_time: start_time)
-      end
-      new_span.set_tags(tags) if tags
-      new_span
-    end
-
-    # Start a new span which is the child of the current span
-    #
-    # @param operation_name [String] The name of the operation represented by the span
-    # @param child_of [Span] A span to be used as the ChildOf reference
-    # @param start_time [Time] the start time of the span
-    # @param tags [Hash] Starting tags for the span
-    #
-    # @return [Span]
-    #
-    def start_active_span(operation_name, child_of: self.current_span, start_time: ::Instana::Util.now_in_ms, tags: nil)
-      self.current_span = start_span(operation_name, child_of: child_of, start_time: start_time, tags: tags)
-    end
-
-    # Returns the currently active span
-    #
-    # @return [Span]
-    #
-    def active_span
-      self.current_span
-    end
-
-    # Inject a span into the given carrier
-    #
-    # @param span_context [SpanContext]
-    # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
-    # @param carrier [Carrier]
-    #
-    def inject(span_context, format, carrier)
-      case format
-      when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY
-        ::Instana.logger.debug 'Unsupported inject format'
-      when OpenTracing::FORMAT_RACK
-        carrier['X-Instana-T'] = ::Instana::Util.id_to_header(span_context.trace_id)
-        carrier['X-Instana-S'] = ::Instana::Util.id_to_header(span_context.span_id)
-      else
-        ::Instana.logger.debug 'Unknown inject format'
-      end
-    end
-
-    # Extract a span from a carrier
-    #
-    # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
-    # @param carrier [Carrier]
-    #
-    # @return [SpanContext]
-    #
-    def extract(format, carrier)
-      case format
-      when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY
-        ::Instana.logger.debug 'Unsupported extract format'
-      when OpenTracing::FORMAT_RACK
-        ::Instana::SpanContext.new(::Instana::Util.header_to_id(carrier['HTTP_X_INSTANA_T']),
-                                     ::Instana::Util.header_to_id(carrier['HTTP_X_INSTANA_S']))
-      else
-        ::Instana.logger.debug 'Unknown inject format'
-        nil
-      end
-    end
-
     ###########################################################################
     # Helper methods
     ###########################################################################
@@ -374,48 +298,6 @@ module Instana
       self.current_span.context
     end
 
-    # Take the current trace_id and convert it to a header compatible
-    # format.
-    #
-    # @return [String] a hexadecimal representation of the current trace ID
-    #
-    def trace_id_header
-      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
-    # formate.
-    #
-    # @return [String] a hexadecimal representation of the current span ID
-    #
-    def span_id_header
-      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_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_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!

data/lib/instana/tracing/processor.rb

@@ -5,7 +5,7 @@ require 'thread'
 
 module Instana
   class Processor
-    def initialize
+    def initialize(logger: ::Instana.logger)
       # The main queue before being reported to the
       # host agent.  Spans in this queue are complete
       # and ready to be sent.
@@ -14,25 +14,22 @@ module Instana
       # This is the maximum number of spans we send to the host
       # agent at once.
       @batch_size = 3000
-    end
-
-    # Adds a Set of spans to the queue
-    #
-    # @param [spans] - the trace to be added to the queue
-    def add_spans(spans)
-      spans.each { |span| @queue.push(span)}
+      @logger = logger
+      @pid = $PROCESS_ID
     end
 
     # Adds a span to the span queue
     #
     # @param [Trace] - the trace to be added to the queue
     def add_span(span)
-      # Occasionally, do a checkup on our background thread.
-      if rand(10) > 8
-        if ::Instana.agent.collect_thread.nil? || !::Instana.agent.collect_thread.alive?
-          ::Instana.agent.spawn_background_thread
-        end
+      # :nocov:
+      if @pid != $PROCESS_ID
+        @logger.info("Proces `#{@pid}` has forked into #{$PROCESS_ID}. Resetting discovery.")
+        ::Instana.agent.spawn_background_thread
+        @pid = $PROCESS_ID
       end
+      # :nocov:
+
       @queue.push(span)
     end
 
@@ -46,18 +43,14 @@ module Instana
     #   - Out of control/growing queue
     #   - Prevent another run of the timer while this is running
     #
-    def send
+    def send(&block)
       return if @queue.empty? || ENV.key?('INSTANA_TEST')
 
       # Retrieve all spans for queued traces
       spans = queued_spans
 
       # Report spans in batches
-      batch = spans.shift(@batch_size)
-      while !batch.empty? do
-        ::Instana.agent.report_spans(batch)
-        batch = spans.shift(@batch_size)
-      end
+      spans.each_slice(@batch_size, &block)
     end
 
     # Retrieves all of the traces in @queue and returns
@@ -75,10 +68,9 @@ module Instana
       until @queue.empty? do
         # Non-blocking pop; ignore exception
         span = @queue.pop(true) rescue nil
-        if span
-          spans << span.raw
-        end
+        spans << span.raw if span.is_a?(Span) && span.context.level == 1
       end
+
       spans
     end
 

data/lib/instana/tracing/span.rb

@@ -6,8 +6,8 @@ module Instana
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
                          :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
-                         :redis, :'resque-client', :'resque-worker', :'graphql.server', :dynamodb, :s3, :sns, :sqs  ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server', :sqs ].freeze
+                         :redis, :'resque-client', :'resque-worker', :'graphql.server', :dynamodb, :s3, :sns, :sqs, :'aws.lambda.entry'  ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server', :sqs, :'aws.lambda.entry' ].freeze
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
                    :'rpc-client', :'sidekiq-client', :redis, :dynamodb, :s3, :sns, :sqs ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
@@ -20,38 +20,40 @@ module Instana
     def initialize(name, parent_ctx: nil, start_time: ::Instana::Util.now_in_ms)
       @data = {}
 
-      if parent_ctx == nil
-        # No parent specified so we're starting a new Trace - this will be the root span
-        id = ::Instana::Util.generate_id
-        @data[:t] = id                    # Trace ID
-        @data[:s] = id                    # Span ID
-        @is_root = true
-      else
-        if parent_ctx.is_a?(::Instana::Span)
-          @parent = parent_ctx
-          parent_context = parent_ctx.context
-        elsif parent_ctx.is_a?(::Instana::SpanContext)
-          parent_context = parent_ctx
-        end
+      if parent_ctx.is_a?(::Instana::Span)
+        @parent = parent_ctx
+        parent_ctx = parent_ctx.context
+      end
 
-        @data[:t] = parent_context.trace_id       # Trace ID
-        @data[:s] = ::Instana::Util.generate_id # Span ID
-        @data[:p] = parent_context.span_id        # Parent ID
+      if parent_ctx.is_a?(::Instana::SpanContext)
+        @is_root = false
 
-        if parent_context.baggage
-          @baggage = parent_ctx.baggage.dup
+        # If we have a parent trace, link to it
+        if parent_ctx.trace_id
+          @data[:t] = parent_ctx.trace_id       # Trace ID
+          @data[:p] = parent_ctx.span_id        # Parent ID
         else
-          @baggage = nil
+          @data[:t] = ::Instana::Util.generate_id
         end
 
-        @is_root = false
+        @data[:s] = ::Instana::Util.generate_id # Span ID
+
+        @baggage = parent_ctx.baggage.dup
+        @level = parent_ctx.level
+      else
+        # No parent specified so we're starting a new Trace - this will be the root span
+        @is_root = true
+        @level = 1
+
+        id = ::Instana::Util.generate_id
+        @data[:t] = id                    # Trace ID
+        @data[:s] = id                    # Span ID
       end
 
       @data[:data] = {}
 
       # Entity Source
-      @data[:f] = { :e => ::Instana.agent.report_pid,
-                    :h => ::Instana.agent.agent_uuid }
+      @data[:f] = ::Instana.agent.source
       # Start time
       if start_time.is_a?(Time)
         @data[:ts] = ::Instana::Util.time_to_ms(start_time)
@@ -59,17 +61,15 @@ module Instana
         @data[:ts] = start_time
       end
 
-      if ::Instana.config[:collect_backtraces]
-        # Attach a backtrace to all exit spans
-        add_stack if EXIT_SPANS.include?(name)
-      end
-
       # Check for custom tracing
       if REGISTERED_SPANS.include?(name.to_sym)
         @data[:n] = name.to_sym
       else
         configure_custom(name)
       end
+
+      # Attach a backtrace to all exit spans
+      add_stack if ::Instana.config[:collect_backtraces] && exit_span?
     end
 
     # Adds a backtrace to this span
@@ -195,7 +195,7 @@ module Instana
     # @return [Instana::SpanContext]
     #
     def context
-      @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], 1, @baggage)
+      @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], @level, @baggage)
     end
 
     # Retrieve the ID for this span
@@ -344,9 +344,7 @@ module Instana
           end
         end
       else
-        if !@data[:data].key?(key)
-          @data[:data][key] = value
-        elsif value.is_a?(Hash) && self[:data][key].is_a?(Hash)
+        if value.is_a?(Hash) && @data[:data][key].is_a?(Hash)
           @data[:data][key].merge!(value)
         else
           @data[:data][key] = value
@@ -381,7 +379,7 @@ module Instana
       if @context
         @context.baggage = @baggage
       else
-        @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], 1, @baggage)
+        @context ||= ::Instana::SpanContext.new(@data[:t], @data[:s], @level, @baggage)
       end
       self
     end
@@ -393,7 +391,6 @@ module Instana
     # @return Value of the baggage item
     #
     def get_baggage_item(key)
-      return nil if @baggage.nil?
       @baggage[key]
     end
 
@@ -403,7 +400,7 @@ module Instana
       if custom?
         tags = @data[:data][:sdk][:custom][:tags]
       else
-        tags = @data[:data][key]
+        tags = @data[:data]
       end
       key ? tags[key] : tags
     end

data/lib/instana/tracing/span_context.rb

@@ -18,7 +18,7 @@ module Instana
     def initialize(tid, sid, level = 1, baggage = {})
       @trace_id = tid
       @span_id = sid
-      @level = level
+      @level = Integer(level || 1)
       @baggage = baggage || {}
     end
 
@@ -31,19 +31,22 @@ module Instana
     end
 
     def trace_parent_header
-      return '' unless valid?
-
-      trace = (@baggage[:external_trace_id] || @trace_id).rjust(32, '0')
-      parent = @span_id.rjust(16, '0')
+      trace = (@baggage[:external_trace_id] || trace_id_header).rjust(32, '0')
+      parent = span_id_header.rjust(16, '0')
       flags = @level == 1 ? "01" : "00"
 
       "00-#{trace}-#{parent}-#{flags}"
     end
 
     def trace_state_header
-      return '' unless valid?
+      external_state = @baggage[:external_state] || ''
+      state = external_state.split(/,/)
+
+      if @level == 1
+        state = state.reject { |s| s.start_with?('in=') }
+        state.unshift("in=#{trace_id_header};#{span_id_header}")
+      end
 
-      state = ["in=#{trace_id_header};#{span_id_header}", @baggage[:external_state]]
       state.compact.join(',')
     end
 
@@ -51,10 +54,12 @@ module Instana
       { :trace_id => @trace_id, :span_id => @span_id }
     end
 
-    private
-
     def valid?
-      @baggage && @trace_id && @span_id
+      @baggage && @trace_id && !@trace_id.emtpy?
+    end
+
+    def active?
+      @level == 1
     end
   end
 end