devcycle-ruby-server-sdk 3.6.1 → 3.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b68b0885c55e6e3f724d839500536a7022f6ec40d691b291125aa9e3b2d09669
-  data.tar.gz: c45af7b53ca8e12b7b6d4d8f109d2f3b8c4ff67471736e952c7d8eed0aa32a08
+  metadata.gz: 914b4bf9e916b2796dcd6ce88be3ecf784b074fd30784bf8f28e2156b0bd8c66
+  data.tar.gz: dc4a335584b6618b4664203460530bc4421232dfdcc6362399694d7278f34bee
 SHA512:
-  metadata.gz: a906bf6a2b314c043b765dbffacd7bd08975b7c69e89ec28a72abbb312a091c4c2a9fa4615076ffe8c400ef4f8d539fe4977fbe31247866d728ca2f33dc88eff
-  data.tar.gz: b7ba08571dba965a3af92c8188b52ce06547e298afff943387246e67565daf8070daf5fe67552c629086bfb563b4a6856d98b31b21b949792011aa580b3e1ed9
+  metadata.gz: 6ca7f4b518dfa6bbd6ffa817263df4f625e7583a2ea61ad6b6ead5cd10ce12f2f586e205e457c39dc9d86831aadfd8e1ce7f1346c02362b1427bce7768a9fac0
+  data.tar.gz: 2d35f58deaa7a1309d8cb1aa6c5e7002e96e957f920d64d49d14a11e03a108051c679fc521acb451c1cd90a5dc32e9caa1754c92f308efecf592cd87da8cb78b

data/lib/devcycle-ruby-server-sdk/api/client.rb

@@ -14,6 +14,7 @@ module DevCycle
       @sdkKey = sdkKey
       @dvc_options = dvc_options
       @logger = dvc_options.logger
+      @eval_hooks_runner = EvalHooksRunner.new
 
       if @dvc_options.enable_cloud_bucketing
         @api_client = ApiClient.default
@@ -172,35 +173,68 @@ module DevCycle
 
       validate_model(user)
 
-      if @dvc_options.enable_cloud_bucketing
-        data, _status_code, _headers = variable_with_http_info(key, user, default, opts)
-        return data
+      # Create hook context
+      hook_context = HookContext.new(key: key, user: user, default_value: default)
+
+      before_hook_error = nil
+      # Run before hooks
+      begin
+        hook_context = @eval_hooks_runner.run_before_hooks(hook_context)
+      rescue BeforeHookError => e
+        before_hook_error = e
+        @logger.warn("Error in before hooks: #{e.message}")
       end
 
-      value = default
-      type = determine_variable_type(default)
-      defaulted = true
-      if local_bucketing_initialized? && @local_bucketing.has_config
-        type_code = variable_type_code_from_type(type)
-        variable_pb = variable_for_user_pb(user, key, type_code)
-        unless variable_pb.nil?
-          value = get_variable_value(variable_pb)
-          defaulted = false
+      variable_result = nil
+
+      begin
+        if @dvc_options.enable_cloud_bucketing
+          data, _status_code, _headers = variable_with_http_info(key, user, default, opts)
+          variable_result = data
+        else
+          value = default
+          type = determine_variable_type(default)
+          defaulted = true
+          if local_bucketing_initialized? && @local_bucketing.has_config
+            type_code = variable_type_code_from_type(type)
+            variable_pb = variable_for_user_pb(user, key, type_code)
+            unless variable_pb.nil?
+              value = get_variable_value(variable_pb)
+              defaulted = false
+            end
+          else
+            @logger.warn("Local bucketing not initialized, returning default value for variable #{key}")
+            variable_event = Event.new({ type: DevCycle::EventTypes[:agg_variable_defaulted], target: key })
+            bucketed_config = BucketedUserConfig.new({}, {}, {}, {}, {}, {}, [])
+            @event_queue.queue_aggregate_event(variable_event, bucketed_config)
+          end
+
+          variable_result = Variable.new({
+            key: key,
+            value: value,
+            type: type,
+            defaultValue: default,
+            isDefaulted: defaulted
+          })
         end
-      else
-        @logger.warn("Local bucketing not initialized, returning default value for variable #{key}")
-        variable_event = Event.new({ type: DevCycle::EventTypes[:agg_variable_defaulted], target: key })
-        bucketed_config = BucketedUserConfig.new({}, {}, {}, {}, {}, {}, [])
-        @event_queue.queue_aggregate_event(variable_event, bucketed_config)
-      end
-
-      Variable.new({
-        key: key,
-        value: value,
-        type: type,
-        defaultValue: default,
-        isDefaulted: defaulted
-      })
+
+
+        # Run after hooks only if no before hook error occurred
+        if before_hook_error != nil
+          @logger.info("before_hook_error is not nil, skipping after hooks")
+          raise before_hook_error
+        else
+          @eval_hooks_runner.run_after_hooks(hook_context)
+        end
+      rescue => e
+        # Run error hooks
+        @eval_hooks_runner.run_error_hooks(hook_context, e)
+      ensure
+        # Run finally hooks in all cases
+        @eval_hooks_runner.run_finally_hooks(hook_context)
+      end
+
+      variable_result
     end
 
     def variable_for_user(user, key, variable_type_code)
