instana 2.9.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52139723659935eb43ab59f60e5c0f7305d860d5457c9545d395f9e4576fc604
-  data.tar.gz: 223dcdbe22af35ceed817411b850114f9cf3e7eb5fce3b3fc1b4f5ffa29c00e1
+  metadata.gz: 651f82ecb4bf26f63225bb880fff4028fca72f641eeac492b3bbb85d4c0be0d2
+  data.tar.gz: b311f0c13d53cf688247b580f018a57a62569eb0a1fa5c25d8fac1a8939ffdf0
 SHA512:
-  metadata.gz: 0743a4a453182c90abb623189d4a6e5105cd03e3823b3b6cf9ee5269c80f14652d21bfc5481c914457a79a8a52633c718cfd1581d219122327996cb67c2b222f
-  data.tar.gz: 767f9eb2f714e83e045f27086061ef11ab3511574b8636c87740595f871a0051ccc977341e0e523f174d4f4d5a4575fbcd3d8b87ed1ab26b347198fbdb3d4d94
+  metadata.gz: 29c82de02af9e09ebaa84da9429d70867f1f8eb3c397836d50a78eaddecf8339a6b20e809bbdadc22dbd0f5f8672e766d96aff1c0802f9a08edefd7bccb0a1ae
+  data.tar.gz: e099c624a54ce5871010efad8ad469d8aebf0672cc7011a49bd26c9b448fcc6883eb58122cc9424f69757432b418b1a38fe332d78b1718c65ba60cae8958754e

data/README.md

