fino-redis 1.9.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af692af92df29315432f0ba40738f8fef5ac0a3ad9eef3cc6b255e7012bb39f9
-  data.tar.gz: 54c19833f212f5010a1bc368b796a6368a0590689bc224cf0197dcfb9cb42a0c
+  metadata.gz: dd947fdfbb60faf85772aa56e55c2b083e091c1763ae9aeb1e258a74f6d070f8
+  data.tar.gz: abd69324d6697b67f6dcd7a1028f65307f5be8d7ee7829878001bddb92ba82f9
 SHA512:
-  metadata.gz: b2e018e28ad7cb6b9a677aa71706e114ba26f1948597e77af973b883f4789ed4a1dd98f640ffedaf1f479996a2cc23b7f7a63fef7d1bdaf893bcba733801b89d
-  data.tar.gz: 65952b10d45da818e6a362e1f3a474563ec24943d8721730f5bcc896388a1c8901b1edc71f8b94cf599b256c736cd6c6d6a88dc6886b556a55596207447c0633
+  metadata.gz: 5b0e4a1ab2b1c46beee78244f43aac3c90a19e7dac495e296f993ec4a8e0d2d9aeb1dc5e55d80e41d4a72169d614b80d6f6b3c985dd72db365cbe1623fdfc936
+  data.tar.gz: 4023d962fbf8642dc144ff90cb7955e456eef1e2deac72def575fc856a5a2eb6f2b2eb447a0be5fcc46f8f999e12603f27403e55d075d5b0b94f69925f3923a2

data/README.md

@@ -83,6 +83,126 @@ Fino.disable(:maintenance_mode, for: "qa")
 Fino.enabled?(:maintenance_mode, for: "qa") #=> false
 ```
 
+### Select setting
+
+The simplest way to define select setting in fino is the following
+
+```ruby
+Fino.configure do
+  # ...
+  section :storefront, label: "Storefront" do
+    setting :purchase_button_color,
+            :select,
+            options: [
+              Fino::Settings::Select::Option.new(label: "Red", value: "red"),
+              Fino::Settings::Select::Option.new(label: "Blue", value: "blue")
+            ],
+            default: "red",
+            description: "Color of the purchase button"
+  end
+  # ...
+end
+```
+
+Options must be an array of `Fino::Settings::Select::Option` instances
+
+Then you can interact with the setting like that
+
+```ruby
+# Read selected option
+selected_option = Fino.value(:purchase_button_color, at: :storefront)
+# => #<Fino::Settings::Select::Option:0x0000000124fecd90 @label="Red", @metadata={}, @value="red">
+
+# Read setting value
+selected_option.value
+# => "red"
+
+# Read options
+Fino.setting(:purchase_button_color, at: :storefront).options
+# => [#<Fino::Settings::Select::Option:0x0000000124fecd90 @label="Red", @metadata={}, @value="red">,
+      #<Fino::Settings::Select::Option:0x0000000124fecca0 @label="Blue", @metadata={}, @value="blue">]
+```
+
+#### Dynamic option
+
+Options can also be defined dynamically using any callable object. Let's take a look at dynamic options in an example
+of LLM model setting using [RubyLLM](https://github.com/crmne/ruby_llm) by @crmne
+
+To define dynamic select options, use `:select` as setting type and provide a callable to `options`. Your object's
+`call` method might be called with `refresh` option which is true only when user initiates options refresh manually.
+This is useful for updating models list in RubyLLM for example
+
+```ruby
+section :llm, label: "LLM" do
+  setting :model,
+          :select,
+          options: proc { |refresh:|
+            RubyLLM.models.refresh! if refresh
+            models = RubyLLM.models.chat_models
+
+            openai_models = models.by_provider(:openai)
+            anthropic_models = models.by_provider(:anthropic)
+
+            build_pricing_label = proc do |model|
+              text_pricing = model.pricing&.text_tokens
+              next unless text_pricing && text_pricing.input && text_pricing.output
+
+              "$#{text_pricing.input} / $#{text_pricing.output} per 1M tokens"
+            end
+
+            [*openai_models, *anthropic_models].map do |model|
+              Fino::Settings::Select::Option.new(
+                label: model.name,
+                value: model.id,
+                metadata: {
+                  provider: model.provider_class.name,
+                  pricing: build_pricing_label.call(model)
+                }.compact
+              )
+            end
+          },
+          default: "gpt-5",
+          description: "Chat model for AI-powered features"
+  end
+end
+```
+
+```ruby
+# Read selected option
+selected_option = Fino.setting(:model, at: :llm).value
+# => #<Fino::Settings::Select::Option:0x0000000126257728
+#     @label="GPT-4",
+#     @metadata={provider: "OpenAI", pricing: "$30 / $60 per 1M tokens"},
+#     @value="gpt-4">
+
+# Read setting value
+selected_option.value
+# => "gpt-4"
+
+# Read options
+Fino.setting(:model, at: :llm).options
+# => [#<Fino::Settings::Select::Option:0x000000012629e448
+#      @label="GPT-5.3 Codex Spark",
+#      @metadata={provider: "OpenAI", pricing: "$1.75 / $14 per 1M tokens"},
+#      @value="gpt-5.3-codex-spark">,
+#     #<Fino::Settings::Select::Option:0x000000012629e1c8
+#      @label="GPT-5.4",
+#      @metadata={provider: "OpenAI", pricing: "$2.5 / $15 per 1M tokens"},
+#      @value="gpt-5.4">, ...]
+
+# Refresh options
+Fino.setting(:model, at: :llm).refresh!
+# I, [2026-03-22T18:23:13.615270 #67293]  INFO -- RubyLLM: Fetching models from providers:
+# I, [2026-03-22T18:23:13.615934 #67293]  INFO -- RubyLLM: Fetching models from models.dev API...
+```
+
+#### Use with RubyLLM
+
+```ruby
+chat = RubyLLM.chat(model: Fino.setting(:model, at: :llm).value)
+chat.ask "Why Ruby?"
+```
+
 ### Overrides
 
 ```ruby
