instana 2.7.2 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c9fe7c6b744ebafc10428dbbfdcfe046fdcfc80b31227b29b4a18ade7ec5dd
-  data.tar.gz: 94b10d48f251f49157203534306399fed404adf619318cdebb0ff1864a74fc41
+  metadata.gz: 80154e97601cca5ffd4537ecc7f664c97f27de2f62c0d72f0951d75749ddb5db
+  data.tar.gz: 61db3e2ab8805be8ed97da7f0b9d0fd24927f8f68a98d7c82075d69859db217a
 SHA512:
-  metadata.gz: 56ff7ee602ef57a060bc1e467e11dc5466469433c54abc6457bb1959c4f5abf82d491b5db272b4cf45bea72335c28a0b9213357c44bf90543c123d424743f9f7
-  data.tar.gz: 811b2bd02833ec5127fdfeee050cab1ce3c1410e120ecd4452c41207b4c7a4fbc11f390ba8a62181f7a56fd3cd073392ca5115a68bfeb3a200f84ad5812a8ba7
+  metadata.gz: 29c643217182cc683c2c770c72fe74d5d3acb84d39766f38363dbd250d6469d49bbf0d00fb9987af600af66b0afec944063d79bff17da91b8dd9f68d9a2eeb1a
+  data.tar.gz: 262ab506d671a71f4eab35078717ff27fedaa46eebaa1cb8cc01eeb6e01a11ce30ea3fec7709b68db246b918bc822ad5d54e971271903a3c99c4c25ef9272433

data/lib/instana/backend/gc_snapshot.rb

@@ -17,18 +17,18 @@ module Instana
         @last_minor_count = 0
       end
 
-      def report
+      def report(poll_rate = 1)
         stats = ::GC.stat
         total_time = ::GC::Profiler.total_time * 1000
 
         ::GC::Profiler.clear
 
         payload = {
-          totalTime: total_time,
+          totalTime: total_time / poll_rate,
           heap_live: stats[:heap_live_slots] || stats[:heap_live_num],
           heap_free: stats[:heap_free_slots] || stats[:heap_free_num],
-          minorGcs: stats[:minor_gc_count] - @last_minor_count,
-          majorGcs: stats[:major_gc_count] - @last_major_count
+          minorGcs: (stats[:minor_gc_count] - @last_minor_count) / poll_rate.to_f,
+          majorGcs: (stats[:major_gc_count] - @last_major_count) / poll_rate.to_f
         }
 
         @last_major_count = stats[:major_gc_count]

data/lib/instana/backend/host_agent_reporting_observer.rb

@@ -1,5 +1,7 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2021
+require 'opentelemetry/exporter/otlp'
+require_relative '../exporter/otlp/converter_factory'
 
 module Instana
   module Backend
@@ -22,7 +24,7 @@ module Instana
         @timer_class = timer_class
         @nonce = Time.now
         @processor = processor
-
+        initialize_otlp_exporter
         # Initialize timers with default 1 second interval
         @metrics_timer = @timer_class.new(execution_interval: 1, run_now: true) { report_metrics_to_backend }
         @traces_timer = @timer_class.new(execution_interval: 1, run_now: true) { report_traces_to_backend }
@@ -36,6 +38,8 @@ module Instana
         if new_version.nil?
           @metrics_timer&.shutdown
           @traces_timer&.shutdown
+          @otlp_exporter&.shutdown
+          @otlp_exporter = nil
         else
           # Read poll_rate from discovery payload - it's nested under plugin.ruby.poll_rate
           discovery = @discovery.value
@@ -90,10 +94,22 @@ module Instana
         path = format(TRACES_DATA_URL, discovery['pid'])
 
         @processor.send do |spans|
