Refactoring, cache tests

Author: hannahramadan

helpers/sql-obfuscation/lib/opentelemetry/helpers/query_summary.rb

@@ -4,8 +4,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-require_relative 'query_summary/cache'
 require_relative 'query_summary/tokenizer'
+require_relative 'query_summary/cache'
 require_relative 'query_summary/parser'
 
 module OpenTelemetry
@@ -17,17 +17,25 @@ module Helpers
     #   QuerySummary.generate_summary("SELECT * FROM users WHERE id = 1")
     #   # => "SELECT users"
     module QuerySummary
-      def self.configure_cache(size: Cache::DEFAULT_SIZE)
-        Cache.configure(size: size)
-      end
+      class << self
+        def configure_cache(size: Cache::DEFAULT_SIZE)
+          cache_instance.configure(size: size)
+        end
+
+        def generate_summary(query)
+          cache_instance.fetch(query) do
+            tokens = Tokenizer.tokenize(query)
+            Parser.build_summary_from_tokens(tokens)
+          end
+        rescue StandardError
+          'UNKNOWN'
+        end
+
+        private
 
-      def self.generate_summary(query)
-        Cache.fetch(query) do
-          tokens = Tokenizer.tokenize(query)
-          Parser.build_summary_from_tokens(tokens)
+        def cache_instance
+          @cache_instance ||= Cache.new
         end
-      rescue StandardError
-        'UNKNOWN'
       end
     end
   end

helpers/sql-obfuscation/lib/opentelemetry/helpers/query_summary/cache.rb

@@ -2,7 +2,7 @@
 
 # Copyright The OpenTelemetry Authors
 #
-# SPDX-License-Identifier: Apache-2.0module OpenTelemetry
+# SPDX-License-Identifier: Apache-2.0
 
 module OpenTelemetry
   module Helpers
@@ -13,39 +13,43 @@ module QuerySummary
       # Uses mutex synchronization for thread safety.
       #
       # @example
-      #   Cache.fetch("SELECT * FROM users") { "SELECT users" } # => "SELECT users"
+      #   cache = Cache.new
+      #   cache.fetch("SELECT * FROM users") { "SELECT users" } # => "SELECT users"
       class Cache
         DEFAULT_SIZE = 1000
 
-        @cache = {}
-        @cache_mutex = Mutex.new
-        @cache_size = DEFAULT_SIZE
+        def initialize(size: DEFAULT_SIZE)
+          @cache = {}
+          @cache_mutex = Mutex.new
+          @cache_size = size
+        end
 
-        def self.fetch(key)
+        def fetch(key)
           @cache_mutex.synchronize do
             return @cache[key] if @cache.key?(key)
 
             result = yield
-            @cache.shift if @cache.size >= @cache_size
+            evict_if_needed
             @cache[key] = result
             result
           end
         end
 
-        def self.configure(size: DEFAULT_SIZE)
-          @cache_mutex.synchronize do
-            @cache_size = size
-            @cache.clear if @cache.size > size
-          end
+        private
+
+        def configure(size: DEFAULT_SIZE)
+          @cache_size = size
+          @cache.clear if @cache.size > size
         end
 
-        def self.store(key, value)
-          @cache_mutex.synchronize do
-            @cache.shift if @cache.size >= @cache_size
-            @cache[key] = value
-          end
+        def clear
+          @cache.clear
+        end
+
+        def evict_if_needed
+          @cache.shift if @cache.size >= @cache_size
         end
       end
     end
   end
-end
+end

helpers/sql-obfuscation/lib/opentelemetry/helpers/query_summary/parser.rb

@@ -25,133 +25,135 @@ class Parser
         TABLE_OPERATIONS = %w[CREATE ALTER DROP TRUNCATE].freeze
         TABLE_OBJECTS = %w[TABLE INDEX PROCEDURE VIEW DATABASE].freeze
 
-        def self.build_summary_from_tokens(tokens)
-          summary_parts = []
-          state = DEFAULT_STATE
-          skip_until = 0 # Next token index to process; allows skipping tokens already consumed by previous operations
+        class << self
+          def build_summary_from_tokens(tokens)
+            summary_parts = []
+            state = DEFAULT_STATE
+            skip_until = 0 # Next token index to process; allows skipping tokens already consumed by previous operations
 
-          tokens.each_with_index do |token, index|
-            next if index < skip_until # Skip already processed tokens
+            tokens.each_with_index do |token, index|
+              next if index < skip_until # Skip already processed tokens
 
-            result = process_token(token, tokens, index, state)
+              result = process_token(token, tokens, index, state)
 
-            summary_parts.concat(result[:parts])
-            state = result[:new_state]
-            skip_until = result[:next_index]
-          end
+              summary_parts.concat(result[:parts])
+              state = result[:new_state]
+              skip_until = result[:next_index]
+            end
 
-          summary_parts.join(' ')
-        end
+            summary_parts.join(' ')
+          end
 