@@ -51,6 +51,179 @@ Although the gem has no configuration required for out of the box metrics and tr
 
 This Ruby gem provides a simple API for tracing and also supports [OpenTracing](http://opentracing.io/).  See the [Ruby Tracing SDK](https://www.ibm.com/docs/en/instana-observability/current?topic=ruby-tracing-sdk) and [OpenTracing](https://www.ibm.com/docs/en/instana-observability/current?topic=ruby-opentracing) pages for details.
 
+## OTLP Export
+
+The `instana` gem supports exporting traces via the **OpenTelemetry Protocol (OTLP)**
+directly to the Instana agent's OTLP receiver, bypassing the native agent trace format.
+OTLP export is **opt-in** — the gem behaves identically to previous versions when
+`INSTANA_TRACING_OTLP_ENABLED` is not set.
+
+### Overview
+
+When OTLP export is enabled:
+- Spans are converted from Instana's internal format to OTLP protobuf
+- The converted spans are sent via HTTP/protobuf to the agent's OTLP port (`4318`)
+- The endpoint is auto-derived from the same host where the Instana agent was discovered
+- The native agent reporting path (`/com.instana.plugin.ruby/traces`) is replaced by OTLP
+
+### Quick Start
+
+The only required change is setting one environment variable before starting your application:
+
+```bash
+INSTANA_TRACING_OTLP_ENABLED=true bundle exec rails server
+```
+
+Expected log output (with `INSTANA_LOG_LEVEL=debug`):
+```
+[Instana] Using OTLP Exporter to export result code: 0
+```
+
+Result code `0` = `SUCCESS`. No other configuration is needed — the endpoint is
+automatically set to `http://<agent-host>:4318/v1/traces`.
+
+### Gem Dependencies
+
+`opentelemetry-exporter-otlp` is a **runtime dependency** of the `instana` gem and
+is installed automatically. No additional gems are required.
+
+> **Note:** gRPC (`OTEL_EXPORTER_OTLP_PROTOCOL=grpc`) is not supported.
+> Only `http/protobuf` is supported and tested.
+
+### Environment Variables
+
+| Variable | Type | Default | Description |
+|---|---|---|---|
+| `INSTANA_TRACING_OTLP_ENABLED` | Boolean | `false` | Enables OTLP export. Valid values: `true`, `1`, `yes` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | String (URL) | auto-derived from agent host | **Base** endpoint URL. `/v1/traces` is appended automatically. |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | String (URL) | `<OTEL_EXPORTER_OTLP_ENDPOINT>/v1/traces` | **Fully-qualified** trace endpoint. Used as-is; overrides `OTEL_EXPORTER_OTLP_ENDPOINT`. |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | String | `http/protobuf` | Transport protocol. Only `http/protobuf` is supported. |
+| `OTEL_EXPORTER_OTLP_HEADERS` | String | — | Comma-separated `key=value` auth headers. e.g. `api-key=secret,x-tenant-id=myorg` |
+| `OTEL_EXPORTER_OTLP_TIMEOUT` | Integer (ms) | `10000` | Maximum time to wait for export completion. |
+| `OTEL_EXPORTER_OTLP_COMPRESSION` | String | — | Compression algorithm. Valid value: `gzip`. |
+| `OTEL_EXPORTER_OTLP_CERTIFICATE` | String (path) | — | Path to CA certificate file for TLS verification. |
+| `OTEL_EXPORTER_OTLP_CLIENT_KEY` | String (path) | — | Path to client private key file for mutual TLS. |
+| `OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE` | String (path) | — | Path to client certificate file for mutual TLS. |
+| `OTEL_EXPORTER_OTLP_INSECURE` | Boolean | `false` | Disable TLS certificate verification. |
+| `OTEL_SEMCONV_STABILITY_OPT_IN` | String | `stable` | Semantic convention stability level. Valid values: `stable`, `development`. |
+
+> **Endpoint precedence:** `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` > `OTEL_EXPORTER_OTLP_ENDPOINT` > auto-derived from agent host
+
+### YAML Configuration
+
+When `INSTANA_CONFIG_PATH` points to a YAML file, OTLP settings are placed under
+the `tracing.otlp` key. YAML configuration takes precedence over environment variables.
+
+**Minimal example** (`config/instana.yml`):
+```yaml
+tracing:
+  otlp:
+    enabled: true
+```
+
+**Full example:**
+```yaml
+tracing:
+  otlp:
+    enabled: true
+    endpoint: "http://localhost:4318/v1/traces"
+    protocol: "http/protobuf"
+    timeout: 10000
+    compression: "gzip"
+    headers:
+      x-instana-key: "YOUR_API_KEY"
+      x-tenant-id:   "YOUR_TENANT"
+    certificate:        "/path/to/ca-cert.pem"
+    client_key:         "/path/to/client-key.pem"
+    client_certificate: "/path/to/client-cert.pem"
+    insecure: false
+    semconv_stability: "stable"
+```
+
+Start the application:
+```bash
+INSTANA_CONFIG_PATH=config/instana.yml bundle exec rails server
+```
+
+### Configuration Precedence
+
+Settings are resolved in this order (highest wins):
+
+```
+INSTANA_CONFIG_PATH YAML  →  Environment variables  →  Agent config  →  Defaults
+```
+
+This means a YAML file always wins over env vars. Agent-provided config (pushed
+via the Instana agent's discovery payload) is applied after env vars but can be
+overridden by YAML or env vars set at startup.
+
+### TLS / mTLS
+
+**Server-side TLS** (verify the collector's certificate):
+```bash
+INSTANA_TRACING_OTLP_ENABLED=true \
+OTEL_EXPORTER_OTLP_ENDPOINT=https://your-collector:4318/v1/traces \
+OTEL_EXPORTER_OTLP_CERTIFICATE=/path/to/ca-cert.pem \
+bundle exec rails server
+```
+
+**Mutual TLS** (client certificate authentication):
+```bash
+INSTANA_TRACING_OTLP_ENABLED=true \
+OTEL_EXPORTER_OTLP_ENDPOINT=https://your-collector:4318/v1/traces \
+OTEL_EXPORTER_OTLP_CERTIFICATE=/path/to/ca-cert.pem \
+OTEL_EXPORTER_OTLP_CLIENT_KEY=/path/to/client-key.pem \
+OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE=/path/to/client-cert.pem \
+bundle exec rails server
+```
+
+### Troubleshooting
+
+**OTLP export is not happening — spans go via the native path**
+
+OTLP is disabled by default. Check that `INSTANA_TRACING_OTLP_ENABLED=true` is set
+in the process environment before the gem initialises (i.e. before `require 'instana'`
+or Rails boot). Verify with:
+```bash
+INSTANA_LOG_LEVEL=debug bundle exec rails server
+# Look for: "Using OTLP Exporter" vs "Using Instana Native Exporter"
+```
+
+**`Failed to initialize OTLP exporter` in the log**
+
+The exporter could not be constructed. Common causes:
+- `OTEL_EXPORTER_OTLP_CERTIFICATE` path does not exist or is not readable
+- `OTEL_EXPORTER_OTLP_CLIENT_KEY` / `OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE` path invalid
+- An unsupported protocol (e.g. `grpc`) was set — only `http/protobuf` is supported
+
+The gem falls back to `@otlp_exporter = nil` and logs an `ERROR` line with the
+exception message. Check that message for the root cause.
+
+**`result code: 1` (FAILURE) — spans not arriving**
+
+The exporter initialised but the export request failed. Common causes:
+- The Instana agent is not running or OTLP is not enabled on the agent side
+- `OTEL_EXPORTER_OTLP_ENDPOINT` points to a wrong host or port
+- `OTEL_EXPORTER_OTLP_ENDPOINT` was set to a base URL like `http://host:4318`
+  without `/v1/traces` — this was a known bug fixed in v2.9.0 (the sensor now
+  appends the path automatically)
+- A firewall is blocking port `4318`
+
+Verify the agent OTLP port is reachable:
+```bash
+curl -s -o /dev/null -w "%{http_code}" \
+  -X POST http://localhost:4318/v1/traces \
+  -H "Content-Type: application/x-protobuf"
+# 200 or 415 = port open; "connection refused" = agent OTLP not enabled
+```
+
+**`HTTP request path is empty` exception (pre-v2.9.0)**
+
+If you are on a version earlier than 2.9.0 and pass a base URL to
+`OTEL_EXPORTER_OTLP_ENDPOINT` (without `/v1/traces`), the `opentelemetry-exporter-otlp`
+gem crashes with `HTTP request path is empty`. Upgrade to v2.9.0 or later, or use
+`OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` with the full path instead.
+
 ## Documentation
 
 You can find more documentation covering supported components and minimum versions in the Instana [documentation portal](https://www.ibm.com/docs/en/instana-observability/current?topic=technologies-monitoring-ruby).

data/lib/instana/backend/host_agent_reporting_observer.rb

@@ -186,11 +186,12 @@ module Instana
 
         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]
+        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]
+        opts[:ssl_verify_mode]         = OpenSSL::SSL::VERIFY_NONE     if config[:insecure]
 
         @otlp_exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(**opts)
       rescue StandardError => e
@@ -198,21 +199,32 @@ module Instana
         @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
 
+      # Returns a fully-qualified OTLP traces endpoint.
+      #
+      # When config_source is 'default', builds the endpoint from the discovered
+      # agent host so OTLP traffic goes to the same host as metrics/traces.
+      #
+      # For user-supplied endpoints, appends '/v1/traces' when the URL has no
+      # path, because OTEL_EXPORTER_OTLP_ENDPOINT is a base URL and the
+      # opentelemetry-exporter-otlp gem only auto-appends the path when no
+      # endpoint is given at all.
       def resolve_otlp_endpoint(endpoint, config_source)
-        return endpoint unless config_source == 'default'
+        if config_source == 'default'
+          agent_host = @client&.host
+          return endpoint unless agent_host
 
-        # 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
+          return "http://#{agent_host}:#{OTLP_DEFAULT_PORT}#{OTLP_TRACES_PATH}"
+        end
 
-        "http://#{agent_host}:#{OTLP_DEFAULT_PORT}#{OTLP_TRACES_PATH}"
+        # User-supplied: append the traces path if no path was given.
+        uri = URI.parse(endpoint)
+        uri.path = OTLP_TRACES_PATH if uri.path.empty? || uri.path == '/'
+        uri.to_s
+      rescue URI::InvalidURIError
+        endpoint
       end
     end
   end

data/lib/instana/base.rb

@@ -6,6 +6,11 @@ require "instana/version"
 require "instana/util"
 
 module Instana
+  # Instana trace context header names
+  INSTANA_TRACE_ID_HEADER = 'X-Instana-T'.freeze
+  INSTANA_SPAN_ID_HEADER = 'X-Instana-S'.freeze
+  INSTANA_LEVEL_HEADER = 'X-Instana-L'.freeze
+
   class << self
     attr_accessor :agent
     attr_accessor :tracer

data/lib/instana/config.rb

@@ -4,7 +4,7 @@
 require 'yaml'
 
 module Instana
-  class Config
+  class Config # rubocop:disable Metrics/ClassLength
 
     LEGACY_TRACING_KEY = 'com.instana.tracing'.freeze
     TRACING_KEY = 'tracing'.freeze
@@ -63,6 +63,9 @@ module Instana
         certificate: nil,
         client_key: nil,
         client_certificate: nil,
+        protocol: 'http/protobuf',
+        semconv_stability: 'stable',
+        insecure: false,
         config_source: 'default'
       }
       read_otlp_config
@@ -80,6 +83,10 @@ module Instana
       # W3C Trace Context Support
       @config[:w3c_trace_correlation] = ENV.fetch('INSTANA_DISABLE_W3C_TRACE_CORRELATION', nil).nil?
 
+      # Server-Timing response header injection (default: injected)
+      # Priority: YAML > env var > agent config > default (false)
+      read_disable_server_timing_config
+
       # HTTP exit span 4xx error classification (opt-in, default: off)
       # Priority: env vars > agent config > default (false / [])
       read_http_exit_config
@@ -148,6 +155,8 @@ module Instana
       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 Server-Timing disable flag from agent if not already set from YAML or env
+      read_disable_server_timing_from_agent(tracing_config) if @config[:disable_server_timing_source] == 'default'
       # Read span filtering configuration from agent
       ::Instana.span_filtering_config&.read_config_from_agent(discovery)
     rescue => e
@@ -257,11 +266,57 @@ module Instana
       @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][:protocol]           = otlp_config['protocol']                 if otlp_config['protocol']