-          response = @client.send_request('POST', path, spans)
+          success = false
+          if @otlp_exporter
+            converted_spans = spans.map do |span|
+              ::Instana::Exporter::Otlp::ConverterFactory.create(span).convert
+            end
+            result_code = @otlp_exporter.export(converted_spans)
+            Instana.logger.debug("Using OTLP Exporter to export result code: #{result_code}")
+            success = result_code == OpenTelemetry::SDK::Trace::Export::SUCCESS
+          else
+            response = @client.send_request('POST', path, spans)
+            Instana.logger.debug("Using Instana Native Exporter to export result code: #{response}")
+            success = response&.ok?
+          end
 
-          unless response.ok?
-            @logger.warn("Failed to send `#{spans.count}` spans to `#{path}`. Response: #{response.code} - #{response.body}")
+          unless success
+            @logger.warn("Failed to send `#{spans.count}` spans to `#{path}`.")
             trigger_rediscovery
             break
           end
@@ -145,7 +161,8 @@ module Instana
         end
 
         if ::Instana.config[:metrics][:gc][:enabled]
-          payload[:gc] = GCSnapshot.instance.report
+          poll_rate = discovery&.dig('plugin', 'ruby', 'poll_rate') || 1
+          payload[:gc] = GCSnapshot.instance.report(poll_rate)
         end
 
         if ::Instana.config[:metrics][:thread][:enabled]
@@ -159,6 +176,44 @@ module Instana
         @discovery.swap { nil }
         ::Instana.agent.announce
       end
+
+      def initialize_otlp_exporter
+        config = ::Instana.config[:otlp]
+        unless config[:enabled]
+          @otlp_exporter = nil
+          return
+        end
+
+        endpoint = resolve_otlp_endpoint(config[:endpoint], config[:config_source])
+        opts = { endpoint: endpoint, timeout: config[:timeout] / 1000.0 }
+        opts[:compression]            = config[:compression]         if config[:compression]
+        opts[:headers]                = config[:headers]             if config[:headers]&.any?
+        opts[:certificate_file]       = config[:certificate] if config[:certificate]
+        opts[:client_certificate_file] = config[:client_certificate] if config[:client_certificate]
+        opts[:client_key_file] = config[:client_key] if config[:client_key]
+
+        @otlp_exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(**opts)
+      rescue StandardError => e
+        @logger.error("Failed to initialize OTLP exporter: #{e.message}")
+        @otlp_exporter = nil
+      end
+
+      # Derive the OTLP endpoint from the discovered agent host when no explicit
+      # endpoint has been configured (config_source == 'default').
+      OTLP_DEFAULT_PORT = 4318
+      OTLP_TRACES_PATH  = '/v1/traces'.freeze
+
+      def resolve_otlp_endpoint(endpoint, config_source)
+        return endpoint unless config_source == 'default'
+
+        # Use the host that was discovered by HostAgentLookup (same host the
+        # metrics/traces client is already talking to) and append the standard
+        # OTLP HTTP port and traces path.
+        agent_host = @client&.host
+        return endpoint unless agent_host
+
+        "http://#{agent_host}:#{OTLP_DEFAULT_PORT}#{OTLP_TRACES_PATH}"
+      end
     end
   end
 end

data/lib/instana/config.rb

@@ -5,16 +5,20 @@ require 'yaml'
 
 module Instana
   class Config
-    def initialize(logger: ::Instana.logger, agent_host: ENV['INSTANA_AGENT_HOST'], agent_port: ENV['INSTANA_AGENT_PORT'])
+
+    LEGACY_TRACING_KEY = 'com.instana.tracing'.freeze
+    TRACING_KEY = 'tracing'.freeze
+
+    def initialize(logger: ::Instana.logger, agent_host: ENV.fetch('INSTANA_AGENT_HOST', nil), agent_port: ENV.fetch('INSTANA_AGENT_PORT', nil)) # rubocop:disable Metrics/MethodLength
       @config = {}
       if agent_host
-        logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{ENV['INSTANA_AGENT_HOST']})"
+        logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{agent_host})"
         @config[:agent_host] = agent_host
       else
         @config[:agent_host] = '127.0.0.1'
       end
       if agent_port