-        def self.process_token(token, tokens, index, state)
-          operation_result = process_main_operation(token, tokens, index, state)
-          return operation_result if operation_result[:processed]
+          def process_token(token, tokens, index, state)
+            operation_result = process_main_operation(token, tokens, index, state)
+            return operation_result if operation_result[:processed]
 
-          collection_result = process_collection_token(token, tokens, index, state)
-          return collection_result if collection_result[:processed]
+            collection_result = process_collection_token(token, tokens, index, state)
+            return collection_result if collection_result[:processed]
 
-          { processed: false, parts: [], new_state: state, next_index: index + 1 }
-        end
+            { processed: false, parts: [], new_state: state, next_index: index + 1 }
+          end
 
-        def self.process_main_operation(token, tokens, index, current_state)
-          upcased_value = token.value.upcase
-
-          case upcased_value
-          when *MAIN_OPERATIONS
-            add_to_summary(token.value, DEFAULT_STATE, index + 1)
-          when *COLLECTION_OPERATIONS
-            add_to_summary(token.value, EXPECT_COLLECTION_STATE, index + 1)
-          when *TRIGGER_COLLECTION
-            trigger_collection_mode(index + 1)
-          when *TABLE_OPERATIONS
-            handle_table_operation(token, tokens, index)
-          when 'UNION'
-            handle_union(token, tokens, index)
-          else
-            not_processed(current_state, index + 1)
+          def process_main_operation(token, tokens, index, current_state)
+            upcased_value = token.value.upcase
+
+            case upcased_value
+            when *MAIN_OPERATIONS
+              add_to_summary(token.value, DEFAULT_STATE, index + 1)
+            when *COLLECTION_OPERATIONS
+              add_to_summary(token.value, EXPECT_COLLECTION_STATE, index + 1)
+            when *TRIGGER_COLLECTION
+              trigger_collection_mode(index + 1)
+            when *TABLE_OPERATIONS
+              handle_table_operation(token, tokens, index)
+            when 'UNION'
+              handle_union(token, tokens, index)
+            else
+              not_processed(current_state, index + 1)
+            end
           end
-        end
 
-        def self.process_collection_token(token, tokens, index, state)
-          return not_processed(state, index + 1) unless state == EXPECT_COLLECTION_STATE
+          def process_collection_token(token, tokens, index, state)
+            return not_processed(state, index + 1) unless state == EXPECT_COLLECTION_STATE
 
-          upcased_value = token.value.upcase
+            upcased_value = token.value.upcase
 
-          if identifier_like?(token) || (token.type == :keyword && can_be_table_name?(upcased_value))
-            handle_collection_identifier(token, tokens, index)
-          elsif token.value == '(' || token.type == :operator
-            handle_collection_operator(token, state, index)
-          else
-            handle_collection_default(token, index)
+            if identifier_like?(token) || (token.type == :keyword && can_be_table_name?(upcased_value))
+              handle_collection_identifier(token, tokens, index)
+            elsif token.value == '(' || token.type == :operator
+              handle_collection_operator(token, state, index)
+            else
+              handle_collection_default(token, index)
+            end
           end
-        end
 
-        def self.handle_collection_identifier(token, tokens, index)
-          skip_count = calculate_alias_skip(tokens, index)
-          new_state = tokens[index + 1 + skip_count]&.value == ',' ? EXPECT_COLLECTION_STATE : DEFAULT_STATE
-          skip_count += 1 if tokens[index + 1 + skip_count]&.value == ','
+          def handle_collection_identifier(token, tokens, index)
+            skip_count = calculate_alias_skip(tokens, index)
+            new_state = tokens[index + 1 + skip_count]&.value == ',' ? EXPECT_COLLECTION_STATE : DEFAULT_STATE
+            skip_count += 1 if tokens[index + 1 + skip_count]&.value == ','
 
-          { processed: true, parts: [token.value], new_state: new_state, next_index: index + 1 + skip_count }
-        end
+            { processed: true, parts: [token.value], new_state: new_state, next_index: index + 1 + skip_count }
+          end
 
-        def self.handle_collection_operator(token, state, index)
-          { processed: true, parts: [], new_state: state, next_index: index + 1 }
-        end
+          def handle_collection_operator(token, state, index)
+            { processed: true, parts: [], new_state: state, next_index: index + 1 }
+          end
 
-        def self.handle_collection_default(token, index)
-          { processed: true, parts: [], new_state: DEFAULT_STATE, next_index: index + 1 }
-        end
+          def handle_collection_default(token, index)
+            { processed: true, parts: [], new_state: DEFAULT_STATE, next_index: index + 1 }
+          end
 
-        def self.identifier_like?(token)
-          %i[identifier quoted_identifier string].include?(token.type)
-        end
+          def identifier_like?(token)
+            %i[identifier quoted_identifier string].include?(token.type)
+          end
 
