testlab_sdk_ruby 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b7e084eaecf8e5963ba3977a3b23e4618b0780a51f804b679f7663003a954f45
+  data.tar.gz: be0d11c361c5076c6f0fb24753a733003cd7cb08df2e5a5b1faca1627894f76d
+SHA512:
+  metadata.gz: 6e1e42b99883f208f8a580fb58e709f067104f4646a59a8aba25492cf3a616b376c785ac4907f30cf171165564b24c161133a2ba8a4c5cb09146a181016fd141
+  data.tar.gz: 0c78c3018c22f8d81c0cd8818c74ba47806aabf5a59612816414c1e1667def427bb232afeea70b6cbd0cb59ad33517236cedc008a1c500812fe1a63c6caa6e03

data/lib/testlab_sdk_ruby/testlab_client.rb

@@ -0,0 +1,140 @@
+require "testlab_sdk_ruby/testlab_feature_logic"
+require "securerandom" # uuid = SecureRandom.uuid
+require "httparty"
+require "rufus-scheduler"
+
+class Client
+  attr_accessor :config, :context, :features
+
+  def initialize(config)
+    @config = config
+    @context = nil
+    @features = {}
+  end
+
+  def add_default_context
+    self.context = { user_id: SecureRandom.uuid, ip: get_ip }
+  end
+
+  def update_context(new_context)
+    self.context = context.merge(new_context)
+  end
+
+  def get_ip
+    response = HTTParty.get("https://ipapi.co/json/")
+    response.parsed_response["ip"]
+  end
+
+  def get_feature_value(name)
+    feature = @features.find { |f| f["name"] == name }
+    return false unless feature
+
+    if feature["type_id"] != 3
+      return is_enabled(features, name, context[:user_id])
+    else
+      enabled = is_enabled(features, name, context[:user_id])
+      # return false unless enabled
+      variant = get_variant(features, name, context[:user_id])
+      users = get_users
+      existing_user =
+        users.find do |user|
+          user["id"] == context[:user_id] && user["variant_id"] == variant["id"]
+        end
+      if enabled && variant && !existing_user
+        create_user(context[:user_id], variant["id"], context[:ip])
+      end
+      enabled && variant
+    end
+  end
+
+  def get_features
+    url = "#{config[:server_address]}/api/feature"
+    response = HTTParty.get(url)
+    self.features = response.parsed_response
+  end
+
+  def timed_fetch(interval)
+    if interval > 0
+      scheduler = Rufus::Scheduler.new
+      scheduler.every "#{interval}.s" do
+        fetch_features
+      end
+      Thread.new { scheduler.join }
+    end
+  end
+
+  def fetch_features
+    url = "#{config[:server_address]}/api/feature"
+    last_modified = Time.now - config[:interval]
+
+    response =
+      HTTParty.get(
+        url,
+        options: {
+          headers: {
+            "If-Modified-Since" => last_modified.rfc2822,
+          },
+        },
+      )
+    puts response.parsed_response
+    self.features = response.parsed_response if response.code == 200
+  end
+
+  def get_users
+    url = "#{config[:server_address]}/api/users"
+    response = HTTParty.get(url)
+    response.parsed_response
+  end
+
+  def create_user(id, variant_id, ip_address)
+    url = "#{config[:server_address]}/api/users"
+
+    response =
+      HTTParty.post(
+        url,
+        {
+          body: {
+            id: id,
+            variant_id: variant_id,
+            ip_address: ip_address,
+          }.to_json,
+          headers: {
+            "Content-Type" => "application/json",
+          },
+        },
+      )
+    if response.code == 200
+      return response.parsed_response
+    else
+      puts "Error creating user: #{response.body}"
+      return response.parsed_response
+    end
+  end
+
+  def create_event(variant_id, user_id)
+    url = "#{config[:server_address]}/api/events"
+
+    response =
+      HTTParty.post(
+        url,
+        {
+          body: { variant_id: variant_id, user_id: user_id }.to_json,
+          headers: {
+            "Content-Type" => "application/json",
+          },
+        },
+      )
+    if response.code == 200
+      return response.parsed_response
+    else
+      puts "Error creating user: #{response.body}"
+      return response.parsed_response
+    end
+  end
+end
+
+# myClient = Client.new({ server_address: "http://localhost:3000", interval: 10 })
+# myClient.add_default_context
+# myClient.get_features
+# puts myClient.context[:user_id]
+# puts myClient.get_feature_value("new_experiment")