@@ -526,6 +560,32 @@ module DevCycle
         raise ArgumentError.new("Invalid type code for variable: #{type_code}")
       end
     end
+
+    def get_variable_value(variable_pb)
+      case variable_pb.type
+      when :Boolean
+        variable_pb.boolValue
+      when :Number
+        variable_pb.doubleValue
+      when :String
+        variable_pb.stringValue
+      when :JSON
+        JSON.parse variable_pb.stringValue
+      end
+    end
+
+    # Adds an eval hook to the client
+    # @param [EvalHook] eval_hook The eval hook to add
+    # @return [void]
+    def add_eval_hook(eval_hook)
+      @eval_hooks_runner.add_hook(eval_hook)
+    end
+
+    # Clears all eval hooks from the client
+    # @return [void]
+    def clear_eval_hooks
+      @eval_hooks_runner.clear_hooks
+    end
   end
 
   # @deprecated Use `DevCycle::Client` instead.

data/lib/devcycle-ruby-server-sdk/api/dev_cycle_provider.rb

@@ -48,15 +48,42 @@ module DevCycle
         raise ArgumentError, "Invalid context type, expected OpenFeature::SDK::EvaluationContext but got #{context.class}"
       end
       args = {}
-      if context.field('user_id')
-        args.merge!(user_id: context.field('user_id'))
-      elsif context.field('targeting_key')
-        args.merge!(user_id: context.field('targeting_key'))
+      user_id = nil
+      user_id_field = nil
+      
+      # Priority order: targeting_key -> user_id -> userId
+      if context.field('targeting_key')
+        user_id = context.field('targeting_key')
+        user_id_field = 'targeting_key'
+      elsif context.field('user_id')
+        user_id = context.field('user_id')
+        user_id_field = 'user_id'
+      elsif context.field('userId')
+        user_id = context.field('userId')
+        user_id_field = 'userId'
       end
+      
+      # Validate user_id is present and is a string
+      if user_id.nil?
+        raise ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId"
+      end
+      
+      unless user_id.is_a?(String)
+        raise ArgumentError, "User ID field '#{user_id_field}' must be a string, got #{user_id.class}"
+      end
+      
+      # Check after type validation to avoid NoMethodError on non-strings
+      if user_id.empty?
+        raise ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId"
+      end
+      
+      args.merge!(user_id: user_id)
+      
       customData = {}
       privateCustomData = {}
       context.fields.each do |field, value|
-        if field === 'user_id' || field === 'targeting_key'
+        # Skip all user ID fields from custom data
+        if field === 'targeting_key' || field === 'user_id' || field === 'userId'
           next
         end
         if !(field === 'privateCustomData' || field === 'customData') && value.is_a?(Hash)

data/lib/devcycle-ruby-server-sdk/eval_hooks_runner.rb

@@ -0,0 +1,135 @@
+require 'devcycle-ruby-server-sdk/models/eval_hook'
+require 'devcycle-ruby-server-sdk/models/eval_hook_context'
+
+module DevCycle
+  # Custom error raised when a before hook fails
+  class BeforeHookError < StandardError
+    attr_reader :original_error, :hook_context
+
+    def initialize(message = nil, original_error = nil, hook_context = nil)
+      super(message || "Before hook execution failed")
+      @original_error = original_error
+      @hook_context = hook_context
+    end
+
+    def to_s
+      msg = super
+      msg += "\nOriginal error: #{@original_error.message}" if @original_error
+      msg
+    end
+  end
+
+  # Custom error raised when an after hook fails
+  class AfterHookError < StandardError
+    attr_reader :original_error, :hook_context
+
+    def initialize(message = nil, original_error = nil, hook_context = nil)
+      super(message || "After hook execution failed")
+      @original_error = original_error
+      @hook_context = hook_context
+    end
+
+    def to_s
+      msg = super
+      msg += "\nOriginal error: #{@original_error.message}" if @original_error
+      msg
+    end
+  end
+
+  class EvalHooksRunner
+    # @return [Array<EvalHook>] Array of eval hooks to run
+    attr_reader :eval_hooks
+
+    # Initializes the EvalHooksRunner with an optional array of eval hooks
+    # @param [Array<EvalHook>, nil] eval_hooks Array of eval hooks to run
+    def initialize(eval_hooks = [])
+      @eval_hooks = eval_hooks || []
+    end
+
+    # Runs all before hooks with the given context
+    # @param [HookContext] context The context to pass to the hooks
+    # @return [HookContext] The potentially modified context
+    # @raise [BeforeHookError] when a before hook fails
+    def run_before_hooks(context)
+      current_context = context
+      
+      @eval_hooks.each do |hook|
+        next unless hook.before
+
+        begin
+          result = hook.before.call(current_context)
+          # If the hook returns a new context, use it for subsequent hooks
+          current_context = result if result.is_a?(DevCycle::HookContext)
+        rescue => e
+          # Raise BeforeHookError to allow client to handle and skip after hooks
+          raise BeforeHookError.new(e.message, e, current_context)
+        end
+      end
+      
+      current_context
+    end
+
+    # Runs all after hooks with the given context
+    # @param [HookContext] context The context to pass to the hooks
+    # @return [void]
+    # @raise [AfterHookError] when an after hook fails
+    def run_after_hooks(context)
+      @eval_hooks.each do |hook|
+        next unless hook.after
+
+        begin
+          hook.after.call(context)
+        rescue => e
+          # Log error but continue with next hook
+          raise AfterHookError.new(e.message, e, context)
+        end
+      end
+    end
+
+    # Runs all finally hooks with the given context
+    # @param [HookContext] context The context to pass to the hooks
+    # @return [void]
+    def run_finally_hooks(context)
+      @eval_hooks.each do |hook|
+        next unless hook.on_finally
+
+        begin
+          hook.on_finally.call(context)
+        rescue => e
+          # Log error but don't re-raise to prevent blocking evaluation
+          warn "Error in finally hook: #{e.message}"
+        end
+      end
+    end
+
+    # Runs all error hooks with the given context and error
+    # @param [HookContext] context The context to pass to the hooks
+    # @param [Exception] error The error that occurred
+    # @return [void]
+    def run_error_hooks(context, error)
+      @eval_hooks.each do |hook|
+        next unless hook.error
+
+        begin
+          hook.error.call(context, error)
+        rescue => e
+          # Log error but don't re-raise to prevent blocking evaluation
+          warn "Error in error hook: #{e.message}"
+        end
+      end
+    end
+
+    # Adds an eval hook to the runner
+    # @param [EvalHook] eval_hook The eval hook to add
+    # @return [void]
+    def add_hook(eval_hook)
+      @eval_hooks << eval_hook
+    end
+
+    # Clears all eval hooks from the runner
+    # @return [void]
+    def clear_hooks
+      @eval_hooks.clear
+    end
+  end
+end

