feat: optimize extract_statement_type regex and encoding in helpers-mysql (#2088)

* perf: optimize extract_statement_type regex and encoding

Remove trailing .* from QUERY_NAME_REGEX to avoid scanning the entire
SQL string after matching the keyword. Only the first capture group
(the SQL operation) is used — the .* forced O(n) cost for no benefit.

Skip utf8_encode when the string is already valid UTF-8, which is the
common case for strings from ActiveRecord/Trilogy. Fall back to
binary: true encoding only for non-UTF-8 or invalid byte sequences.

Benchmarked improvements (combined):
- Short queries (53c):  1.91µs → 833ns  (2.3×)
- Long JOINs (768c):    6.97µs → 1.13µs (6.2×)
- IN clauses (2,406c): 15.19µs → 886ns  (17.1×)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* style: fix rubocop offenses

- Use modifier unless for single-line body
- Use unary plus (+) instead of .dup for unfreezing strings
- Use single-quoted strings where interpolation is not needed
- Remove redundant .freeze on string literals (frozen_string_literal)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Ariel Valentin <arielvalentin@users.noreply.github.com>

Author: 3 people

helpers/mysql/lib/opentelemetry/helpers/mysql.rb

@@ -42,7 +42,7 @@ module MySQL
       # Ignore query names that might appear in comments prepended to the
       # statement.
       PREPENDED_COMMENTS_REGEX = %r{(?:\/\*.*?\*\/)}m
-      QUERY_NAME_REGEX = Regexp.new("^\s*(?:#{PREPENDED_COMMENTS_REGEX})?\s*\\b(#{QUERY_NAMES.join('|')})\\b.*", Regexp::IGNORECASE)
+      QUERY_NAME_REGEX = Regexp.new("^\s*(?:#{PREPENDED_COMMENTS_REGEX})?\s*\\b(#{QUERY_NAMES.join('|')})\\b", Regexp::IGNORECASE)
 
       # This is a span naming utility intended for use in MySQL database
       # adapter instrumentation.
@@ -68,9 +68,11 @@ def database_span_name(sql, operation, database_name, config)
 
       # @api private
       def extract_statement_type(sql)
-        sql = OpenTelemetry::Common::Utilities.utf8_encode(sql, binary: true)
+        return unless sql
 
-        QUERY_NAME_REGEX.match(sql) { |match| match[1].downcase } unless sql.nil?
+        sql = OpenTelemetry::Common::Utilities.utf8_encode(sql, binary: true) unless sql.encoding == ::Encoding::UTF_8 && sql.valid_encoding?
+
+        QUERY_NAME_REGEX.match(sql) { |match| match[1].downcase }
       rescue StandardError => e
         OpenTelemetry.handle_error(message: 'Error extracting SQL statement type', exception: e)
         nil

helpers/mysql/test/helpers/mysql_test.rb

@@ -102,55 +102,168 @@
       end
     end
 
-    describe 'when sql contains invalid byte sequences' do
-      let(:sql) { "SELECT * from users where users.id = 1 and users.email = 'test@test.com\255'" }
+    describe 'recognizes all supported query names' do
+      {
+        'SELECT 1' => 'select',
+        'INSERT INTO users VALUES (1)' => 'insert',
+        'UPDATE users SET name = "a"' => 'update',
+        'DELETE FROM users' => 'delete',
+        'BEGIN' => 'begin',
+        'COMMIT' => 'commit',
+        'ROLLBACK' => 'rollback',
+        'SAVEPOINT sp1' => 'savepoint',
+        'RELEASE SAVEPOINT sp1' => 'release savepoint',
+        'EXPLAIN SELECT 1' => 'explain',
+        'DROP DATABASE test_db' => 'drop database',
+        'DROP TABLE users' => 'drop table',
+        'CREATE DATABASE test_db' => 'create database',
+        'CREATE TABLE users (id INT)' => 'create table',
+        "SET NAMES 'utf8mb4'" => 'set names'
+      }.each do |query, expected|
+        it "extracts '#{expected}' from: #{query[0..40]}" do
+          assert_equal(expected, OpenTelemetry::Helpers::MySQL.extract_statement_type(query))
+        end
+      end
+    end
 
-      it 'extracts the statement' do
-        assert_equal('select', extract_statement_type)
+    describe 'case insensitivity' do
+      it 'handles uppercase' do
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type('SELECT 1'))
+      end
+
+      it 'handles lowercase' do
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type('select 1'))
+      end
+
+      it 'handles mixed case' do
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type('SeLeCt 1'))
+      end
+
+      it 'handles mixed case for multi-word keywords' do
+        assert_equal('drop table', OpenTelemetry::Helpers::MySQL.extract_statement_type('Drop Table users'))
       end
     end
 
