togglr-sdk 1.0.0

data/generated/spec/spec_helper.rb

@@ -0,0 +1,111 @@
+=begin
+#SDK API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.15.0
+
+=end
+
+# load the gem
+require 'togglr-client'
+
+# The following  was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/generated/togglr-client.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+=begin
+#SDK API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.15.0
+
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+require "togglr-client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "togglr-client"
+  s.version     = TogglrClient::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["OpenAPI-Generator"]
+  s.email       = [""]
+  s.homepage    = "https://openapi-generator.tech"
+  s.summary     = "SDK API Ruby Gem"
+  s.description = "No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)"
+  s.license     = "Unlicense"
+  s.required_ruby_version = ">= 2.7"
+  s.metadata    = {}
+
+  s.add_runtime_dependency 'faraday', '>= 1.0.1', '< 3.0'
+  s.add_runtime_dependency 'faraday-multipart'
+  s.add_runtime_dependency 'marcel'
+
+  s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
+
+  s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ["lib"]
+end

data/lib/togglr/cache.rb

@@ -0,0 +1,45 @@
+require 'lru_redux'
+
+module Togglr
+  class Cache
+    class Entry
+      attr_reader :value, :enabled, :found, :expires_at
+
+      def initialize(value, enabled, found, ttl)
+        @value = value
+        @enabled = enabled
+        @found = found
+        @expires_at = Time.now + ttl
+      end
+
+      def expired?
+        Time.now > @expires_at
+      end
+    end
+
+    def initialize(size, ttl)
+      @cache = LruRedux::TTL::Cache.new(size, ttl)
+    end
+
+    def get(key)
+      entry = @cache[key]
+      return nil if entry.nil? || entry.expired?
+
+      entry
+    end
+
+    def set(key, value, enabled, found)
+      entry = Entry.new(value, enabled, found, @cache.ttl)
+      @cache[key] = entry
+    end
+
+    def clear
+      @cache.clear
+    end
+
+    def size
+      @cache.size
+    end
+  end
+end
+

data/lib/togglr/client.rb

