instana 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52139723659935eb43ab59f60e5c0f7305d860d5457c9545d395f9e4576fc604
-  data.tar.gz: 223dcdbe22af35ceed817411b850114f9cf3e7eb5fce3b3fc1b4f5ffa29c00e1
+  metadata.gz: 85a74f9236a4a35af2f74850bb0c5230a921f37b23bdf80af6b578375fe620d3
+  data.tar.gz: eaaa01ae5c3a67c7d374fff6ccdf58be1bff45e8ba36186e2617b3084abb2e90
 SHA512:
-  metadata.gz: 0743a4a453182c90abb623189d4a6e5105cd03e3823b3b6cf9ee5269c80f14652d21bfc5481c914457a79a8a52633c718cfd1581d219122327996cb67c2b222f
-  data.tar.gz: 767f9eb2f714e83e045f27086061ef11ab3511574b8636c87740595f871a0051ccc977341e0e523f174d4f4d5a4575fbcd3d8b87ed1ab26b347198fbdb3d4d94
+  metadata.gz: 1338789ea5e37aa238bc08815cdbabf801ead7b17f28a9fc49e1efefecfa103ed2d0eb2958be6a50efa821169c2b4551e2b521b6f518585fa75e30a84cc92b0e
+  data.tar.gz: f1290dc8888e9e570bc2ee6a1dab5f11ac2f241726a0bf809aaa4c8fa5066d2bc142a268be3e85183052e9f26eff5a9a3377cf48b06a91acf9861f1c490f4da5

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/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
@@ -257,6 +260,9 @@ 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
 
@@ -381,6 +387,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 +408,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 +425,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

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

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

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

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

data/lib/instana/version.rb

@@ -2,6 +2,6 @@
 # (c) Copyright Instana Inc. 2016
 
 module Instana
-  VERSION = "2.9.0"
+  VERSION = "2.10.0"
   VERSION_FULL = "instana-#{VERSION}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
@@ -416,7 +416,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.22
 specification_version: 4
 summary: Ruby Distributed Tracing & Metrics Sensor for Instana
 test_files: []