-        def self.can_be_table_name?(upcased_value)
-          # Keywords that can also be used as table/object names in certain contexts
-          TABLE_OBJECTS.include?(upcased_value)
-        end
+          def can_be_table_name?(upcased_value)
+            # Keywords that can also be used as table/object names in certain contexts
+            TABLE_OBJECTS.include?(upcased_value)
+          end
 
-        def self.calculate_alias_skip(tokens, index)
-          next_token = tokens[index + 1]
-          if next_token && next_token.value&.upcase == 'AS'
-            2  # Skip 'AS' and the alias
-          elsif next_token && next_token.type == :identifier
-            1  # Skip the alias
-          else
-            0
+          def calculate_alias_skip(tokens, index)
+            next_token = tokens[index + 1]
+            if next_token && next_token.value&.upcase == 'AS'
+              2  # Skip 'AS' and the alias
+            elsif next_token && next_token.type == :identifier
+              1  # Skip the alias
+            else
+              0
+            end
           end
-        end
 
-        def self.add_to_summary(part, new_state, next_index)
-          { processed: true, parts: [part], new_state: new_state, next_index: next_index }
-        end
+          def add_to_summary(part, new_state, next_index)
+            { processed: true, parts: [part], new_state: new_state, next_index: next_index }
+          end
 
-        def self.trigger_collection_mode(next_index)
-          { processed: true, parts: [], new_state: EXPECT_COLLECTION_STATE, next_index: next_index }
-        end
+          def trigger_collection_mode(next_index)
+            { processed: true, parts: [], new_state: EXPECT_COLLECTION_STATE, next_index: next_index }
+          end
 
-        def self.not_processed(current_state, next_index)
-          { processed: false, parts: [], new_state: current_state, next_index: next_index }
-        end
+          def not_processed(current_state, next_index)
+            { processed: false, parts: [], new_state: current_state, next_index: next_index }
+          end
 
-        def self.handle_union(token, tokens, index)
-          next_token = tokens[index + 1]
-          if next_token && next_token.value&.upcase == 'ALL'
-            { processed: true, parts: ["#{token.value} #{next_token.value}"], new_state: DEFAULT_STATE, next_index: index + 2 }
-          else
-            add_to_summary(token.value, DEFAULT_STATE, index + 1)
+          def handle_union(token, tokens, index)
+            next_token = tokens[index + 1]
+            if next_token && next_token.value&.upcase == 'ALL'
+              { processed: true, parts: ["#{token.value} #{next_token.value}"], new_state: DEFAULT_STATE, next_index: index + 2 }
+            else
+              add_to_summary(token.value, DEFAULT_STATE, index + 1)
+            end
           end
-        end
 
-        def self.handle_table_operation(token, tokens, index)
-          next_token_obj = tokens[index + 1]
-          next_token = next_token_obj&.value&.upcase
+          def handle_table_operation(token, tokens, index)
+            next_token_obj = tokens[index + 1]
+            next_token = next_token_obj&.value&.upcase
 
-          case next_token
-          when 'TABLE', 'INDEX', 'PROCEDURE', 'VIEW', 'DATABASE'
-            { processed: true, parts: ["#{token.value} #{next_token}"], new_state: EXPECT_COLLECTION_STATE, next_index: index + 2 }
-          else
-            add_to_summary(token.value, DEFAULT_STATE, index + 1)
+            case next_token
+            when 'TABLE', 'INDEX', 'PROCEDURE', 'VIEW', 'DATABASE'
+              { processed: true, parts: ["#{token.value} #{next_token}"], new_state: EXPECT_COLLECTION_STATE, next_index: index + 2 }
+            else
+              add_to_summary(token.value, DEFAULT_STATE, index + 1)
+            end
           end
         end
       end

helpers/sql-obfuscation/lib/opentelemetry/helpers/query_summary/tokenizer.rb

@@ -36,23 +36,25 @@ class Tokenizer
 
         EXCLUDED_TYPES = %i[whitespace comment].freeze
 
-        def self.tokenize(query)
-          scanner = StringScanner.new(query)
-          tokens = []
+        class << self
+          def tokenize(query)
+            scanner = StringScanner.new(query)
+            tokens = []
 
-          scan_next_token(scanner, tokens) until scanner.eos?
+            scan_next_token(scanner, tokens) until scanner.eos?
 
-          tokens
-        end
+            tokens
+          end
 
-        def self.scan_next_token(scanner, tokens)
-          matched = TOKEN_REGEX.any? do |type, regex|
-            next unless (value = scanner.scan(regex))
+          def scan_next_token(scanner, tokens)
+            matched = TOKEN_REGEX.any? do |type, regex|
+              next unless (value = scanner.scan(regex))
 
-            tokens << Token.new(type, value) unless EXCLUDED_TYPES.include?(type)
-            true
+              tokens << Token.new(type, value) unless EXCLUDED_TYPES.include?(type)
+              true
+            end
+            scanner.getch unless matched
           end
-          scanner.getch unless matched
         end
       end
     end