instana 2.9.0 → 2.11.0

data/lib/instana/exporter/otlp/messaging_converter.rb

@@ -11,15 +11,36 @@ module Instana
     module Otlp
       # Converter for messaging spans to OTLP format
       class MessagingConverter < BaseConverter
-        # Build OTel-compliant span name for messaging (RabbitMQ) spans
+        # Build OTel-compliant span name for messaging spans
         #
-        # Formula per SPAN_NAME_PATTERNS.txt Section 3 (bunny/AMQP):
-        #   publish → "{exchange} publish"   (or "{queue} publish" when no exchange)
-        #   receive → "{queue} receive"
+        # Formula per SPAN_NAME_PATTERNS.txt Section 3 (bunny/AMQP / Kafka):
+        #   RabbitMQ publish → "{exchange} publish"   (or "{queue} publish" when no exchange)
+        #   RabbitMQ receive → "{queue} receive"
+        #   Kafka            → "{service} {access}"    (e.g., "orders send")
         #
         # @return [String] The span name
         def span_name
-          rabbitmq_data = span[:data]&.[](:rabbitmq) || {}
+          if (rabbitmq_data = span[:data]&.[](:rabbitmq))
+            rabbitmq_span_name(rabbitmq_data)
+          elsif (kafka_data = span[:data]&.[](:kafka))
+            kafka_span_name(kafka_data)
+          else
+            super
+          end
+        end
+
+        def convert_attributes
+          attributes = {}
+
+          convert_rabbitmq_attributes(attributes, span[:data]&.[](:rabbitmq))
+          convert_kafka_attributes(attributes, span[:data]&.[](:kafka))
+
+          attributes
+        end
+
+        private
+
+        def rabbitmq_span_name(rabbitmq_data)
           sort = rabbitmq_data[:sort].to_s
 
           if sort == 'publish'
@@ -32,26 +53,51 @@ module Instana
           end
         end
 
-        def convert_attributes
-          attributes = {}
+        def kafka_span_name(kafka_data)
+          service = kafka_data[:service].to_s.strip
+          access = kafka_data[:access].to_s.strip
+          parts = [service, access].reject(&:empty?)
+          parts.empty? ? 'kafka' : parts.join(' ')
+        end
 
-          rabbitmq_data = span[:data]&.[](:rabbitmq)
-          if rabbitmq_data
-            add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'rabbitmq')
-            add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME,
-                          rabbitmq_destination_name(rabbitmq_data))
-            add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY, rabbitmq_data[:key])
-            add_attribute(attributes, 'messaging.rabbitmq.queue', rabbitmq_data[:queue])
-            add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, rabbitmq_data[:address])
-
-            operation = rabbitmq_data[:sort] == 'publish' ? 'send' : 'receive'
-            add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_TYPE, operation)
-          end
+        def convert_rabbitmq_attributes(attributes, rabbitmq_data)
+          return unless rabbitmq_data
 
-          attributes
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'rabbitmq')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME,
+                        rabbitmq_destination_name(rabbitmq_data))
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY, rabbitmq_data[:key])
+          add_attribute(attributes, 'messaging.rabbitmq.queue', rabbitmq_data[:queue])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, extract_host(rabbitmq_data[:address]))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, extract_port(rabbitmq_data[:address]))
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_MESSAGE_BODY_SIZE, rabbitmq_data[:size])
+
+          operation = rabbitmq_data[:sort] == 'publish' ? 'send' : 'receive'
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_TYPE, operation)
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_NAME, rabbitmq_data[:sort])
         end
 
-        private
+        def convert_kafka_attributes(attributes, kafka_data)
+          return unless kafka_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'kafka')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME, kafka_data[:service])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_NAME, kafka_data[:access])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_TYPE, kafka_data[:access])
+        end
+
+        def extract_host(address)
+          return nil unless address
+
+          address.to_s.split(':').first
+        end
+
+        def extract_port(address)
+          return nil unless address
+
+          port = address.to_s.split(':').last
+          port.to_i if port =~ /^\d+$/
+        end
 
         # Build the composite destination name per spec:
         #   Producer (publish): "{exchange}:{key}"  — omit absent parts

data/lib/instana/exporter/otlp/rpc_converter.rb

@@ -6,6 +6,7 @@ require_relative 'base_converter'
 require 'opentelemetry/semconv/incubating/rpc'
 require 'opentelemetry/semconv/incubating/code'
 require 'opentelemetry/semconv/server'