data/lib/testlab_sdk_ruby/testlab_feature_logic.rb

@@ -0,0 +1,88 @@
+def hash_message(message)
+  hash = 0
+  message.each_char do |c|
+    hash = (hash << 5) - hash + c.ord
+    hash &= 0xFFFFFFFF # Convert to 32-bit integer
+  end
+  (hash.to_f / 2**32).abs # Scale to [0, 1]
+end
+
+def is_active?(start_date, end_date)
+  current_date = DateTime.now
+  current_date >= start_date && current_date <= end_date
+end
+
+def is_enabled(features, name, user_id)
+  # Find target feature based on name
+  feature = features.find { |f| f["name"] == name }
+  raise TypeError, "Provided name does not match any feature." if feature.nil?
+
+  # Return false if current date is outside of date range for feature
+  start_date = DateTime.parse(feature["start_date"])
+  end_date = DateTime.parse(feature["end_date"])
+
+  return false unless is_active?(start_date, end_date)
+
+  # Return false if feature is not running (toggled off) or if the hashed ID is outside of the target user_percentage range
+  # For Type 3 (features), users can only be assigned to one feature (total percentage of users enrolled in features can not exceed 100%)
+
+  case feature["type_id"]
+  when 1
+    feature["is_running"]
+  when 2
+    hashed_id = hash_message(user_id + name)
+    feature["is_running"] && hashed_id < feature["user_percentage"]
+  when 3
+    hashed_id = hash_message(user_id)
+    type_3_features =
+      features.filter do |f|
+        f["type_id"] == 3 &&
+          is_active?(
+            DateTime.parse(f["start_date"]),
+            DateTime.parse(f["end_date"]),
+          )
+      end
+    segment_start = 0
+    segment_end = 0
+
+    type_3_features.each do |exp|
+      segment_end += exp["user_percentage"]
+      if hashed_id >= segment_start && hashed_id <= segment_end &&
+           exp["name"] == name
+        return true
+      else
+        segment_start = segment_end
+      end
+    end
+  end
+
+  false
+end
+
+def get_variant(features, name, user_id)
+  hashed_id = hash_message(user_id)
+  puts "uuid, hashed #{user_id}, #{hashed_id}"
+
+  feature = features.find { |f| f["name"] == name }
+  raise TypeError, "Provided name does not match any feature." unless feature
+
+  variants = feature["variant_arr"]
+  type3features = features.select { |f| f["type_id"] == 3 }
+  segment_start, segment_end = 0, 0
+
+  type3features.each do |exp|
+    segment_end += exp["user_percentage"]
+    if hashed_id >= segment_start && hashed_id <= segment_end &&
+         exp["name"] == name
+      running_total = segment_start
+      variants.each do |variant|
+        running_total += variant["weight"].to_f * variant["weight"].to_f
+        return variant if hashed_id <= running_total
+      end
+    else
+      segment_start = segment_end
+    end
+  end
+
+  return false
+end

data/lib/testlab_sdk_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TestlabSdkRuby
+  VERSION = "0.2.0"
+end

data/lib/testlab_sdk_ruby.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "testlab_sdk_ruby/version"
+
+require "testlab_sdk_ruby/testlab_client"
+
+class Config
+  def initialize(server_address, interval)
+    @server_address = server_address
+    @interval = interval
+  end
+
+  def connect
+    client =
+      Client.new({ server_address: @server_address, interval: @interval })
+    client.get_features
+    client.add_default_context
+    client.timed_fetch(@interval)
+    client
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: testlab_sdk_ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alison Martinez
+- Chelsea Saunders
+- Sarah Bunker
+- Abbie Papka
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/testlab_sdk_ruby.rb
+- lib/testlab_sdk_ruby/testlab_client.rb
+- lib/testlab_sdk_ruby/testlab_feature_logic.rb
+- lib/testlab_sdk_ruby/version.rb
+homepage: https://github.com/TestL-ab
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Client SDK for accessing TestLab A/B testing platform
+test_files: []