optimizely-sdk 4.0.1 → 5.0.0

data/lib/optimizely/odp/odp_event_manager.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require_relative 'odp_event_api_manager'
+require_relative '../helpers/constants'
+require_relative 'odp_event'
+
+module Optimizely
+  class OdpEventManager
+    # Events passed to the OdpEventManager are immediately added to an EventQueue.
+    # The OdpEventManager maintains a single consumer thread that pulls events off of
+    # the BlockingQueue and buffers them for either a configured batch size or for a
+    # maximum duration before the resulting OdpEvent is sent to Odp.
+
+    attr_reader :batch_size, :api_manager, :logger
+    attr_accessor :odp_config
+
+    def initialize(
+      api_manager: nil,
+      logger: NoOpLogger.new,
+      proxy_config: nil,
+      request_timeout: nil,
+      flush_interval: nil
+    )
+      @odp_config = nil
+      @api_host = nil
+      @api_key = nil
+
+      @mutex = Mutex.new
+      @event_queue = SizedQueue.new(Optimizely::Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_QUEUE_CAPACITY])
+      @queue_capacity = Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_QUEUE_CAPACITY]
+      # received signal should be sent after adding item to event_queue
+      @received = ConditionVariable.new
+      @logger = logger
+      @api_manager = api_manager || OdpEventApiManager.new(logger: @logger, proxy_config: proxy_config, timeout: request_timeout)
+      @flush_interval = flush_interval || Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_FLUSH_INTERVAL_SECONDS]
+      @batch_size = @flush_interval&.zero? ? 1 : Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_BATCH_SIZE]
+      @flush_deadline = 0
+      @retry_count = Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_RETRY_COUNT]
+      # current_batch should only be accessed by processing thread
+      @current_batch = []
+      @thread = nil
+      @thread_exception = false
+    end
+
+    def start!(odp_config)
+      if running?
+        @logger.log(Logger::WARN, 'Service already started.')
+        return
+      end
+
+      @odp_config = odp_config
+      @api_host = odp_config.api_host
+      @api_key = odp_config.api_key
+
+      @thread = Thread.new { run }
+      @logger.log(Logger::INFO, 'Starting scheduler.')
+    end
+
+    def flush
+      begin
+        @event_queue.push(:FLUSH_SIGNAL, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error flushing ODP event queue.')
+        return
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def update_config
+      begin
+        # Adds update config signal to event_queue.
+        @event_queue.push(:UPDATE_CONFIG, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error updating ODP config for the event queue')
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def dispatch(event)
+      if @thread_exception
+        @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], 'Queue is down'))
+        return
+      end
+
+      # if the processor has been explicitly stopped. Don't accept tasks
+      unless running?
+        @logger.log(Logger::WARN, 'ODP event queue is shutdown, not accepting events.')
+        return
+      end
+
+      begin
+        @logger.log(Logger::DEBUG, 'ODP event queue: adding event.')
+        @event_queue.push(event, true)
+      rescue => e
+        @logger.log(Logger::WARN, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], e.message))
+        return
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def send_event(type:, action:, identifiers:, data:)
+      case @odp_config&.odp_state
+      when nil
+        @logger.log(Logger::DEBUG, 'ODP event queue: cannot send before config has been set.')
+        return
+      when OdpConfig::ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::DEBUG, 'ODP event queue: cannot send before the datafile has loaded.')
+        return
+      when OdpConfig::ODP_CONFIG_STATE[:NOT_INTEGRATED]
+        @logger.log(Logger::DEBUG, Helpers::Constants::ODP_LOGS[:ODP_NOT_INTEGRATED])
+        return
+      end
+
+      event = Optimizely::OdpEvent.new(type: type, action: action, identifiers: identifiers, data: data)
+      dispatch(event)
+    end
+
+    def stop!
+      return unless running?
+
+      begin
+        @event_queue.push(:SHUTDOWN_SIGNAL, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error stopping ODP event queue.')
+        return
+      end
+
+      @event_queue.close
+
+      @mutex.synchronize do
+        @received.signal
+      end
+
+      @logger.log(Logger::INFO, 'Stopping ODP event queue.')
+
+      @thread.join
+
+      @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], @current_batch.to_json)) unless @current_batch.empty?
+    end
+
+    def running?
+      !!@thread && !!@thread.status && !@event_queue.closed?
+    end
+
+    private
+
+    def run
+      loop do
+        @mutex.synchronize do
+          @received.wait(@mutex, queue_timeout) if @event_queue.empty?
+        end
+
+        begin
+          item = @event_queue.pop(true)
+        rescue ThreadError => e
+          raise unless e.message == 'queue empty'
+
+          item = nil
+        end
+
+        case item
+        when :SHUTDOWN_SIGNAL
+          @logger.log(Logger::DEBUG, 'ODP event queue: received shutdown signal.')
+          break
+
+        when :FLUSH_SIGNAL
+          @logger.log(Logger::DEBUG, 'ODP event queue: received flush signal.')
+          flush_batch!
+
+        when :UPDATE_CONFIG
+          @logger.log(Logger::DEBUG, 'ODP event queue: received update config signal.')
+          process_config_update
+
+        when Optimizely::OdpEvent
+          add_to_batch(item)
+
+        when nil && !@current_batch.empty?
+          @logger.log(Logger::DEBUG, 'ODP event queue: flushing on interval.')
+          flush_batch!
+        end
+      end
+    rescue SignalException
+      @thread_exception = true
+      @logger.log(Logger::ERROR, 'Interrupted while processing ODP events.')
+    rescue => e
+      @thread_exception = true
+      @logger.log(Logger::ERROR, "Uncaught exception processing ODP events. Error: #{e.message}")
+    ensure
+      @logger.log(Logger::INFO, 'Exiting ODP processing loop. Attempting to flush pending events.')
+      flush_batch!
+    end
+
+    def flush_batch!
+      if @current_batch.empty?
+        @logger.log(Logger::DEBUG, 'ODP event queue: nothing to flush.')
+        return
+      end
+
+      if @api_key.nil? || @api_host.nil?
+        @logger.log(Logger::DEBUG, Helpers::Constants::ODP_LOGS[:ODP_NOT_INTEGRATED])
+        @current_batch.clear
+        return
+      end
+
+      @logger.log(Logger::DEBUG, "ODP event queue: flushing batch size #{@current_batch.length}.")
+      should_retry = false
+
+      i = 0
+      while i < @retry_count
+        begin
+          should_retry = @api_manager.send_odp_events(@api_key, @api_host, @current_batch)
+        rescue StandardError => e
+          should_retry = false
+          @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], "Error: #{e.message} #{@current_batch.to_json}"))
+        end
+        break unless should_retry
+
+        @logger.log(Logger::DEBUG, 'Error dispatching ODP events, scheduled to retry.') if i < @retry_count
+        i += 1
+      end
+
+      @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], "Failed after #{i} retries: #{@current_batch.to_json}")) if should_retry
+
+      @current_batch.clear
+    end
+
+    def add_to_batch(event)
+      set_flush_deadline if @current_batch.empty?
+
+      @current_batch << event
+      return unless @current_batch.length >= @batch_size
+
+      @logger.log(Logger::DEBUG, 'ODP event queue: flushing on batch size.')
+      flush_batch!
+    end
+
+    def set_flush_deadline
+      # Sets time that next flush will occur.
+      @flush_deadline = Time.new + @flush_interval
+    end
+
+    def time_till_flush
+      # Returns seconds until next flush; no less than 0.
+      [0, @flush_deadline - Time.new].max
+    end
+
+    def queue_timeout
+      # Returns seconds until next flush or None if current batch is empty.
+      return nil if @current_batch.empty?
+
+      time_till_flush
+    end
+
+    def process_config_update
+      # Updates the configuration used to send events.
+      flush_batch! unless @current_batch.empty?
+
+      @api_key = @odp_config&.api_key
+      @api_host = @odp_config&.api_host
+    end
+  end
+end