-        logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{ENV['INSTANA_AGENT_PORT']})"
+        logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{agent_port})"
         @config[:agent_port] = agent_port
       else
         @config[:agent_port] = 42699
@@ -30,7 +34,7 @@ module Instana
       @config[:tracing] = { :enabled => true }
 
       # Enable/disable tracing exit spans as root spans
-      @config[:allow_exit_as_root] = ENV['INSTANA_ALLOW_EXIT_AS_ROOT'] == '1'
+      @config[:allow_exit_as_root] = ENV.fetch('INSTANA_ALLOW_EXIT_AS_ROOT', nil) == '1'
 
       # Enable/Disable logging
       @config[:logging] = { :enabled => true }
@@ -49,6 +53,20 @@ module Instana
       # @config[:back_trace] = { stack_trace_level: nil }
       read_span_stack_config
 
+      # OTLP exporter configuration (default: disabled)
+      @config[:otlp] = {
+        enabled: false,
+        endpoint: 'http://localhost:4318/v1/traces',
+        timeout: 10_000,
+        compression: nil,
+        headers: {},
+        certificate: nil,
+        client_key: nil,
+        client_certificate: nil,
+        config_source: 'default'
+      }
+      read_otlp_config
+
       # By default, collected SQL will be sanitized to remove potentially sensitive bind params such as:
       #   > SELECT  "blocks".* FROM "blocks"  WHERE "blocks"."name" = "Mr. Smith"
       #
@@ -60,7 +78,7 @@ module Instana
       @config[:sanitize_sql] = true
 
       # W3C Trace Context Support
-      @config[:w3c_trace_correlation] = ENV['INSTANA_DISABLE_W3C_TRACE_CORRELATION'].nil?
+      @config[:w3c_trace_correlation] = ENV.fetch('INSTANA_DISABLE_W3C_TRACE_CORRELATION', nil).nil?
 
       @config[:post_fork_proc] = proc { ::Instana.agent.spawn_background_thread }
 
@@ -94,7 +112,7 @@ module Instana
     # Priority: Environment variables > YAML file > Agent discovery > Defaults
     def read_span_stack_config
       # Try environment variables first
-      if ENV['INSTANA_STACK_TRACE'] || ENV['INSTANA_STACK_TRACE_LENGTH']
+      if ENV.fetch('INSTANA_STACK_TRACE', nil) || ENV.fetch('INSTANA_STACK_TRACE_LENGTH', nil)
         read_span_stack_config_from_env
         @config[:back_trace_technologies] = {}
         return
@@ -122,6 +140,8 @@ module Instana
 
       # Read stack trace configuration from agent if not already set from YAML or env
       read_span_stack_config_from_agent(tracing_config) if should_read_from_agent?(:back_trace)
+      # Read OTLP configuration from agent if not already set from YAML or env
+      read_otlp_config_from_agent(tracing_config) if should_read_from_agent?(:otlp)
       # Read span filtering configuration from agent
       ::Instana.span_filtering_config&.read_config_from_agent(discovery)
     rescue => e
@@ -143,17 +163,17 @@ module Instana
     # Read stack trace configuration from YAML file
     # Returns hash with :global and :technologies keys or nil if not found
     def read_span_stack_config_from_yaml
-      config_path = ENV['INSTANA_CONFIG_PATH']
+      config_path = ENV.fetch('INSTANA_CONFIG_PATH', nil)
       return nil unless config_path && File.exist?(config_path)
 
       begin
         yaml_content = YAML.safe_load(File.read(config_path))
 
         # Support both "tracing" and "com.instana.tracing" as top-level keys
-        if yaml_content['com.instana.tracing']
-          ::Instana.logger.warn('Please use "tracing" instead of "com.instana.tracing"')
+        if yaml_content[LEGACY_TRACING_KEY]
+          ::Instana.logger.warn("Please use \"#{TRACING_KEY}\" instead of \"#{LEGACY_TRACING_KEY}\"")
         end
