opentelemetry-instrumentation-trilogy 0.68.0 → 0.69.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca36bf926d9b8424c449d8752ec6639e1686ca6730d9c8f08c7b739ccdd970c1
-  data.tar.gz: 5d89e6a9fdc07871f156f66d19fb9aa28b4fa7dd7621d95f64fd734aac385431
+  metadata.gz: 61673a70660a205354946b86bedb7ee5a3aa2cfd7af0aebab52b3c10e80b8c63
+  data.tar.gz: 6db4aa4e8c9cf0b62093d39b8e71a27f66735702271ac33426a755fce2240bd9
 SHA512:
-  metadata.gz: ab0eec895a37c79f72f49321fcce1836e8debd6245a67ed65a2a5f1a13e52310c61b28134e06689e690dfa1b9c5e52517082b42e544794b957e181e7c70a5ec8
-  data.tar.gz: b7e16175e4843890dac1662555cb9fcff7150fcfccea9c5e207f853b679dde127a0036927c44c7e1033c32e7cb24f19c2079d7717a316c75be7d30ca8c07d082
+  metadata.gz: 216d40455f51acf894bb5aecf79abc6050d972598509b19e0356ce1c01bef1c57da6f12045d2be745ffc9411ef449817a594bd312aa01ee357b35f0836c7a84e
+  data.tar.gz: d5b67b6383b4a21e9932ef6123d617a92d8f13763c6df1163ae749106503e4667a17329ff7213e8baa7eee3909e7bb5679392045a407978fdc3472376e0463cd

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release History: opentelemetry-instrumentation-trilogy
 
+## v0.69.0 / 2026-05-21
+
+- ADDED: Add `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable support for span attributes (#2095)
+
 ## v0.68.0 / 2026-04-14
 
 - BREAKING CHANGE: Min Ruby Version 3.3 (#2125)

data/README.md

@@ -51,18 +51,53 @@ OpenTelemetry::Instrumentation::Trilogy.with_attributes('pizzatoppings' => 'mush
 end
 ```
 
+## Compatibility
+
+This gem requires Trilogy 2.11 or higher and will not work with a future Trilogy 3.x release.
+
+## Configuration Options
+
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `db_statement` | `:obfuscate` | Controls how SQL queries appear in spans. `:obfuscate` replaces literal values with `?`, `:include` records the raw SQL, `:omit` excludes the attribute entirely. |
+| `obfuscation_limit` | `2000` | Maximum length of the obfuscated SQL statement. Statements exceeding this limit are truncated. |
+| `peer_service` | `nil` | Deprecated with no replacement. Sets the `peer.service` attribute on spans (old semantic conventions only). |
+| `propagator` | `'none'` | Propagator for injecting trace context into SQL comments. `'none'` disables propagation, `'tracecontext'` uses W3C Trace Context, `'vitess'` uses Vitess-style propagation (requires `opentelemetry-propagator-vitess` gem). |
+| `record_exception` | `true` | Records exceptions as span events when an error occurs. |
+| `span_name` | `:statement_type` | Controls span naming (old semantic conventions only). `:statement_type` uses the SQL operation (e.g., `SELECT`), `:db_name` uses the database name, `:db_operation_and_name` combines both. |
+
 ## Semantic Conventions
 