data/lib/optimizely/odp/odp_manager.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'optimizely/logger'
+require_relative '../helpers/constants'
+require_relative '../helpers/validator'
+require_relative '../exceptions'
+require_relative 'odp_config'
+require_relative 'lru_cache'
+require_relative 'odp_segment_manager'
+require_relative 'odp_event_manager'
+
+module Optimizely
+  class OdpManager
+    ODP_LOGS = Helpers::Constants::ODP_LOGS
+    ODP_MANAGER_CONFIG = Helpers::Constants::ODP_MANAGER_CONFIG
+    ODP_CONFIG_STATE = Helpers::Constants::ODP_CONFIG_STATE
+
+    # update_odp_config must be called to complete initialization
+    def initialize(
+      disable:,
+      segments_cache: nil,
+      segment_manager: nil,
+      event_manager: nil,
+      fetch_segments_timeout: nil,
+      odp_event_timeout: nil,
+      odp_flush_interval: nil,
+      logger: nil
+    )
+      @enabled = !disable
+      @segment_manager = segment_manager
+      @event_manager = event_manager
+      @logger = logger || NoOpLogger.new
+      @odp_config = OdpConfig.new
+
+      unless @enabled
+        @logger.log(Logger::INFO, ODP_LOGS[:ODP_NOT_ENABLED])
+        return
+      end
+
+      unless @segment_manager
+        segments_cache ||= LRUCache.new(
+          Helpers::Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_CAPACITY],
+          Helpers::Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_TIMEOUT_SECONDS]
+        )
+        @segment_manager = Optimizely::OdpSegmentManager.new(segments_cache, nil, @logger, timeout: fetch_segments_timeout)
+      end
+
+      @event_manager ||= Optimizely::OdpEventManager.new(logger: @logger, request_timeout: odp_event_timeout, flush_interval: odp_flush_interval)
+
+      @segment_manager.odp_config = @odp_config
+    end
+
+    def fetch_qualified_segments(user_id:, options:)
+      # Returns qualified segments for the user from the cache or the ODP server if not in the cache.
+      #
+      # @param user_id - The user id.
+      # @param options - An array of OptimizelySegmentOptions used to ignore and/or reset the cache.
+      #
+      # @return - Array of qualified segments or nil.
+      options ||= []
+      unless @enabled
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_NOT_ENABLED])
+        return nil
+      end
+
+      if @odp_config.odp_state == ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::ERROR, 'Cannot fetch segments before the datafile has loaded.')
+        return nil
+      end
+
+      @segment_manager.fetch_qualified_segments(ODP_MANAGER_CONFIG[:KEY_FOR_USER_ID], user_id, options)
+    end
+
+    def identify_user(user_id:)
+      unless @enabled
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (ODP disabled).')
+        return
+      end
+
+      case @odp_config.odp_state
+      when ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (datafile not ready).')
+        return
+      when ODP_CONFIG_STATE[:NOT_INTEGRATED]
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (ODP not integrated).')
+        return
+      end
+
+      @event_manager.send_event(
+        type: ODP_MANAGER_CONFIG[:EVENT_TYPE],
+        action: 'identified',
+        identifiers: {ODP_MANAGER_CONFIG[:KEY_FOR_USER_ID] => user_id},
+        data: {}
+      )
+    end
+
+    def send_event(type:, action:, identifiers:, data:)
+      # Send an event to the ODP server.
+      #
+      # @param type - the event type.
+      # @param action - the event action name.
+      # @param identifiers - a hash for identifiers.
+      # @param data - a hash for associated data. The default event data will be added to this data before sending to the ODP server.
+      unless @enabled
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_NOT_ENABLED])
+        return
+      end
+
+      unless Helpers::Validator.odp_data_types_valid?(data)
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_INVALID_DATA])
+        return
+      end
+
+      @event_manager.send_event(type: type, action: action, identifiers: identifiers, data: data)
+    end
+
+    def update_odp_config(api_key, api_host, segments_to_check)
+      # Update the odp config, reset the cache and send signal to the event processor to update its config.
+      # Start the event manager if odp is integrated.
+      return unless @enabled
+
+      config_changed = @odp_config.update(api_key, api_host, segments_to_check)
+      unless config_changed
+        @logger.log(Logger::DEBUG, 'Odp config was not changed.')
+        return
+      end
+
+      @segment_manager.reset
+
+      if @event_manager.running?
+        @event_manager.update_config
+      elsif @odp_config.odp_state == ODP_CONFIG_STATE[:INTEGRATED]
+        @event_manager.start!(@odp_config)
+      end
+    end
+
+    def stop!
+      return unless @enabled
+
+      @event_manager.stop!
+    end
+  end
+end