@@ -116,6 +236,44 @@ Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
 Fino.value(:model, at: :openai, for: "user_2") #=> "gpt-5"
 ```
 
+#### Experiment analysis
+
+Fino adapters might support A/B testing analysis, both built-in `solid` and `redis` adapters do
+
+When you run an A/B test for a setting, fino automatically calculates variant based on a stable identifier you pass as
+a `for` option
+
+```ruby
+Fino.set(model: "gpt-5", at: :openai, variants: { 20.0 => "gpt-6" })
+
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+Fino.value(:model, at: :openai, for: "user_1") #=> "gpt-6"
+
+Fino.value(:model, at: :openai, for: "user_2") #=> "gpt-5"
+```
+
+Later in your code, when user performs a "desired" action, simply call
+
+```ruby
+Fino.convert!(:model, at: :openai, for: "user_2")
+```
+
+to record a "convertion" for `user_2`. As Fino knows the right variant for `user_2`, conversion will be counted
+todards it. Thanks to that later you'll be able to call
+
+```ruby
+Fino.analyse(:model, at: :openai)
+```
+
+to receive a detailed report over variants performance. Also bar charts comparing all variants and a chart displaying
+amount of conversions over time per variant will be accessible on UI with `fino-rails`
+
+To reset analysis data for an experiment:
+
+```ruby
+Fino.reset_analysis!(:model, at: :openai)
+```
+
 ### Unit conversion
 
 Fino is able to convert numeric settings into various units
@@ -258,6 +416,14 @@ end
    end
    ```
 
+## Development
+
+To create and mugrate dummy app db to test solid adapter, do
+
+```bash
+cd spec/dummy && bin/rails db:create db:migrate
+```
+
 ## Releasing
 
 `rake release`

data/lib/fino/redis/adapter.rb

@@ -7,6 +7,9 @@ class Fino::Redis::Adapter
 
   DEFAULT_REDIS_NAMESPACE = "fino"
   SETTINGS_NAMESPACE = "s"
+  CONVERSIONS_NAMESPACE = "c"
+  CONVERSIONS_KEYS_NAMESPACE = "ck"
+  CONVERSIONS_TTL = 7 * 24 * 60 * 60 # 7 days
   PERSISTED_SETTINGS_KEYS_REDIS_KEY = "psl"
   SCOPE_PREFIX = "s"
   VARIANT_PREFIX = "v"
@@ -30,7 +33,7 @@ class Fino::Redis::Adapter
   end
 
   def write(setting_definition, value, overrides, variants)
-    serialize_value = ->(raw_value) { setting_definition.type_class.serialize(raw_value) }
+    serialize_value = ->(raw_value) { setting_definition.serialize(raw_value) }
 
     hash = { VALUE_KEY => serialize_value.call(value) }
 
@@ -86,6 +89,44 @@ class Fino::Redis::Adapter
     end
   end
 
+  #
+  # A/B testing analysis
+  #
+
+  def record_ab_testing_conversion(setting_definition, variant, scope, time)
+    timestamp_ms = (time.to_f * 1000).to_i
+
+    key = build_redis_key(CONVERSIONS_NAMESPACE, setting_definition.key, variant.id)
+    tracking_key = build_redis_key(CONVERSIONS_KEYS_NAMESPACE, setting_definition.key)
+
+    redis.pipelined do |pipeline|
+      pipeline.zadd(key, timestamp_ms, scope.to_s, nx: true)
+      pipeline.expire(key, CONVERSIONS_TTL)
+      pipeline.sadd(tracking_key, key)
+    end
+  end
+
+  def read_ab_testing_conversions(setting_definition, variants)
+    keys = variants.map { |v| build_redis_key(CONVERSIONS_NAMESPACE, setting_definition.key, v.id) }
+
+    results = redis.pipelined do |pipeline|
+      keys.each { |key| pipeline.zrange(key, 0, -1, withscores: true) }
+    end
+
+    variants.zip(results).to_h
+  end
+
+  def clear_ab_testing_conversions(setting_key)
+    tracking_key = build_redis_key(CONVERSIONS_KEYS_NAMESPACE, setting_key)
+    keys = redis.smembers(tracking_key)
+    return unless keys.any?
+
+    redis.pipelined do |pipeline|
+      keys.each { |key| pipeline.del(key) }
+      pipeline.del(tracking_key)
+    end
+  end
+
   private
 
   attr_reader :redis, :redis_namespace

data/lib/fino/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Fino
-  VERSION = "1.9.1"
+  VERSION = "1.11.0"
   REQUIRED_RUBY_VERSION = ">= 3.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fino-redis
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Egor Iskrenkov
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.1
+        version: 1.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.1
+        version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement