Ruby SDK: All tests passing (412/412 unit, 137/138 cross-SDK)

.gitignore

@@ -11,4 +11,12 @@
 .rspec_status
 .byebug_history
 
-.gemspec
+.gemspec
+.claude/
+.DS_Store
+AUDIT_REPORT.md
+FIXES_SUMMARY.md
+SILENT_FAILURE_AUDIT.md
+vendor/
+*.bak
+*.backup

CHANGELOG.md

@@ -1,7 +1,28 @@
-## [Unreleased]
+## [2.0.0] - Unreleased
+
+Behavior now matches the JavaScript SDK (the reference implementation).
+
+### Breaking
+- Read methods (`treatment`, `peek_treatment`, `variable_value`, `peek_variable_value`, `variable_keys`, `custom_field_keys`, `custom_field_value`, `custom_field_value_type`) raise `IllegalStateException` "ABsmartly Context is not yet ready." before the context is ready and "ABsmartly Context is finalized." after `close`, instead of returning 0 / the default. `experiments` raises only when not ready. `publish` and `refresh` raise when not ready.
+- The finalize event is named `"finalize"` (`ContextEventLogger::EVENT_TYPE::FINALIZE`); `EVENT_TYPE::CLOSE` is kept as a deprecated alias with the new value.
+- `close` after a failed final publish returns the failure and leaves the context open with its events queued, so it can be retried. It used to seal the context and orphan the events.
+- A failed `refresh` no longer marks the context failed: it logs the error, returns it and keeps the current data. `refresh` on a failed context is a no-op.
+- `ABSmartly.new` is a class-level overload (config object or `endpoint, api_key:, application:, environment:, ...`); subclasses that override `initialize` must adapt.
+- `Client#headers` is no longer a public accessor.
+- `Array.wrap`, `String#underscore` and `String#compare_to` core extensions removed.
+- `match` no longer caps pattern/text length (the JavaScript SDK has no cap); an invalid pattern still evaluates to null.
+
+### Fixed
+- Units are hashed from the UTF-8 encoding of their Unicode text: non-UTF-8 strings (e.g. UTF-16) are transcoded, surrogate pairs written as CESU-8 are joined into 4-byte sequences, and lone surrogates or invalid bytes become U+FFFD.
+- HTTP: network errors and 5xx responses are retried for both the context fetch and publish; a connection error fails the context instead of raising out of `create_context`.
+- A raising event logger no longer breaks the operation that logs (initialization, treatment, publish).
+- `in` with an object haystack finds symbol keys (audience attributes are parsed with symbolized names).
+- An indeterminate audience result (no filter) keeps a cached assignment instead of re-assigning.
+- An exposure or goal can no longer be queued after `close` sealed the context.
 
 ### Added
 - Configurable connection pool settings: `pool_size` and `pool_idle_timeout`
+- Backwards-compatible class aliases: `SDK` (alias for `ABSmartly`) and `SDKConfig` (alias for `ABSmartlyConfig`)
 
 ## [0.1.0] - 2022-08-03
 

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    absmartly-sdk (1.3.0)
+    absmartly-sdk (2.0.0)
       base64 (~> 0.2)
       faraday (~> 2.0)
       faraday-net_http_persistent (~> 2.0)

absmartly.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|example)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
   spec.bindir = "exe"

example/example.rb

@@ -4,10 +4,10 @@
 
 # config file
 Absmartly.configure_client do |config|
-  config.endpoint = "https://demo.absmartly.io/v1"
-  config.api_key = "x3ZyxmeKmb6n3VilTGs5I6-tBdaS9gYyr3i4YQXmUZcpPhH8nd8ev44NoEL_3yvA"
-  config.application = "www"
-  config.environment = "prod"
+  config.endpoint = ENV.fetch("ABSMARTLY_ENDPOINT", "https://demo.absmartly.io/v1")
+  config.api_key = ENV.fetch("ABSMARTLY_API_KEY") { raise "Set ABSMARTLY_API_KEY environment variable" }
+  config.application = ENV.fetch("ABSMARTLY_APPLICATION", "www")
+  config.environment = ENV.fetch("ABSMARTLY_ENVIRONMENT", "prod")
 end
 
 # define a new context request

lib/a_b_smartly.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 require "time"
+require "ostruct"
 require_relative "context"
 require_relative "audience_matcher"
 require_relative "default_context_data_provider"
+require_relative "default_context_publisher"
 require_relative "default_context_event_handler"
 require_relative "default_variable_parser"
 require_relative "default_audience_deserializer"
 require_relative "scheduled_thread_pool_executor"
+require_relative "client_config"
+require_relative "client"
 
 class ABSmartly
   attr_accessor :context_data_provider, :context_event_handler,
@@ -18,7 +22,33 @@ def self.create(config)
     ABSmartly.new(config)
   end
 
-  def initialize(config)
+  def self.new(config_or_endpoint = nil,
+               api_key: nil,
+               application: nil,
+               environment: nil,
+               timeout: nil,
+               retries: nil,
+               context_event_logger: nil)
+    if config_or_endpoint.is_a?(ABSmartlyConfig)
+      allocate.tap { |instance| instance.send(:initialize_from_config, config_or_endpoint) }
+    else
+      allocate.tap { |instance|
+        instance.send(:initialize_from_params,
+          config_or_endpoint,
+          api_key,
+          application,
+          environment,
+          timeout,
+          retries,
+          context_event_logger
+        )
+      }
+    end
+  end
+
+  private
+
+  def initialize_from_config(config)
     @context_data_provider = config.context_data_provider
     @context_event_handler = config.context_event_handler
     @context_event_logger = config.context_event_logger