-        tracing_config = yaml_content['tracing'] || yaml_content['com.instana.tracing']
+        tracing_config = yaml_content[TRACING_KEY] || yaml_content[LEGACY_TRACING_KEY]
         return nil unless tracing_config
 
         result = {}
@@ -178,8 +198,8 @@ module Instana
     # Read stack trace configuration from environment variables
     def read_span_stack_config_from_env
       @config[:back_trace] = {
-        stack_trace_level: ENV['INSTANA_STACK_TRACE'] || 'error',
-        stack_trace_length: ENV['INSTANA_STACK_TRACE_LENGTH']&.to_i || 30,
+        stack_trace_level: ENV.fetch('INSTANA_STACK_TRACE', 'error'),
+        stack_trace_length: ENV.fetch('INSTANA_STACK_TRACE_LENGTH', 30).to_i,
         config_source: 'env'
       }
     end
@@ -217,8 +237,128 @@ module Instana
       }
     end
 
+    # Read OTLP configuration from agent discovery
+    # @param tracing_config [Hash] The tracing configuration from discovery
+    def read_otlp_config_from_agent(tracing_config)
+      otlp_config = tracing_config['otlp']
+      return unless otlp_config.is_a?(Hash)
+
+      @config[:otlp][:enabled]            = truthy?(otlp_config['enabled'])         unless otlp_config['enabled'].nil?
+      @config[:otlp][:endpoint]           = otlp_config['endpoint']                 if otlp_config['endpoint']
+      @config[:otlp][:timeout]            = otlp_config['timeout'].to_i             if otlp_config['timeout']
+      @config[:otlp][:compression]        = otlp_config['compression']              if otlp_config['compression']
+      @config[:otlp][:headers]            = otlp_config['headers']                  if otlp_config['headers'].is_a?(Hash)
+      @config[:otlp][:certificate]        = otlp_config['certificate']              if otlp_config['certificate']
+      @config[:otlp][:client_key]         = otlp_config['client_key']               if otlp_config['client_key']
+      @config[:otlp][:client_certificate] = otlp_config['client_certificate']       if otlp_config['client_certificate']
+      @config[:otlp][:config_source]      = 'agent'
+    end
+
     private
 
