devcycle-ruby-server-sdk 1.2.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b37103165cc47272d718527f01a20fd41e5a4fa851329a1b9ae472d04c561e87
-  data.tar.gz: dc33b920301e236e1f4829c3c5b2bfa811c4c7649146d59719aefb81111bded1
+  metadata.gz: fc0fd57c7d492253c2a5aed803845d028057f5075f33ed40b7cd31d6862bd7b2
+  data.tar.gz: 3cf436a16d4ae282192e77687fccaf17d3346b1facb364a26f4ae932ed658140
 SHA512:
-  metadata.gz: bd9a35095127bfd7e51a9af0894b7d0244e9d8f494566a85b95b71179c1090f79cf4d757d427a98553aaccbc90bbcb1cd8606f0001b3b09f36dedc3629286588
-  data.tar.gz: 5ca612fe98bad4539f5b5d87ac1b3512d0eca2fbb285a3482d5675c1b4cfd52643bd94ff3dbebca585cf5f288e8bb08d7bee5ccee869b45d27e44c08bd472116
+  metadata.gz: 8e463d4849b50cfd4a346e252909d968f2a41ed31e3bac91de33ad968ecca3afd0ceefb1243cb3326049853894502f8979cd8574fa81bc12cbc9cf66ea34edfb
+  data.tar.gz: f9467f2c7ad852e18b9de9bba1a96a73b55febe9ab25d64571e09e19ab9dac394a965d543f77c3aed44a4a1719368c677151d016ca8ba0c0772d2592a78489cf

data/Gemfile

@@ -1,8 +1,14 @@
 source 'https://rubygems.org'
 
 gemspec
+gem 'sorbet-runtime'
+gem 'oj'
+gem 'wasmtime'
+gem 'concurrent-ruby'
 
 group :development, :test do
+  gem 'sorbet'
+  gem 'tapioca', require: false
   gem 'rake', '~> 13.0.1'
   gem 'pry-byebug'
   gem 'rubocop', '~> 0.66.0'

data/devcycle-ruby-server-sdk.gemspec

@@ -24,10 +24,18 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.4"
 
   s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1'
+  s.add_runtime_dependency 'wasmtime', '5.0.0'
+  s.add_runtime_dependency 'concurrent-ruby', '1.2.0'
+  s.add_runtime_dependency 'sorbet-runtime', '0.5.10648'
+  s.add_runtime_dependency 'oj', '3.13.2'
+
 
   s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
 
-  s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+  s.files         = Dir['README.md', 'LICENSE',
+                        'lib/**/*',
+                        'devcycle-ruby-server-sdk.gemspec',
+                        'Gemfile']
   s.test_files    = `find spec/*`.split("\n")
   s.executables   = []
   s.require_paths = ["lib"]

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

@@ -11,13 +11,58 @@ OpenAPI Generator version: 5.3.0
 =end
 
 require 'cgi'
+require 'logger'
 
 module DevCycle
   class DVCClient
-    attr_accessor :api_client
+    def initialize(sdkKey, dvc_options = DVCOptions.new, wait_for_init = false)
+      if sdkKey.nil?
+        raise ArgumentError('Missing SDK key!')
+      elsif !sdkKey.start_with?('server') && !sdkKey.start_with?('dvc_server')
+        raise ArgumentError('Invalid SDK key!')
+      end
+
+      @sdkKey = sdkKey
+      @dvc_options = dvc_options
+      @logger = dvc_options.logger
+
+      if @dvc_options.enable_cloud_bucketing
+        @api_client = ApiClient.default
+        @api_client.config.api_key['bearerAuth'] = @sdkKey
+        @api_client.config.enable_edge_db = @dvc_options.enable_edge_db
+        @api_client.config.logger = @logger
+      else
+        @localbucketing = LocalBucketing.new(@sdkKey, dvc_options, wait_for_init)
+        @event_queue = EventQueue.new(@sdkKey, dvc_options.event_queue_options, @localbucketing)
+      end
+    end
+
+    def close
+      if @dvc_options.enable_cloud_bucketing
+        @logger.info("Cloud Bucketing does not require closing.")
+        return
+      end
+      if @localbucketing != nil
+        if !@localbucketing.initialized
+          @logger.info("Awaiting client initialization before closing")
+          while !@localbucketing.initialized
+            sleep(0.5)
+          end
+        end
+        @localbucketing.close
+        @localbucketing = nil
+        @logger.info("Closed DevCycle Local Bucketing Engine.")
+      end
+
+      @event_queue.close
+      @logger.info("Closed DevCycle Client.")
+    end
 
