instana 1.195.1 → 1.197.0.pre2

data/lib/instana/snapshot/ruby_process.rb

@@ -0,0 +1,48 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Snapshot
+    # Describes the current Ruby process
+    # @since 1.197.0
+    class RubyProcess
+      ID = 'com.instana.plugin.ruby'.freeze
+
+      def initialize(pid: Process.pid)
+        @pid = pid
+      end
+
+      def entity_id
+        @pid.to_s
+      end
+
+      def data
+        metrics_data.merge(Util.take_snapshot)
+      end
+
+      def snapshot
+        {
+          name: ID,
+          entityId: entity_id,
+          data: data
+        }
+      end
+
+      private
+
+      def metrics_data
+        proc_table = Sys::ProcTable.ps(pid: Process.pid)
+        process = Backend::ProcessInfo.new(proc_table)
+
+        {
+          pid: @pid,
+          name: Util.get_app_name,
+          exec_args: process.arguments,
+          gc: Backend::GCSnapshot.instance.report,
+          thread: {count: ::Thread.list.count},
+          memory: {rss_size: proc_table.rss / 1024} # Bytes to Kilobytes
+        }
+      end
+    end
+  end
+end

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
     #######################################
@@ -38,8 +49,8 @@ module Instana
     #     :level specifies data collection level (optional)
     #
     def start_or_continue_trace(name, kvs = {}, incoming_context = nil, &block)
-      log_start_or_continue(name, kvs, incoming_context)
-      yield
+      span = log_start_or_continue(name, kvs, incoming_context)
+      yield(span)
     rescue Exception => e
       log_error(e)
       raise
@@ -59,8 +70,8 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in this new span
     #
     def trace(name, kvs = {}, &block)
-      log_entry(name, kvs)
-      yield
+      span = log_entry(name, kvs)
+      yield(span)
     rescue Exception => e
       log_error(e)
       raise
@@ -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,10 +6,10 @@ 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  ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server' ].freeze
+                         :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
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
-                   :'rpc-client', :'sidekiq-client', :redis, :dynamodb ].freeze
+                   :'rpc-client', :'sidekiq-client', :redis, :dynamodb, :s3, :sns, :sqs ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
 
     attr_accessor :parent
@@ -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