-This instrumentation generally uses [Database semantic conventions](https://opentelemetry.io/docs/specs/semconv/database/database-spans/).
+This instrumentation generally uses [Database semantic conventions](https://opentelemetry.io/docs/specs/semconv/database/database-spans/). See the [Database semantic convention stability](#database-semantic-convention-stability) section for how to switch between stable and old conventions.
+
+| Stable Attribute Name | Old Attribute Name | Type | Notes |
+| - | - | - | - |
+| `db.namespace` | `db.name` | String | Database name from connection_options |
+| `db.query.text` | `db.statement` | String | The database query being executed; set according to the `db_statement` config option |
+| `db.response.status_code` | — | String | The Trilogy error code, if available |
+| `db.system.name` | `db.system` | String | DBMS product identifier; always `mysql` |
+| `error.type` | — | String | The exception class name when the operation fails |
+| `server.address` | `net.peer.name` | String | Database host from connection_options |
+| `server.port` | — | Integer | Database port from connection_options |
+| — | `db.instance.id` | String | Connected host, e.g. result of `SELECT @@hostname` |
+| — | `db.user` | String | Database username from connection_options |
+| — | `peer.service` | String | Configured via the `peer_service` config option |
+
+## Database semantic convention stability
+
+In the OpenTelemetry ecosystem, database semantic conventions have now reached a stable state. However, the initial Trilogy instrumentation was introduced before this stability was achieved, which resulted in database attributes being based on an older version of the semantic conventions.
+
+To facilitate the migration to stable semantic conventions, you can use the `OTEL_SEMCONV_STABILITY_OPT_IN` environment variable. This variable allows you to opt-in to the new stable conventions, ensuring compatibility and future-proofing your instrumentation.
+
+When setting the value for `OTEL_SEMCONV_STABILITY_OPT_IN`, you can specify which conventions you wish to adopt:
+
+- `database` - Emits the stable database and networking conventions and ceases emitting the old conventions previously emitted by the instrumentation.
+- `database/dup` - Emits both the old and stable database and networking conventions, enabling a phased rollout of the stable semantic conventions.
+- Default behavior (in the absence of either value) is to continue emitting the old database and networking conventions the instrumentation previously emitted.
+
+During the transition from old to stable conventions, Trilogy instrumentation code comes in three patch versions: `dup`, `old`, and `stable`. These versions are identical except for the attributes they send. Any changes to Trilogy instrumentation should consider all three patches.
 
-| Attribute Name | Type | Notes |
-| - | - | - |
-| `db.instance.id` | String | The name of the DB host executing the query e.g. `SELECT @@hostname` |
-| `db.name` | String | The name of the database from connection_options |
-| `db.statement` | String | SQL statement being executed |
-| `db.user` | String | The username from connection_options |
-| `db.system` | String | `mysql` |
-| `net.peer.name` | String | The name of the remote host from connection_options |
+For additional information on migration, please refer to our [documentation](https://opentelemetry.io/docs/specs/semconv/non-normative/db-migration/).
 
 ## How can I get involved?
 

data/lib/opentelemetry/instrumentation/trilogy/instrumentation.rb

@@ -7,7 +7,70 @@
 module OpenTelemetry
   module Instrumentation
     module Trilogy
-      # The Instrumentation class contains logic to detect and install the Trilogy instrumentation
+      # The {OpenTelemetry::Instrumentation::Trilogy::Instrumentation} class contains logic to detect and install the Trilogy instrumentation
+      #
+      # Installation and configuration of this instrumentation is done within the
+      # {https://www.rubydoc.info/gems/opentelemetry-sdk/OpenTelemetry/SDK#configure-instance_method OpenTelemetry::SDK#configure}
+      # block, calling {https://www.rubydoc.info/gems/opentelemetry-sdk/OpenTelemetry%2FSDK%2FConfigurator:use use()}
+      # or {https://www.rubydoc.info/gems/opentelemetry-sdk/OpenTelemetry%2FSDK%2FConfigurator:use_all use_all()}.
+      #
+      # ## Configuration keys and options
+      #
+      # ### `:db_statement`
+      #
+      # Controls how SQL queries appear in spans.
+      #
+      # - `:obfuscate` **(default)** - Replaces literal values with `?` to prevent
+      #   sensitive data from being recorded.
+      # - `:include` - Records the raw SQL query as-is.
+      # - `:omit` - Excludes the SQL query attribute entirely.
+      #
+      # ### `:obfuscation_limit`
+      #
+      # Maximum length of the obfuscated SQL statement. Statements exceeding this limit
+      # are truncated. Default is `2000`.
+      #
+      # ### `:peer_service`
+      #
+      # Sets the `peer.service` attribute on spans. Default is `nil`.
+      # Only applies when using old semantic conventions. Deprecated with no replacement.
+      #
+      # ### `:propagator`
+      #
+      # Propagator for injecting trace context into SQL comments.
+      #
+      # - `'none'` **(default)** - Disables trace context propagation.
+      # - `'tracecontext'` - Uses W3C Trace Context format via SQL comments.
+      # - `'vitess'` - Uses Vitess-style propagation. Requires the
+      #   `opentelemetry-propagator-vitess` gem.
+      #
+      # ### `:record_exception`
+      #
+      # Records exceptions as span events when an error occurs. Default is `true`.
+      #
+      # ### `:span_name`
+      #
+      # Controls how span names are generated. Only applies when using old semantic
+      # conventions; ignored for stable semantic conventions.
+      #
+      # - `:statement_type` **(default)** - Uses the SQL operation (e.g., `SELECT`).
+      # - `:db_name` - Uses the database name.
+      # - `:db_operation_and_name` - Combines the operation and database name.
+      #
+      # @example An explicit default configuration
+      #   OpenTelemetry::SDK.configure do |c|
+      #     c.use_all({
+      #       'OpenTelemetry::Instrumentation::Trilogy' => {
+      #         db_statement: :obfuscate,
+      #         obfuscation_limit: 2000,
+      #         peer_service: nil,
+      #         propagator: 'none',
+      #         record_exception: true,
+      #         span_name: :statement_type,
+      #       },
+      #     })
+      #   end
+      #
       class Instrumentation < OpenTelemetry::Instrumentation::Base
         install do |config|
           require_dependencies
@@ -20,7 +83,7 @@ module OpenTelemetry
         end
 
         compatible do
-          Gem::Requirement.create('>= 2.3', '< 3.0').satisfied_by?(Gem::Version.new(::Trilogy::VERSION))
+          Gem::Requirement.create('>= 2.11', '< 3.0').satisfied_by?(Gem::Version.new(::Trilogy::VERSION))
         end
 
         option :peer_service, default: nil, validate: :string
@@ -30,16 +93,47 @@ module OpenTelemetry
         option :propagator, default: 'none', validate: %w[none tracecontext vitess]
         option :record_exception, default: true, validate: :boolean
 
-        attr_reader :propagator
+        attr_reader :propagator, :semconv
 
         private
 
         def require_dependencies
-          require_relative 'patches/client'
+          @semconv = determine_semconv
+
+          case @semconv
+          when :old
+            require_relative 'patches/old/client'
+          when :stable
+            require_relative 'patches/stable/client'
+          when :dup
+            require_relative 'patches/dup/client'
+          end
         end
 
         def patch_client
-          ::Trilogy.prepend(Patches::Client)
+          case @semconv
+          when :old
+            ::Trilogy.prepend(Patches::Old::Client)
+          when :stable
+            ::Trilogy.prepend(Patches::Stable::Client)
+          when :dup
+            ::Trilogy.prepend(Patches::Dup::Client)
+          end
+        end
+
+        def determine_semconv
+          opt_in = ENV.fetch('OTEL_SEMCONV_STABILITY_OPT_IN', nil)
+          return :old if opt_in.nil?
+
+          opt_in_values = opt_in.split(',').map(&:strip)
+
+          if opt_in_values.include?('database/dup')
+            :dup
+          elsif opt_in_values.include?('database')
+            :stable
+          else
+            :old
+          end
         end
 
         def configure_propagator(config)

data/lib/opentelemetry/instrumentation/trilogy/patches/dup/client.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry-helpers-mysql'
+require 'opentelemetry-helpers-sql-processor'
+
+module OpenTelemetry
+  module Instrumentation
+    module Trilogy
+      module Patches
+        module Dup
+          # Module to prepend to Trilogy for instrumentation (emits both old and stable semantic conventions)
+          module Client
+            def initialize(options = {})
+              @connection_options = options # This is normally done by Trilogy#initialize
+              @_otel_database_name = connection_options&.dig(:database)
+              @_otel_base_attributes = _build_otel_base_attributes.freeze
+
+              tracer.in_span(
+                'connect',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span|
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            def ping(...)
+              tracer.in_span(
+                'ping',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span|
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            def query(sql)
+              context_attributes = OpenTelemetry::Instrumentation::Trilogy.attributes
+
+              tracer.in_span(
+                OpenTelemetry::Helpers::MySQL.database_span_name(
+                  sql,
+                  context_attributes[OpenTelemetry::SemanticConventions::Trace::DB_OPERATION],
+                  @_otel_database_name,
+                  config
+                ),
+                attributes: client_attributes(sql).merge!(context_attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span, context|
+                if propagator && sql.frozen?
+                  sql = +sql
+                  propagator.inject(sql, context: context)
+                  sql.freeze
+                elsif propagator
+                  propagator.inject(sql, context: context)
+                end
+
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            private
+
+            def _build_otel_base_attributes
+              database_user = connection_options&.dig(:username)
+              mysql_host = connection_options&.fetch(:host, nil) || 'unknown sock'
+              mysql_port = connection_options&.dig(:port)
+
+              # Include both old and stable attributes
+              attributes = {
+                # Old conventions
+                ::OpenTelemetry::SemanticConventions::Trace::DB_SYSTEM => 'mysql',
+                ::OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => mysql_host,
+                # Stable conventions
+                'db.system.name' => 'mysql',
+                'server.address' => mysql_host
+              }
+
+              attributes['server.port'] = mysql_port if mysql_port
+
+              # Database name (old: db.name, stable: db.namespace)
+              if @_otel_database_name
+                attributes[::OpenTelemetry::SemanticConventions::Trace::DB_NAME] = @_otel_database_name
+                attributes['db.namespace'] = @_otel_database_name
+              end
+
+              # db.user (old only - removed in stable)
+              attributes[::OpenTelemetry::SemanticConventions::Trace::DB_USER] = database_user if database_user
+
+              # peer.service (old only - not stable and not a db attribute)
+              attributes[::OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] unless config[:peer_service].nil?
+              attributes
+            end
+
+            def client_attributes(sql = nil)
+              attributes = @_otel_base_attributes.dup
+
+              # Old convention
+              attributes['db.instance.id'] = @connected_host unless @connected_host.nil?
+
+              if sql
+                case config[:db_statement]
+                when :obfuscate
+                  obfuscated = OpenTelemetry::Helpers::SqlProcessor.obfuscate_sql(sql, obfuscation_limit: config[:obfuscation_limit], adapter: :mysql)
+                  # Old convention
+                  attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] = obfuscated
+                  # Stable convention
+                  attributes['db.query.text'] = obfuscated
+                when :include
+                  # Old convention
+                  attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] = sql
+                  # Stable convention
+                  attributes['db.query.text'] = sql
+                end
+              end
+
+              attributes
+            end
+
+            def set_error_attributes(span, error)
+              span.set_attribute('error.type', error.class.name)
+              span.set_attribute('db.response.status_code', error.error_code.to_s) if error.respond_to?(:error_code) && error.error_code
+            end
+
+            def tracer
+              Trilogy::Instrumentation.instance.tracer
+            end
+
+            def config
+              Trilogy::Instrumentation.instance.config
+            end
+
+            def propagator
+              Trilogy::Instrumentation.instance.propagator
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/trilogy/patches/old/client.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry-helpers-mysql'
+require 'opentelemetry-helpers-sql-processor'
+
+module OpenTelemetry
+  module Instrumentation
+    module Trilogy
+      module Patches
+        module Old
+          # Module to prepend to Trilogy for instrumentation (old semantic conventions)
+          module Client
+            def initialize(options = {})
+              @connection_options = options # This is normally done by Trilogy#initialize
+              @_otel_database_name = connection_options&.dig(:database)
+              @_otel_base_attributes = _build_otel_base_attributes.freeze
+
+              tracer.in_span(
+                'connect',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do
+                super
+              end
+            end
+
+            def ping(...)
+              tracer.in_span(
+                'ping',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do
+                super
+              end
+            end
+
+            def query(sql)
+              context_attributes = OpenTelemetry::Instrumentation::Trilogy.attributes
+
+              tracer.in_span(
+                OpenTelemetry::Helpers::MySQL.database_span_name(
+                  sql,
+                  context_attributes[OpenTelemetry::SemanticConventions::Trace::DB_OPERATION],
+                  @_otel_database_name,
+                  config
+                ),
+                attributes: client_attributes(sql).merge!(context_attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |_span, context|
+                if propagator && sql.frozen?
+                  sql = +sql
+                  propagator.inject(sql, context: context)
+                  sql.freeze
+                elsif propagator
+                  propagator.inject(sql, context: context)
+                end
+
+                super
+              end
+            end
+
+            private
+
+            def _build_otel_base_attributes
+              database_user = connection_options&.dig(:username)
+
+              attributes = {
+                ::OpenTelemetry::SemanticConventions::Trace::DB_SYSTEM => 'mysql',
+                ::OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => connection_options&.fetch(:host, 'unknown sock') || 'unknown sock'
+              }
+
+              attributes[::OpenTelemetry::SemanticConventions::Trace::DB_NAME] = @_otel_database_name if @_otel_database_name
+              attributes[::OpenTelemetry::SemanticConventions::Trace::DB_USER] = database_user if database_user
+              attributes[::OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] unless config[:peer_service].nil?
+              attributes
+            end
+
+            def client_attributes(sql = nil)
+              attributes = @_otel_base_attributes.dup
+
+              attributes['db.instance.id'] = @connected_host unless @connected_host.nil?
+
+              if sql
+                case config[:db_statement]
+                when :obfuscate
+                  attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] =
+                    OpenTelemetry::Helpers::SqlProcessor.obfuscate_sql(sql, obfuscation_limit: config[:obfuscation_limit], adapter: :mysql)
+                when :include
+                  attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] = sql
+                end
+              end
+
+              attributes
+            end
+
+            def tracer
+              Trilogy::Instrumentation.instance.tracer
+            end
+
+            def config
+              Trilogy::Instrumentation.instance.config
+            end
+
+            def propagator
+              Trilogy::Instrumentation.instance.propagator
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/trilogy/patches/stable/client.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry-helpers-mysql'
+require 'opentelemetry-helpers-sql-processor'
+
+module OpenTelemetry
+  module Instrumentation
+    module Trilogy
+      module Patches
+        module Stable
+          # Module to prepend to Trilogy for instrumentation (stable semantic conventions)
+          module Client
+            def initialize(options = {})
+              @connection_options = options # This is normally done by Trilogy#initialize
+              @_otel_database_name = connection_options&.dig(:database)
+              @_otel_base_attributes = _build_otel_base_attributes.freeze
+
+              tracer.in_span(
+                'connect',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span|
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            def ping(...)
+              tracer.in_span(
+                'ping',
+                attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span|
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            def query(sql)
+              context_attributes = OpenTelemetry::Instrumentation::Trilogy.attributes
+
+              tracer.in_span(
+                OpenTelemetry::Helpers::MySQL.database_span_name(
+                  sql,
+                  context_attributes[OpenTelemetry::SemanticConventions::Trace::DB_OPERATION],
+                  @_otel_database_name,
+                  config
+                ),
+                attributes: client_attributes(sql).merge!(context_attributes),
+                kind: :client,
+                record_exception: config[:record_exception]
+              ) do |span, context|
+                if propagator && sql.frozen?
+                  sql = +sql
+                  propagator.inject(sql, context: context)
+                  sql.freeze
+                elsif propagator
+                  propagator.inject(sql, context: context)
+                end
+
+                super
+              rescue StandardError => e
+                set_error_attributes(span, e)
+                raise
+              end
+            end
+
+            private
+
+            def _build_otel_base_attributes
+              mysql_host = connection_options&.fetch(:host, nil) || 'unknown sock'
+              mysql_port = connection_options&.dig(:port)
+
+              attributes = {
+                'db.system.name' => 'mysql',
+                'server.address' => mysql_host
+              }
+
+              attributes['server.port'] = mysql_port if mysql_port
+
+              attributes['db.namespace'] = @_otel_database_name if @_otel_database_name
+              attributes
+            end
+
+            def client_attributes(sql = nil)
+              attributes = @_otel_base_attributes.dup
+
+              if sql
+                case config[:db_statement]
+                when :obfuscate
+                  attributes['db.query.text'] =
+                    OpenTelemetry::Helpers::SqlProcessor.obfuscate_sql(sql, obfuscation_limit: config[:obfuscation_limit], adapter: :mysql)
+                when :include
+                  attributes['db.query.text'] = sql
+                end
+              end
+
+              attributes
+            end
+
+            def set_error_attributes(span, error)
+              span.set_attribute('error.type', error.class.name)
+              span.set_attribute('db.response.status_code', error.error_code.to_s) if error.respond_to?(:error_code) && error.error_code
+            end
+
+            def tracer
+              Trilogy::Instrumentation.instance.tracer
+            end
+
+            def config
+              Trilogy::Instrumentation.instance.config
+            end
+
+            def propagator
+              Trilogy::Instrumentation.instance.propagator
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/trilogy/version.rb

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module Trilogy
-      VERSION = '0.68.0'
+      VERSION = '0.69.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-trilogy
 version: !ruby/object:Gem::Version
-  version: 0.68.0
+  version: 0.69.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
@@ -94,16 +94,18 @@ files:
 - lib/opentelemetry/instrumentation.rb
 - lib/opentelemetry/instrumentation/trilogy.rb
 - lib/opentelemetry/instrumentation/trilogy/instrumentation.rb
-- lib/opentelemetry/instrumentation/trilogy/patches/client.rb
+- lib/opentelemetry/instrumentation/trilogy/patches/dup/client.rb
+- lib/opentelemetry/instrumentation/trilogy/patches/old/client.rb
+- lib/opentelemetry/instrumentation/trilogy/patches/stable/client.rb
 - lib/opentelemetry/instrumentation/trilogy/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-trilogy/0.68.0/file/CHANGELOG.md
-  source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/opentelemetry-instrumentation-trilogy/v0.68.0/instrumentation/trilogy
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-trilogy/0.69.0/file/CHANGELOG.md
+  source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/opentelemetry-instrumentation-trilogy/v0.69.0/instrumentation/trilogy
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-trilogy/0.68.0
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-trilogy/0.69.0
 rdoc_options: []
 require_paths:
 - lib

data/lib/opentelemetry/instrumentation/trilogy/patches/client.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-require 'opentelemetry-helpers-mysql'
-require 'opentelemetry-helpers-sql-processor'
-
-module OpenTelemetry
-  module Instrumentation
-    module Trilogy
-      module Patches
-        # Module to prepend to Trilogy for instrumentation
-        module Client
-          def initialize(options = {})
-            @connection_options = options # This is normally done by Trilogy#initialize
-            @_otel_database_name = connection_options&.dig(:database)
-            @_otel_base_attributes = _build_otel_base_attributes.freeze
-
-            tracer.in_span(
-              'connect',
-              attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
-              kind: :client,
-              record_exception: config[:record_exception]
-            ) do
-              super
-            end
-          end
-
-          def ping(...)
-            tracer.in_span(
-              'ping',
-              attributes: client_attributes.merge!(OpenTelemetry::Instrumentation::Trilogy.attributes),
-              kind: :client,
-              record_exception: config[:record_exception]
-            ) do
-              super
-            end
-          end
-
-          def query(sql)
-            context_attributes = OpenTelemetry::Instrumentation::Trilogy.attributes
-
-            tracer.in_span(
-              OpenTelemetry::Helpers::MySQL.database_span_name(
-                sql,
-                context_attributes[OpenTelemetry::SemanticConventions::Trace::DB_OPERATION],
-                @_otel_database_name,
-                config
-              ),
-              attributes: client_attributes(sql).merge!(context_attributes),
-              kind: :client,
-              record_exception: config[:record_exception]
-            ) do |_span, context|
-              if propagator && sql.frozen?
-                sql = +sql
-                propagator.inject(sql, context: context)
-                sql.freeze
-              elsif propagator
-                propagator.inject(sql, context: context)
-              end
-
-              super
-            end
-          end
-
-          private
-
-          def _build_otel_base_attributes
-            database_user = connection_options&.dig(:username)
-
-            attributes = {
-              ::OpenTelemetry::SemanticConventions::Trace::DB_SYSTEM => 'mysql',
-              ::OpenTelemetry::SemanticConventions::Trace::NET_PEER_NAME => connection_options&.fetch(:host, 'unknown sock') || 'unknown sock'
-            }
-
-            attributes[::OpenTelemetry::SemanticConventions::Trace::DB_NAME] = @_otel_database_name if @_otel_database_name
-            attributes[::OpenTelemetry::SemanticConventions::Trace::DB_USER] = database_user if database_user
-            attributes[::OpenTelemetry::SemanticConventions::Trace::PEER_SERVICE] = config[:peer_service] unless config[:peer_service].nil?
-            attributes
-          end
-
-          def client_attributes(sql = nil)
-            attributes = @_otel_base_attributes.dup
-
-            attributes['db.instance.id'] = @connected_host unless @connected_host.nil?
-
-            if sql
-              case config[:db_statement]
-              when :obfuscate
-                attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] =
-                  OpenTelemetry::Helpers::SqlProcessor.obfuscate_sql(sql, obfuscation_limit: config[:obfuscation_limit], adapter: :mysql)
-              when :include
-                attributes[::OpenTelemetry::SemanticConventions::Trace::DB_STATEMENT] = sql
-              end
-            end
-
-            attributes
-          end
-
-          def tracer
-            Trilogy::Instrumentation.instance.tracer
-          end
-
-          def config
-            Trilogy::Instrumentation.instance.config
-          end
-
-          def propagator
-            Trilogy::Instrumentation.instance.propagator
-          end
-        end
-      end
-    end
-  end
-end