data/lib/optimizely/odp/odp_segment_api_manager.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'json'
+require_relative '../exceptions'
+
+module Optimizely
+  class OdpSegmentApiManager
+    # Interface that handles fetching audience segments.
+
+    def initialize(logger: nil, proxy_config: nil, timeout: nil)
+      @logger = logger || NoOpLogger.new
+      @proxy_config = proxy_config
+      @timeout = timeout || Optimizely::Helpers::Constants::ODP_GRAPHQL_API_CONFIG[:REQUEST_TIMEOUT]
+    end
+
+    # Fetch segments from the ODP GraphQL API.
+    #
+    # @param api_key - public api key
+    # @param api_host - domain url of the host
+    # @param user_key - vuid or fs_user_id (client device id or fullstack id)
+    # @param user_value - value of user_key
+    # @param segments_to_check - array of segments to check
+
+    def fetch_segments(api_key, api_host, user_key, user_value, segments_to_check)
+      url = "#{api_host}/v3/graphql"
+
+      headers = {'Content-Type' => 'application/json', 'x-api-key' => api_key.to_s}
+
+      payload = {
+        query: 'query($userId: String, $audiences: [String]) {' \
+               "customer(#{user_key}: $userId) " \
+               '{audiences(subset: $audiences) {edges {node {name state}}}}}',
+        variables: {
+          userId: user_value.to_s,
+          audiences: segments_to_check || []
+        }
+      }.to_json
+
+      begin
+        response = Helpers::HttpUtils.make_request(
+          url, :post, payload, headers, @timeout, @proxy_config
+        )
+      rescue SocketError, Timeout::Error, Net::ProtocolError, Errno::ECONNRESET => e
+        @logger.log(Logger::DEBUG, "GraphQL download failed: #{e}")
+        log_segments_failure('network error')
+        return nil
+      rescue Errno::EINVAL, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, HTTPUriError => e
+        log_segments_failure(e)
+        return nil
+      end
+
+      status = response.code.to_i
+      if status >= 400
+        log_segments_failure(status)
+        return nil
+      end
+
+      begin
+        response = JSON.parse(response.body)
+      rescue JSON::ParserError
+        log_segments_failure('JSON decode error')
+        return nil
+      end
+
+      if response.include?('errors')
+        error = response['errors'].first if response['errors'].is_a? Array
+        error_code = extract_component(error, 'extensions', 'code')
+        if error_code == 'INVALID_IDENTIFIER_EXCEPTION'
+          log_segments_failure('invalid identifier', Logger::WARN)
+        else
+          error_class = extract_component(error, 'extensions', 'classification') || 'decode error'
+          log_segments_failure(error_class)
+        end
+        return nil
+      end
+
+      audiences = extract_component(response, 'data', 'customer', 'audiences', 'edges')
+      unless audiences
+        log_segments_failure('decode error')
+        return nil
+      end
+
+      audiences.filter_map do |edge|
+        name = extract_component(edge, 'node', 'name')
+        state = extract_component(edge, 'node', 'state')
+        unless name && state
+          log_segments_failure('decode error')
+          return nil
+        end
+        state == 'qualified' ? name : nil
+      end
+    end
+
+    private
+
+    def log_segments_failure(message, level = Logger::ERROR)
+      @logger.log(level, format(Optimizely::Helpers::Constants::ODP_LOGS[:FETCH_SEGMENTS_FAILED], message))
+    end
+
+    def extract_component(hash, *components)
+      hash.dig(*components) if hash.is_a? Hash
+    rescue TypeError
+      nil
+    end
+  end
+end

