openfeature-go-feature-flag-provider 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88b909669520d990cdd3bab857d26fe0aebd5a6d753a311d88b73fd8026cfd49
-  data.tar.gz: f5ae9b1d0a474a1f547f1dd9b84b0f9c4cee48f938f79e1b2d96ca67acc5380c
+  metadata.gz: ddfe59a26f6cb77f15f337d09960c06d01f35465e388c39a3b06603f36c0f573
+  data.tar.gz: 7598fabc63d82fa717b8dd388a1ccd4825db1a71e86aa5d92161eb704751616f
 SHA512:
-  metadata.gz: 68053f645f8b2ea7d3c48f71e5c22bf6b64308cf4656a3480611bc82f200d38df9d527134e734b51e017bbf96814eb7b9abbb5b86205860eaafc7ff68df3d37c
-  data.tar.gz: 1f5125e5d8360b48a12282f227dc69ea9302dd273c4bd728ce5c67ff159f11aaa97753a8dcca25a7d36959400e5d40c4af80b39150cb83cd5a514058f1099248
+  metadata.gz: ab45b781c719f2f037677808d3fce03e49dbe683f9c33acdc52065e79ccc0b81a428f642bc55310ffef543f54dbea1e530665954f8a0b714df052f8ba6dbcdc2
+  data.tar.gz: 1c831f1f4a7015fd811111fc91d6f1055a9feb032771be4b87c467edba901f3d4aff394c22d9dc9966ad3ec0cd18feeafc087d547534946e86fc424810128374

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.1.8](https://github.com/open-feature/ruby-sdk-contrib/compare/openfeature-go-feature-flag-provider/v0.1.7...openfeature-go-feature-flag-provider/v0.1.8) (2026-01-13)
+
+
+### 🐛 Bug Fixes
+
+* Make goff unix socket client thread safe ([#74](https://github.com/open-feature/ruby-sdk-contrib/issues/74)) ([ec25c37](https://github.com/open-feature/ruby-sdk-contrib/commit/ec25c3787b108ed2af8d7f1c9efbd6a258870a21))
+
+## [0.1.7](https://github.com/open-feature/ruby-sdk-contrib/compare/openfeature-go-feature-flag-provider/v0.1.6...openfeature-go-feature-flag-provider/v0.1.7) (2025-11-19)
+
+
+### ✨ New Features
+
+* **GoFeatureFlag:** unix client ([#66](https://github.com/open-feature/ruby-sdk-contrib/issues/66)) ([3f68ce8](https://github.com/open-feature/ruby-sdk-contrib/commit/3f68ce8691646779755affb2c86edf51ae21b40b))
+
 ## [0.1.6](https://github.com/open-feature/ruby-sdk-contrib/compare/openfeature-go-feature-flag-provider/v0.1.5...openfeature-go-feature-flag-provider/v0.1.6) (2025-11-11)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    openfeature-go-feature-flag-provider (0.1.6)
+    openfeature-go-feature-flag-provider (0.1.8)
       faraday-net_http_persistent (~> 2.3)
       openfeature-sdk (~> 0.3.1)
 

data/lib/openfeature/go-feature-flag/client/common.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "open_feature/sdk"
+require_relative "../error/errors"
+require_relative "../model/ofrep_api_response"
+
+module OpenFeature
+  module GoFeatureFlag
+    module Client
+      class Common
+        def initialize(endpoint: nil, custom_headers: nil)
+          raise "This should be overwritten by implementations"
+        end
+
+        def evaluate_ofrep_api(flag_key:, evaluation_context:)
+          raise "This should be overwritten by implementations"
+        end
+
+        private
+
+        def headers
+          {"Content-Type" => "application/json"}.merge(@custom_headers || {})
+        end
+
+        def evaluation_request(evaluation_context)
+          ctx = evaluation_context || OpenFeature::SDK::EvaluationContext.new
+          fields = ctx.fields.dup
+          # replace targeting_key by targetingKey without mutating original fields
+          fields["targetingKey"] = ctx.targeting_key
+          fields.delete("targeting_key")
+
+          {context: fields}
+        end
+
+        def check_retry_after
+          lock = (@retry_lock ||= Mutex.new)
+          lock.synchronize do
+            return if @retry_after.nil?
+            if Time.now < @retry_after
+              raise OpenFeature::GoFeatureFlag::RateLimited.new(nil)
+            else
+              @retry_after = nil
+            end
+          end
+        end
+
+        def parse_error_response(response)
+          required_keys = %w[key error_code]
+          parsed = JSON.parse(response.body)
+
+          missing_keys = required_keys - parsed.keys
+          unless missing_keys.empty?
+            raise OpenFeature::GoFeatureFlag::ParseError.new(response)
+          end
+
+          OpenFeature::GoFeatureFlag::OfrepApiResponse.new(
+            value: nil,
+            key: parsed["key"],
+            reason: SDK::Provider::Reason::ERROR,
+            variant: nil,
+            error_code: error_code_mapper(parsed["error_code"]),
+            error_details: parsed["error_details"],
+            metadata: nil
+          )
+        end
+
+        def parse_success_response(response)
+          required_keys = %w[key value reason variant]
+          parsed = JSON.parse(response.body)
+
+          missing_keys = required_keys - parsed.keys
+          unless missing_keys.empty?
+            raise OpenFeature::GoFeatureFlag::ParseError.new(response)
+          end
+
+          OpenFeature::GoFeatureFlag::OfrepApiResponse.new(
+            value: parsed["value"],
+            key: parsed["key"],
+            reason: reason_mapper(parsed["reason"]),
+            variant: parsed["variant"],
+            error_code: nil,
+            error_details: nil,
+            metadata: parsed["metadata"]
+          )
+        end
+
+        def reason_mapper(reason_str)
+          reason_str = reason_str.upcase
+          reason_map = {
+            "STATIC" => SDK::Provider::Reason::STATIC,
+            "DEFAULT" => SDK::Provider::Reason::DEFAULT,
+            "TARGETING_MATCH" => SDK::Provider::Reason::TARGETING_MATCH,
+            "SPLIT" => SDK::Provider::Reason::SPLIT,
+            "CACHED" => SDK::Provider::Reason::CACHED,
+            "DISABLED" => SDK::Provider::Reason::DISABLED,
+            "UNKNOWN" => SDK::Provider::Reason::UNKNOWN,
+            "STALE" => SDK::Provider::Reason::STALE,
+            "ERROR" => SDK::Provider::Reason::ERROR
+          }
+          reason_map[reason_str] || SDK::Provider::Reason::UNKNOWN
+        end
+
+        def error_code_mapper(error_code_str)
+          error_code_str = error_code_str.upcase
+          error_code_map = {
+            "PROVIDER_NOT_READY" => SDK::Provider::ErrorCode::PROVIDER_NOT_READY,
+            "FLAG_NOT_FOUND" => SDK::Provider::ErrorCode::FLAG_NOT_FOUND,
+            "PARSE_ERROR" => SDK::Provider::ErrorCode::PARSE_ERROR,
+            "TYPE_MISMATCH" => SDK::Provider::ErrorCode::TYPE_MISMATCH,
+            "TARGETING_KEY_MISSING" => SDK::Provider::ErrorCode::TARGETING_KEY_MISSING,
+            "INVALID_CONTEXT" => SDK::Provider::ErrorCode::INVALID_CONTEXT,
+            "GENERAL" => SDK::Provider::ErrorCode::GENERAL
+          }
+          error_code_map[error_code_str] || SDK::Provider::ErrorCode::GENERAL
+        end
+
+        def parse_retry_later_header(response)
+          retry_after = response["Retry-After"]
+          return nil if retry_after.nil?
+
+          begin
+            next_retry_time =
+              if /^\d+$/.match?(retry_after)
+                # Retry-After is in seconds
+                Time.now + Integer(retry_after)
+              else
+                # Retry-After is an HTTP-date
+                Time.httpdate(retry_after)
+              end
+            # Protect updates and never shorten an existing backoff window
+            lock = (@retry_lock ||= Mutex.new)
+            lock.synchronize do
+              @retry_after = [@retry_after, next_retry_time].compact.max
+            end
+          rescue ArgumentError
+            # ignore invalid Retry-After header
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openfeature/go-feature-flag/client/http_api.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "common"
+require "faraday/net_http_persistent"
+
+module OpenFeature
+  module GoFeatureFlag
+    module Client
+      class HttpApi < Common
+        def initialize(endpoint: nil, custom_headers: nil, instrumentation: nil)
+          @custom_headers = custom_headers
+          @faraday_connection = Faraday.new(url: endpoint, headers: headers) do |f|
+            f.request :instrumentation, instrumentation if instrumentation
+            f.adapter :net_http_persistent do |http|
+              http.idle_timeout = 30
+            end
+          end
+        end
+
+        def evaluate_ofrep_api(flag_key:, evaluation_context:)
+          check_retry_after
+          request = evaluation_request(evaluation_context)
+
+          response = @faraday_connection.post("/ofrep/v1/evaluate/flags/#{flag_key}") do |req|
+            req.body = request.to_json
+          end
+
+          case response.status
+          when 200
+            parse_success_response(response)
+          when 400
+            parse_error_response(response)
+          when 401, 403
+            raise OpenFeature::GoFeatureFlag::UnauthorizedError.new(response)
+          when 404
+            raise OpenFeature::GoFeatureFlag::FlagNotFoundError.new(response, flag_key)
+          when 429
+            parse_retry_later_header(response)
+            raise OpenFeature::GoFeatureFlag::RateLimited.new(response)
+          else
+            raise OpenFeature::GoFeatureFlag::InternalServerError.new(response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openfeature/go-feature-flag/client/unix_api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "common"
+require_relative "../internal/http_unix"
+
+module OpenFeature
+  module GoFeatureFlag
+    module Client
+      class UnixApi < Common
+        def initialize(endpoint: nil, custom_headers: nil, unix_socket_client_factory: nil)
+          @custom_headers = custom_headers
+          @endpoint = endpoint
+          @unix_socket_client_factory = unix_socket_client_factory || ->(ep) { HttpUnix.new(ep) }
+        end
+
+        def evaluate_ofrep_api(flag_key:, evaluation_context:)
+          check_retry_after
+
+          request = evaluation_request(evaluation_context)
+          response = thread_local_socket.post("/ofrep/v1/evaluate/flags/#{flag_key}", request, headers)
+
+          case response.code
+          when "200"
+            parse_success_response(response)
+          when "400"
+            parse_error_response(response)
+          when "401", "403"
+            raise OpenFeature::GoFeatureFlag::UnauthorizedError.new(response)
+          when "404"
+            raise OpenFeature::GoFeatureFlag::FlagNotFoundError.new(response, flag_key)
+          when "429"
+            parse_retry_later_header(response)
+            raise OpenFeature::GoFeatureFlag::RateLimited.new(response)
+          else
+            raise OpenFeature::GoFeatureFlag::InternalServerError.new(response)
+          end
+        end
+
+        private
+
+        def thread_local_socket
+          key = "openfeature_goff_unix_socket_#{object_id}"
+          Thread.current[key] ||= @unix_socket_client_factory.call(@endpoint)
+        end
+      end
+    end
+  end
+end

data/lib/openfeature/go-feature-flag/go_feature_flag_provider.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
+require "openfeature/go-feature-flag/client/http_api"
+require "openfeature/go-feature-flag/client/unix_api"
+
 module OpenFeature
   module GoFeatureFlag
     # This class is the entry point for the GoFeatureFlagProvider
     class Provider
       PROVIDER_NAME = "GO Feature Flag Provider"
+      Client = OpenFeature::GoFeatureFlag::Client
       attr_reader :metadata, :options
 
       def initialize(options: Options.new)
         @metadata = SDK::Provider::ProviderMetadata.new(name: PROVIDER_NAME)
         @options = options
-        @goff_api = GoFeatureFlagApi.new(endpoint: options.endpoint, custom_headers: options.custom_headers, instrumentation: options.instrumentation)
+        @goff_api = build_client(options)
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -95,6 +99,17 @@ module OpenFeature
           raise InvalidOptionError.new(SDK::Provider::ErrorCode::GENERAL, "invalid flag key provided")
         end
       end
+
+      def build_client(options)
+        case options.type
+        when "http"
+          Client::HttpApi.new(endpoint: options.endpoint, custom_headers: options.custom_headers, instrumentation: options.instrumentation)
+        when "unix"
+          Client::UnixApi.new(endpoint: options.endpoint, custom_headers: options.custom_headers)
+        else
+          raise InvalidOptionError.new(SDK::Provider::ErrorCode::GENERAL, "Invalid client type: '#{options.type}'. Supported types are: 'http', 'unix'")
+        end
+      end
     end
   end
 end

data/lib/openfeature/go-feature-flag/internal/http_unix.rb

@@ -0,0 +1,31 @@
+require "net/http"
+
+class HttpUnix < Net::HTTP
+  BufferedIO = ::Net::BufferedIO
+  UNIX_REGEXP = %r{^unix://}i
+
+  def initialize(address, port = nil)
+    super(address, port)
+    @socket_type = "unix"
+    @socket_path = address.sub(UNIX_REGEXP, "")
+
+    @host = "localhost"
+    @port = 1031
+  end
+
+  def connect
+    s = UNIXSocket.open(@socket_path)
+    @socket = BufferedIO.new(s,
+      read_timeout: @read_timeout,
+      continue_timeout: @continue_timeout,
+      debug_output: @debug_output)
+    on_connect
+  end
+
+  def post(url, body, headers)
+    request = Net::HTTP::Post.new(url, headers)
+    request["host"] = "localhost" # required to form correct HTTP request
+    request.body = body.to_json
+    request(request)
+  end
+end

data/lib/openfeature/go-feature-flag/options.rb

@@ -6,11 +6,12 @@ module OpenFeature
   module GoFeatureFlag
     # This class is the configuration class for the GoFeatureFlagProvider
     class Options
-      attr_accessor :endpoint, :custom_headers, :exporter_metadata, :instrumentation
+      attr_accessor :endpoint, :custom_headers, :exporter_metadata, :instrumentation, :type
 
-      def initialize(endpoint: nil, headers: {}, exporter_metadata: {}, instrumentation: nil)
-        validate_endpoint(endpoint: endpoint)
+      def initialize(endpoint: nil, headers: {}, exporter_metadata: {}, instrumentation: nil, type: "http")
+        validate_endpoint(endpoint, type)
         validate_instrumentation(instrumentation: instrumentation)
+        @type = type
         @endpoint = endpoint
         @custom_headers = headers
         @exporter_metadata = exporter_metadata
@@ -19,11 +20,18 @@ module OpenFeature
 
       private
 
-      def validate_endpoint(endpoint: nil)
+      def validate_endpoint(endpoint, type)
         return if endpoint.nil?
 
-        uri = URI.parse(endpoint)
-        raise ArgumentError, "Invalid URL for endpoint: #{endpoint}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+        case type
+        when "http"
+          uri = URI.parse(endpoint)
+          raise ArgumentError, "Invalid URL for endpoint: #{endpoint}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+        when "unix"
+          raise ArgumentError, "File not found: #{endpoint}" unless File.exist?(endpoint)
+        else
+          raise ArgumentError, "Invalid Type: #{type}"
+        end
       rescue URI::InvalidURIError
         raise ArgumentError, "Invalid URL for endpoint: #{endpoint}"
       end

data/lib/openfeature/go-feature-flag/version.rb

@@ -1,5 +1,5 @@
 module OpenFeature
   module GoFeatureFlag
-    GO_FEATURE_FLAG_PROVIDER_VERSION = "0.1.6"
+    GO_FEATURE_FLAG_PROVIDER_VERSION = "0.1.8"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openfeature-go-feature-flag-provider
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Thomas Poignant
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-11 00:00:00.000000000 Z
+date: 2026-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openfeature-sdk
@@ -136,9 +136,12 @@ files:
 - README.md
 - Rakefile
 - bin/rake
+- lib/openfeature/go-feature-flag/client/common.rb
+- lib/openfeature/go-feature-flag/client/http_api.rb
+- lib/openfeature/go-feature-flag/client/unix_api.rb
 - lib/openfeature/go-feature-flag/error/errors.rb
 - lib/openfeature/go-feature-flag/go_feature_flag_provider.rb
-- lib/openfeature/go-feature-flag/goff_api.rb
+- lib/openfeature/go-feature-flag/internal/http_unix.rb
 - lib/openfeature/go-feature-flag/model/ofrep_api_response.rb
 - lib/openfeature/go-feature-flag/options.rb
 - lib/openfeature/go-feature-flag/version.rb

data/lib/openfeature/go-feature-flag/goff_api.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require "open_feature/sdk"
-require "net/http"
-require "json"
-require "faraday/net_http_persistent"
-require_relative "error/errors"
-require_relative "model/ofrep_api_response"
-
-module OpenFeature
-  module GoFeatureFlag
-    # This class is the entry point for the GoFeatureFlagProvider
-    class GoFeatureFlagApi
-      def initialize(endpoint: nil, custom_headers: nil, instrumentation: nil)
-        @faraday_connection = Faraday.new(url: endpoint, headers: headers(custom_headers)) do |f|
-          f.request :instrumentation, instrumentation if instrumentation
-          f.adapter :net_http_persistent do |http|
-            http.idle_timeout = 30
-          end
-        end
-      end
-
-      def evaluate_ofrep_api(flag_key:, evaluation_context:)
-        unless @retry_after.nil?
-          if Time.now < @retry_after
-            raise OpenFeature::GoFeatureFlag::RateLimited.new(nil)
-          else
-            @retry_after = nil
-          end
-        end
-
-        evaluation_context = OpenFeature::SDK::EvaluationContext.new if evaluation_context.nil?
-        # replace targeting_key by targetingKey
-        evaluation_context.fields["targetingKey"] = evaluation_context.targeting_key
-        evaluation_context.fields.delete("targeting_key")
-
-        response = @faraday_connection.post("/ofrep/v1/evaluate/flags/#{flag_key}") do |req|
-          req.body = {context: evaluation_context.fields}.to_json
-        end
-
-        case response.status
-        when 200
-          parse_success_response(response)
-        when 400
-          parse_error_response(response)
-        when 401, 403
-          raise OpenFeature::GoFeatureFlag::UnauthorizedError.new(response)
-        when 404
-          raise OpenFeature::GoFeatureFlag::FlagNotFoundError.new(response, flag_key)
-        when 429
-          parse_retry_later_header(response)
-          raise OpenFeature::GoFeatureFlag::RateLimited.new(response)
-        else
-          raise OpenFeature::GoFeatureFlag::InternalServerError.new(response)
-        end
-      end
-
-      private
-
-      def headers(custom_headers)
-        {"Content-Type" => "application/json"}.merge(custom_headers || {})
-      end
-
-      def parse_error_response(response)
-        required_keys = %w[key error_code]
-        parsed = JSON.parse(response.body)
-
-        missing_keys = required_keys - parsed.keys
-        unless missing_keys.empty?
-          raise OpenFeature::GoFeatureFlag::ParseError.new(response)
-        end
-
-        OpenFeature::GoFeatureFlag::OfrepApiResponse.new(
-          value: nil,
-          key: parsed["key"],
-          reason: SDK::Provider::Reason::ERROR,
-          variant: nil,
-          error_code: error_code_mapper(parsed["error_code"]),
-          error_details: parsed["error_details"],
-          metadata: nil
-        )
-      end
-
-      def parse_success_response(response)
-        required_keys = %w[key value reason variant]
-        parsed = JSON.parse(response.body)
-
-        missing_keys = required_keys - parsed.keys
-        unless missing_keys.empty?
-          raise OpenFeature::GoFeatureFlag::ParseError.new(response)
-        end
-
-        OpenFeature::GoFeatureFlag::OfrepApiResponse.new(
-          value: parsed["value"],
-          key: parsed["key"],
-          reason: reason_mapper(parsed["reason"]),
-          variant: parsed["variant"],
-          error_code: nil,
-          error_details: nil,
-          metadata: parsed["metadata"]
-        )
-      end
-
-      def reason_mapper(reason_str)
-        reason_str = reason_str.upcase
-        reason_map = {
-          "STATIC" => SDK::Provider::Reason::STATIC,
-          "DEFAULT" => SDK::Provider::Reason::DEFAULT,
-          "TARGETING_MATCH" => SDK::Provider::Reason::TARGETING_MATCH,
-          "SPLIT" => SDK::Provider::Reason::SPLIT,
-          "CACHED" => SDK::Provider::Reason::CACHED,
-          "DISABLED" => SDK::Provider::Reason::DISABLED,
-          "UNKNOWN" => SDK::Provider::Reason::UNKNOWN,
-          "STALE" => SDK::Provider::Reason::STALE,
-          "ERROR" => SDK::Provider::Reason::ERROR
-        }
-        reason_map[reason_str] || SDK::Provider::Reason::UNKNOWN
-      end
-
-      def error_code_mapper(error_code_str)
-        error_code_str = error_code_str.upcase
-        error_code_map = {
-          "PROVIDER_NOT_READY" => SDK::Provider::ErrorCode::PROVIDER_NOT_READY,
-          "FLAG_NOT_FOUND" => SDK::Provider::ErrorCode::FLAG_NOT_FOUND,
-          "PARSE_ERROR" => SDK::Provider::ErrorCode::PARSE_ERROR,
-          "TYPE_MISMATCH" => SDK::Provider::ErrorCode::TYPE_MISMATCH,
-          "TARGETING_KEY_MISSING" => SDK::Provider::ErrorCode::TARGETING_KEY_MISSING,
-          "INVALID_CONTEXT" => SDK::Provider::ErrorCode::INVALID_CONTEXT,
-          "GENERAL" => SDK::Provider::ErrorCode::GENERAL
-        }
-        error_code_map[error_code_str] || SDK::Provider::ErrorCode::GENERAL
-      end
-
-      def parse_retry_later_header(response)
-        retry_after = response["Retry-After"]
-        return nil if retry_after.nil?
-
-        begin
-          @retry_after = if /^\d+$/.match?(retry_after)
-            # Retry-After is in seconds
-            Time.now + Integer(retry_after)
-          else
-            # Retry-After is an HTTP-date
-            Time.httpdate(retry_after)
-          end
-        rescue ArgumentError
-          # ignore invalid Retry-After header
-          nil
-        end
-      end
-    end
-  end
-end