ff-ruby-server-sdk 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dc03fbc008625a0836f68d7633ed828fca000860ca0ed4bb570acac0e5d0b1c
-  data.tar.gz: 4d7b5998b0fa349c54f08589a094c2d9674989dde242bd0ca173222e92d579c1
+  metadata.gz: '09354edeb352628c1f9744e9c685dc27c2547fc81f3db0e9254dfe8bc9122d58'
+  data.tar.gz: 7f011367b6a2d16162b42f2f02db2730cd04dcff6bf75170d90b2c065e4203a6
 SHA512:
-  metadata.gz: 8c0be4cdc264f5efa858b9746824e0304a255f21ff1c8b030e3b9556766f895c7864c26e279bab9370d696e5005934c55a79a11be23d146e8fd477cc82ad2bcf
-  data.tar.gz: a17fdcd1fbcdbc8d4942acf543b06751648a6c986c3abb82e0bb7b239ce0e983349fa6cab0dc9a679df4b4250bce527ab76c93c27560edfa839b328ffb06bd53
+  metadata.gz: 3f3f09d1185dc89443b8b55bf9fe3bdb5ae6105cae81ec861df2affe25b2ade4b7aa7c3620dc1fc41cdde1979b624c8eef3d57e15474ffd8c2934d8dbc03b843
+  data.tar.gz: 02eabc3cce448322b89c5901e183b8d2e9f25d47b605569d26aa07743f669e51d2779efc2c87179e711e37e68f381c6a1458352568e8bff399f19a548fc2b5cd

data/Gemfile

@@ -16,10 +16,16 @@ gem "moneta"
 
 # SSE support:
 gem "rest-client"
-gem "sse-client"
 
 # Concurrency support:
-gem "concurrent-ruby", require: "concurrent"
+gem "concurrent-ruby", "1.1.10", require: "concurrent"
 
 # Evaluator dependencies:
 gem "murmurhash3"
+
+gem "typhoeus"
+
+group :test do
+  gem 'simplecov', '~> 0.21.2'
+end
+

data/README.md

@@ -81,7 +81,7 @@ client.close
 
 ```bash
 # Install the deps
-gem install ff-ruby-server-sdk typhoeus openapi_client
+gem install ff-ruby-server-sdk typhoeus
 
 # Set your API Key
 export FF_API_KEY=<your key here>
@@ -96,7 +96,7 @@ use docker to quickly get started
 
 ```bash
 # Install the package
-docker run -v $(pwd):/app -w /app -e FF_API_KEY=$FF_API_KEY ruby:2.7-buster gem install --install-dir ./gems ff-ruby-server-sdk typhoeus openapi_client
+docker run -v $(pwd):/app -w /app -e FF_API_KEY=$FF_API_KEY ruby:2.7-buster gem install --install-dir ./gems ff-ruby-server-sdk typhoeus
 
 # Run the script
 docker run -v $(pwd):/app -w /app -e FF_API_KEY=$FF_API_KEY -e GEM_HOME=/app/gems ruby:2.7-buster ruby ./example/getting_started/getting_started.rb
@@ -108,6 +108,7 @@ Further examples and config options are in the further reading section:
 
 [Further Reading](docs/further_reading.md)
 