+    # Read OTLP configuration — precedence: YAML > env vars > defaults (agent handled separately)
+    def read_otlp_config
+      # Try YAML first
+      yaml_otlp = parse_otlp_config_from_yaml
+      if yaml_otlp
+        @config[:otlp].merge!(yaml_otlp)
+        @config[:otlp][:config_source] = 'yaml'
+        return
+      end
+
+      # Try environment variables
+      env_otlp = parse_otlp_config_from_env
+      if env_otlp
+        @config[:otlp].merge!(env_otlp)
+        @config[:otlp][:config_source] = 'env'
+      end
+      # Otherwise leave defaults ('default' config_source), agent can update later
+    end
+
+    # Parse OTLP config from YAML file at INSTANA_CONFIG_PATH under tracing.otlp
+    # @return [Hash, nil] merged OTLP settings or nil if not found
+    def parse_otlp_config_from_yaml
+      config_path = ENV.fetch('INSTANA_CONFIG_PATH', nil)
+      return nil unless config_path && File.exist?(config_path)
+
+      begin
+        yaml_content = YAML.safe_load(File.read(config_path))
+        tracing_config = yaml_content[TRACING_KEY] || yaml_content[LEGACY_TRACING_KEY]
+        return nil unless tracing_config
+
+        otlp_yaml = tracing_config['otlp']
+        return nil unless otlp_yaml.is_a?(Hash)
+
+        build_otlp_yaml_result(otlp_yaml)
+      rescue => e
+        ::Instana.logger.warn("Failed to load OTLP configuration from YAML: #{e.message}")
+        nil
+      end
+    end
+
+    def build_otlp_yaml_result(otlp_yaml)
+      result = {}
+      result[:enabled]            = truthy?(otlp_yaml['enabled'])   unless otlp_yaml['enabled'].nil?
+      result[:endpoint]           = otlp_yaml['endpoint']           if otlp_yaml['endpoint']
+      result[:timeout]            = otlp_yaml['timeout'].to_i       if otlp_yaml['timeout']
+      result[:compression]        = otlp_yaml['compression']        if otlp_yaml['compression']
+      result[:headers]            = otlp_yaml['headers']            if otlp_yaml['headers'].is_a?(Hash)
+      result[:certificate]        = otlp_yaml['certificate']        if otlp_yaml['certificate']
+      result[:client_key]         = otlp_yaml['client_key']         if otlp_yaml['client_key']
+      result[:client_certificate] = otlp_yaml['client_certificate'] if otlp_yaml['client_certificate']
+      result.empty? ? nil : result
+    end
+
+    # Parse OTLP config from environment variables
+    # @return [Hash, nil] merged OTLP settings or nil if no relevant env vars are set
+    def parse_otlp_config_from_env
+      raw = otlp_env_vars
+      return nil if raw.values.all?(&:nil?)
+
+      result = {}
+      result[:enabled]            = truthy?(raw[:enabled_raw])              unless raw[:enabled_raw].nil?
+      result[:endpoint]           = raw[:endpoint]                          if raw[:endpoint]
+      result[:timeout]            = raw[:timeout_raw].to_i                  if raw[:timeout_raw]
+      result[:compression]        = raw[:compression]                       if raw[:compression]
+      result[:headers]            = parse_otlp_headers(raw[:headers_raw])   if raw[:headers_raw]
+      result[:certificate]        = raw[:certificate]                       if raw[:certificate]
+      result[:client_key]         = raw[:client_key]                        if raw[:client_key]
+      result[:client_certificate] = raw[:client_cert]                       if raw[:client_cert]
+      result
+    end
+
+    # Collect raw OTLP-related environment variable values into a single hash
+    # @return [Hash]
+    def otlp_env_vars
+      {
+        enabled_raw: ENV.fetch('INSTANA_TRACING_OTLP_ENABLED', nil),
+        endpoint: ENV.fetch('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT', nil) || ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil),
+        timeout_raw: ENV.fetch('OTEL_EXPORTER_OTLP_TIMEOUT', nil),
+        compression: ENV.fetch('OTEL_EXPORTER_OTLP_COMPRESSION', nil),
+        headers_raw: ENV.fetch('OTEL_EXPORTER_OTLP_TRACES_HEADERS', nil) || ENV.fetch('OTEL_EXPORTER_OTLP_HEADERS', nil),
+        certificate: ENV.fetch('OTEL_EXPORTER_OTLP_CERTIFICATE', nil),
+        client_key: ENV.fetch('OTEL_EXPORTER_OTLP_CLIENT_KEY', nil),
+        client_cert: ENV.fetch('OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE', nil)
+      }
+    end
+
+    # Parse OTEL_EXPORTER_OTLP_HEADERS value (comma-separated key=value pairs) into a Hash
+    # @param headers_str [String] e.g. "api-key=secret,x-tenant=tenant1"
+    # @return [Hash]
+    def parse_otlp_headers(headers_str)
+      return {} unless headers_str
+
+      headers_str.split(',').each_with_object({}) do |pair, hash|
+        key, value = pair.split('=', 2)
+        hash[key.strip] = value&.strip if key
+      end
+    end
+
+    # Normalise a truthy string value to a boolean
+    def truthy?(value)
+      %w[true 1 yes].include?(value.to_s.downcase)
+    end
+
     # Parse global stack trace configuration from a config hash
     # @param global_config [Hash] The global configuration hash
     # @param config_source [String] The source of the configuration ('yaml', 'agent', etc.)

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/incubating/messaging'
+require 'opentelemetry/semconv/db'
+require 'opentelemetry/semconv/incubating/db'
+
+module Instana
+  module Exporter
+    module Otlp
+      # Converter for AWS SDK spans (SQS, SNS, DynamoDB) to OTLP format
+      class AwsConverter < BaseConverter
+        # Build OTel-compliant span name for AWS SDK spans
+        #
+        # Formulas per SPAN_NAME_PATTERNS.txt Section 6:
+        #   SQS send/publish  → "{queue} publish"
+        #   SQS receive/delete → "{queue} receive"
+        #   SNS               → "{topic} publish"
+        #   DynamoDB          → "DynamoDB.{op}"      e.g. "DynamoDB.PutItem"
+        #   S3                → "S3.{op}"            e.g. "S3.PutObject"
+        #   Lambda invoke     → "Lambda.{function}"
+        #
+        # @return [String] The span name
+        def span_name
+          data = span[:data] || {}
+          sqs_span_name(data[:sqs]) ||
+            sns_span_name(data[:sns]) ||
+            dynamodb_span_name(data[:dynamodb]) ||
+            s3_span_name(data[:s3]) ||
+            lambda_span_name(data.dig(:aws, :lambda, :invoke)) ||
+            super
+        end
+
+        def convert_attributes
+          attributes = {}
+          data = span[:data]
+          return attributes unless data
+
+          convert_sqs_attributes(attributes, data[:sqs])
+          convert_sns_attributes(attributes, data[:sns])
+          convert_dynamodb_attributes(attributes, data[:dynamodb])
+          convert_s3_attributes(attributes, data[:s3])
+          convert_lambda_attributes(attributes, data.dig(:aws, :lambda, :invoke))
+
+          attributes
+        end
+
+        private
+
+        def sqs_span_name(sqs)
+          return unless sqs
+
+          queue = sqs[:queue].to_s.strip
+          operation = sqs[:type].to_s =~ /^(delete|receive)/ ? 'receive' : 'publish'
+          queue.empty? ? "SQS #{operation}" : "#{queue} #{operation}"
+        end
+
+        def sns_span_name(sns)
+          return unless sns
+
+          topic = sns[:topic].to_s.strip
+          topic = sns[:target].to_s.strip if topic.empty?
+          topic.empty? ? 'SNS publish' : "#{topic} publish"
+        end
+
+        def dynamodb_span_name(ddb)
+          return unless ddb
+
+          op = ddb[:op].to_s.strip
+          op.empty? ? 'DynamoDB' : "DynamoDB.#{op}"
+        end
+
+        def s3_span_name(s3_data)
+          return unless s3_data
+
+          op = s3_data[:op].to_s.strip
+          op.empty? ? 'S3' : "S3.#{op}"
+        end
+
+        def lambda_span_name(lambda_data)
+          return unless lambda_data
+
+          fn = lambda_data[:function].to_s.strip
+          fn.empty? ? 'Lambda.invoke' : "Lambda.#{fn}"
+        end
+
+        def convert_sqs_attributes(attributes, sqs_data)
+          return unless sqs_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'aws_sqs')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME, sqs_data[:queue])
+          add_attribute(attributes, 'messaging.aws.sqs.message_group_id', sqs_data[:group])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_BATCH_MESSAGE_COUNT, sqs_data[:size])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_TYPE, sqs_operation_type(sqs_data[:type]))
+        end
+
+        def sqs_operation_type(type)
+          case type.to_s
+          when /^send/, /^single\.sync/ then 'send'
+          when /^delete/ then 'process'
+          when /^create/, /^get/ then 'create'
+          else 'send'
+          end
+        end
+
+        def convert_sns_attributes(attributes, sns_data)
+          return unless sns_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'aws_sns')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME, sns_data[:topic])
+          add_attribute(attributes, 'messaging.aws.sns.target_arn', sns_data[:target])
+          add_attribute(attributes, 'messaging.aws.sns.phone_number', sns_data[:phone])
+          add_attribute(attributes, 'messaging.aws.sns.subject', sns_data[:subject])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_TYPE, 'send')
+        end
+
+        def convert_dynamodb_attributes(attributes, dynamodb_data)
+          return unless dynamodb_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, 'dynamodb')
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_OPERATION_NAME, dynamodb_data[:op])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_NAMESPACE, dynamodb_data[:table])
+          add_attribute(attributes, 'aws.dynamodb.table_name', dynamodb_data[:table])
+        end
+
+        def convert_s3_attributes(attributes, s3_data)
+          return unless s3_data
+
+          add_attribute(attributes, 'aws.service', 's3')
+          add_attribute(attributes, 'aws.s3.bucket', s3_data[:bucket])
+          add_attribute(attributes, 'aws.s3.key', s3_data[:key])
+          add_attribute(attributes, 'aws.s3.operation', s3_data[:op])
+        end
+
+        def convert_lambda_attributes(attributes, lambda_data)
+          return unless lambda_data
+
+          add_attribute(attributes, 'aws.service', 'lambda')
+          add_attribute(attributes, 'aws.lambda.function_name', lambda_data[:function])
+          add_attribute(attributes, 'aws.lambda.invocation_type', lambda_data[:type])
+          add_attribute(attributes, 'faas.invoked_name', lambda_data[:function])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/incubating/messaging'
+require 'opentelemetry/semconv/server'
+
+module Instana
+  module Exporter
+    module Otlp
+      class BackgroundJobConverter < BaseConverter
+        # Build OTel-compliant span name for background-job spans
+        #
+        # Formula per SPAN_NAME_PATTERNS.txt Section 3 (sidekiq / resque):
+        #   client/producer → "{queue} publish"
+        #   worker/consumer → "{queue} process"
+        #
+        # @return [String] The span name
+        def span_name
+          span_type = span[:n].to_s
+          data_key  = span_type.to_sym
+          job_data  = span[data_key] || span[:data]&.[](data_key) || {}
+
+          queue = job_data[:queue] || job_data['queue']
+          queue = queue.to_s.strip
+
+          operation = span_type.end_with?('-client') ? 'publish' : 'process'
+          queue.empty? ? operation : "#{queue} #{operation}"
+        end
+
+        def convert_attributes
+          attributes = {}
+          span_type  = span[:n].to_s
+
+          if span_type == 'sidekiq-client' # rubocop:disable Style/CaseLikeIf
+            convert_job_attributes(attributes, span[:'sidekiq-client'] || span[:data]&.[](:'sidekiq-client'), 'sidekiq', 'publish')
+          elsif span_type == 'sidekiq-worker'
+            convert_job_attributes(attributes, span[:'sidekiq-worker'] || span[:data]&.[](:'sidekiq-worker'), 'sidekiq', 'process')
+          elsif span_type == 'resque-client'
+            convert_job_attributes(attributes, span[:'resque-client'] || span[:data]&.[](:'resque-client'), 'resque', 'publish')
+          elsif span_type == 'resque-worker'
+            convert_job_attributes(attributes, span[:'resque-worker'] || span[:data]&.[](:'resque-worker'), 'resque', 'process')
+          end
+
+          attributes
+        end
+
+        private
+
+        def convert_job_attributes(attributes, data, system, operation)
+          return unless data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, system)
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME, data[:queue] || data['queue'])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION, operation)
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_MESSAGE_ID, data[:job_id] || data['job_id'])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_CONSUMER_GROUP_NAME, data[:job] || data['job'])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, extract_host(data[:'redis-url'] || data['redis-url']))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, extract_port(data[:'redis-url'] || data['redis-url']))
+        end
+
+        def extract_host(connection)
+          return nil unless connection
+
+          connection.to_s.split(':').first
+        end
+
+        def extract_port(connection)
+          return nil unless connection
+
+          port = connection.to_s.split(':').last
+          port.to_i if port =~ /^\d+$/
+        end
+      end
+    end
+  end
+end