instana 2.7.2 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c9fe7c6b744ebafc10428dbbfdcfe046fdcfc80b31227b29b4a18ade7ec5dd
-  data.tar.gz: 94b10d48f251f49157203534306399fed404adf619318cdebb0ff1864a74fc41
+  metadata.gz: 52139723659935eb43ab59f60e5c0f7305d860d5457c9545d395f9e4576fc604
+  data.tar.gz: 223dcdbe22af35ceed817411b850114f9cf3e7eb5fce3b3fc1b4f5ffa29c00e1
 SHA512:
-  metadata.gz: 56ff7ee602ef57a060bc1e467e11dc5466469433c54abc6457bb1959c4f5abf82d491b5db272b4cf45bea72335c28a0b9213357c44bf90543c123d424743f9f7
-  data.tar.gz: 811b2bd02833ec5127fdfeee050cab1ce3c1410e120ecd4452c41207b4c7a4fbc11f390ba8a62181f7a56fd3cd073392ca5115a68bfeb3a200f84ad5812a8ba7
+  metadata.gz: 0743a4a453182c90abb623189d4a6e5105cd03e3823b3b6cf9ee5269c80f14652d21bfc5481c914457a79a8a52633c718cfd1581d219122327996cb67c2b222f
+  data.tar.gz: 767f9eb2f714e83e045f27086061ef11ab3511574b8636c87740595f871a0051ccc977341e0e523f174d4f4d5a4575fbcd3d8b87ed1ab26b347198fbdb3d4d94

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,11 @@ 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?
+
+      # HTTP exit span 4xx error classification (opt-in, default: off)
+      # Priority: env vars > agent config > default (false / [])
+      read_http_exit_config
 
       @config[:post_fork_proc] = proc { ::Instana.agent.spawn_background_thread }
 
@@ -94,7 +116,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 +144,10 @@ 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 HTTP exit 4xx classification from agent if env vars did not already set it
+      read_http_exit_classification_from_agent(tracing_config) unless env_http_exit_classification_set?
       # Read span filtering configuration from agent
       ::Instana.span_filtering_config&.read_config_from_agent(discovery)
     rescue => e
@@ -143,17 +169,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 +204,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 +243,197 @@ 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 HTTP exit 4xx error classification config (wrapper — same pattern as read_span_stack_config / read_otlp_config)
+    def read_http_exit_config
+      @config[:http_exit_classify_all_4xx_as_errors] = false
+      @config[:http_exit_classify_as_errors] = []
+      read_http_exit_classification_from_env
+    end
+
+    # Read HTTP exit 4xx classification from environment variables (highest priority).
+    def read_http_exit_classification_from_env
+      classify_codes_raw = ENV.fetch('INSTANA_TRACING_HTTP_EXIT_CLASSIFY_AS_ERRORS', nil)
+      if classify_codes_raw
+        codes = classify_codes_raw.split(',').filter_map do |part|
+          part = part.strip
+          if part.match?(/\A\d+\z/)
+            code = part.to_i
+            if (400..499).cover?(code)
+              code
+            else
+              msg = "Ignoring out-of-range value in INSTANA_TRACING_HTTP_EXIT_CLASSIFY_AS_ERRORS: #{code}, must be 400-499"
+              ::Instana.logger.warn(msg)
+              nil
+            end
+          elsif part != ''
+            ::Instana.logger.warn("Ignoring non-integer value in INSTANA_TRACING_HTTP_EXIT_CLASSIFY_AS_ERRORS: #{part}")
+            nil
+          end
+        end
+        @config[:http_exit_classify_as_errors] = codes unless codes.empty?
+      else
+        classify_all_raw = ENV.fetch('INSTANA_TRACING_HTTP_EXIT_CLASSIFY_ALL_4XX_AS_ERRORS', nil)
+        @config[:http_exit_classify_all_4xx_as_errors] = truthy?(classify_all_raw) if classify_all_raw
+      end
+    end
+
+    # Return true if env vars have already configured HTTP exit 4xx classification.
+    def env_http_exit_classification_set?
+      ENV.key?('INSTANA_TRACING_HTTP_EXIT_CLASSIFY_AS_ERRORS') ||
+        ENV.key?('INSTANA_TRACING_HTTP_EXIT_CLASSIFY_ALL_4XX_AS_ERRORS')
+    end
+
+    # Read HTTP exit 4xx classification from agent discovery response (lowest priority).
+    # @param tracing_config [Hash] the tracing sub-hash from the discovery payload
+    def read_http_exit_classification_from_agent(tracing_config)
+      http_cfg = tracing_config['http']
+      return unless http_cfg.is_a?(Hash)
+
+      exit_cfg = http_cfg['exit']
+      return unless exit_cfg.is_a?(Hash)
+
+      if exit_cfg.key?('classify-as-errors')
+        codes = Array(exit_cfg['classify-as-errors']).filter_map do |code|
+          if code.is_a?(Integer) && (400..499).cover?(code)
+            code
+          else
+            ::Instana.logger.warn("Ignoring invalid value in agent config tracing.http.exit.classify-as-errors: #{code}")
+            nil
+          end
+        end
+        @config[:http_exit_classify_as_errors] = codes unless codes.empty?
+      elsif exit_cfg.key?('classify-all-4xx-as-errors')
+        val = exit_cfg['classify-all-4xx-as-errors']
+        if [true, false].include?(val)
+          @config[:http_exit_classify_all_4xx_as_errors] = val
+        else
+          ::Instana.logger.warn("Ignoring non-boolean value in agent config tracing.http.exit.classify-all-4xx-as-errors: #{val}")
+        end
+      end
+    end
+
+    # 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