+require 'opentelemetry/semconv/network'
 
 module Instana
   module Exporter
@@ -48,10 +49,13 @@ module Instana
 
         private
 
+        # gRPC status code mapping: 0 = OK for success, otherwise derive from error
+        GRPC_STATUS_CODE_OK = 0
+
         # Convert gRPC span attributes
         def convert_grpc_attributes(attributes, rpc_data)
           # RPC system
-          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::RPC::RPC_SYSTEM, 'grpc')
+          add_attribute(attributes, Instana::Exporter::Otlp::RPC_SYSTEM_ATTR, 'grpc')
 
           # RPC service and method
           if rpc_data[:call]
@@ -60,9 +64,20 @@ module Instana
             add_attribute(attributes, OpenTelemetry::SemConv::Incubating::RPC::RPC_METHOD, method)
           end
 
-          # Network peer
+          # Server host and port
           add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, rpc_data[:host])
-          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, rpc_data.dig(:peer, :address))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, parse_port(rpc_data[:port]))
+
+          # Network peer address (peer.address → network.peer.address)
+          peer = rpc_data[:peer]
+          if peer
+            add_attribute(attributes, OpenTelemetry::SemConv::NETWORK::NETWORK_PEER_ADDRESS, peer[:address])
+            add_attribute(attributes, OpenTelemetry::SemConv::NETWORK::NETWORK_PEER_PORT, parse_port(peer[:port]))
+          end
+
+          # gRPC status code (integer): 0 = OK for success spans
+          grpc_status = grpc_status_code(rpc_data)
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::RPC::RPC_GRPC_STATUS_CODE, grpc_status)
 
           # gRPC-specific attributes
           add_attribute(attributes, 'rpc.grpc.call_type', rpc_data[:call_type])
@@ -71,7 +86,7 @@ module Instana
         # Convert ActionCable span attributes
         def convert_action_cable_attributes(attributes, rpc_data)
           # RPC system
-          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::RPC::RPC_SYSTEM, 'actioncable')
+          add_attribute(attributes, Instana::Exporter::Otlp::RPC_SYSTEM_ATTR, 'actioncable')
 
           # ActionCable-specific attributes
           add_attribute(attributes, 'rails.actioncable.channel', rpc_data[:call])
@@ -96,6 +111,51 @@ module Instana
 
           [parts[1], parts[2]]
         end
+
+        # Parse port value to integer, returns nil if invalid or out of range
+        def parse_port(port)
+          return nil unless port
+
+          int_port = port.to_i
+          int_port if int_port >= 0 && int_port <= 65_535
+        end
+
+        # Map to gRPC status code integer.
+        # For successful spans (ec = 0) → 0 (OK).
+        # For error spans with a recognized gRPC status string in the error → map it.
+        # Otherwise → nil (omit the attribute).
+        GRPC_STATUS_CODES = {
+          'OK' => 0,
+          'CANCELLED' => 1,
+          'UNKNOWN' => 2,
+          'INVALID_ARGUMENT' => 3,
+          'DEADLINE_EXCEEDED' => 4,
+          'NOT_FOUND' => 5,
+          'ALREADY_EXISTS' => 6,
+          'PERMISSION_DENIED' => 7,
+          'RESOURCE_EXHAUSTED' => 8,
+          'FAILED_PRECONDITION' => 9,
+          'ABORTED' => 10,
+          'OUT_OF_RANGE' => 11,
+          'UNIMPLEMENTED' => 12,
+          'INTERNAL' => 13,
+          'UNAVAILABLE' => 14,
+          'DATA_LOSS' => 15,
+          'UNAUTHENTICATED' => 16
+        }.freeze
+
+        def grpc_status_code(rpc_data)
+          error_count = span[:ec].to_i
+          return GRPC_STATUS_CODE_OK if error_count.zero?
+
+          # Attempt to extract gRPC status string from error message
+          error_msg = rpc_data[:error].to_s
+          GRPC_STATUS_CODES.each do |name, code|
+            return code if error_msg.include?(name)
+          end
+
+          GRPC_STATUS_CODES['UNKNOWN']
+        end
       end
     end
   end

data/lib/instana/instrumentation/active_job.rb