+[Ruby on Rails example](ruby_on_rails_example/README.md)
 
 -------------------------
 [Harness](https://www.harness.io/) is a feature management platform that helps teams to build better software and to

data/buildInContainer.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+ruby -v
+apt-get update
+apt-get install -y npm
+apt-get install -y maven
+apt-get install -y jq
+mvn --version
+npm install @openapitools/openapi-generator-cli -g
+npm install @openapitools/openapi-generator-cli -D
+gem install minitest-junit
+sh scripts/install.sh
+gem env
+gem install ff-ruby-server-sdk typhoeus
+ruby test/ff/ruby/server/sdk/sdk_test.rb --junit

data/example/getting_started/getting_started.rb

@@ -32,7 +32,7 @@ target = Target.new("RubySDK", identifier="rubysdk", attributes={"location": "em
 # Loop forever reporting the state of the flag
 loop do
   result = client.bool_variation(flagName, target, false)
-  logger.info "Flag variation:  #{result}"
+  logger.info "Flag #{flagName} is set to:  #{result}"
   sleep 10
 end
 

data/example/tls_example/tls_example.rb

@@ -0,0 +1,67 @@
+require 'ff/ruby/server/sdk/api/config'
+require 'ff/ruby/server/sdk/dto/target'
+require 'ff/ruby/server/sdk/api/cf_client'
+require 'ff/ruby/server/sdk/api/config_builder'
+
+require "logger"
+require "securerandom"
+
+$stdout.sync = true
+logger = Logger.new $stdout
+
+# API Key
+apiKey = ENV['FF_API_KEY'] || 'changeme'
+
+# Flag Name
+flagName = ENV['FF_FLAG_NAME'] || 'harnessappdemodarkmode'
+
+logger.info "Harness Ruby SDK TLS example"
+
+=begin
+ For ff servers with a custom or private CAs, you can use 'tls_ca_cert' to pass in the CA bundle in ASCII PEM format.
+ You should also include any intermediate CAs so the full trust chain can be resolved. Typhoeus HTTP client uses libcurl
+ underneath, when developing you should enable debugging(true) to get more detailed error diagnostics logged, which
+ aren't reported through OpenAPI. Common errors include:
+
+ SSL peer certificate or SSH remote key was not OK - you have an invalid or missing CA for the server you're trying
+                                                     to connect to. It can also mean the server hostname and request
+                                                     hostname don't match.
+ SSL: no alternative certificate subject name      - The hostname or IP used in your SDK URLs do not match the SANs
+   matches target host name ‘<host>'                 configured in the cert sent by the web server. You should either
+                                                     fix your URLs or ensure the SANs in the X.509 cert are configured
+                                                     correctly.
+
+The example below assumes you have an ff-server (or proxy) configured with TLS for a server hosted on
+'ffserver:8000' where the web server's cert has a SANs with DNS entry 'ffserver'. CA.crt tells the SDK you trust this
+server.
+
+Typhoeus/libcurl by default has its default CA bundle stored at /etc/ssl/cert.pem. You can append your CA here if
+you choose not to use 'tls_ca_cert'.
+
+=end
+
+
+client = CfClient.instance
+client.init(apiKey, ConfigBuilder.new.logger(logger)
+                                 .event_url("https://ffserver:8001/api/1.0")
+                                 .config_url("https://ffserver:8000/api/1.0")
+                                 .tls_ca_cert("/path/to/CA.crt")
+                                 .debugging(true)
+                                 .build)
+
+client.wait_for_initialization
+
+
+# Create a target (different targets can get different results based on rules.  This include a custom attribute 'location')
+target = Target.new("RubySDK", identifier="rubysdk", attributes={"location": "emea"})
+
+# Loop forever reporting the state of the flag
+loop do
+  result = client.bool_variation(flagName, target, false)
+  logger.info "#{flagName} flag variation:  #{result}"
+  sleep 10
+end
+
+client.close
+
+

data/lib/ff/ruby/server/sdk/api/auth_service.rb

@@ -2,56 +2,47 @@ require_relative "../common/closeable"
 
 class AuthService < Closeable
 
-  def initialize(connector = nil, poll_interval_in_sec = 60, callback = nil, logger = nil)
+  def initialize(connector, callback, logger, retry_delay_ms = 6000)
 
     unless connector.kind_of?(Connector)
-
       raise "The 'connector' parameter must be of '" + Connector.to_s + "' data type"
     end
 
     unless callback.kind_of?(ClientCallback)
-
       raise "The 'callback' parameter must be of '" + ClientCallback.to_s + "' data type"
     end
 
+    @logger = logger
     @callback = callback
     @connector = connector
-    @poll_interval_in_sec = poll_interval_in_sec
-
-    if logger != nil
-
-      @logger = logger
-    else
-
-      @logger = Logger.new(STDOUT)
-    end
+    @retry_delay_ms = retry_delay_ms
+    @authenticated = false
   end
 
   def start_async
-
     @logger.debug "Async starting: " + self.to_s
 
-    @ready = true
-
-    @thread = Thread.new do
-
-      @logger.debug "Async started: " + self.to_s
-
-      while @ready do
-
-        @logger.debug "Async auth iteration"
-
-        if @connector.authenticate
+    @thread = Thread.new :report_on_exception => true do
+      attempt = 1
+      until @authenticated do
+        http_code = @connector.authenticate
 
+        if http_code == 200
+          @authenticated = true
           @callback.on_auth_success
           stop_async
-          @logger.info "Stopping Auth service"
+        elsif should_retry_http_code http_code
+          delay_ms = @retry_delay_ms * [10, attempt].min
+          @logger.warn "Got HTTP code #{http_code} while authenticating on attempt #{attempt}, will retry in #{delay_ms} ms"
+          sleep(delay_ms/1000)
+          attempt += 1
+          @logger.info "Retrying to authenticate, attempt #{attempt}..."
         else
-
-          @logger.error "Exception while authenticating, retry in " + @poll_interval_in_sec.to_s + " seconds"
+          @logger.warn "Auth Service got HTTP code #{http_code} while authenticating, will not attempt to reconnect"
+          @callback.on_auth_failed
+          stop_async
+          next
         end
-
-        sleep(@poll_interval_in_sec)
       end
     end
 
@@ -59,33 +50,50 @@ class AuthService < Closeable
   end
 
   def close
-
     stop_async
   end
 
-  def on_auth_success
+  protected
 
-    unless @callback == nil
+  def on_auth_success
 
+    if @callback != nil
       unless @callback.kind_of?(ClientCallback)
-
         raise "Expected '" + ClientCallback.to_s + "' data type for the callback"
       end
-
       @callback.on_auth_success
     end
   end
 
-  protected
-
   def stop_async
-
-    @ready = false
-
     if @thread != nil
-
+      @logger.info "Stopping Auth service, status=#{@thread.status}"
       @thread.exit
       @thread = nil
+      @logger.info "Stopping Auth service done"
+    end
+  end
+
+  private
+
+  def is_authenticated
+    @authenticated
+  end
+
+  def should_retry_http_code(code)
+    # 408 request timeout
+    # 425 too early
+    # 429 too many requests
+    # 500 internal server error
+    # 502 bad gateway
+    # 503 service unavailable
+    # 504 gateway timeout
+    #  -1 OpenAPI error (timeout etc)
+    case code
+    when 408,425,429,500,502,503,504,-1
+      return true
+    else
+      return false
     end
   end
 end

data/lib/ff/ruby/server/sdk/api/cf_client.rb

@@ -1,5 +1,5 @@
-require "openapi_client"
 
+require_relative "../../generated/lib/openapi_client"
 require_relative "../common/closeable"
 require_relative "inner_client"
 

data/lib/ff/ruby/server/sdk/api/client_callback.rb

@@ -2,44 +2,49 @@ require_relative "../common/closeable"
 
 class ClientCallback < Closeable
 
+  TBI = RuntimeError.new("To be implemented")
+
   def initialize
     super
-
-    @tbi = "To be implemented"
   end
 
   def on_auth_success
 
-    raise @tbi
+    raise TBI
+  end
+
+  def on_auth_failed
+
+    raise TBI
   end
 
   def on_authorized
 
-    raise @tbi
+    raise TBI
   end
 
   def is_closing
 
-    raise @tbi
+    raise TBI
   end
 
   def on_processor_ready(processor)
 
-    raise @tbi
+    raise TBI
   end
 
   def on_update_processor_ready
 
-    raise @tbi
+    raise TBI
   end
 
   def on_metrics_processor_ready
 
-    raise @tbi
+    raise TBI
   end
 
   def update(message, manual)
 
-    raise @tbi
+    raise TBI
   end
 end

data/lib/ff/ruby/server/sdk/api/config.rb

@@ -7,7 +7,7 @@ class Config
   attr_accessor :config_url, :event_url, :stream_enabled, :poll_interval_in_seconds, :analytics_enabled,
                 :frequency, :buffer_size, :all_attributes_private, :private_attributes, :connection_timeout,
                 :read_timeout, :write_timeout, :debugging, :metrics_service_acceptable_duration, :cache, :store,
-                :logger
+                :logger, :ssl_ca_cert
 
   # Static:
   class << self
@@ -35,7 +35,7 @@ class Config
 
     @frequency = @@min_frequency
 
-    @buffer_size = 1024
+    @buffer_size = 2048
 
     @all_attributes_private = false
 
@@ -82,7 +82,7 @@ class Config
 
   def verify_ssl
 
-    nil
+    true
   end
 
   def cert_file
@@ -97,7 +97,7 @@ class Config
 
   def ssl_ca_cert
 
-    nil
+    @ssl_ca_cert
   end
 
   def client_side_validation

data/lib/ff/ruby/server/sdk/api/config_builder.rb

@@ -83,6 +83,11 @@ class ConfigBuilder
     self
   end
 
+  def tls_ca_cert(cert_file)
+    @config.ssl_ca_cert = cert_file
+    self
+  end
+
   def logger(logger)
 
     @config.logger = logger

data/lib/ff/ruby/server/sdk/api/inner_client.rb

@@ -97,17 +97,21 @@ class InnerClient < ClientCallback
     @poll_processor.start
 
     if @config.stream_enabled
-
       @update_processor.start
     end
 
     if @config.analytics_enabled
-
       @metrics_processor.start
     end
 
   end
 
+  def on_auth_failed
+    @config.logger.warn "Authentication failed with a non-recoverable error - defaults will be served"
+    @initialized = true
+
+  end
+
   def close
 
     @config.logger.info "Closing the client: " + self.to_s
@@ -268,12 +272,13 @@ class InnerClient < ClientCallback
     @metrics_processor.init(@connector, @config, @metrics_callback)
 
     @evaluator = Evaluator.new(@repository, logger = @config.logger)
-    @evaluator_callback = InnerClientFlagEvaluateCallback.new(@metrics_processor, logger = @config.logger)
 
-    @auth_service = AuthService.new(
+    if @config.analytics_enabled
+      @evaluator_callback = InnerClientFlagEvaluateCallback.new(@metrics_processor, logger = @config.logger)
+    end
 
+    @auth_service = AuthService.new(
       connector = @connector,
-      poll_interval_in_sec = @config.poll_interval_in_seconds,
       callback = self,
       logger = @config.logger
     )
@@ -312,4 +317,5 @@ class InnerClient < ClientCallback
 
     @my_mutex.synchronize(&block)
   end
+
 end

data/lib/ff/ruby/server/sdk/api/inner_client_flag_evaluate_callback.rb

@@ -25,6 +25,6 @@ class InnerClientFlagEvaluateCallback < FlagEvaluateCallback
 
     @logger.debug "Processing evaluation: " + feature_config.feature.to_s + ", " + target.identifier.to_s
 
-    @metrics_processor.push_to_queue(target, feature_config, variation)
+    @metrics_processor.register_evaluation(target, feature_config, variation)
   end
 end

data/lib/ff/ruby/server/sdk/api/inner_client_updater.rb

@@ -53,7 +53,7 @@ class InnerClientUpdater < Updater
 
   def on_error
 
-    @logger.error "Error occurred"
+    @logger.error "InnerClientUpdater error occurred"
   end
 
   def update(message)

data/lib/ff/ruby/server/sdk/api/metrics_event.rb

@@ -2,15 +2,27 @@ class MetricsEvent
 
   attr_accessor :feature_config, :target, :variation
 
-  def initialize(
-
-    feature_config,
-    target,
-    variation
-  )
+  def initialize(feature_config, target, variation)
 
     @target = target
     @variation = variation
     @feature_config = feature_config
+    freeze
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def eql?(other)
+    feature_config.feature == other.feature_config.feature and
+      variation.identifier == other.variation.identifier and
+      target.identifier == other.target.identifier
   end
+
+  def hash
+    feature_config.feature.hash | variation.identifier.hash | target.identifier.hash
+  end
+
+
 end

data/lib/ff/ruby/server/sdk/api/metrics_processor.rb

@@ -9,25 +9,47 @@ require_relative "../api/summary_metrics"
 
 class MetricsProcessor < Closeable
 
-  def init(
+  class FrequencyMap < Concurrent::Map
+    def initialize(options = nil, &block)
+      super
+    end
 
-    connector,
-    config,
-    callback
-  )
+    def increment(key)
+      compute(key) do |old_value|
+        if old_value == nil; 1 else old_value + 1 end
+      end
+    end
 
-    unless connector.kind_of?(Connector)
+    def get(key)
+      self[key]
+    end
+
+    def drain_to_map
+      result = {}
+      each_key do |key|
+        result[key] = 0
+      end
+      result.each_key do |key|
+        value = get_and_set(key, 0)
+        result[key] = value
+        delete_pair(key, 0)
+      end
+      result
+    end
+  end
 
+
+  def init(connector, config, callback)
+
+    unless connector.kind_of?(Connector)
       raise "The 'connector' must be of '" + Connector.to_s + "' data type"
     end
 
     unless callback.kind_of?(MetricsCallback)
-
       raise "The 'callback' must be of '" + MetricsCallback.to_s + "' data type"
     end
 
     unless config.kind_of?(Config)
-
       raise "The 'config' must be of '" + Config.to_s + "' data type"
     end
 
@@ -51,247 +73,151 @@ class MetricsProcessor < Closeable
     @feature_name_attribute = "featureName"
     @variation_identifier_attribute = "variationIdentifier"
 
-    @queue = SizedQueue.new(@config.buffer_size)
-    @executor = Concurrent::FixedThreadPool.new(100)
+    @executor = Concurrent::FixedThreadPool.new(10)
+
+    @frequency_map = FrequencyMap.new
+
+    @max_buffer_size = config.buffer_size - 1
 
     @callback.on_metrics_ready
   end
 
   def start
-
     @config.logger.info "Starting metrics processor with request interval: " + @config.frequency.to_s
     start_async
   end
 
   def stop
-
     @config.logger.info "Stopping metrics processor"
     stop_async
   end
 
   def close
-
     stop
     @config.logger.info "Closing metrics processor"
   end
 
-  def push_to_queue(
-
-    target,
-    feature_config,
-    variation
-  )
-
-    @executor.post do
-
-      @config.logger.debug "Pushing to the metrics queue: START"
-
-      event = MetricsEvent.new(feature_config, target, variation)
-      @queue.push(event)
-
-      @config.logger.debug "Pushing to the metrics queue: END, queue size: " + @queue.size.to_s
-
-    end
-  end
-
-  def send_data_and_reset_cache(data)
-
-    @config.logger.debug "Reading from queue and building cache"
-
-    @jar_version = get_version
-
-    unless data.empty?
-
-      map = {}
-
-      data.each do |event|
-
-        new_value = 1
-        current = map[event]
-
-        if current != nil
-
-          new_value = current + 1
-        end
-
-        map[event] = new_value
-      end
-
-      metrics = prepare_summary_metrics_body(map)
-
-      if !metrics.metrics_data.empty? && !metrics.target_data.empty?
+  def register_evaluation(target, feature_config, variation)
 
-        start_time = (Time.now.to_f * 1000).to_i
-
-        @connector.post_metrics(metrics)
-
-        end_time = (Time.now.to_f * 1000).to_i
-
-        if end_time - start_time > @config.metrics_service_acceptable_duration
-
-          @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
-        end
+    if @frequency_map.size > @max_buffer_size
+      @config.logger.warn "metrics buffer is full #{@frequency_map.size} - flushing metrics"
+      @executor.post do
+        run_one_iteration
       end
-
-      @global_target_set.merge(@staging_target_set)
-      @staging_target_set.clear
     end
+
+    event = MetricsEvent.new(feature_config, target, variation)
+    @frequency_map.increment event
   end
 
-  protected
+  private
 
   def run_one_iteration
+    send_data_and_reset_cache @frequency_map.drain_to_map
 
-    @config.logger.debug "Async metrics iteration: " + @thread.to_s
-
-    data = []
+    @config.logger.debug "metrics: frequency map size #{@frequency_map.size}. global target size #{@global_target_set.size}"
+  end
 
-    until @queue.empty?
+  def send_data_and_reset_cache(map)
+    metrics = prepare_summary_metrics_body(map)
 
-      item = @queue.pop
-      data.push(item)
+    if !metrics.metrics_data.empty? && !metrics.target_data.empty?
+      start_time = (Time.now.to_f * 1000).to_i
+      @connector.post_metrics(metrics)
+      end_time = (Time.now.to_f * 1000).to_i
+      if end_time - start_time > @config.metrics_service_acceptable_duration
+        @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
+      end
     end
 
-    send_data_and_reset_cache(data)
-  end
+    @global_target_set.merge(@staging_target_set)
+    @staging_target_set.clear
 
-  def prepare_summary_metrics_body(data)
+  end
 
-    summary_metrics_data = {}
+  def prepare_summary_metrics_body(freq_map)
     metrics = OpenapiClient::Metrics.new({ :target_data => [], :metrics_data => [] })
-
-    add_target_data(
-
-      metrics,
-      Target.new(
-
-        name = @global_target_name,
-        identifier = @global_target
-      )
-    )
-
-    data.each do |key, value|
-
-      target = key.target
-
-      add_target_data(metrics, target)
-
-      summary_metrics = prepare_summary_metrics_key(key)
-
-      summary_metrics_data[summary_metrics] = value
+    add_target_data(metrics, Target.new(name = @global_target_name, identifier = @global_target))
+    freq_map.each_key do |key|
+      add_target_data(metrics, key.target)
     end
-
-    summary_metrics_data.each do |key, value|
-
+    total_count = 0
+    freq_map.each do |key, value|
+      total_count += value
       metrics_data = OpenapiClient::MetricsData.new({ :attributes => [] })
       metrics_data.timestamp = (Time.now.to_f * 1000).to_i
       metrics_data.count = value
       metrics_data.metrics_type = "FFMETRICS"
-      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @feature_name_attribute, :value => key.feature_name }))
-      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @variation_identifier_attribute, :value => key.variation_identifier }))
+      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @feature_name_attribute, :value => key.feature_config.feature }))
+      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @variation_identifier_attribute, :value => key.variation.identifier }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @target_attribute, :value => @global_target }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_type, :value => @server }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_language, :value => "ruby" }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_version, :value => @jar_version }))
-
       metrics.metrics_data.push(metrics_data)
     end