@@ -0,0 +1,267 @@
+require 'json'
+require 'retries'
+require 'digest'
+
+# Load generated client files directly
+require_relative '../togglr-client/api_client'
+require_relative '../togglr-client/api_error'
+require_relative '../togglr-client/version'
+require_relative '../togglr-client/configuration'
+require_relative '../togglr-client/models/feature_error_report'
+require_relative '../togglr-client/models/feature_health'
+require_relative '../togglr-client/models/evaluate_request'
+require_relative '../togglr-client/api/default_api'
+
+module Togglr
+  class Client
+    def initialize(config)
+      @config = config
+      @cache = config.cache_enabled ? Cache.new(config.cache_size, config.cache_ttl) : nil
+      
+      # Initialize generated API client
+      api_config = TogglrClient::Configuration.new
+      api_config.base_path = config.base_url
+      api_config.api_key['Authorization'] = config.api_key
+      api_config.ssl_verify = !config.insecure
+      @api_client = TogglrClient::DefaultApi.new(TogglrClient::ApiClient.new(api_config))
+    end
+
+    def self.new_with_defaults(api_key, *options)
+      config = Config.default(api_key)
+      
+      # Apply options
+      options.each do |option|
+        option.call(config) if option.respond_to?(:call)
+      end
+      
+      yield(config) if block_given?
+      new(config)
+    end
+
+    def evaluate(feature_key, context)
+      evaluate_with_context(feature_key, context, @config.api_key)
+    end
+
+    def evaluate_with_context(feature_key, context, project_api_key)
+      start_time = Time.now
+      @config.metrics.inc_evaluate_request
+
+      # Check cache first
+      cache_key = build_cache_key(feature_key, context)
+      if @cache
+        entry = @cache.get(cache_key)
+        if entry
+          @config.metrics.inc_cache_hit
+          @config.logger.debug('cache hit', feature_key: feature_key, cache_key: cache_key)
+          return [entry.value, entry.enabled, entry.found]
+        end
+        @config.metrics.inc_cache_miss
+      end
+
+      # Make API call with retries
+      result = with_retries(max_tries: @config.retries + 1) do
+        evaluate_single(feature_key, context, project_api_key)
+      end
+
+      # Record metrics
+      latency = Time.now - start_time
+      @config.metrics.observe_evaluate_latency(latency)
+
+      value, enabled, found, error = result
+      if error
+        @config.metrics.inc_evaluate_error(error.class.name)
+        raise error
+      end
+
+      # Cache result if successful
+      @cache&.set(cache_key, value, enabled, found)
+
+      [value, enabled, found]
+    end
+
+    def is_enabled(feature_key, context)
+      _, enabled, found = evaluate(feature_key, context)
+      raise FeatureNotFoundError, "Feature #{feature_key} not found" unless found
+
+      enabled
+    end
+
+    def is_enabled_or_default(feature_key, context, default_value)
+      is_enabled(feature_key, context)
+    rescue StandardError => e
+      @config.logger.warn('evaluation failed, using default',
+                          feature_key: feature_key, error: e.message, default: default_value)
+      default_value
+    end
+
+    def health_check
+      begin
+        @api_client.health_check
+      rescue TogglrClient::ApiError => e
+        raise "Health check failed with status #{e.code}: #{e.message}"
+      end
+    end
+
+    # Report an error for a feature
+    def report_error(feature_key, error_type, error_message, context = {})
+      error = report_error_with_retries(feature_key, error_type, error_message, context)
+      raise error if error
+      nil # Success - error queued for processing
+    end
+
+    # Get feature health information
+    def get_feature_health(feature_key)
+      health, error = get_feature_health_with_retries(feature_key)
+      raise error if error
+      health
+    end
+
+    # Check if feature is healthy (simple boolean check)
+    def is_feature_healthy(feature_key)
+      health = get_feature_health(feature_key)
+      health.healthy?
+    end
+
+    def close
+      @cache&.clear
+    end
+
+    private
+
+    def build_cache_key(feature_key, context)
+      context_hash = Digest::SHA256.hexdigest(context.to_h.to_json)[0, 16]
+      "#{feature_key}:#{context_hash}"
+    end
+
+    def evaluate_single(feature_key, context, project_api_key)
+      begin
+        # Create evaluate request using generated client
+        evaluate_request = TogglrClient::EvaluateRequest.new(context.to_h)
+        response = @api_client.evaluate_feature(feature_key, evaluate_request)
+        
+        [response.value, response.enabled, true, nil]
+      rescue TogglrClient::ApiError => e
+        case e.code
+        when 404
+          ['', false, false, nil] # Feature not found, not an error
+        when 401
+          [nil, nil, nil, UnauthorizedError.new('Authentication required')]
+        when 400
+          [nil, nil, nil, BadRequestError.new('Bad request')]
+        when 500
+          [nil, nil, nil, InternalServerError.new('Internal server error')]
+        else
+          [nil, nil, nil, APIError.new(e.code.to_s, e.message, e.code)]
+        end
+      end
+    end
+
+    def with_retries(max_tries:)
+      retries = 0
+      begin
+        yield
+      rescue StandardError => e
+        retries += 1
+        raise e unless retries < max_tries && should_retry?(e)
+
+        delay = calculate_backoff_delay(retries)
+        @config.logger.debug('retrying after delay', attempt: retries, delay: delay)
+        sleep(delay)
+        retry
+      end
+    end
+
+    def should_retry?(error)
+      case error
+      when NetworkError, TimeoutError, InternalServerError
+        true
+      else
+        false
+      end
+    end
+
+    def calculate_backoff_delay(attempt)
+      delay = @config.backoff.base_delay
+      (attempt - 1).times do
+        delay = [delay * @config.backoff.factor, @config.backoff.max_delay].min
+      end
+      delay
+    end
+
+    def report_error_with_retries(feature_key, error_type, error_message, context)
+      with_retries(max_tries: @config.retries + 1) do
+        error = report_error_single(feature_key, error_type, error_message, context)
+        raise error if error
+        nil # Success
+      end
+    end
+
+    def report_error_single(feature_key, error_type, error_message, context)
+      begin
+        error_report = TogglrClient::FeatureErrorReport.new(
+          error_type: error_type,
+          error_message: error_message,
+          context: context
+        )
+        
+        @api_client.report_feature_error(feature_key, error_report)
+        # Success - error queued for processing
+        nil
+      rescue TogglrClient::ApiError => e
+        case e.code
+        when 401
+          UnauthorizedError.new('Authentication required')
+        when 400
+          BadRequestError.new('Bad request')
+        when 404
+          FeatureNotFoundError.new("Feature #{feature_key} not found")
+        when 500
+          InternalServerError.new('Internal server error')
+        else
+          APIError.new(e.code.to_s, e.message, e.code)
+        end
+      end
+    end
+
+    def get_feature_health_with_retries(feature_key)
+      with_retries(max_tries: @config.retries + 1) do
+        get_feature_health_single(feature_key)
+      end
+    end
+
+    def get_feature_health_single(feature_key)
+      begin
+        api_health = @api_client.get_feature_health(feature_key)
+        health = convert_feature_health(api_health)
+        [health, nil] # health, error
+      rescue TogglrClient::ApiError => e
+        case e.code
+        when 401
+          [nil, UnauthorizedError.new('Authentication required')]
+        when 400
+          [nil, BadRequestError.new('Bad request')]
+        when 404
+          [nil, FeatureNotFoundError.new("Feature #{feature_key} not found")]
+        when 500
+          [nil, InternalServerError.new('Internal server error')]
+        else
+          [nil, APIError.new(e.code.to_s, e.message, e.code)]
+        end
+      end
+    end
+
+    private
+
+    def convert_feature_health(api_health)
+      FeatureHealth.new(
+        feature_key: api_health.feature_key,
+        environment_key: api_health.environment_key,
+        enabled: api_health.enabled || false,
+        auto_disabled: api_health.auto_disabled || false,
+        error_rate: api_health.error_rate || 0,
+        threshold: api_health.threshold || 0,
+        last_error_at: api_health.last_error_at
+      )
+    end
+  end
+end