+      @config[:otlp][:semconv_stability]  = otlp_config['semconv_stability']        if otlp_config['semconv_stability']
+      @config[:otlp][:insecure]           = truthy?(otlp_config['insecure'])        unless otlp_config['insecure'].nil?
       @config[:otlp][:config_source]      = 'agent'
     end
 
     private
 
+    # Read disable-server-timing from YAML (tracing.global) or INSTANA_TRACING_DISABLE_SERVER_TIMING.
+    # Agent value is applied later via read_config_from_agent if neither is set.
+    def read_disable_server_timing_config
+      @config[:disable_server_timing] = false
+      @config[:disable_server_timing_source] = 'default'
+
+      yaml_value = parse_disable_server_timing_from_yaml
+      unless yaml_value.nil?
+        @config[:disable_server_timing] = truthy?(yaml_value)
+        @config[:disable_server_timing_source] = 'yaml'
+        return
+      end
+
+      env_value = ENV.fetch('INSTANA_TRACING_DISABLE_SERVER_TIMING', nil)
+      return if env_value.nil? || env_value.strip.empty?
+
+      @config[:disable_server_timing] = truthy?(env_value.strip)
+      @config[:disable_server_timing_source] = 'env'
+    end
+
+    # @return [Object, nil] raw YAML value of tracing.global.disable-server-timing, or nil if not set
+    def parse_disable_server_timing_from_yaml
+      config_path = ENV.fetch('INSTANA_CONFIG_PATH', nil)
+      return nil unless config_path && File.exist?(config_path)
+
+      yaml_content = YAML.safe_load(File.read(config_path))
+      tracing_config = yaml_content[TRACING_KEY] || yaml_content[LEGACY_TRACING_KEY]
+      global_config = tracing_config && tracing_config['global']
+      global_config.is_a?(Hash) ? global_config['disable-server-timing'] : nil
+    rescue => e
+      ::Instana.logger.warn("Failed to load disable-server-timing configuration from YAML: #{e.message}")
+      nil
+    end
+
+    # @param tracing_config [Hash] the tracing sub-hash from the discovery payload
+    def read_disable_server_timing_from_agent(tracing_config)
+      global_config = tracing_config['global']
+      return unless global_config.is_a?(Hash) && !global_config['disable-server-timing'].nil?
+
+      @config[:disable_server_timing] = truthy?(global_config['disable-server-timing'])
+      @config[:disable_server_timing_source] = 'agent'
+    end
+
     # 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