@@ -1,19 +1,5 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2021
-module OpenTelemetry
-  module Trace
-    module Propagation
-      module TraceContext
-        # A TraceParent is an implementation of the W3C trace context specification
-        # https://www.w3.org/TR/trace-context/
-        # {Trace::SpanContext}
-        class TraceParent
-          REGEXP = /^(?<version>[A-Fa-f0-9]{2})-(?<trace_id>[A-Fa-f0-9]{32})-(?<span_id>[A-Fa-f0-9]{32})-(?<flags>[A-Fa-f0-9]{2})(?<ignored>-.*)?$/
-        end
-      end
-    end
-  end
-end
 
 module Instana
   module Instrumentation
@@ -48,11 +34,8 @@ module Instana
               job_id: job.job_id
             }
           }
-          incoming_context = if job.arguments.is_a?(Array) && job.arguments.last.is_a?(Hash) && job.arguments.last.key?(:instana_context)
-                               instana_context = job.arguments.last[:instana_context]
-                               job.arguments.pop
-                               instana_context ? ::Instana::SpanContext.new(trace_id: instana_context[:trace_id], span_id: instana_context[:span_id]) : nil
-                             end
+          incoming_context = ::Instana::Instrumentation::ActiveJob.extract_context(job)
+
           Trace.with_span(OpenTelemetry::Trace.non_recording_span(incoming_context)) do
             ::Instana.tracer.in_span(:activejob, attributes: tags) do
               block.call
@@ -60,6 +43,38 @@ module Instana
           end
         end
       end
+
+      def self.extract_context(job)
+        # 1. From job arguments (Instana payload)
+        if job.arguments.is_a?(Array) && job.arguments.last.is_a?(Hash) && job.arguments.last.key?(:instana_context)
+          instana_context = job.arguments.last[:instana_context]
+          job.arguments.pop
+          return instana_context ? ::Instana::SpanContext.new(
+            trace_id: instana_context[:trace_id],
+            span_id: instana_context[:span_id],
+            level: instana_context[:level] || 1
+          ) : nil
+        end
+
+        # 2. From job.__otel_headers (if opentelemetry-instrumentation-active_job is active)
+        if job.respond_to?(:__otel_headers) && job.__otel_headers.is_a?(Hash)
+          headers = job.__otel_headers
+          tp = headers['traceparent'] || headers[:traceparent]
+          if tp
+            ctx = parse_w3c_traceparent(tp, headers['tracestate'] || headers[:tracestate])
+            return ctx if ctx
+          end
+        end
+
+        nil
+      end
+
+      def self.parse_w3c_traceparent(traceparent, tracestate)
+        ctx = ::Instana::Util.parse_w3c_trace_context(traceparent, tracestate)
+        return nil unless ctx
+
+        ::Instana::SpanContext.new(trace_id: ctx[:trace_id], span_id: ctx[:span_id], level: ctx[:level])
+      end
     end
   end
 end

data/lib/instana/instrumentation/aws_sdk_lambda.rb

@@ -9,15 +9,24 @@ module Instana
         def call(context)
           return @handler.call(context) unless [:invoke_async, :invoke].include?(context.operation_name)
 
-          if context.params[:client_context].nil? && ::Instana.tracer.tracing? && context.operation_name == :invoke
+          if ::Instana.tracer.tracing? && context.operation_name == :invoke
             span_context = ::Instana.tracer.context
-            payload = {
-              'X-INSTANA-T' => span_context.trace_id,
-              'X-INSTANA-S' => span_context.span_id,
-              'X-INSTANA-L' => span_context.level.to_s
-            }
+            if span_context
+              trace_payload = {
+                'X-INSTANA-T' => span_context.trace_id,
+                'X-INSTANA-S' => span_context.span_id,
+                'X-INSTANA-L' => span_context.level.to_s,
+                'traceparent' => span_context.trace_parent_header,
+                'tracestate' => span_context.trace_state_header
+              }.reject { |_, v| v.nil? || v.empty? }
 
-            context.params[:client_context] = Base64.strict_encode64(JSON.dump(payload))
+              merged = if context.params[:client_context]
+                         JSON.parse(Base64.strict_decode64(context.params[:client_context])).merge(trace_payload)
+                       else
+                         trace_payload
+                       end
+              context.params[:client_context] = Base64.strict_encode64(JSON.dump(merged))
+            end
           end
 
           tags = {

data/lib/instana/instrumentation/aws_sdk_sns.rb

@@ -14,11 +14,41 @@ module Instana
           }.reject { |_, v| v.nil? }
 
           if context.operation_name == :publish
