instana 1.195.4 → 1.197.0.pre1

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
     #######################################
@@ -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

@@ -16,23 +16,10 @@ module Instana
       @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)}
-    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
-      end
       @queue.push(span)
     end
 
@@ -46,18 +33,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 +58,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

@@ -20,38 +20,34 @@ 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
+
+      if parent_ctx.is_a?(::Instana::SpanContext)
+        @is_root = false
 
-        @data[:t] = parent_context.trace_id       # Trace ID
+        @data[:t] = parent_ctx.trace_id       # Trace ID
         @data[:s] = ::Instana::Util.generate_id # Span ID
-        @data[:p] = parent_context.span_id        # Parent ID
+        @data[:p] = parent_ctx.span_id        # Parent ID
 
-        if parent_context.baggage
-          @baggage = parent_ctx.baggage.dup
-        else
-          @baggage = nil
-        end
+        @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
 
-        @is_root = false
+        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 +55,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 +189,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 +338,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 +373,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 +385,6 @@ module Instana
     # @return Value of the baggage item
     #
     def get_baggage_item(key)
-      return nil if @baggage.nil?
       @baggage[key]
     end
 
@@ -403,7 +394,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