@@ -381,6 +436,9 @@ module Instana
       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[:protocol]           = otlp_yaml['protocol']           if otlp_yaml['protocol']
+      result[:semconv_stability]  = otlp_yaml['semconv_stability']  if otlp_yaml['semconv_stability']
+      result[:insecure]           = truthy?(otlp_yaml['insecure'])  unless otlp_yaml['insecure'].nil?
       result.empty? ? nil : result
     end
 
@@ -399,6 +457,9 @@ module Instana
       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[:protocol]           = raw[:protocol]                          if raw[:protocol]
+      result[:semconv_stability]  = raw[:semconv_stability]                 if raw[:semconv_stability]
+      result[:insecure]           = truthy?(raw[:insecure_raw])             unless raw[:insecure_raw].nil?
       result
     end
 
@@ -413,7 +474,10 @@ module Instana
         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)
+        client_cert: ENV.fetch('OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE', nil),
+        protocol: ENV.fetch('OTEL_EXPORTER_OTLP_PROTOCOL', nil),
+        semconv_stability: ENV.fetch('OTEL_SEMCONV_STABILITY_OPT_IN', nil),
+        insecure_raw: ENV.fetch('OTEL_EXPORTER_OTLP_INSECURE', nil)
       }
     end
 

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

@@ -6,6 +6,9 @@ require_relative 'base_converter'
 require 'opentelemetry/semconv/incubating/messaging'
 require 'opentelemetry/semconv/db'
 require 'opentelemetry/semconv/incubating/db'