+    @config.logger.debug "Pushed #{total_count} metric evaluations to server. metrics_data count is #{freq_map.size}"
 
     metrics
   end
 
-  private
-
-  def start_async
-
-    @config.logger.debug "Async starting: " + self.to_s
-
-    @ready = true
-
-    @thread = Thread.new do
-
-      @config.logger.debug "Async started: " + self.to_s
-
-      while @ready do
-
-        unless @initialized
-
-          @initialized = true
-          @config.logger.info "Metrics processor initialized"
-        end
-
-        sleep(@config.frequency)
-
-        run_one_iteration
-      end
-    end
-
-    @thread.run
-  end
-
-  def stop_async
-
-    @queue.clear
-
-    @ready = false
-    @initialized = false
-  end
-
-  def prepare_summary_metrics_key(key)
-
-    SummaryMetrics.new(
-
-      feature_name = key.feature_config.feature,
-      variation_identifier = key.variation.identifier,
-      variation_value = key.variation.value
-    )
-  end
-
   def add_target_data(metrics, target)
 
     target_data = OpenapiClient::TargetData.new({ :attributes => [] })
     private_attributes = target.private_attributes
 
     if !@staging_target_set.include?(target) && !@global_target_set.include?(target) && !target.is_private
-
       @staging_target_set.add(target)