data/lib/togglr/config.rb

@@ -0,0 +1,37 @@
+module Togglr
+  class Config
+    attr_accessor :base_url, :api_key, :timeout, :retries, :backoff,
+                  :cache_enabled, :cache_size, :cache_ttl, :use_circuit_breaker,
+                  :logger, :metrics, :max_connections, :insecure
+
+    def initialize(api_key)
+      @base_url = 'http://localhost:8090'
+      @api_key = api_key
+      @timeout = 0.8 # seconds
+      @retries = 2
+      @backoff = Backoff.new
+      @cache_enabled = false
+      @cache_size = 100
+      @cache_ttl = 5 # seconds
+      @use_circuit_breaker = false
+      @logger = NoOpLogger.new
+      @metrics = NoOpMetrics.new
+      @max_connections = 100
+      @insecure = false
+    end
+
+    def self.default(api_key)
+      new(api_key)
+    end
+
+    class Backoff
+      attr_accessor :base_delay, :max_delay, :factor
+
+      def initialize
+        @base_delay = 0.1 # seconds
+        @max_delay = 2.0 # seconds
+        @factor = 2.0
+      end
+    end
+  end
+end

data/lib/togglr/errors.rb

@@ -0,0 +1,25 @@
+module Togglr
+  class Error < StandardError; end
+
+  class UnauthorizedError < Error; end
+  class ForbiddenError < Error; end
+  class NotFoundError < Error; end
+  class TooManyRequestsError < Error; end
+  class NetworkError < Error; end
+  class TimeoutError < Error; end
+  class InvalidConfigError < Error; end
+  class FeatureNotFoundError < Error; end
+  class BadRequestError < Error; end
+  class InternalServerError < Error; end
+
+  class APIError < Error
+    attr_reader :code, :message, :status_code
+
+    def initialize(code, message, status_code)
+      @code = code
+      @message = message
+      @status_code = status_code
+      super(message)
+    end
+  end
+end