-            ::Instana.tracer.in_span(:sns, attributes: {sns: sns_tags}) { @handler.call(context) }
+            ::Instana.tracer.in_span(:sns, attributes: { sns: sns_tags }) do |_span|
+              if ::Instana.tracer.tracing?
+                inject_trace_attributes(context.params)
+              end
+              @handler.call(context)
+            end
+          elsif context.operation_name == :publish_batch
+            ::Instana.tracer.in_span(:sns, attributes: { sns: sns_tags }) do |_span|
+              if ::Instana.tracer.tracing?
+                context.params[:publish_batch_request_entries]&.each do |entry|
+                  inject_trace_attributes(entry)
+                end
+              end
+              @handler.call(context)
+            end
           else
             @handler.call(context)
           end
         end
+
+        private
+
+        def inject_trace_attributes(params)
+          span_context = ::Instana.tracer.context
+          return unless span_context
+
+          params[:message_attributes] ||= {}
+          available_slots = 10 - params[:message_attributes].size
+
+          extra = ::Instana::Util.aws_message_attributes_w3c(span_context)
+          extra.merge!(::Instana::Util.aws_message_attributes_instana(span_context)) if available_slots >= 5
+
+          extra.reject! { |_, v| v[:string_value].nil? || v[:string_value].empty? }
+          params[:message_attributes].merge!(extra)
+        end
       end
 
       def add_handlers(handlers, _config)

data/lib/instana/instrumentation/aws_sdk_sqs.rb

@@ -36,11 +36,16 @@ module Instana
 
         def inject_instana_headers(span, params)
           params[:message_attributes] ||= {}
-          params[:message_attributes].merge!({
-                                               "X_INSTANA_T" => {data_type: 'String', string_value: span.context.trace_id},
-                                               "X_INSTANA_S" => {data_type: 'String', string_value: span.context.span_id},
-                                               "X_INSTANA_L" => {data_type: 'String', string_value: span.context.level.to_s}
-                                             })
+          span_context = span.context
+          return unless span_context
+
+          available_slots = 10 - params[:message_attributes].size
+
+          extra = ::Instana::Util.aws_message_attributes_w3c(span_context)
+          extra.merge!(::Instana::Util.aws_message_attributes_instana(span_context)) if available_slots >= 5
+
+          extra.reject! { |_, v| v[:string_value].nil? || v[:string_value].empty? }
+          params[:message_attributes].merge!(extra)
         end
 
         def tags_for(operation_name, params)

data/lib/instana/instrumentation/bunny.rb

@@ -20,9 +20,11 @@ module Instana
           ::Instana.tracer.in_span(:rabbitmq, attributes: kvs) do |span|
             # Inject trace context into message headers
             options[:headers] ||= {}
-            options[:headers]['X-Instana-T'] = span.context.trace_id
-            options[:headers]['X-Instana-S'] = span.context.span_id
-            options[:headers]['X-Instana-L'] = span.context.level.to_s
+            options[:headers][INSTANA_TRACE_ID_HEADER] = span.context.trace_id
+            options[:headers][INSTANA_SPAN_ID_HEADER] = span.context.span_id
+            options[:headers][INSTANA_LEVEL_HEADER] = span.context.level.to_s
+            options[:headers]['traceparent']  = span.context.trace_parent_header
+            options[:headers]['tracestate']   = span.context.trace_state_header
 
             super(payload, options)
           end
@@ -113,13 +115,28 @@ module Instana
         return {} unless properties && properties.headers
 
         headers = properties.headers
+
+        if headers[INSTANA_TRACE_ID_HEADER]
+          extract_instana_context(headers)
+        elsif headers['traceparent']
+          extract_w3c_context(headers)
+        else
+          {}
+        end
+      end
+
+      def extract_instana_context(headers)
         {
-          trace_id: headers['X-Instana-T'],
-          span_id: headers['X-Instana-S'],
-          level: headers['X-Instana-L']&.to_i
+          trace_id: headers[INSTANA_TRACE_ID_HEADER],
+          span_id: headers[INSTANA_SPAN_ID_HEADER],
+          level: headers[INSTANA_LEVEL_HEADER]&.to_i || 1
         }.reject { |_, v| v.nil? }
       end
 
+      def extract_w3c_context(headers)
+        ::Instana::Util.parse_w3c_trace_context(headers['traceparent'], headers['tracestate']) || {}
+      end
+
       def log_error(error)
         # Log errors on to console if INSTANA_DEBUG is enabled
         ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{error.message}" }

data/lib/instana/instrumentation/grpc.rb

@@ -8,8 +8,8 @@ module Instana
     module GRPCCientInstrumentation
       CALL_TYPES = [:request_response, :client_streamer, :server_streamer, :bidi_streamer]
 