-
       attributes = target.attributes
-
       attributes.each do |k, v|
-
         key_value = OpenapiClient::KeyValue.new
-
         if !private_attributes.empty?
-
           unless private_attributes.include?(k)
-
             key_value = OpenapiClient::KeyValue.new({ :key => k, :value => v.to_s })
           end
         else
-
           key_value = OpenapiClient::KeyValue.new({ :key => k, :value => v.to_s })
         end
-
         target_data.attributes.push(key_value)
       end
-
       target_data.identifier = target.identifier
-
       if target.name == nil || target.name == ""
-
         target_data.name = target.identifier
       else
-
         target_data.name = target.name
       end
-
       metrics.target_data.push(target_data)
     end
   end
 
-  def get_version
+  def start_async
+    @config.logger.debug "Async starting: " + self.to_s
+    @ready = true
+    @thread = Thread.new do
+      @config.logger.debug "Async started: " + self.to_s
+      while @ready do
+        unless @initialized
+          @initialized = true
+          @config.logger.info "Metrics processor initialized"
+        end
+        sleep(@config.frequency)
+        run_one_iteration
+      end
+    end
+    @thread.run
+  end
 
+  def stop_async
+    @ready = false
+    @initialized = false
+  end
+
+  def get_version
     Ff::Ruby::Server::Sdk::VERSION
   end