data/lib/optimizely/odp/odp_segment_manager.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'optimizely/logger'
+require_relative 'odp_segment_api_manager'
+
+module Optimizely
+  class OdpSegmentManager
+    # Schedules connections to ODP for audience segmentation and caches the results
+    attr_accessor :odp_config
+    attr_reader :segments_cache, :api_manager, :logger
+
+    def initialize(segments_cache, api_manager = nil, logger = nil, proxy_config = nil, timeout: nil)
+      @odp_config = nil
+      @logger = logger || NoOpLogger.new
+      @api_manager = api_manager || OdpSegmentApiManager.new(logger: @logger, proxy_config: proxy_config, timeout: timeout)
+      @segments_cache = segments_cache
+    end
+
+    # Returns qualified segments for the user from the cache or the ODP server if not in the cache.
+    #
+    # @param user_key - The key for identifying the id type.
+    # @param user_value - The id itself.
+    # @param options - An array of OptimizelySegmentOptions used to ignore and/or reset the cache.
+    #
+    # @return - Array of qualified segments.
+    def fetch_qualified_segments(user_key, user_value, options)
+      odp_api_key = @odp_config&.api_key
+      odp_api_host = @odp_config&.api_host
+      segments_to_check = @odp_config&.segments_to_check
+
+      if odp_api_key.nil? || odp_api_host.nil?
+        @logger.log(Logger::ERROR, format(Optimizely::Helpers::Constants::ODP_LOGS[:FETCH_SEGMENTS_FAILED], 'ODP is not enabled'))
+        return nil
+      end
+
+      unless segments_to_check&.size&.positive?
+        @logger.log(Logger::DEBUG, 'No segments are used in the project. Returning empty list')
+        return []
+      end
+
+      cache_key = make_cache_key(user_key, user_value)
+
+      ignore_cache = options.include?(OptimizelySegmentOption::IGNORE_CACHE)
+      reset_cache = options.include?(OptimizelySegmentOption::RESET_CACHE)
+
+      reset if reset_cache
+
+      unless ignore_cache || reset_cache
+        segments = @segments_cache.lookup(cache_key)
+        unless segments.nil?
+          @logger.log(Logger::DEBUG, 'ODP cache hit. Returning segments from cache.')
+          return segments
+        end
+        @logger.log(Logger::DEBUG, 'ODP cache miss.')
+      end
+
+      @logger.log(Logger::DEBUG, 'Making a call to ODP server.')
+
+      segments = @api_manager.fetch_segments(odp_api_key, odp_api_host, user_key, user_value, segments_to_check)
+      @segments_cache.save(cache_key, segments) unless segments.nil? || ignore_cache
+      segments
+    end
+
+    def reset
+      @segments_cache.reset
+      nil
+    end
+
+    private
+
+    def make_cache_key(user_key, user_value)
+      "#{user_key}-$-#{user_value}"
+    end
+  end
+
+  class OptimizelySegmentOption
+    # Options for the OdpSegmentManager
+    IGNORE_CACHE = :IGNORE_CACHE
+    RESET_CACHE = :RESET_CACHE
+  end
+end

data/lib/optimizely/optimizely_config.rb

@@ -19,8 +19,9 @@ module Optimizely
   require 'json'
   class OptimizelyConfig
     include Optimizely::ConditionTreeEvaluator
-    def initialize(project_config)
+    def initialize(project_config, logger = nil)
       @project_config = project_config
+      @logger = logger || NoOpLogger.new
       @rollouts = @project_config.rollouts
       @audiences = []
       audience_id_lookup_dict = {}
@@ -91,6 +92,7 @@ module Optimizely
 
     def experiments_map
       experiments_id_map.values.reduce({}) do |experiments_key_map, experiment|
+        @logger.log(Logger::WARN, "Duplicate experiment keys found in datafile: #{experiment['key']}") if experiments_key_map.key? experiment['key']
         experiments_key_map.update(experiment['key'] => experiment)
       end
     end
@@ -201,7 +203,7 @@ module Optimizely
     def stringify_conditions(conditions, audiences_map)
       operand = 'OR'
       conditions_str = ''
-      length = conditions.length()
+      length = conditions.length
       return '' if length.zero?
       return "\"#{lookup_name_from_id(conditions[0], audiences_map)}\"" if length == 1 && !OPERATORS.include?(conditions[0])