-      CALL_TYPES.each do |call_type|
-        define_method(call_type) do |method, *others, **options|
+      CALL_TYPES.each do |call_type| # rubocop:disable Metrics/BlockLength
+        define_method(call_type) do |method, *others, **options| # rubocop:disable Metrics/BlockLength
           begin
             kvs = { rpc: {} }
 
@@ -26,10 +26,15 @@ module Instana
 
             context = ::Instana.tracer.context
             if context
-              options[:metadata] = (options[:metadata] || {}).merge(
+              extra = {
                 'x-instana-t' => context.trace_id_header,
-                'x-instana-s' => context.span_id_header
-              )
+                'x-instana-s' => context.span_id_header,
+                'x-instana-l' => context.level.to_s,
+                'traceparent' => context.trace_parent_header,
+                'tracestate' => context.trace_state_header
+              }
+              extra.reject! { |_, v| v.nil? || v.empty? }
+              options[:metadata] = (options[:metadata] || {}).merge(extra)
             end
 
             super(method, *others, **options)
@@ -58,12 +63,7 @@ module Instana
             kvs = { rpc: {} }
             metadata = active_call.metadata
 
-            incoming_context = nil
-            if metadata.key?('x-instana-t')
-              incoming_context = SpanContext.new(trace_id: ::Instana::Util.header_to_id(metadata['x-instana-t']),
-                                                 span_id: metadata.key?('x-instana-s') ? ::Instana::Util.header_to_id(metadata['x-instana-s']) : nil,
-                                                 level: metadata.key?('x-instana-l') ? metadata['x-instana-l'] : nil)
-            end
+            incoming_context = extract_grpc_context(metadata)
 
             kvs[:rpc][:flavor] = :grpc
             kvs[:rpc][:host] = Socket.gethostname
@@ -87,6 +87,34 @@ module Instana
           end
         end
       end
+
+      private
+
+      def extract_grpc_context(metadata)
+        if metadata.key?('x-instana-t')
+          extract_instana_grpc_context(metadata)
+        elsif metadata.key?('traceparent')
+          extract_w3c_grpc_context(metadata)
+        end
+      end
+
+      def extract_instana_grpc_context(metadata)
+        SpanContext.new(
+          trace_id: ::Instana::Util.header_to_id(metadata['x-instana-t']),
+          span_id: metadata.key?('x-instana-s') ? ::Instana::Util.header_to_id(metadata['x-instana-s']) : nil,
+          level: metadata['x-instana-l'] || 1
+        )
+      end
+
+      def extract_w3c_grpc_context(metadata)
+        ctx = ::Instana::Util.parse_w3c_trace_context(metadata['traceparent'], metadata['tracestate'])
+        return nil unless ctx
+
+        SpanContext.new(trace_id: ctx[:trace_id],
+                        span_id: ctx[:span_id],
+                        level: ctx[:level],
+                        baggage: ctx.slice(:external_trace_id, :external_trace_flags, :external_state))
+      end
     end
   end
 end

data/lib/instana/instrumentation/instrumented_request.rb

@@ -32,19 +32,14 @@ module Instana
 
       context[:level] = @env['HTTP_X_INSTANA_L'][0] if @env['HTTP_X_INSTANA_L']
 
-      unless ::Instana.config[:w3c_trace_correlation]
-        trace_state = parse_trace_state
-
-        if context[:from_w3c] && trace_state.empty?
-          context.delete(:span_id)
-          context[:from_w3c] = false
-        elsif context[:from_w3c] && !trace_state.empty?
-          context[:trace_id] = trace_state[:t]
-          context[:span_id] = trace_state[:p]
-          context[:from_w3c] = false
-        end
+      # Honour W3C sampled bit when no X-Instana-L is present.
+      if context[:level].nil? && context[:external_trace_flags]
+        w3c_sampled = (context[:external_trace_flags].to_i(16) & 0x01) == 1
+        context[:level] = w3c_sampled ? '1' : '0'
       end
 
+      apply_legacy_w3c_override(context) unless ::Instana.config[:w3c_trace_correlation]
+
       context
     end
 
@@ -107,6 +102,21 @@ module Instana
 
     private
 