+
+  def get_frequency_map
+    @frequency_map
+  end
+
 end

data/lib/ff/ruby/server/sdk/connector/events.rb

@@ -1,5 +1,5 @@
 require "json"
-require "sse-client"
+require 'restclient'
 
 require_relative './service'
 
@@ -10,109 +10,105 @@ class Events < Service
     url,
     headers,
     updater,
-    logger = nil
+    config
   )
 
-    if @updater != nil
+    @url = url
+    @headers = headers
+    @headers['params'] = {}
+    @updater = updater
+    @config = config
 
+    if @updater != nil
       unless @updater.kind_of?(Updater)
-
         raise "The 'callback' parameter must be of '" + Updater.to_s + "' data type"
       end
     end
 
-    @updater = updater
-
-    if logger != nil
-
-      @logger = logger
+    if @config.logger != nil
+      @logger = @config.logger
     else
-
       @logger = Logger.new(STDOUT)
     end
 
-    @sse = SSE::EventSource.new(
-
-      url = url,
-      query = {},
-      headers = headers
-    )
-
-    @sse.open do
-
-      on_open
-    end
-
-    @sse.error do |error|
-
-      if error != nil
-
-        @logger.error "SSE ERROR: " + error.body
-      end
-
-      on_error
-    end
-
-    @sse.message do |message|
-
-      on_message(message)
-    end
-
-    @sse.on("*") do |message|
-
-      on_message(message)
-    end
-
     @updater.on_ready
   end
 
   def start