+require 'opentelemetry/semconv/incubating/rpc'
+require 'opentelemetry/semconv/incubating/cloud'
+require 'opentelemetry/semconv/incubating/faas'
 
 module Instana
   module Exporter
@@ -128,10 +131,18 @@ module Instana
         def convert_s3_attributes(attributes, s3_data)
           return unless s3_data
 
-          add_attribute(attributes, 'aws.service', 's3')
+          add_attribute(attributes, Instana::Exporter::Otlp::RPC_SYSTEM_ATTR, 'aws-api')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::RPC::RPC_METHOD, s3_rpc_method(s3_data[:op]))
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CLOUD::CLOUD_PROVIDER, 'aws')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::CLOUD::CLOUD_REGION, s3_data[:region])
           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 s3_rpc_method(operation)
+          return unless operation
+
+          "S3.#{operation}"
         end
 
         def convert_lambda_attributes(attributes, lambda_data)
@@ -140,7 +151,7 @@ module Instana
           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])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::FAAS::FAAS_INVOKED_NAME, lambda_data[:function])
         end
       end
     end

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

@@ -41,6 +41,8 @@ module Instana
             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')
+          elsif span_type == 'activejob'
+            convert_activejob_attributes(attributes, span[:data]&.[](:activejob))
           end
 
           attributes
@@ -53,13 +55,22 @@ module Instana
 
           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_OPERATION_NAME, 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 convert_activejob_attributes(attributes, data)
+          return unless data
+
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_SYSTEM, 'activejob')
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_DESTINATION_NAME, data[:queue] || data['queue'])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_OPERATION_NAME, data[:action] || data['action'])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::MESSAGING::MESSAGING_MESSAGE_ID, data[:job_id] || data['job_id'])
+        end
+
         def extract_host(connection)
           return nil unless connection
 

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