@@ -35,7 +65,7 @@ def initialize(config)
       end
 
       if @context_event_handler.nil?
-        @context_event_handler = DefaultContextEventHandler.new(@client)
+        @context_event_handler = DefaultContextPublisher.new(@client)
       end
     end
 
@@ -51,13 +81,62 @@ def initialize(config)
     end
   end
 
+  def initialize_from_params(endpoint, api_key, application, environment, timeout, retries, event_logger)
+    raise ArgumentError.new("Missing required parameter: endpoint") if endpoint.nil? || endpoint.to_s.strip.empty?
+    raise ArgumentError.new("Missing required parameter: api_key") if api_key.nil? || api_key.to_s.strip.empty?
+    raise ArgumentError.new("Missing required parameter: application") if application.nil? || application.to_s.strip.empty?
+    raise ArgumentError.new("Missing required parameter: environment") if environment.nil? || environment.to_s.strip.empty?
+
+    timeout ||= 3000
+    retries ||= 5
+
+    raise ArgumentError.new("timeout must be a positive number") if Integer(timeout) <= 0
+    raise ArgumentError.new("retries must be a non-negative number") if Integer(retries) < 0
+
+    client_config = ClientConfig.create
+    client_config.endpoint = endpoint
+    client_config.api_key = api_key
+    client_config.application = application
+    client_config.environment = environment
+    client_config.connect_timeout = timeout.to_f / 1000.0
+    client_config.connection_request_timeout = timeout.to_f / 1000.0
+    client_config.max_retries = retries
+
+    @client = Client.create(client_config)
+    @context_data_provider = DefaultContextDataProvider.new(@client)
+    @context_event_handler = DefaultContextPublisher.new(@client)
+    @context_event_logger = event_logger
+    @variable_parser = DefaultVariableParser.new
+    @audience_deserializer = DefaultAudienceDeserializer.new
+    @scheduler = ScheduledThreadPoolExecutor.new(1)
+  end
+
+  public
+
   def create_context(config)
     validate_params(config)
     Context.create(get_utc_format, config, @context_data_provider.context_data,
                    @context_data_provider, @context_event_handler, @context_event_logger, @variable_parser,
                    AudienceMatcher.new(@audience_deserializer))
   end
 
+  def create_context_async(config)
+    validate_params(config)
+    context = Context.create_async(get_utc_format, config, @context_data_provider,
+                                   @context_event_handler, @context_event_logger, @variable_parser,
+                                   AudienceMatcher.new(@audience_deserializer))
+    data_provider = @context_data_provider
+    Thread.new do
+      begin
+        data_future = data_provider.context_data
+        context.set_data(data_future)
+      rescue => e
+        context.set_data(OpenStruct.new(success?: false, exception: e))
+      end
+    end
+    context
+  end
+
   def create_context_with(config, data)
     validate_params(config)
     Context.create(get_utc_format, config, data,
@@ -86,3 +165,5 @@ def validate_params(params)
       end
     end
 end
+
+SDK = ABSmartly

lib/a_b_smartly_config.rb

@@ -43,3 +43,5 @@ def client=(client)
     self
   end
 end
+
+SDKConfig = ABSmartlyConfig

lib/absmartly.rb

@@ -32,6 +32,10 @@ def create_context(context_config)
       sdk.create_context(context_config)
     end
 
+    def create_context_async(context_config)
+      sdk.create_context_async(context_config)
+    end
+
     def create_context_with(context_config, data)
       sdk.create_context_with(context_config, data)
     end

lib/absmartly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Absmartly
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

lib/audience_matcher.rb

@@ -32,7 +32,11 @@ def evaluate(audience, attributes)
         Result.new(@json_expr.evaluate_boolean_expr(filter, attributes))
       end
     end
-  rescue
+  rescue JSON::ParserError => e
+    warn("Failed to parse audience JSON: #{e.message}")
+    nil
+  rescue StandardError => e
+    warn("Audience evaluation failed: #{e.class} - #{e.message}")
     nil
   end
 end

lib/client.rb

@@ -5,7 +5,7 @@
 require_relative "default_context_event_serializer"
 
 class Client
-  attr_accessor :url, :query, :headers, :http_client, :executor, :deserializer, :serializer
+  attr_accessor :url, :query, :http_client, :executor, :deserializer, :serializer
   attr_reader :data_future, :promise, :exception
 
   def self.create(config, http_client = nil)
@@ -50,9 +50,21 @@ def initialize(config, http_client = nil)
   end
 
   def context_data
-    @promise = @http_client.get(@url, @query, @headers)
+    @exception = nil
+    @data_future = nil
+    begin
+      @promise = @http_client.get(@url, @query, @headers)
+    rescue StandardError => e
+      # A network failure fails the context instead of escaping create_context.
+      @promise = nil
+      @exception = e
+      warn("Failed to fetch context data: #{e.class} - #{e.message}")
+      return self
+    end
+
     unless @promise.success?
       @exception = Exception.new(@promise.body)
+      warn("Failed to fetch context data (status=#{@promise.respond_to?(:status) ? @promise.status : 'unknown'})")
       return self
     end
 
@@ -64,7 +76,12 @@ def context_data
   def publish(event)
     content = @serializer.serialize(event)
     response = @http_client.put(@url, nil, @headers, content)
-    return Exception.new(response.body) unless response.success?
+
+    unless response.success?
+      error = Exception.new(response.body)
+      warn("Publish failed (status=#{response.respond_to?(:status) ? response.status : 'unknown'})")
+      return error
+    end
 
     response
   end
@@ -76,4 +93,9 @@ def close
   def success?
     @promise&.success? || false
   end
+
+  def inspect
+    "#<Client url=#{@url.inspect}>"
+  end
+
 end