-
     @logger.info "Starting EventSource service"
-
-    @sse.start
+    begin
+      conn = RestClient::Request.execute(method: :get,
+                                         url: @url,
+                                         headers: @headers,
+                                         block_response: proc { |response| response_handler response },
+                                         before_execution_proc: nil,
+                                         log: false,
+                                         read_timeout: 60,
+                                         ssl_ca_file: @config.ssl_ca_cert)
+
+
+    rescue => e
+      @logger.warn "SSE connection failed: " + e.message
+      on_error
+    end
   end
 
   def stop
-
     @logger.info "Stopping EventSource service"
-
     on_closed
   end
 
   def close
-
     stop
   end
 
   def on_open
-
     @logger.info "EventSource connected"
-
     @updater.on_connected
   end
 
   def on_error
-
     @logger.error "EventSource error"
-
     @updater.on_error
-
     stop
   end
 
   def on_closed
-
     @logger.info "EventSource disconnected"
-
     @updater.on_disconnected
   end
 
   def on_message(message)
-
     @logger.debug "EventSource message received " + message.to_s
-
     msg = JSON.parse(message)
     @updater.update(msg)
   end
+
+  private
+
+  def emit_line(line)
+    if line.start_with?("data:")
+      @logger.debug "SSE emit line: " + line
+      on_message line[line.index("{")..-1]
+    end
+  end
+
+  def response_handler(response)
+    on_open
+    case response.code
+    when "200"
+      line = ""
+      response.read_body do |chunk|
+        line << chunk
+        while line.sub!(/^(.*)\n/,"")
+            emit_line $1
+        end
+      end
+      close
+    else
+      @logger.error "SSE ERROR: http_code=%d body=%d" % [response.code, response.body]
+      on_error
+    end
+  end
+
 end

