instana 2.7.2 → 2.8.0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/db'
+require 'opentelemetry/semconv/server'
+
+module Instana
+  module Exporter
+    module Otlp
+      # Converter for database spans to OTLP format
+      class DatabaseConverter < BaseConverter
+        def convert_attributes
+          attributes = {}
+          data = span[:data] || {}
+
+          convert_activerecord_attributes(attributes, data[:activerecord])
+          convert_sequel_attributes(attributes, data[:sequel])
+          convert_redis_attributes(attributes, data[:redis])
+          convert_memcache_attributes(attributes, data[:memcache])
+          convert_mongo_attributes(attributes, data[:mongo])
+
+          attributes
+        end
+
+        # Build OTel-compliant span name for database spans
+        #
+        # Formulas per SPAN_NAME_PATTERNS.txt Section 2:
+        #   activerecord / sequel  → "{adapter} {db}"       e.g. "mysql2 myapp"
+        #   redis                  → "redis {command}"       e.g. "redis GET"
+        #   memcache               → "memcached {command}"   e.g. "memcached get"
+        #   mongo                  → "{namespace}.{command}" e.g. "users.find"
+        #
+        # @return [String] The span name
+        def span_name
+          data = span[:data] || {}
+          activerecord_span_name(data[:activerecord]) ||
+            sequel_span_name(data[:sequel]) ||
+            redis_span_name(data[:redis]) ||
+            memcache_span_name(data[:memcache]) ||
+            mongo_span_name(data[:mongo]) ||
+            super
+        end
+
+        private
+
+        def activerecord_span_name(ar_data)
+          return unless ar_data
+
+          parts = [ar_data[:adapter], ar_data[:db]].compact.reject(&:empty?)
+          parts.empty? ? 'activerecord' : parts.join(' ')
+        end
+
+        def sequel_span_name(seq)
+          return unless seq
+
+          parts = [seq[:adapter], seq[:db]].compact.reject(&:empty?)
+          parts.empty? ? 'sequel' : parts.join(' ')
+        end
+
+        def redis_span_name(redis)
+          return unless redis
+
+          cmd = redis[:command].to_s.strip
+          cmd.empty? ? 'redis' : "redis #{cmd}"
+        end
+
+        def memcache_span_name(mc_data)
+          return unless mc_data
+
+          cmd = mc_data[:command].to_s.strip
+          cmd.empty? ? 'memcached' : "memcached #{cmd}"
+        end
+
+        def mongo_span_name(mongo)
+          return unless mongo
+
+          ns  = mongo[:namespace].to_s.strip
+          cmd = mongo[:command].to_s.strip
+          parts = [ns, cmd].reject(&:empty?)
+          parts.empty? ? 'mongodb' : parts.join('.')
+        end
+
+        def convert_activerecord_attributes(attributes, ar_data)
+          return unless ar_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, ar_data[:adapter])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_NAMESPACE, ar_data[:db])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_QUERY_TEXT, ar_data[:sql])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::DB::DB_USER, ar_data[:username])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, ar_data[:host])
+        end
+
+        def convert_sequel_attributes(attributes, seq_data)
+          return unless seq_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, seq_data[:adapter])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_NAMESPACE, seq_data[:db])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_QUERY_TEXT, seq_data[:sql])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::DB::DB_USER, seq_data[:username])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, seq_data[:host])
+        end
+
+        def convert_redis_attributes(attributes, redis_data)
+          return unless redis_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, 'redis')
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_QUERY_TEXT, redis_data[:command])
+          add_attribute(attributes, 'db.redis.database_index', redis_data[:db])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, extract_host(redis_data[:connection]))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, extract_port(redis_data[:connection]))
+        end
+
+        def convert_memcache_attributes(attributes, mc_data)
+          return unless mc_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, 'memcached')
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_OPERATION_NAME, mc_data[:command])
+          add_attribute(attributes, 'db.memcached.key', mc_data[:key])
+          add_attribute(attributes, 'db.memcached.keys', mc_data[:keys])
+          add_attribute(attributes, 'db.memcached.namespace', mc_data[:namespace])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, extract_host(mc_data[:server]))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, extract_port(mc_data[:server]))
+        end
+
+        def convert_mongo_attributes(attributes, mongo_data)
+          return unless mongo_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_SYSTEM_NAME, 'mongodb')
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_NAMESPACE, mongo_data[:namespace])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_OPERATION_NAME, mongo_data[:command])
+          add_attribute(attributes, OpenTelemetry::SemConv::DB::DB_QUERY_TEXT, mongo_data[:json])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, mongo_data.dig(:peer, :hostname))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, mongo_data.dig(:peer, :port))
+        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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/incubating/graphql'
+
+module Instana
+  module Exporter
+    module Otlp
+      # Converter for GraphQL spans to OTLP format
+      class GraphqlConverter < BaseConverter
+        # Build OTel-compliant span name for GraphQL spans
+        #
+        # Formula per SPAN_NAME_PATTERNS.txt Section 7 (observability):
+        #   "{operationType} {operationName}"  e.g. "query MyQuery"
+        #   Falls back to just "{operationType}" when no name, or "graphql" when both absent.
+        #
+        # @return [String] The span name
+        def span_name
+          gql = span[:data]&.[](:graphql) || {}
+          type = gql[:operationType].to_s.strip
+          name = gql[:operationName].to_s.strip
+
+          if type.empty?
+            'graphql'
+          elsif name.empty?
+            type
+          else
+            "#{type} #{name}"
+          end
+        end
+
+        def convert_attributes
+          attributes = {}
+
+          graphql_data = span[:data]&.[](:graphql)
+          return attributes unless graphql_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::GRAPHQL::GRAPHQL_OPERATION_NAME, graphql_data[:operationName])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::GRAPHQL::GRAPHQL_OPERATION_TYPE, graphql_data[:operationType])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::GRAPHQL::GRAPHQL_DOCUMENT, format_fields(graphql_data[:fields]))
+
+          # Add arguments as custom attribute
+          add_attribute(attributes, 'graphql.arguments', format_arguments(graphql_data[:arguments])) if graphql_data[:arguments]
+
+          attributes
+        end
+
+        private
+
+        def format_fields(fields)
+          return nil unless fields
+
+          fields.map { |obj, flds| "#{obj} { #{flds.join(', ')} }" }.join(', ')
+        end
+
+        def format_arguments(arguments)
+          return nil unless arguments
+
+          arguments.map { |obj, args| "#{obj}(#{args.join(', ')})" }.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/http'
+require 'opentelemetry/semconv/url'
+require 'opentelemetry/semconv/server'
+require 'opentelemetry/semconv/user_agent'
+
+module Instana
+  module Exporter
+    module Otlp
+      # Converter for HTTP spans to OTLP format
+      # Handles conversion of HTTP-related spans with specific attributes
+      class HttpConverter < BaseConverter
+        # Extract HTTP-specific attributes as plain key/value pairs
+        # @return [Hash] HTTP attributes
+        def convert_attributes
+          attributes = {}
+          http_data = span[:data]&.[](:http) || {}
+
+          add_attribute(attributes, OpenTelemetry::SemConv::HTTP::HTTP_REQUEST_METHOD, http_data[:method])
+          add_attribute(attributes, OpenTelemetry::SemConv::URL::URL_FULL, http_data[:url])
+          add_attribute(attributes, OpenTelemetry::SemConv::URL::URL_PATH, http_data[:path])
+          add_attribute(attributes, OpenTelemetry::SemConv::URL::URL_QUERY, http_data[:params])
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_ADDRESS, extract_host(http_data[:host]))
+          add_attribute(attributes, OpenTelemetry::SemConv::SERVER::SERVER_PORT, extract_port(http_data[:host], http_data[:url]))
+          add_attribute(attributes, OpenTelemetry::SemConv::URL::URL_SCHEME, extract_scheme(http_data[:url]))
+          add_attribute(attributes, OpenTelemetry::SemConv::HTTP::HTTP_RESPONSE_STATUS_CODE, http_data[:status])
+          add_attribute(attributes, OpenTelemetry::SemConv::USER_AGENT::USER_AGENT_ORIGINAL, http_data.dig(:header, 'user-agent'))
+
+          add_protocol_attributes(attributes, http_data[:protocol])
+
+          attributes
+        end
+
+        # Build OTel-compliant span status, treating EXIT spans with 4xx as ERROR
+        #
+        # @param error_count [Integer] Span error count
+        # @param error_msg   [String, nil] Pre-extracted error message
+        # @return [Status]
+        def build_status(error_count, error_msg)
+          return super unless error_count.zero?
+
+          http_data = span[:data]&.[](:http) || {}
+          status_code = http_data[:status].to_i
+
+          if convert_span_kind == :client && status_code >= 400 && status_code < 500
+            Status.new(OpenTelemetry::Trace::Status::ERROR, '')
+          else
+            super
+          end
+        end
+
+        # Build OTel-compliant span name for HTTP spans
+        #
+        # Convention (stable): "{METHOD}" or "{METHOD} {url.template/path}"
+        # Falls back to "HTTP" when no method is present.
+        #
+        # @return [String] The span name
+        def span_name
+          http_data = span[:data]&.[](:http) || {}
+          method = http_data[:method].to_s.upcase
+          method = 'HTTP' if method.empty?
+
+          path = http_data[:path].to_s.strip
+          path.empty? ? method : "#{method} #{path}"
+        end
+
+        private
+
+        # Extract scheme from URL
+        # @param url [String] The URL
+        # @return [String, nil] The scheme (http or https)
+        def extract_scheme(url)
+          return nil unless url
+
+          uri = URI.parse(url)
+          uri.scheme
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        # Extract the host part from a "host:port" string or bare hostname
+        # @param host_str [String, nil] e.g. "api.example.com:8080" or "api.example.com"
+        # @return [String, nil]
+        def extract_host(host_str)
+          return nil unless host_str
+
+          part = host_str.to_s.split(':').first
+          part && !part.empty? ? part : host_str
+        end
+
+        # Extract the port from a "host:port" string, falling back to the URL port
+        # @param host_str [String, nil] e.g. "api.example.com:8080"
+        # @param url      [String, nil] full URL as fallback
+        # @return [Integer, nil]
+        def extract_port(host_str, url)
+          if host_str&.include?(':')
+            port = host_str.split(':').last
+            return port.to_i unless port.nil? || port.empty?
+          end
+
+          return nil unless url
+
+          uri = URI.parse(url)
+          uri.port
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        # Emit network.protocol.name and network.protocol.version from e.g. "HTTP/1.1"
+        # @param attributes [Hash]
+        # @param protocol   [String, nil] e.g. "HTTP/1.1" or "h2"
+        def add_protocol_attributes(attributes, protocol)
+          return unless protocol
+
+          parts = protocol.to_s.split('/', 2)
+          name    = parts[0].downcase
+          version = parts[1]
+
+          add_attribute(attributes, 'network.protocol.name', name)
+          add_attribute(attributes, 'network.protocol.version', version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# 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
+      # Converter for messaging spans to OTLP format
+      class MessagingConverter < BaseConverter
+        # Build OTel-compliant span name for messaging (RabbitMQ) spans
+        #
+        # Formula per SPAN_NAME_PATTERNS.txt Section 3 (bunny/AMQP):
+        #   publish → "{exchange} publish"   (or "{queue} publish" when no exchange)
+        #   receive → "{queue} receive"
+        #
+        # @return [String] The span name
+        def span_name
+          rabbitmq_data = span[:data]&.[](:rabbitmq) || {}
+          sort = rabbitmq_data[:sort].to_s
+
+          if sort == 'publish'
+            dest = rabbitmq_data[:exchange].to_s.strip
+            dest = rabbitmq_data[:queue].to_s.strip if dest.empty?
+            dest.empty? ? 'publish' : "#{dest} publish"
+          else
+            queue = rabbitmq_data[:queue].to_s.strip
+            queue.empty? ? 'receive' : "#{queue} receive"
+          end
+        end
+
+        def convert_attributes
+          attributes = {}
+
+          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
+
+          attributes
+        end
+
+        private
+
+        # Build the composite destination name per spec:
+        #   Producer (publish): "{exchange}:{key}"  — omit absent parts
+        #   Consumer (receive): "{exchange}:{key}:{queue}" — omit absent; deduplicate key==queue
+        #
+        # @param data [Hash] rabbitmq span data
+        # @return [String, nil]
+        def rabbitmq_destination_name(data)
+          exchange = data[:exchange].to_s.strip
+          key      = data[:key].to_s.strip
+          queue    = data[:queue].to_s.strip
+          sort     = data[:sort].to_s
+
+          if sort == 'publish'
+            parts = [exchange, key].reject(&:empty?)
+          else
+            # Consumer: exchange:key:queue, dedup key==queue
+            parts = [exchange, key]
+            parts << queue unless queue.empty? || queue == key
+            parts = parts.reject(&:empty?)
+          end
+          parts.empty? ? nil : parts.join(':')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2026
+
+require_relative 'base_converter'
+require 'opentelemetry/semconv/incubating/code'
+
+module Instana
+  module Exporter
+    module Otlp
+      # Converter for Rails-related spans (ActionController, ActionView, ActionMailer) to OTLP format
+      class RailsConverter < BaseConverter
+        ACTIONMAILER_SPAN = 'mail.actionmailer'
+
+        # Build OTel-compliant span name for Rails spans
+        #
+        # Formulas per SPAN_NAME_PATTERNS.txt Sections 5 & 7:
+        #   actioncontroller  → "{Controller}#{action}"    e.g. "UsersController#index"
+        #   actionview        → "{view_name}"              e.g. "users/index"
+        #   render            → "{type} {name}"            e.g. "template users/index"
+        #   mail.actionmailer → "{Class}#{method}"         e.g. "UserMailer#welcome_email"
+        #
+        # @return [String] The span name
+        def span_name
+          case span[:n].to_s
+          when 'actioncontroller'
+            d = span_data_for(:actioncontroller)
+            ctrl   = d[:controller].to_s.strip
+            action = d[:action].to_s.strip
+            parts  = [ctrl, action].reject(&:empty?)
+            parts.empty? ? 'actioncontroller' : parts.join('#')
+          when 'actionview'
+            d = span_data_for(:actionview)
+            d[:name].to_s.strip.then { |n| n.empty? ? 'actionview' : n }
+          when 'render'
+            d = span_data_for(:render)
+            type = d[:type].to_s.strip
+            name = d[:name].to_s.strip
+            parts = [type, name].reject(&:empty?)
+            parts.empty? ? 'render' : parts.join(' ')
+          when ACTIONMAILER_SPAN
+            d = span_data_for(:actionmailer)
+            klass  = d[:class].to_s.strip
+            method = d[:method].to_s.strip
+            parts  = [klass, method].reject(&:empty?)
+            parts.empty? ? ACTIONMAILER_SPAN : parts.join('#')
+          else
+            super
+          end
+        end
+
+        def convert_attributes
+          attributes = {}
+          span_type  = span[:n].to_s
+
+          if span_type == 'actioncontroller' # rubocop:disable Style/CaseLikeIf
+            convert_action_controller_attributes(attributes)
+          elsif span_type == 'actionview'
+            convert_action_view_attributes(attributes)
+          elsif span_type == 'render'
+            convert_render_attributes(attributes)
+          elsif span_type == ACTIONMAILER_SPAN
+            convert_action_mailer_attributes(attributes)
+          end
+
+          attributes
+        end
+
+        private
+
+        # Return the data hash for a given span data key, falling back to
+        # top-level span key, then an empty hash.
+        def span_data_for(key)
+          span[:data]&.[](key) || span[key] || {}
+        end
+
+        # Convert ActionController span attributes
+        def convert_action_controller_attributes(attributes)
+          controller_data = span[:data]&.[](:actioncontroller) || span[:actioncontroller]
+          return unless controller_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CODE::CODE_NAMESPACE, controller_data[:controller])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CODE::CODE_FUNCTION, controller_data[:action])
+        end
+
+        # Convert ActionView span attributes
+        def convert_action_view_attributes(attributes)
+          view_data = span[:data]&.[](:actionview) || span[:actionview]
+          return unless view_data
+
+          add_attribute(attributes, 'rails.view.name', view_data[:name])
+        end
+
+        # Convert render span attributes
+        def convert_render_attributes(attributes)
+          render_data = span[:data]&.[](:render) || span[:render]
+          return unless render_data
+
+          add_attribute(attributes, 'rails.render.type', render_data[:type])
+          add_attribute(attributes, 'rails.render.name', render_data[:name])
+        end
+
+        # Convert ActionMailer span attributes
+        def convert_action_mailer_attributes(attributes)
+          mailer_data = span[:data]&.[](:actionmailer) || span[:actionmailer]
+          return unless mailer_data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CODE::CODE_NAMESPACE, mailer_data[:class])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CODE::CODE_FUNCTION, mailer_data[:method])
+        end
+      end
+    end
+  end
+end