data/lib/devcycle-ruby-server-sdk/models/eval_hook.rb

@@ -0,0 +1,28 @@
+module DevCycle
+  class EvalHook
+    # Callback to be executed before evaluation
+    attr_accessor :before
+
+    # Callback to be executed after evaluation
+    attr_accessor :after
+
+    # Callback to be executed finally (always runs)
+    attr_accessor :on_finally
+
+    # Callback to be executed on error
+    attr_accessor :error
+
+    # Initializes the object with optional callback functions
+    # @param [Hash] callbacks Callback functions in the form of hash
+    # @option callbacks [Proc, nil] :before Callback to execute before evaluation
+    # @option callbacks [Proc, nil] :after Callback to execute after evaluation
+    # @option callbacks [Proc, nil] :on_finally Callback to execute finally (always runs)
+    # @option callbacks [Proc, nil] :error Callback to execute on error
+    def initialize(callbacks = {})
+      @before = callbacks[:before]
+      @after = callbacks[:after]
+      @on_finally = callbacks[:on_finally]
+      @error = callbacks[:error]
+    end
+  end
+end

data/lib/devcycle-ruby-server-sdk/models/eval_hook_context.rb

@@ -0,0 +1,22 @@
+module DevCycle
+  class HookContext
+    # The key of the variable being evaluated
+    attr_accessor :key
+
+    # The user for whom the variable is being evaluated
+    attr_accessor :user
+
+    # The default value for the variable
+    attr_accessor :default_value
+
+    # Initializes the object
+    # @param [String] key The key of the variable being evaluated
+    # @param [DevCycle::User] user The user for whom the variable is being evaluated
+    # @param [Object] default_value The default value for the variable
+    def initialize(key:, user:, default_value:)
+      @key = key
+      @user = user
+      @default_value = default_value
+    end
+  end
+end

data/lib/devcycle-ruby-server-sdk/version.rb

@@ -1,3 +1,3 @@
 module DevCycle
-  VERSION = '3.6.1'
+  VERSION = '3.6.2'
 end

data/lib/devcycle-ruby-server-sdk.rb

@@ -25,6 +25,11 @@ require 'devcycle-ruby-server-sdk/models/user'
 require 'devcycle-ruby-server-sdk/models/user_data_and_events_body'
 require 'devcycle-ruby-server-sdk/models/variable'
 
+# Eval Hooks
+require 'devcycle-ruby-server-sdk/eval_hooks_runner'
+require 'devcycle-ruby-server-sdk/models/eval_hook'
+require 'devcycle-ruby-server-sdk/models/eval_hook_context'
+
 # APIs
 require 'devcycle-ruby-server-sdk/api/client'
 require 'devcycle-ruby-server-sdk/api/dev_cycle_provider'

data/spec/devcycle_provider_spec.rb

@@ -4,18 +4,109 @@ require 'spec_helper'
 require 'open_feature/sdk'
 
 context 'user_from_openfeature_context' do
-  context 'user_id' do
+  context 'user_id validation' do
+    it 'raises error when no user ID fields are provided' do
+      context = OpenFeature::SDK::EvaluationContext.new(email: 'test@example.com')
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId")
+    end
+
+    it 'raises error when targeting_key is not a string' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 123)
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID field 'targeting_key' must be a string, got Integer")
+    end
+
+    it 'raises error when user_id is not a string' do
+      context = OpenFeature::SDK::EvaluationContext.new(user_id: 123)
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID field 'user_id' must be a string, got Integer")
+    end
+
+    it 'raises error when userId is not a string' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 123)
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID field 'userId' must be a string, got Integer")
+    end
+
+    it 'raises error when targeting_key is nil' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: nil)
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId")
+    end
 