data/lib/ff/ruby/server/sdk/connector/harness_connector.rb

@@ -13,6 +13,7 @@ class HarnessConnector < Connector
     @config = config
     @on_unauthorized = on_unauthorized
     @user_agent = "RubySDK " + Ff::Ruby::Server::Sdk::VERSION
+    @sdk_info = "Ruby #{Ff::Ruby::Server::Sdk::VERSION} Server"
 
     @api = OpenapiClient::ClientApi.new(make_api_client)
     @metrics_api = OpenapiClient::MetricsApi.new(make_metrics_api_client)
@@ -36,14 +37,21 @@ class HarnessConnector < Connector
 
       @config.logger.info "Token has been obtained"
       process_token
-      return true
+      return 200
 
     rescue OpenapiClient::ApiError => e
 
+      if e.message.include? "the server returns an error"
+        # NOTE openapi-generator 5.2.1 has a bug where exceptions don't contain any useful information and we can't
+        # determine if a timeout has occurred. This is fixed in 6.3.0 but requires Ruby version to be increased to 2.7
+        # https://github.com/OpenAPITools/openapi-generator/releases/tag/v6.3.0
+        @config.logger.warn "OpenapiClient::ApiError [\n\n#{e}\n]"
+        return -1
+      end
+
       log_error(e)
+      return e.code
     end
-
-    false
   end
 
   def get_flags
@@ -59,6 +67,7 @@ class HarnessConnector < Connector
     rescue OpenapiClient::ApiError => e
 
       log_error(e)
+      return nil
     end
   end
 
@@ -75,6 +84,7 @@ class HarnessConnector < Connector
     rescue OpenapiClient::ApiError => e
 
       log_error(e)
+      return nil
     end
   end
 
@@ -139,15 +149,19 @@ class HarnessConnector < Connector
     headers = {
 
       "Authorization" => "Bearer " + @token,
-      "API-Key" => @api_key
-    }
+      "API-Key" => @api_key,
+      "User-Agent" => @user_agent,
+      "Harness-SDK-Info" =>  @sdk_info,
+      "Harness-AccountID" => @account_id,
+      "Harness-EnvironmentID" => @environment_id
+    }.compact
 
     @event_source = Events.new(
 
       url,
       headers,
       updater,
-      @config.logger
+      @config
     )
 
     @event_source
@@ -169,7 +183,10 @@ class HarnessConnector < Connector
     api_client = OpenapiClient::ApiClient.new
 
     api_client.config = @config
+    api_client.config.connection_timeout = @config.read_timeout / 1000
+    api_client.config.read_timeout = @config.read_timeout / 1000
     api_client.user_agent = @user_agent
+    api_client.default_headers['Harness-SDK-Info'] = @sdk_info
 
     api_client
   end
@@ -189,30 +206,32 @@ class HarnessConnector < Connector
 
     api_client.config = config
     api_client.user_agent = @user_agent
+    api_client.default_headers['Harness-SDK-Info'] = @sdk_info
 
     api_client
   end
 
   def process_token