+    def apply_legacy_w3c_override(context)
+      return unless context[:from_w3c]
+
+      trace_state = parse_trace_state
+
+      if trace_state.empty?
+        context.delete(:span_id)
+      else
+        context[:trace_id] = trace_state[:t]
+        context[:span_id] = trace_state[:p]
+      end
+
+      context[:from_w3c] = false
+    end
+
     def context_from_instana_headers
       sanitized_t = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_T'])
       sanitized_s = ::Instana::Util.header_to_id(@env['HTTP_X_INSTANA_S'])

data/lib/instana/instrumentation/rack.rb

@@ -139,6 +139,8 @@ module Instana
       end
 
       headers['Traceparent'] = trace_context.trace_parent_header
+      return if ::Instana.config[:disable_server_timing]
+
       headers['Server-Timing'] = "intid;desc=#{trace_context.trace_id_header}"
     end
   end

data/lib/instana/instrumentation/resque.rb

@@ -79,7 +79,8 @@ module Instana
                           context_from_wire = job.payload['args'].pop
                           ::Instana::SpanContext.new(
                             trace_id: context_from_wire['trace_id'],
-                            span_id: context_from_wire['span_id']
+                            span_id: context_from_wire['span_id'],
+                            level: context_from_wire['level'] || 1
                           )
                         end
         span = OpenTelemetry::Trace.non_recording_span(trace_context) if trace_context

data/lib/instana/instrumentation/shoryuken.rb

@@ -15,24 +15,45 @@ module Instana
         }
 
         context = incomming_context_from(sqs_message.message_attributes)
-        instana_context = Instana::SpanContext.new(trace_id: context[:trace_id], span_id: context[:span_id], level: context[:level])
-        Trace.with_span(OpenTelemetry::Trace.non_recording_span(instana_context)) do
-          ::Instana.tracer.in_span(:sqs, attributes: {sqs: sqs_tags}, &block)
+        if context[:trace_id]
+          instana_context = Instana::SpanContext.new(
+            trace_id: context[:trace_id],
+            span_id: context[:span_id],
+            level: context[:level] || 1
+          )
+          Trace.with_span(OpenTelemetry::Trace.non_recording_span(instana_context)) do
+            ::Instana.tracer.in_span(:sqs, attributes: { sqs: sqs_tags }, &block)
+          end
+        else
+          ::Instana.tracer.in_span(:sqs, attributes: { sqs: sqs_tags }, &block)
         end
       end
 
       private
 
       def incomming_context_from(attributes)
-        trace_id = read_message_header(attributes, 'X_INSTANA_T')
-        span_id = read_message_header(attributes, 'X_INSTANA_S')
-        level = read_message_header(attributes, 'X_INSTANA_L')
-
-        {
-          trace_id: trace_id,
-          span_id: span_id,
-          level: level
-        }.reject { |_, v| v.nil? }
+        return {} unless attributes
+
+        if read_message_header(attributes, 'X_INSTANA_T')
+          trace_id = read_message_header(attributes, 'X_INSTANA_T')
+          span_id = read_message_header(attributes, 'X_INSTANA_S')
+          level = read_message_header(attributes, 'X_INSTANA_L')
+
+          {
+            trace_id: trace_id,
+            span_id: span_id,
+            level: level ? level.to_i : 1
+          }.reject { |_, v| v.nil? }
+        else
+          w3c_context_from(attributes)
+        end
+      end
+
+      def w3c_context_from(attributes)
+        ::Instana::Util.parse_w3c_trace_context(
+          read_message_header(attributes, 'traceparent'),
+          read_message_header(attributes, 'tracestate')
+        ) || {}
       end
 
       def read_message_header(attributes, key)

data/lib/instana/instrumentation/sidekiq-client.rb

@@ -31,6 +31,7 @@ module Instana
           if context
             msg['X-Instana-T'] = context.trace_id_header
             msg['X-Instana-S'] = context.span_id_header
+            msg['X-Instana-L'] = context.level.to_s
           end
 
           result = yield

data/lib/instana/instrumentation/sidekiq-worker.rb

@@ -30,10 +30,12 @@ module Instana
         trace_context = nil
         if msg.key?('X-Instana-T')
           trace_id = msg.delete('X-Instana-T')
-          span_id = msg.delete('X-Instana-S')
+          span_id  = msg.delete('X-Instana-S')
+          level    = msg.delete('X-Instana-L')
           trace_context = ::Instana::SpanContext.new(
             trace_id: ::Instana::Util.header_to_id(trace_id),
-            span_id: span_id ? ::Instana::Util.header_to_id(span_id) : nil
+            span_id: span_id ? ::Instana::Util.header_to_id(span_id) : nil,
+            level: level || 1
           )
         end