-    def initialize(api_client = ApiClient.default)
-      @api_client = api_client
+    def set_client_custom_data(customdata)
+      if @api_client.config.enable_cloud_bucketing
+        fail ArgumentError("Client Custom Data is only available in Local bucketing mode.")
+      end
+      @localbucketing.set_client_custom_data(customdata)
     end
 
     def validate_model(model)
@@ -36,8 +81,17 @@ module DevCycle
 
       validate_model(user_data)
 
-      data, _status_code, _headers = all_features_with_http_info(user_data, opts)
-      data
+      if @dvc_options.enable_cloud_bucketing
+        data, _status_code, _headers = all_features_with_http_info(user_data, opts)
+        return data
+      end
+
+      if local_bucketing_initialized?
+        bucketed_config = @localbucketing.generate_bucketed_config(user_data)
+        bucketed_config.features
+      else
+        {}
+      end
     end
 
     # Get all features by key for user data
@@ -65,14 +119,14 @@ module DevCycle
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(user_data)
+      post_body = opts[:debug_body] || user_data.to_json
 
       # return_type
       return_type = opts[:debug_return_type] || 'Hash<String, Feature>'
@@ -110,8 +164,36 @@ module DevCycle
 
       validate_model(user_data)
 
-      data, _status_code, _headers = variable_with_http_info(key, user_data, default, opts)
-      data
+      if @dvc_options.enable_cloud_bucketing
+        data, _status_code, _headers = variable_with_http_info(key, user_data, default, opts)
+        return data
+      end
+
+      if local_bucketing_initialized?
+        bucketed_config = @localbucketing.generate_bucketed_config(user_data)
+        variable_json = bucketed_config.variables[key]
+        if variable_json == nil
+          variable_event = Event.new({ type: DevCycle::EventTypes[:agg_variable_defaulted], target: key })
+          @event_queue.queue_aggregate_event(variable_event, bucketed_config)
+
+          return Variable.new({ key: key, value: default, isDefaulted: true })
+        end
+
+        variable_event = Event.new({ type: DevCycle::EventTypes[:agg_variable_evaluated], target: key })
+        @event_queue.queue_aggregate_event(variable_event, bucketed_config)
+
+        Variable.new({
+                       key: key,
+                       type: variable_json['type'],
+                       value: variable_json['value'],
+                       isDefaulted: false
+                     })
+      else
+        variable_event = Event.new({ type: DevCycle::EventTypes[:agg_variable_defaulted], target: key })
+        @event_queue.queue_aggregate_event(variable_event, bucketed_config)
+
+        Variable.new({ key: key, value: default, isDefaulted: true })
+      end
     end
 
     # Get variable by key for user data
@@ -145,14 +227,14 @@ module DevCycle
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(user_data)
+      post_body = opts[:debug_body] || user_data.to_json
 
       # return_type
       return_type = opts[:debug_return_type] || 'Variable'
@@ -196,8 +278,17 @@ module DevCycle
 
       validate_model(user_data)
 
-      data, _status_code, _headers = all_variables_with_http_info(user_data, opts)
-      data
+      if @dvc_options.enable_cloud_bucketing
+        data, _status_code, _headers = all_variables_with_http_info(user_data, opts)
+        return data
+      end
+
+      if local_bucketing_initialized?
+        bucketed_config = @localbucketing.generate_bucketed_config(user_data)
+        bucketed_config.variables
+      else
+        {}
+      end
     end
 
     # Get all variables by key for user data
@@ -225,14 +316,14 @@ module DevCycle
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(user_data)
+      post_body = opts[:debug_body] || user_data.to_json
 
       # return_type
       return_type = opts[:debug_return_type] || 'Hash<String, Variable>'
@@ -275,8 +366,16 @@ module DevCycle
 
       validate_model(event_data)
 
-      data, _status_code, _headers = track_with_http_info(user_data, event_data, opts)
-      data
+      if @dvc_options.enable_cloud_bucketing
+        track_with_http_info(user_data, event_data, opts)
+        return
+      end
+
+      if local_bucketing_initialized?
+        @event_queue.queue_event(user_data, event_data)
+      else
+        @logger.warn('track called before DVCClient initialized, event will not be tracked')
+      end
     end
 
     # Post events to DevCycle for user
@@ -294,9 +393,9 @@ module DevCycle
       end
 
       user_data_and_events_body = DevCycle::UserDataAndEventsBody.new({
-        user: user_data,
-        events: [event_data]
-      })
+                                                                        user: user_data,
+                                                                        events: [event_data]
+                                                                      })
 
       # resource path
       local_var_path = '/v1/track'