-
-    headers = {
-
-      "Authorization" => "Bearer " + @token
-    }
-
-    @api.api_client.default_headers = @api.api_client.default_headers.merge(headers)
-    @metrics_api.api_client.default_headers = @metrics_api.api_client.default_headers.merge(headers)
-
     decoded_token = JWT.decode @token, nil, false
 
     if decoded_token != nil && !decoded_token.empty?
 
       @environment = decoded_token[0]["environment"]
       @cluster = decoded_token[0]["clusterIdentifier"]
+      @environment_id = decoded_token[0]["environmentIdentifier"]
+      @account_id = decoded_token[0]["accountID"]
+
+      headers = {
+        "Authorization" => "Bearer " + @token,
+        "Harness-AccountID" => @account_id,
+        "Harness-EnvironmentID" => @environment_id
+      }.compact
+
+      @api.api_client.default_headers = @api.api_client.default_headers.merge(headers)
+      @metrics_api.api_client.default_headers = @metrics_api.api_client.default_headers.merge(headers)
 
       @config.logger.debug "Token has been processed: environment='" + @environment.to_s + "', cluster='" + @cluster.to_s + "'"
     else
-
       @config.logger.error "ERROR: Could not obtain the environment and cluster data from the token"
     end
   end
@@ -231,6 +250,12 @@ class HarnessConnector < Connector
 
   def log_error(e)
 
-    @config.logger.error "ERROR - Start\n\n" + e.to_s + "\nERROR - End"
+    if e.code == 0
+      type = "typhoeus/libcurl"
+    else
+      type = "HTTP code #{e.code}"
+    end
+
+    @config.logger.warn "OpenapiClient::ApiError (#{type}) [\n\n" + e.to_s + "\n]"
   end
 end

data/lib/ff/ruby/server/sdk/version.rb

@@ -5,7 +5,7 @@ module Ff
     module Server
       module Sdk
 
-        VERSION = "1.0.6"
+        VERSION = "1.1.0"
       end
     end
   end

data/scripts/openapi.sh

@@ -57,12 +57,9 @@ if which openapi-generator-cli; then
       gem install concurrent-ruby -v 1.1.10 && \
       gem install murmurhash3 -v 0.1.6 && \
       cd "$dir_path/.." && \
-      openapi-generator-cli generate -i api.yaml -g ruby -o "$generated_path" && \
-      cd "$generated_path" && gem build openapi_client.gemspec && \
-      test -e "openapi_client-1.0.0.gem" && \
-      gem install --dev "openapi_client-1.0.0.gem"; then
+      openapi-generator-cli generate -i api.yaml -g ruby -o "$generated_path"; then
 
-      echo "Generated API has been installed with success: $generated_path"
+      echo "API has been generated with success: $generated_path"
   else
 
       echo "ERROR: 'openapi-generator-cli' is not installed [1] 😬"

data/scripts/sdk_specs.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 export ff_ruby_sdk="ff-ruby-server-sdk"
-export ff_ruby_sdk_version="1.0.6"
+export ff_ruby_sdk_version="1.1.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ff-ruby-server-sdk
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - 'Miloš Vasić, cyr.: Милош Васић'
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-19 00:00:00.000000000 Z
+date: 2023-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -122,20 +122,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.1.0
-- !ruby/object:Gem::Dependency
-  name: sse-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -165,19 +151,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.1.6
 - !ruby/object:Gem::Dependency
-  name: openapi_client
+  name: typhoeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
 description: Harness is a feature management platform that helps teams to build better
   software and to test features quicker.
 email:
@@ -198,6 +190,7 @@ files:
 - api.yaml
 - bin/console
 - bin/setup
+- buildInContainer.sh
 - docs/build.md
 - docs/further_reading.md
 - docs/images/ff-gui.png
@@ -207,6 +200,7 @@ files:
 - example/number_variation_example/number_variation_example.rb
 - example/simple_example/example.rb
 - example/string_variation_example/string_variation_example.rb
+- example/tls_example/tls_example.rb
 - example/url_change_example/url_change_example.rb
 - lib/ff/ruby/server/generated/lib/openapi_client.rb
 - lib/ff/ruby/server/generated/lib/openapi_client/api/client_api.rb
@@ -291,7 +285,7 @@ metadata:
   homepage_uri: https://www.harness.io/
   source_code_uri: https://github.com/harness/ff-ruby-server-sdk
   changelog_uri: https://github.com/harness/ff-ruby-server-sdk/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -307,8 +301,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Harness is a feature management platform that helps teams to build better
   software and to test features quicker.