data/lib/togglr/logger.rb

@@ -0,0 +1,38 @@
+module Togglr
+  class Logger
+    def debug(msg, **kwargs); end
+    def info(msg, **kwargs); end
+    def warn(msg, **kwargs); end
+    def error(msg, **kwargs); end
+  end
+
+  class NoOpLogger < Logger
+    # No-op implementation
+  end
+
+  class StdoutLogger < Logger
+    def debug(msg, **kwargs)
+      puts "[DEBUG] #{msg} #{format_kwargs(kwargs)}"
+    end
+
+    def info(msg, **kwargs)
+      puts "[INFO] #{msg} #{format_kwargs(kwargs)}"
+    end
+
+    def warn(msg, **kwargs)
+      puts "[WARN] #{msg} #{format_kwargs(kwargs)}"
+    end
+
+    def error(msg, **kwargs)
+      puts "[ERROR] #{msg} #{format_kwargs(kwargs)}"
+    end
+
+    private
+
+    def format_kwargs(kwargs)
+      return '' if kwargs.empty?
+
+      kwargs.map { |k, v| "#{k}=#{v}" }.join(' ')
+    end
+  end
+end

data/lib/togglr/metrics.rb

@@ -0,0 +1,44 @@
+module Togglr
+  class Metrics
+    def inc_evaluate_request; end
+    def inc_evaluate_error(code); end
+    def observe_evaluate_latency(duration); end
+    def inc_cache_hit; end
+    def inc_cache_miss; end
+  end
+
+  class NoOpMetrics < Metrics
+    # No-op implementation
+  end
+
+  class StdoutMetrics < Metrics
+    def initialize
+      @counters = Hash.new(0)
+    end
+
+    def inc_evaluate_request
+      @counters[:evaluate_requests] += 1
+    end
+
+    def inc_evaluate_error(code)
+      @counters[:"evaluate_errors_#{code}"] += 1
+    end
+
+    def observe_evaluate_latency(duration)
+      @counters[:total_latency] += duration
+      @counters[:latency_count] += 1
+    end
+
+    def inc_cache_hit
+      @counters[:cache_hits] += 1
+    end
+
+    def inc_cache_miss
+      @counters[:cache_misses] += 1
+    end
+
+    def stats
+      @counters.dup
+    end
+  end
+end

data/lib/togglr/models.rb

@@ -0,0 +1,56 @@
+module Togglr
+  # Model for error reporting
+  class ErrorReport
+    attr_accessor :error_type, :error_message, :context
+
+    def initialize(error_type, error_message, context = {})
+      @error_type = error_type
+      @error_message = error_message
+      @context = context
+    end
+
+    def to_h
+      {
+        error_type: @error_type,
+        error_message: @error_message,
+        context: @context
+      }
+    end
+
+    def self.new_with_context(error_type, error_message, context = {})
+      new(error_type, error_message, context)
+    end
+  end
+
+  # Model for feature health information
+  class FeatureHealth
+    attr_accessor :feature_key, :environment_key, :enabled, :auto_disabled, 
+                  :error_rate, :threshold, :last_error_at
+
+    def initialize(data = {})
+      @feature_key = data['feature_key']
+      @environment_key = data['environment_key']
+      @enabled = data['enabled']
+      @auto_disabled = data['auto_disabled']
+      @error_rate = data['error_rate']
+      @threshold = data['threshold']
+      @last_error_at = data['last_error_at']
+    end
+
+    def healthy?
+      !@auto_disabled && @enabled
+    end
+
+    def to_h
+      {
+        feature_key: @feature_key,
+        environment_key: @environment_key,
+        enabled: @enabled,
+        auto_disabled: @auto_disabled,
+        error_rate: @error_rate,
+        threshold: @threshold,
+        last_error_at: @last_error_at
+      }
+    end
+  end
+end