-    describe 'when sql contains unknown query statement' do
-      let(:sql) { 'DESELECT 1' }
+    describe 'leading whitespace' do
+      it 'handles leading spaces' do
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type('   SELECT 1'))
+      end
 
-      # nil sets the span name to 'mysql'
-      it 'returns nil' do
-        assert_nil(extract_statement_type)
+      it 'handles leading newlines' do
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type("\nSELECT 1"))
       end
     end
 
-    describe 'when sql contains multiple query statements' do
-      let(:sql) { 'EXPLAIN SELECT 1' }
+    describe 'queries with long trailing content' do
+      it 'extracts from queries with large IN clauses' do
+        ids = (1..500).to_a.join(', ')
+        sql = "SELECT * FROM users WHERE id IN (#{ids})"
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
 
-      it 'extracts the statement type that begins the query' do
-        assert_equal('explain', extract_statement_type)
+      it 'extracts from queries with multiple JOINs' do
+        sql = <<~SQL
+          SELECT u.*, p.*, c.*, o.*
+          FROM users u
+          JOIN profiles p ON p.user_id = u.id
+          JOIN companies c ON c.id = u.company_id
+          JOIN orders o ON o.user_id = u.id
+          WHERE u.active = 1
+        SQL
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'extracts from long INSERT with many values' do
+        values = (1..100).map { |i| "(#{i}, 'user#{i}')" }.join(', ')
+        sql = "INSERT INTO users (id, name) VALUES #{values}"
+        assert_equal('insert', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
       end
     end
 
-    describe 'when sql with marginalia-style prepended comments includes a query statement' do
-      let(:sql) do
-        "/*action='update',application='TrilogyTest',controller='users'*/ SELECT `users`.* FROM `users` WHERE `users`.`id` = 1 LIMIT 1"
+    describe 'prepended comments' do
+      it 'handles marginalia-style comments' do
+        sql = "/*action='update',application='TrilogyTest',controller='users'*/ SELECT `users`.* FROM `users` WHERE `users`.`id` = 1 LIMIT 1"
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
       end
 
-      it 'does not capture the query statement within the comment' do
-        assert_equal('select', extract_statement_type)
+      it 'does not capture a keyword that appears only inside a comment' do
+        sql = "/*action='delete'*/ SELECT 1"
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles comments with whitespace before and after' do
+        sql = '  /* comment */  SELECT 1'
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles multi-line comments' do
+        sql = "/* multi\nline\ncomment */ SELECT 1"
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+    end
+
+    describe 'encoding handling' do
+      it 'handles UTF-8 encoded strings' do
+        sql = (+'SELECT * FROM users').force_encoding('UTF-8')
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles ASCII encoded strings' do
+        sql = (+'SELECT * FROM users').force_encoding('ASCII')
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles binary (ASCII-8BIT) encoded strings' do
+        sql = (+'SELECT * FROM users').force_encoding('ASCII-8BIT')
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles strings with invalid byte sequences' do
+        sql = "SELECT * from users where users.id = 1 and users.email = 'test@test.com\255'"
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
+      end
+
+      it 'handles frozen strings' do
+        sql = 'SELECT * FROM users'
+        assert_equal('select', OpenTelemetry::Helpers::MySQL.extract_statement_type(sql))
       end
     end
 
-    describe 'when sql is nil' do
-      let(:sql) { nil }
+    describe 'nil and empty inputs' do
+      it 'returns nil for nil' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type(nil))
+      end
 
-      it 'returns nil' do
-        assert_nil(extract_statement_type)
+      it 'returns nil for empty string' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type(''))
+      end
+
+      it 'returns nil for whitespace-only string' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type('   '))
+      end
+    end
+
+    describe 'unrecognized statements' do
+      it 'returns nil for unknown keywords' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type('DESELECT 1'))
+      end
+
+      it 'returns nil for partial keyword matches' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type('SELECTIONS 1'))
+      end
+
+      it 'does not match keywords embedded mid-string' do
+        assert_nil(OpenTelemetry::Helpers::MySQL.extract_statement_type('MYSELECT 1'))
       end
     end
 
     describe 'when an error is raised' do
       it 'logs a message' do
+        sql = (+'SELECT 1').force_encoding('ASCII-8BIT')
         result = nil
         OpenTelemetry::TestHelpers.with_test_logger do |log_stream|
           allow(OpenTelemetry::Common::Utilities).to receive(:utf8_encode) { |_| raise 'boom!' }
-          extract_statement_type
+          result = OpenTelemetry::Helpers::MySQL.extract_statement_type(sql)
 
           assert_nil(result)
           assert_match(/Error extracting/, log_stream.string)