-    it 'returns a user with the user_id from the context' do
-      context = OpenFeature::SDK::EvaluationContext.new(user_id: 'user_id')
+    it 'raises error when targeting_key is empty string' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: '')
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId")
+    end
+
+    it 'raises error when user_id is empty string' do
+      context = OpenFeature::SDK::EvaluationContext.new(user_id: '')
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId")
+    end
+
+    it 'raises error when userId is empty string' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: '')
+      expect {
+        DevCycle::Provider.user_from_openfeature_context(context)
+      }.to raise_error(ArgumentError, "User ID is required. Must provide one of: targeting_key, user_id, or userId")
+    end
+  end
+
+  context 'user_id fields priority' do
+    it 'returns a user with the user_id from the context when only user_id is provided' do
+      context = OpenFeature::SDK::EvaluationContext.new(user_id: 'user_id_value')
       user = DevCycle::Provider.user_from_openfeature_context(context)
-      expect(user.user_id).to eq('user_id')
+      expect(user.user_id).to eq('user_id_value')
     end
 
-    it 'returns a user with the targeting_key from the context' do
-      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key')
+    it 'returns a user with the targeting_key from the context when only targeting_key is provided' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key_value')
       user = DevCycle::Provider.user_from_openfeature_context(context)
-      expect(user.user_id).to eq('targeting_key')
+      expect(user.user_id).to eq('targeting_key_value')
+    end
+
+    it 'returns a user with the userId from the context when only userId is provided' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId_value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId_value')
+    end
+
+    it 'prioritizes targeting_key over user_id' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key_value', user_id: 'user_id_value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key_value')
+      expect(user.customData).to eq({})
+    end
+
+    it 'prioritizes targeting_key over userId' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key_value', userId: 'userId_value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key_value')
+      expect(user.customData).to eq({})
+    end
+
+    it 'prioritizes user_id over userId' do
+      context = OpenFeature::SDK::EvaluationContext.new(user_id: 'user_id_value', userId: 'userId_value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('user_id_value')
+      expect(user.customData).to eq({})
+    end
+
+    it 'prioritizes targeting_key over both user_id and userId' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key_value', user_id: 'user_id_value', userId: 'userId_value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key_value')
+      expect(user.customData).to eq({})
     end
   end
   context 'email' do
@@ -31,6 +122,19 @@ context 'user_from_openfeature_context' do
       expect(user.user_id).to eq('targeting_key')
       expect(user.email).to eq('email')
     end
+    it 'returns a user with a valid userId and email' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', email: 'email')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.email).to eq('email')
+    end
+    it 'prioritizes targeting_key over user_id with email' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key', user_id: 'user_id', email: 'email')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key')
+      expect(user.email).to eq('email')
+      expect(user.customData).to eq({})
+    end
   end
 
   context 'customData' do
@@ -40,6 +144,18 @@ context 'user_from_openfeature_context' do
       expect(user.user_id).to eq('user_id')
       expect(user.customData).to eq({ 'key' => 'value' })
     end
+    it 'returns a user with userId and customData' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', customData: { 'key' => 'value' })
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.customData).to eq({ 'key' => 'value' })
+    end
+    it 'excludes all user ID fields from customData' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key', user_id: 'user_id', userId: 'userId', customData: { 'key' => 'value' })
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key')
+      expect(user.customData).to eq({ 'key' => 'value' })
+    end
   end
 
   context 'privateCustomData' do
@@ -49,6 +165,12 @@ context 'user_from_openfeature_context' do
       expect(user.user_id).to eq('user_id')
       expect(user.privateCustomData).to eq({ 'key' => 'value' })
     end
+    it 'returns a user with userId and privateCustomData' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', privateCustomData: { 'key' => 'value' })
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.privateCustomData).to eq({ 'key' => 'value' })
+    end
   end
 
   context 'appVersion' do
@@ -65,6 +187,20 @@ context 'user_from_openfeature_context' do
       expect(user.user_id).to eq('user_id')
       expect(user.appBuild).to eq(1)
     end
+
+    it 'returns a user with userId and appVersion' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', appVersion: '1.0.0')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.appVersion).to eq('1.0.0')
+    end
+
+    it 'returns a user with userId and appBuild' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', appBuild: 1)
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.appBuild).to eq(1)
+    end
   end
   context 'randomFields' do
     it 'returns a user with customData fields mapped to any non-standard fields' do
@@ -73,6 +209,20 @@ context 'user_from_openfeature_context' do
       expect(user.user_id).to eq('user_id')
       expect(user.customData).to eq({ 'randomField' => 'value' })
     end