@@ -5,10 +5,22 @@
 require_relative 'resource'
 require 'opentelemetry/trace'
 require 'forwardable'
+require 'opentelemetry/semconv/incubating/rpc'
 
 module Instana
   module Exporter
     module Otlp
+      # Compatibility shim: RPC_SYSTEM_NAME was added in a newer release of
+      # opentelemetry-semantic_conventions.  Fall back to the deprecated
+      # RPC_SYSTEM constant ('rpc.system') on older installs (e.g. Ruby 3.2
+      # lockfiles that resolve an earlier gem version).
+      RPC_SYSTEM_ATTR =
+        if OpenTelemetry::SemConv::Incubating::RPC.const_defined?(:RPC_SYSTEM_NAME)
+          OpenTelemetry::SemConv::Incubating::RPC::RPC_SYSTEM_NAME
+        else
+          OpenTelemetry::SemConv::Incubating::RPC::RPC_SYSTEM
+        end
+
       # Base class for all OTLP span converters
       #
       # Provides common interface and shared functionality for converting Instana spans
@@ -312,12 +324,12 @@ module Instana
           timestamp = calculate_end_timestamp
 
           if stacktrace
-            attrs = { 'exception.type' => span_name }
+            attrs = {}
             attrs['exception.message']    = error_msg if error_msg
             attrs['exception.stacktrace'] = stacktrace
             [Event.new('exception', attrs, timestamp)]
           else
-            [Event.new('error', { 'error.type' => span_name }, timestamp)]
+            [Event.new('error', {}, timestamp)]
           end
         end
 

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

@@ -82,32 +82,51 @@ module Instana
           parts.empty? ? 'mongodb' : parts.join('.')
         end
 
+        # Normalize an ActiveRecord/Sequel adapter name to OTel db.system.name.
+        # Only adapters that are actively instrumented and tested are listed here.
+        DB_SYSTEM_NORMALIZATION = {
+          'mysql2' => 'mysql',
+          'sqlite3' => 'sqlite',
+          'postgresql' => 'postgresql',
+          'mysql' => 'mysql',
+          'sqlite' => 'sqlite'
+        }.freeze
+
+        def normalize_db_system(adapter)
+          return unless adapter
+
+          DB_SYSTEM_NORMALIZATION.fetch(adapter.to_s.downcase, adapter.to_s.downcase)
+        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_SYSTEM_NAME, normalize_db_system(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])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::DB::DB_COLLECTION_NAME, ar_data[:table])
         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_SYSTEM_NAME, normalize_db_system(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])
+          add_attribute(attributes, OpenTelemetry::SemConv::Incubating::DB::DB_COLLECTION_NAME, seq_data[:table])
         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_OPERATION_NAME, redis_data[:command])
           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::DB::DB_NAMESPACE, redis_data[:db]&.to_s)
           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
@@ -119,7 +138,7 @@ module Instana
           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::DB::DB_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
@@ -131,6 +150,7 @@ module Instana
           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::Incubating::DB::DB_COLLECTION_NAME, mongo_data[:collection])
           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

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

@@ -7,6 +7,7 @@ require 'opentelemetry/semconv/http'
 require 'opentelemetry/semconv/url'
 require 'opentelemetry/semconv/server'
 require 'opentelemetry/semconv/user_agent'
+require 'opentelemetry/semconv/network'
 
 module Instana
   module Exporter
@@ -120,8 +121,8 @@ module Instana
           name    = parts[0].downcase
           version = parts[1]
 
-          add_attribute(attributes, 'network.protocol.name', name)
-          add_attribute(attributes, 'network.protocol.version', version)
+          add_attribute(attributes, OpenTelemetry::SemConv::NETWORK::NETWORK_PROTOCOL_NAME, name)
+          add_attribute(attributes, OpenTelemetry::SemConv::NETWORK::NETWORK_PROTOCOL_VERSION, version)
         end
       end
     end