@@ -311,7 +410,7 @@ module DevCycle
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
 
       # form parameters
@@ -345,5 +444,13 @@ module DevCycle
       end
       return data, status_code, headers
     end
+
+    def flush_events
+      @event_queue.flush_events
+    end
+
+    def local_bucketing_initialized?
+      !@localbucketing.nil? && @localbucketing.initialized
+    end
   end
 end

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

@@ -31,7 +31,7 @@ module DevCycle
     # @option config [Configuration] Configuration for initializing the object, default to Configuration.default
     def initialize(config = Configuration.default)
       @config = config
-      @user_agent = "OpenAPI-Generator/#{VERSION}/ruby"
+      @user_agent = "DevCycle-Ruby:#{VERSION}"
       @default_headers = {
         'Content-Type' => 'application/json',
         'User-Agent' => @user_agent

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

@@ -137,9 +137,9 @@ module DevCycle
 
     attr_accessor :force_ending_format
 
-   # Define if EdgeDB is Enabled (Boolean)
-   # Default to false
-   attr_accessor :enable_edge_db
+    # Define if EdgeDB is Enabled (Boolean)
+    # Default to false
+    attr_accessor :enable_edge_db
 
     def initialize
       @scheme = 'https'
@@ -169,7 +169,7 @@ module DevCycle
 
     # The default Configuration object.
     def self.default
-      @@default ||= Configuration.new
+      @default ||= Configuration.new
     end
 
     def configure
@@ -280,7 +280,7 @@ module DevCycle
     end
 
     def enable_edge_db=(enable_edge_db = false)
-      if(enable_edge_db)
+      if (enable_edge_db)
         @enable_edge_db = true
       end
     end

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

@@ -0,0 +1,21 @@
+module DevCycle
+  class BucketedUserConfig
+    attr_accessor :project
+    attr_accessor :environment
+    attr_accessor :features
+    attr_accessor :feature_variation_map
+    attr_accessor :variable_variation_map
+    attr_accessor :variables
+    attr_accessor :known_variable_keys
+
+    def initialize(project, environment, features, feature_var_map, variable_var_map, variables, known_variable_keys)
+      @project = project
+      @environment = environment
+      @features = features
+      @feature_variation_map = feature_var_map
+      @variable_variation_map = variable_var_map
+      @variables = variables
+      @known_variable_keys = known_variable_keys
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'concurrent-ruby'
+require 'typhoeus'
+require 'json'
+
+module DevCycle
+  class ConfigManager
+    extend T::Sig
+    sig { params(
+      sdkKey: String,
+      local_bucketing: LocalBucketing,
+      wait_for_init: T::Boolean
+    ).void }
+    def initialize(sdkKey, local_bucketing, wait_for_init)
+      @first_load = true
+      @config_version = "v1"
+      @local_bucketing = local_bucketing
+      @sdkKey = sdkKey
+      @config_e_tag = ""
+      @logger = local_bucketing.options.logger
+
+      @config_poller = Concurrent::TimerTask.new(
+        {
+          execution_interval: @local_bucketing.options.config_polling_interval_ms.fdiv(1000),
+          run_now: true
+        }) do |task|
+        fetch_config(false, task)
+      end
+
+      t = Thread.new { fetch_config(false, nil) }
+      t.join if wait_for_init
+    end
+
+    def fetch_config(retrying, task)
+      req = Typhoeus::Request.new(
+        get_config_url,
+        headers: {
+          Accept: "application/json",
+        })
+
+      if @config_e_tag != ""
+        req.options[:headers]['If-None-Match'] = @config_e_tag
+      end
+
+      resp = req.run
+
+      case resp.code
+      when 304
+        return nil
+      when 200
+        return set_config(resp.body, resp.headers['Etag'])
+      when 403
+        raise("Failed to download DevCycle config; Invalid SDK Key.")
+      when 500...599
+        if !retrying
+          return fetch_config(true, task)
+        end
+        @logger.warn("Failed to download DevCycle config. Status: #{resp.code}")
+      else
+        if task != nil
+          task.shutdown
+        end
+        raise("Unexpected response code - DevCycle Response: #{Oj.dump(resp)}")
+      end
+
+      nil
+    end
+
+    def set_config(config, etag)
+      if !JSON.parse(config).is_a?(Hash)
+        raise("Invalid JSON body parsed from Config Response")
+      end
+
+      @local_bucketing.store_config(@sdkKey, config)
+      @config_e_tag = etag
+
+      if @first_load
+        @logger.info("Config Set. Client Initialized.")
+        @first_load = false
+        @local_bucketing.initialized = true
+        @config_poller.execute
+      end
+    end
+
+    def get_config_url
+      configBasePath = @local_bucketing.options.config_cdn_uri
+      "#{configBasePath}/config/#{@config_version}/server/#{@sdkKey}.json"
+    end
+
+    def close
+      @config_poller.shutdown
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+require 'oj'
+
+module DevCycle
+  class DVCOptions
+    attr_reader :config_polling_interval_ms
+    attr_reader :enable_edge_db
+    attr_reader :enable_cloud_bucketing
+    attr_reader :config_cdn_uri
+    attr_reader :events_api_uri
+    attr_reader :bucketing_api_uri
+    attr_reader :logger
+
+    def initialize(
+      enable_cloud_bucketing: false,
+      event_flush_interval_ms: 10 * 1000,
+      disable_custom_event_logging: false,
+      disable_automatic_event_logging: false,
+      config_polling_interval_ms: 10000,
+      request_timeout_ms: 5000,
+      max_event_queue_size: 2000,
+      flush_event_queue_size: 1000,
+      event_request_chunk_size: 100,
+      logger: nil,
+      events_api_uri: 'https://events.devcycle.com',
+      enable_edge_db: false
+    )
+      @logger = logger || defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      @enable_cloud_bucketing = enable_cloud_bucketing
+
+      @enable_edge_db = enable_edge_db
+
+      if !@enable_cloud_bucketing && @enable_edge_db
+        raise ArgumentError.new('Cannot enable edgedb without enabling cloud bucketing.')
+      end
+
+      if config_polling_interval_ms < 1000
+        @logger.warn('config_polling_interval cannot be less than 1000ms, defaulting to 10000ms')
+        config_polling_interval_ms = 10000
+      end
+      @config_polling_interval_ms = config_polling_interval_ms
+
+      if request_timeout_ms <= 5000
+        request_timeout_ms = 5000
+      end
+      @request_timeout_ms = request_timeout_ms
+
+
+      if event_flush_interval_ms < 500 || event_flush_interval_ms > (60 * 1000)
+        raise ArgumentError.new('event_flush_interval_ms must be between 500ms and 1 minute')
+      end
+      @event_flush_interval_ms = event_flush_interval_ms
+
+      if flush_event_queue_size >= max_event_queue_size
+        raise ArgumentError.new("flush_event_queue_size: #{flush_event_queue_size} must be " +
+          "smaller than max_event_queue_size: #{@max_event_queue_size}")
+      elsif flush_event_queue_size < event_request_chunk_size || max_event_queue_size < event_request_chunk_size
+        throw ArgumentError.new("flush_event_queue_size: #{flush_event_queue_size} and " +
+          "max_event_queue_size: #{max_event_queue_size} " +
+          "must be larger than event_request_chunk_size: #{event_request_chunk_size}")
+      elsif flush_event_queue_size > 20000 || max_event_queue_size > 20000
+        raise ArgumentError.new("flush_event_queue_size: #{flush_event_queue_size} or " +
+          "max_event_queue_size: #{max_event_queue_size} must be smaller than 20,000")
+      end
+      @flush_event_queue_size = flush_event_queue_size
+      @max_event_queue_size = max_event_queue_size
+      @event_request_chunk_size = event_request_chunk_size
+
+      @disable_custom_event_logging = disable_custom_event_logging
+      @disable_automatic_event_logging = disable_automatic_event_logging
+      @config_cdn_uri = "https://config-cdn.devcycle.com"
+      @events_api_uri = events_api_uri
+      @bucketing_api_uri = "https://bucketing-api.devcyle.com"
+    end
+
+    def event_queue_options
+      EventQueueOptions.new(
+        @event_flush_interval_ms,
+        @disable_automatic_event_logging,
+        @disable_custom_event_logging,
+        @max_event_queue_size,
+        @flush_event_queue_size,
+        @events_api_uri,
+        @event_request_chunk_size,
+        @logger
+      )
+    end
+  end
+
+  class EventQueueOptions
+    attr_reader :event_flush_interval_ms
+    attr_reader :disable_automatic_event_logging
+    attr_reader :disable_custom_event_logging
+    attr_reader :max_event_queue_size
+    attr_reader :flush_event_queue_size
+    attr_reader :events_api_uri
+    attr_reader :event_request_chunk_size
+    attr_reader :logger
+
+    def initialize (
+      event_flush_interval_ms,
+      disable_automatic_event_logging,
+      disable_custom_event_logging,
+      max_event_queue_size,
+      flush_event_queue_size,
+      events_api_uri,
+      event_request_chunk_size,
+      logger
+    )
+      @event_flush_interval_ms = event_flush_interval_ms
+      @disable_automatic_event_logging = disable_automatic_event_logging
+      @disable_custom_event_logging = disable_custom_event_logging
+      @max_event_queue_size = max_event_queue_size
+      @flush_event_queue_size = flush_event_queue_size
+      @events_api_uri = events_api_uri
+      @event_request_chunk_size = event_request_chunk_size
+      @logger = logger
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+require 'typhoeus'
+require 'sorbet-runtime'
+require 'concurrent-ruby'
+
+module DevCycle
+  class EventQueue
+    extend T::Sig
+
+    sig { params(sdkKey: String, options: EventQueueOptions, local_bucketing: LocalBucketing).void }
+    def initialize(sdkKey, options, local_bucketing)
+      @sdkKey = sdkKey
+      @events_api_uri = options.events_api_uri
+      @logger = options.logger
+      @event_flush_interval_ms = options.event_flush_interval_ms
+      @flush_event_queue_size = options.flush_event_queue_size
+      @max_event_queue_size = options.max_event_queue_size
+
+      @flush_timer_task = Concurrent::TimerTask.new(
+        execution_interval: @event_flush_interval_ms.fdiv(1000),
+        run_now: true
+      ) {
+        flush_events
+      }
+      @flush_timer_task.execute
+      @flush_timer_task.add_observer(FlushTimerTaskObserver.new)
+
+      @local_bucketing = local_bucketing
+      @local_bucketing.init_event_queue(options)
+
+      @flush_mutex = Mutex.new
+      nil
+    end
+
+    def close
+      @flush_timer_task.shutdown
+      flush_events
+    end
+
+    sig { returns(NilClass) }
+    def flush_events
+      @flush_mutex.synchronize do
+        payloads = @local_bucketing.flush_event_queue
+        if payloads.length == 0
+          return
+        end
+        eventCount = payloads.reduce(0) { |sum, payload| sum + payload.eventCount }
+        @logger.debug("DVC: Flushing #{eventCount} event(s) for #{payloads.length} user(s)")
+
+        payloads.each do |payload|
+          begin
+            response = Typhoeus.post(
+              @events_api_uri + '/v1/events/batch',
+              headers: { 'Authorization': @sdkKey },
+              body: { 'batch': payload.records }.to_json
+            )
+            if response.code != 201
+              @logger.error("Error publishing events, status: #{response.code}, body: #{response.return_message}")
+              @local_bucketing.on_payload_failure(payload.payloadId, response.code >= 500)
+            else
+              @logger.debug("DVC: Flushed #{eventCount} event(s), for #{payload.records.length} user(s)")
+              @local_bucketing.on_payload_success(payload.payloadId)
+            end
+          rescue => e
+            @logger.error("DVC Error Flushing Events response message: #{e.message}")
+            @local_bucketing.on_payload_failure(payload.payloadId, false)
+          end
+        end
+      end
+      nil
+    end
+
+    # Todo: implement PopulatedUser
+    sig { params(user: UserData, event: Event).returns(NilClass) }
+    def queue_event(user, event)
+      if max_event_queue_size_reached?
+        @logger.warn("Max event queue size reached, dropping event: #{event}")
+        return
+      end
+
+      @local_bucketing.queue_event(user, event)
+      nil
+    end
+
+    sig { params(event: Event, bucketed_config: T.nilable(BucketedUserConfig)).returns(NilClass) }
+    def queue_aggregate_event(event, bucketed_config)
+      if max_event_queue_size_reached?
+        @logger.warn("Max event queue size reached, dropping event: #{event}")
+        return
+      end
+
+      @local_bucketing.queue_aggregate_event(event, bucketed_config)
+      nil
+    end
+
+    sig { returns(T::Boolean) }
+    def max_event_queue_size_reached?
+      queue_size = @local_bucketing.check_event_queue_size()
+      if queue_size >= @flush_event_queue_size
+        flush_events
+        if queue_size >= @max_event_queue_size
+          return true
+        end
+      end
+      false
+    end
+  end
+
+  # Todo: remove when done testing
+  class FlushTimerTaskObserver
+    def update(time, result, ex)
+      return if ex.nil?
+
+      if ex.is_a?(Concurrent::TimeoutError)
+        print("DVC FlushTimerTaskObserver: Execution timed out")
+      else
+        print("DVC FlushTimerTaskObserver: Execution failed with error: #{ex}")
+      end
+    end
+  end
+end