+
+    it 'returns a user with userId and customData fields mapped to any non-standard fields' do
+      context = OpenFeature::SDK::EvaluationContext.new(userId: 'userId', randomField: 'value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('userId')
+      expect(user.customData).to eq({ 'randomField' => 'value' })
+    end
+
+    it 'excludes all user ID fields from custom data with random fields' do
+      context = OpenFeature::SDK::EvaluationContext.new(targeting_key: 'targeting_key', user_id: 'user_id', userId: 'userId', randomField: 'value')
+      user = DevCycle::Provider.user_from_openfeature_context(context)
+      expect(user.user_id).to eq('targeting_key')
+      expect(user.customData).to eq({ 'randomField' => 'value' })
+    end
   end
 
   context 'provider' do

data/spec/eval_hooks_runner_spec.rb

@@ -0,0 +1,410 @@
+require 'spec_helper'
+require 'devcycle-ruby-server-sdk/eval_hooks_runner'
+
+describe DevCycle::EvalHooksRunner do
+  let(:test_context) { DevCycle::HookContext.new(key: 'test-key', user: 'test-user', default_value: 'test-default') }
+
+  describe 'initialization' do
+    it 'initializes with empty hooks array' do
+      runner = DevCycle::EvalHooksRunner.new
+      expect(runner.eval_hooks).to be_empty
+    end
+
+    it 'initializes with provided hooks' do
+      hook = DevCycle::EvalHook.new
+      runner = DevCycle::EvalHooksRunner.new([hook])
+      expect(runner.eval_hooks).to include(hook)
+    end
+  end
+
+  describe '#add_hook' do
+    it 'adds a hook to the runner' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new
+      
+      runner.add_hook(hook)
+      expect(runner.eval_hooks).to include(hook)
+    end
+
+    it 'can add multiple hooks' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook1 = DevCycle::EvalHook.new
+      hook2 = DevCycle::EvalHook.new
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      expect(runner.eval_hooks).to include(hook1, hook2)
+      expect(runner.eval_hooks.length).to eq(2)
+    end
+  end
+
+  describe '#clear_hooks' do
+    it 'removes all hooks from the runner' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new
+      
+      runner.add_hook(hook)
+      expect(runner.eval_hooks).not_to be_empty
+      
+      runner.clear_hooks
+      expect(runner.eval_hooks).to be_empty
+    end
+  end
+
+  describe '#run_before_hooks' do
+    it 'runs before hooks in order' do
+      execution_order = []
+      runner = DevCycle::EvalHooksRunner.new
+      
+      hook1 = DevCycle::EvalHook.new(
+        before: ->(context) {
+          execution_order << 'hook1'
+          context
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        before: ->(context) {
+          execution_order << 'hook2'
+          context
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      result = runner.run_before_hooks(test_context)
+      
+      expect(execution_order).to eq(['hook1', 'hook2'])
+      expect(result).to eq(test_context)
+    end
+
+    it 'returns modified context from before hook' do
+      runner = DevCycle::EvalHooksRunner.new
+      modified_context = DevCycle::HookContext.new(key: 'modified', user: 'modified-user', default_value: 'modified-default')
+      
+      hook = DevCycle::EvalHook.new(
+        before: ->(context) {
+          modified_context
+        }
+      )
+      
+      runner.add_hook(hook)
+      result = runner.run_before_hooks(test_context)
+      
+      expect(result).to eq(modified_context)
+    end
+
+    it 'handles hooks without before callbacks' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new # No before callback
+      
+      runner.add_hook(hook)
+      result = runner.run_before_hooks(test_context)
+      
+      expect(result).to eq(test_context)
+    end
+
+    it 'raises BeforeHookError when a before hook raises an error' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook1_called = false
+      
+      hook1 = DevCycle::EvalHook.new(
+        before: ->(context) {
+          hook1_called = true
+          raise StandardError, 'Hook 1 error'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        before: ->(context) {
+          # This should not be called because hook1 raises an error
+          context
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      expect { runner.run_before_hooks(test_context) }.to raise_error(DevCycle::BeforeHookError, /Hook 1 error/)
+      expect(hook1_called).to be true
+    end
+  end
+
+  describe '#run_after_hooks' do
+    it 'runs after hooks in order' do
+      execution_order = []
+      runner = DevCycle::EvalHooksRunner.new
+      
+      hook1 = DevCycle::EvalHook.new(
+        after: ->(context) {
+          execution_order << 'hook1'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        after: ->(context) {
+          execution_order << 'hook2'
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      runner.run_after_hooks(test_context)
+      
+      expect(execution_order).to eq(['hook1', 'hook2'])
+    end
+
+    it 'handles hooks without after callbacks' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new # No after callback
+      
+      expect { runner.run_after_hooks(test_context) }.not_to raise_error
+    end
+
+    it 'raises AfterHookError when an after hook raises an error' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook1_called = false
+      
+      hook1 = DevCycle::EvalHook.new(
+        after: ->(context) {
+          hook1_called = true
+          raise StandardError, 'Hook 1 error'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        after: ->(context) {
+          # This should not be called because hook1 raises an error
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      expect { runner.run_after_hooks(test_context) }.to raise_error(DevCycle::AfterHookError, /Hook 1 error/)
+      expect(hook1_called).to be true
+    end
+  end
+
+  describe '#run_error_hooks' do
+    it 'runs error hooks with context and error' do
+      runner = DevCycle::EvalHooksRunner.new
+      error_hook_called = false
+      received_error = nil
+      
+      hook = DevCycle::EvalHook.new(
+        error: ->(context, error) {
+          error_hook_called = true
+          received_error = error
+        }
+      )
+      
+      runner.add_hook(hook)
+      test_error = StandardError.new('Test error')
+      
+      runner.run_error_hooks(test_context, test_error)
+      
+      expect(error_hook_called).to be true
+      expect(received_error).to eq(test_error)
+    end
+
+    it 'runs multiple error hooks in order' do
+      execution_order = []
+      runner = DevCycle::EvalHooksRunner.new
+      
+      hook1 = DevCycle::EvalHook.new(
+        error: ->(context, error) {
+          execution_order << 'hook1'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        error: ->(context, error) {
+          execution_order << 'hook2'
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      test_error = StandardError.new('Test error')
+      runner.run_error_hooks(test_context, test_error)
+      
+      expect(execution_order).to eq(['hook1', 'hook2'])
+    end
+
+    it 'handles hooks without error callbacks' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new # No error callback
+      
+      test_error = StandardError.new('Test error')
+      expect { runner.run_error_hooks(test_context, test_error) }.not_to raise_error
+    end
+
+    it 'continues execution when an error hook raises an error' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook1_called = false
+      hook2_called = false
+      
+      hook1 = DevCycle::EvalHook.new(
+        error: ->(context, error) {
+          hook1_called = true
+          raise StandardError, 'Error hook error'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        error: ->(context, error) {
+          hook2_called = true
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      test_error = StandardError.new('Test error')
+      runner.run_error_hooks(test_context, test_error)
+      
+      expect(hook1_called).to be true
+      expect(hook2_called).to be true
+    end
+  end
+
+  describe '#run_finally_hooks' do
+    it 'runs finally hooks in order' do
+      execution_order = []
+      runner = DevCycle::EvalHooksRunner.new
+      
+      hook1 = DevCycle::EvalHook.new(
+        on_finally: ->(context) {
+          execution_order << 'hook1'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        on_finally: ->(context) {
+          execution_order << 'hook2'
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      runner.run_finally_hooks(test_context)
+      
+      expect(execution_order).to eq(['hook1', 'hook2'])
+    end
+
+    it 'handles hooks without finally callbacks' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook = DevCycle::EvalHook.new # No finally callback
+      
+      expect { runner.run_finally_hooks(test_context) }.not_to raise_error
+    end
+
+    it 'continues execution when a finally hook raises an error' do
+      runner = DevCycle::EvalHooksRunner.new
+      hook1_called = false
+      hook2_called = false
+      
+      hook1 = DevCycle::EvalHook.new(
+        on_finally: ->(context) {
+          hook1_called = true
+          raise StandardError, 'Finally hook error'
+        }
+      )
+      
+      hook2 = DevCycle::EvalHook.new(
+        on_finally: ->(context) {
+          hook2_called = true
+        }
+      )
+      
+      runner.add_hook(hook1)
+      runner.add_hook(hook2)
+      
+      runner.run_finally_hooks(test_context)
+      
+      expect(hook1_called).to be true
+      expect(hook2_called).to be true
+    end
+  end
+end
+
+describe DevCycle::EvalHook do
+  describe 'initialization' do
+    it 'initializes with no callbacks' do
+      hook = DevCycle::EvalHook.new
+      expect(hook.before).to be_nil
+      expect(hook.after).to be_nil
+      expect(hook.on_finally).to be_nil
+      expect(hook.error).to be_nil
+    end
+
+    it 'initializes with provided callbacks' do
+      before_callback = ->(context) { context }
+      after_callback = ->(context) { }
+      error_callback = ->(context, error) { }
+      finally_callback = ->(context) { }
+      
+      hook = DevCycle::EvalHook.new(
+        before: before_callback,
+        after: after_callback,
+        error: error_callback,
+        on_finally: finally_callback
+      )
+      
+      expect(hook.before).to eq(before_callback)
+      expect(hook.after).to eq(after_callback)
+      expect(hook.error).to eq(error_callback)
+      expect(hook.on_finally).to eq(finally_callback)
+    end
+
+    it 'initializes with partial callbacks' do
+      before_callback = ->(context) { context }
+      
+      hook = DevCycle::EvalHook.new(before: before_callback)
+      
+      expect(hook.before).to eq(before_callback)
+      expect(hook.after).to be_nil
+      expect(hook.on_finally).to be_nil
+      expect(hook.error).to be_nil
+    end
+  end
+end
+
+describe DevCycle::HookContext do
+  describe 'initialization' do
+    it 'initializes with required parameters' do
+      user = { user_id: 'test-user' }
+      context = DevCycle::HookContext.new(
+        key: 'test-key',
+        user: user,
+        default_value: 'test-default'
+      )
+      
+      expect(context.key).to eq('test-key')
+      expect(context.user).to eq(user)
+      expect(context.default_value).to eq('test-default')
+    end
+
+    it 'allows modification of attributes' do
+      context = DevCycle::HookContext.new(
+        key: 'original-key',
+        user: 'original-user',
+        default_value: 'original-default'
+      )
+      
+      context.key = 'modified-key'
+      context.user = 'modified-user'
+      context.default_value = 'modified-default'
+      
+      expect(context.key).to eq('modified-key')
+      expect(context.user).to eq('modified-user')
+      expect(context.default_value).to eq('modified-default')
+    end
+  end
+end 

data/spec/eval_hooks_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe DevCycle::Client do
+  let(:test_user) { DevCycle::User.new(user_id: 'test-user', email: 'test@example.com') }
+  let(:test_key) { 'test-variable' }
+  let(:test_default) { 'default-value' }
+  let(:options) { DevCycle::Options.new }
+  
+  # Use unique SDK keys for each test to avoid WASM initialization conflicts
+  let(:valid_sdk_key) { "server-test-key-#{SecureRandom.hex(4)}" }
+  let(:client) { DevCycle::Client.new(valid_sdk_key, options) }
+
+  after(:each) do
+    client.close if client.respond_to?(:close)
+  end
+
+  describe 'eval hooks functionality' do
+    context 'hook management' do
+      it 'initializes with an empty eval hooks runner' do
+        expect(client.instance_variable_get(:@eval_hooks_runner)).to be_a(DevCycle::EvalHooksRunner)
+        expect(client.instance_variable_get(:@eval_hooks_runner).eval_hooks).to be_empty
+      end
+
+      it 'can add eval hooks' do
+        hook = DevCycle::EvalHook.new
+        client.add_eval_hook(hook)
+        expect(client.instance_variable_get(:@eval_hooks_runner).eval_hooks).to include(hook)
+      end
+
+      it 'can clear eval hooks' do
+        hook = DevCycle::EvalHook.new
+        client.add_eval_hook(hook)
+        expect(client.instance_variable_get(:@eval_hooks_runner).eval_hooks).not_to be_empty
+        
+        client.clear_eval_hooks
+        expect(client.instance_variable_get(:@eval_hooks_runner).eval_hooks).to be_empty
+      end
+    end
+
+    context 'variable evaluation with hooks' do
+      it 'runs before hooks before variable evaluation' do
+        before_hook_called = false
+        hook = DevCycle::EvalHook.new(
+          before: ->(context) {
+            before_hook_called = true
+            expect(context.key).to eq(test_key)
+            expect(context.user).to eq(test_user)
+            expect(context.default_value).to eq(test_default)
+            context
+          }
+        )
+        client.add_eval_hook(hook)
+
+        result = client.variable(test_user, test_key, test_default)
+        expect(before_hook_called).to be true
+        expect(result.isDefaulted).to be true
+        expect(result.value).to eq(test_default)
+      end
+
+      it 'runs after hooks after successful variable evaluation' do
+        after_hook_called = false
+        hook = DevCycle::EvalHook.new(
+          after: ->(context) {
+            after_hook_called = true
+            expect(context.key).to eq(test_key)
+            expect(context.user).to eq(test_user)
+            expect(context.default_value).to eq(test_default)
+          }
+        )
+        client.add_eval_hook(hook)
+
+        result = client.variable(test_user, test_key, test_default)
+        expect(after_hook_called).to be true
+        expect(result.isDefaulted).to be true
+        expect(result.value).to eq(test_default)
+      end
+
+      it 'runs error hooks when variable evaluation fails' do
+        error_hook_called = false
+        hook = DevCycle::EvalHook.new(
+          error: ->(context, error) {
+            error_hook_called = true
+            expect(context.key).to eq(test_key)
+            expect(context.user).to eq(test_user)
+            expect(context.default_value).to eq(test_default)
+          }
+        )
+        client.add_eval_hook(hook)
+
+        # Force an error by making determine_variable_type raise an error
+        allow(client).to receive(:determine_variable_type).and_raise(StandardError, 'Variable type error')
+
+        client.variable(test_user, test_key, test_default)
+        expect(error_hook_called).to be true
+      end
+
+      it 'runs finally hooks regardless of success or failure' do
+        finally_hook_called = false
+        hook = DevCycle::EvalHook.new(
+          on_finally: ->(context) {
+            finally_hook_called = true
+            expect(context.key).to eq(test_key)
+            expect(context.user).to eq(test_user)
+            expect(context.default_value).to eq(test_default)
+          }
+        )
+        client.add_eval_hook(hook)
+
+        result = client.variable(test_user, test_key, test_default)
+        expect(finally_hook_called).to be true
+        expect(result.isDefaulted).to be true
+        expect(result.value).to eq(test_default)
+      end
+
+      it 'skips after hooks when before hook raises an error' do
+        before_hook_called = false
+        after_hook_called = false
+        error_hook_called = false
+        finally_hook_called = false
+
+        hook = DevCycle::EvalHook.new(
+          before: ->(context) {
+            before_hook_called = true
+            raise StandardError, 'Before hook error'
+          },
+          after: ->(context) {
+            after_hook_called = true
+          },
+          error: ->(context, error) {
+            error_hook_called = true
+            expect(error).to be_a(StandardError)
+            expect(error.message).to include('Before hook error')
+          },
+          on_finally: ->(context) {
+            finally_hook_called = true
+          }
+        )
+        client.add_eval_hook(hook)
+
+        client.variable(test_user, test_key, test_default)
+        expect(before_hook_called).to be true
+        expect(after_hook_called).to be false
+        expect(error_hook_called).to be true
+        expect(finally_hook_called).to be true
+      end
+
+      it 'runs multiple hooks in order' do
+        execution_order = []
+        
+        hook1 = DevCycle::EvalHook.new(
+          before: ->(context) {
+            execution_order << 'hook1_before'
+            context
+          },
+          after: ->(context) {
+            execution_order << 'hook1_after'
+          },
+          on_finally: ->(context) {
+            execution_order << 'hook1_finally'
+          }
+        )
+
+        hook2 = DevCycle::EvalHook.new(
+          before: ->(context) {
+            execution_order << 'hook2_before'
+            context
+          },
+          after: ->(context) {
+            execution_order << 'hook2_after'
+          },
+          on_finally: ->(context) {
+            execution_order << 'hook2_finally'
+          }
+        )
+
+        client.add_eval_hook(hook1)
+        client.add_eval_hook(hook2)
+
+        result = client.variable(test_user, test_key, test_default)
+        
+        expect(execution_order).to eq([
+          'hook1_before', 'hook2_before',
+          'hook1_after', 'hook2_after',
+          'hook1_finally', 'hook2_finally'
+        ])
+        expect(result.isDefaulted).to be true
+        expect(result.value).to eq(test_default)
+      end
+
+      it 'allows before hooks to modify context' do
+        modified_context = nil
+        hook = DevCycle::EvalHook.new(
+          before: ->(context) {
+            # Modify the context
+            context.key = 'modified-key'
+            context.user = DevCycle::User.new(user_id: 'modified-user', email: 'modified@example.com')
+            context
+          },
+          after: ->(context) {
+            modified_context = context
+          }
+        )
+        client.add_eval_hook(hook)
+
+        result = client.variable(test_user, test_key, test_default)
+        
+        expect(modified_context.key).to eq('modified-key')
+        expect(modified_context.user).to eq(DevCycle::User.new(user_id: 'modified-user', email: 'modified@example.com'))
+        expect(result.isDefaulted).to be true
+        expect(result.value).to eq(test_default)
+      end
+
+      it 'works with different variable types' do
+        # Test with boolean default
+        boolean_hook_called = false
+        boolean_hook = DevCycle::EvalHook.new(
+          after: ->(context) {
+            boolean_hook_called = true
+          }
+        )
+        client.add_eval_hook(boolean_hook)
+
+        boolean_result = client.variable(test_user, 'boolean-test', true)
+        expect(boolean_hook_called).to be true
+        expect(boolean_result.isDefaulted).to be true
+        expect(boolean_result.value).to eq(true)
+
+        # Test with number default
+        number_hook_called = false
+        number_hook = DevCycle::EvalHook.new(
+          after: ->(context) {
+            number_hook_called = true
+          }
+        )
+        client.add_eval_hook(number_hook)
+
+        number_result = client.variable(test_user, 'number-test', 42)
+        expect(number_hook_called).to be true
+        expect(number_result.isDefaulted).to be true
+        expect(number_result.value).to eq(42)
+      end
+
+    end
+  end
+end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: devcycle-ruby-server-sdk
 version: !ruby/object:Gem::Version
-  version: 3.6.1
+  version: 3.6.2
 platform: ruby
 authors:
 - DevCycleHQ
@@ -165,6 +165,7 @@ files:
 - lib/devcycle-ruby-server-sdk/api_client.rb
 - lib/devcycle-ruby-server-sdk/api_error.rb
 - lib/devcycle-ruby-server-sdk/configuration.rb
+- lib/devcycle-ruby-server-sdk/eval_hooks_runner.rb
 - lib/devcycle-ruby-server-sdk/localbucketing/bucketed_user_config.rb
 - lib/devcycle-ruby-server-sdk/localbucketing/bucketing-lib.release.wasm
 - lib/devcycle-ruby-server-sdk/localbucketing/config_manager.rb
@@ -179,6 +180,8 @@ files:
 - lib/devcycle-ruby-server-sdk/localbucketing/proto/variableForUserParams_pb.rb
 - lib/devcycle-ruby-server-sdk/localbucketing/update_wasm.sh
 - lib/devcycle-ruby-server-sdk/models/error_response.rb
+- lib/devcycle-ruby-server-sdk/models/eval_hook.rb
+- lib/devcycle-ruby-server-sdk/models/eval_hook_context.rb
 - lib/devcycle-ruby-server-sdk/models/event.rb
 - lib/devcycle-ruby-server-sdk/models/feature.rb
 - lib/devcycle-ruby-server-sdk/models/inline_response201.rb
@@ -190,6 +193,8 @@ files:
 - spec/api_client_spec.rb
 - spec/configuration_spec.rb
 - spec/devcycle_provider_spec.rb
+- spec/eval_hooks_runner_spec.rb
+- spec/eval_hooks_spec.rb
 - spec/spec_helper.rb
 homepage: https://devcycle.com
 licenses:
@@ -209,7 +214,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: DevCycle Bucketing API Ruby Gem
 test_files:
@@ -217,4 +222,6 @@ test_files:
 - spec/api_client_spec.rb
 - spec/configuration_spec.rb
 - spec/devcycle_provider_spec.rb
+- spec/eval_hooks_runner_spec.rb
+- spec/eval_hooks_spec.rb
 - spec/spec_helper.rb