launchdarkly-openfeature-server-sdk 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1120d07e2dfc8caa553538ee9e81a28c0d8e49086251f5b267f6b7a81713beb8
-  data.tar.gz: aae128996f603273d9ca9eb4ea1dba80a5b14f67f027cf20840b87abb2973aca
+  metadata.gz: 1246acd88a6e54ba166c00106b8262d5fdb0bd7a8e0ae68b5bf066eae7d883c7
+  data.tar.gz: 62e9efe0c482e5bb4650d5fe9079fe702cb156ecbd5d1fa8b7932a483efcb0a9
 SHA512:
-  metadata.gz: 7fe4363d6defdd32fa8ee9c1cd829d59d8945f7af4a2bd43532da96580d50a2d6068a2d116f954c418e89ba4acaef5fc793f44d84ca0374f98fd139941238fd1
-  data.tar.gz: 4e22e388a089408a98fab7ffffb299df6669749a5a2e6e0fc5db4e4b8c5f079ff7612709ca3d525df6f5b772a27357ff737287c77433a07da84275c8fe9cb25e
+  metadata.gz: 1c403999bb9c8a6bb5a8428ad40ab226174fa5fbee201331e2ca412d84bf1626e73af7fa53f4b4edf6a8e31ee78789e5403ca2749a441520e04c0b752e051936
+  data.tar.gz: ee6272c867a1a1c6f2f1e490b7873e63da1211197035bdd44f4e33013ebea898e26e6489ebfb89ad5e947f90ba222e8f0a6b0842cafc34e64e494953ba132fcc

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.0.0"
+  ".": "0.1.0"
 }

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0 (2024-08-05)
+
+
+### Features
+
+* Add initial implementation of provider ([#1](https://github.com/launchdarkly/openfeature-ruby-server/issues/1)) ([7550e14](https://github.com/launchdarkly/openfeature-ruby-server/commit/7550e14d94f6a70b0087ba9801dfbfe93c1b374d))
+
+## Changelog

data/CODEOWNERS

@@ -0,0 +1,2 @@
+# Repository Maintainers
+* @launchdarkly/team-sdk-ruby

data/CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to the LaunchDarkly OpenFeature provider for the Server-side SDK for Ruby
+
+LaunchDarkly has published an [SDK contributor's guide](https://docs.launchdarkly.com/sdk/concepts/contributors-guide) that provides a detailed explanation of how our SDKs work. See below for additional information on how to contribute to this provider.
+
+## Submitting bug reports and feature requests
+
+The LaunchDarkly SDK team monitors the [issue tracker](https://github.com/launchdarkly/openfeature-ruby-server-sdk/issues) in the provider repository. Bug reports and feature requests specific to this provider should be filed in this issue tracker. The SDK team will respond to all newly filed issues within two business days.
+
+## Submitting pull requests
+
+We encourage pull requests and other contributions from the community. Before submitting pull requests, ensure that all temporary or unintended code is removed. Don't worry about adding reviewers to the pull request; the LaunchDarkly SDK team will add themselves. The SDK team will acknowledge all pull requests within two business days.
+
+## Build instructions
+
+### Prerequisites
+
+This SDK is built with [Bundler](https://bundler.io/). To install Bundler, run `gem install bundler`. You might need `sudo` to execute the command successfully.
+
+To install the runtime dependencies:
+
+```
+bundle install
+```
+
+### Testing
+
+To run all unit tests:
+
+```
+bundle exec rspec spec
+```
+
+### Building documentation
+
+Documentation is built automatically with YARD for each release. To build the documentation locally:
+
+```
+cd docs
+make
+```
+
+The output will appear in `docs/build/html`.
+
+## Code organization
+
+The SDK's namespacing convention is as follows:
+
+* `LaunchDarkly::OpenFeature`: This namespace contains the most commonly used classes and methods in the SDK, such as `Provider`.
+
+A special case is the namespace `LaunchDarkly::OpenFeature::Impl`, and any namespaces within it. Everything under `Impl` is considered a private implementation detail: all files there are excluded from the generated documentation, and are considered subject to change at any time and not supported for direct use by application developers. We do this because Ruby's scope/visibility system is somewhat limited compared to other languages: a method can be `private` or `protected` within a class, but there is no way to make it visible to other classes in the SDK yet invisible to code outside of the SDK, and there is similarly no way to hide a class.
+
+So, if there is a class whose existence is entirely an implementation detail, it should be in `Impl`. Similarly, classes that are _not_ in `Impl` must not expose any public members that are not meant to be part of the supported public API. This is important because of our guarantee of backward compatibility for all public APIs within a major version: we want to be able to change our implementation details to suit the needs of the code, without worrying about breaking a customer's code. Due to how the language works, we can't actually prevent an application developer from referencing those classes in their code, but this convention makes it clear that such use is discouraged and unsupported.
+
+## Documenting types and methods
+
+All classes and public methods outside of `LaunchDarkly::OpenFeature::Impl` should have documentation comments. These are used to build the API documentation that is published at https://launchdarkly.github.io/openfeature-ruby-server-sdk/ and https://www.rubydoc.info/gems/launchdarkly-openfeature-server-sdk. The documentation generator is YARD; see https://yardoc.org/ for the comment format it uses.
+
+Please try to make the style and terminology in documentation comments consistent with other documentation comments in the SDK. Also, if a class or method is being added that has an equivalent in other SDKs, and if we have described it in a consistent away in those other SDKs, please reuse the text whenever possible (with adjustments for anything language-specific) rather than writing new text.

data/Gemfile

@@ -2,9 +2,14 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in openfeature-ruby-server.gemspec
+# Specify your gem's dependencies in launchdarkly-openfeature-server-sdk.gemspec
 gemspec
 
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+gem "rubocop-performance", "~> 1.15"
+gem "rubocop-rake", "~> 0.6"
+gem "rubocop-rspec", "~> 2.27"

data/PROVENANCE.md

@@ -0,0 +1,43 @@
+## Verifying SDK build provenance with the SLSA framework
+
+LaunchDarkly uses the [SLSA framework](https://slsa.dev/spec/v1.0/about) (Supply-chain Levels for Software Artifacts) to help developers make their supply chain more secure by ensuring the authenticity and build integrity of our published SDK packages.
+
+As part of [SLSA requirements for level 3 compliance](https://slsa.dev/spec/v1.0/requirements), LaunchDarkly publishes provenance about our SDK package builds using [GitHub's generic SLSA3 provenance generator](https://github.com/slsa-framework/slsa-github-generator/blob/main/internal/builders/generic/README.md#generation-of-slsa3-provenance-for-arbitrary-projects) for distribution alongside our packages. These attestations are available for download from the GitHub release page for the release version under Assets > `multiple-provenance.intoto.jsonl`.
+
+To verify SLSA provenance attestations, we recommend using [slsa-verifier](https://github.com/slsa-framework/slsa-verifier). Example usage for verifying SDK packages is included below:
+
+<!-- x-release-please-start-version -->
+```
+# Set the version of the SDK to verify
+SDK_VERSION=0.1.0
+```
+<!-- x-release-please-end -->
+
+```
+# Download gem
+$ gem fetch launchdarkly-openfeature-server-sdk -v $SDK_VERSION
+
+# Download provenance from Github release
+$ curl --location -O \
+  https://github.com/launchdarkly/openfeature-ruby-server/releases/download/${SDK_VERSION}/launchdarkly-openfeature-server-sdk-${SDK_VERSION}.gem.intoto.jsonl
+
+# Run slsa-verifier to verify provenance against package artifacts 
+$ slsa-verifier verify-artifact \
+--provenance-path launchdarkly-openfeature-server-sdk-${SDK_VERSION}.gem.intoto.jsonl \
+--source-uri github.com/launchdarkly/openfeature-ruby-server \
+launchdarkly-openfeature-server-sdk-${SDK_VERSION}.gem
+```
+
+Below is a sample of expected output.
+
+```
+Verified signature against tlog entry index 78214752 at URL: https://rekor.sigstore.dev/api/v1/log/entries/24296fb24b8ad77ab941c118ef7e0b2d656b962a0d670c6ac91cfa37d07b7b121ae560b00a978ecf
+Verified build using builder "https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v1.7.0" at commit f43b3ad834103fdc282652efbfe4963e8dfa737b
+Verifying artifact launchdarkly-server-sdk-8.3.0.gem: PASSED
+
+PASSED: Verified SLSA provenance
+```
+
+Alternatively, to verify the provenance manually, the SLSA framework specifies [recommendations for verifying build artifacts](https://slsa.dev/spec/v1.0/verifying-artifacts) in their documentation.
+
+**Note:** These instructions do not apply when building our SDKs from source. 

data/SECURITY.md

@@ -0,0 +1,5 @@
+# Reporting and Fixing Security Issues
+
+Please report all security issues to the LaunchDarkly security team by submitting a bug bounty report to our [HackerOne program](https://hackerone.com/launchdarkly?type=team). LaunchDarkly will triage and address all valid security issues following the response targets defined in our program policy. Valid security issues may be eligible for a bounty.
+
+Please do not open issues or pull requests for security issues. This makes the problem immediately visible to everyone, including potentially malicious actors.

data/docs/Makefile

@@ -0,0 +1,26 @@
+ifeq ($(LD_RELEASE_VERSION),)
+TITLE=LaunchDarkly Ruby OTEL Library
+else
+TITLE=LaunchDarkly Ruby OTEL Library ($(LD_RELEASE_VERSION))
+endif
+
+.PHONY: dependencies html
+
+html: dependencies
+	rm -rf ./build
+	cd .. && yard doc \
+		-o docs/build/html \
+		--title "$(TITLE)" \
+		--no-private \
+		--markup markdown \
+		--embed-mixins \
+		-r docs/index.md \
+		lib/*.rb \
+		lib/**/*.rb \
+		lib/**/**/*.rb \
+		lib/**/**/**/*.rb
+	rm -f build/html/frames.html
+
+dependencies:
+	gem install --conservative yard
+	gem install --conservative redcarpet  # provides Markdown formatting

data/docs/index.md

@@ -0,0 +1,7 @@
+# LaunchDarkly OpenFeature Server-Side Provider
+
+This generated API documentation lists all types and methods in the SDK.
+
+The API documentation for the most recent release is hosted on [GitHub Pages](https://launchdarkly.github.io/openfeature-ruby-server). API documentation for current and past releases is hosted on [RubyDoc.info](https://www.rubydoc.info/gems/launchdarkly-openfeature-server-sdk).
+
+Source code and readme: [GitHub](https://github.com/launchdarkly/openfeature-ruby-server)

data/launchdarkly-openfeature-server-sdk.gemspec

@@ -27,4 +27,10 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "launchdarkly-server-sdk", "~> 8.4.0"
+  spec.add_runtime_dependency "openfeature-sdk", "~> 0.4.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
 end

data/lib/ldclient-openfeature/impl/context_converter.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'ldclient-rb'
+require 'open_feature/sdk'
+
+module LaunchDarkly
+  module OpenFeature
+    module Impl
+      class EvaluationContextConverter
+        #
+        # @param logger [Logger]
+        #
+        def initialize(logger)
+          @logger = logger
+        end
+
+        #
+        # Create an LDContext from an EvaluationContext.
+        #
+        # A context will always be created, but the created context may be invalid. Log messages will be written to
+        # indicate the source of the problem.
+        #
+        # @param context [OpenFeature::SDK::EvaluationContext]
+        #
+        # @return [LaunchDarkly::LDContext]
+        #
+        def to_ld_context(context)
+          kind = context.field('kind')
+
+          return build_multi_context(context) if kind == "multi"
+
+          unless kind.nil? || kind.is_a?(String)
+            @logger.warn("'kind' was set to a non-string value; defaulting to user")
+            kind = 'user'
+          end
+
+          targeting_key = context.targeting_key
+          key = context.field('key')
+          targeting_key = get_targeting_key(targeting_key, key)
+
+          kind ||= 'user'
+          build_single_context(context.fields, kind, targeting_key)
+        end
+
+        #
+        # @param targeting_key [String, nil]
+        # @param key [any]
+        #
+        # @return [String]
+        #
+        private def get_targeting_key(targeting_key, key)
+          # The targeting key may be set but empty. So we want to treat an empty string as a not defined one. Later it
+          # could become null, so we will need to check that.
+          if !targeting_key.nil? && targeting_key != "" && key.is_a?(String)
+            # There is both a targeting key and a key. It will work, but probably is not intentional.
+            @logger.warn("EvaluationContext contained both a 'key' and 'targeting_key'.")
+          end
+
+          @logger.warn("A non-string 'key' attribute was provided.") unless key.nil? || key.is_a?(String)
+
+          targeting_key ||= key unless key.nil? || !key.is_a?(String)
+
+          if targeting_key.nil? || targeting_key == "" || !targeting_key.is_a?(String)
+            @logger.error("The EvaluationContext must contain either a 'targeting_key' or a 'key' and the type must be a string.")
+          end
+
+          targeting_key || ""
+        end
+
+        #
+        # @param context [OpenFeature::SDK::EvaluationContext]
+        #
+        # @return [LaunchDarkly::LDContext]
+        #
+        private def build_multi_context(context)
+          contexts = []
+
+          context.fields.each do |kind, attributes|
+            next if kind == 'kind'
+
+            unless attributes.is_a?(Hash)
+              @logger.warn("Top level attributes in a multi-kind context should be dictionaries")
+              next
+            end
+
+            key = attributes.fetch(:key, nil)
+            targeting_key = attributes.fetch(:targeting_key, nil)
+
+            next unless targeting_key.nil? || targeting_key.is_a?(String)
+
+            targeting_key = get_targeting_key(targeting_key, key)
+            single_context = build_single_context(attributes, kind, targeting_key)
+
+            contexts << single_context
+          end
+
+          LaunchDarkly::LDContext.create_multi(contexts)
+        end
+
+        #
+        # @param attributes [Hash]
+        # @param kind [String]
+        # @param key [String]
+        #
+        # @return [LaunchDarkly::LDContext]
+        #
+        private def build_single_context(attributes, kind, key)
+          context = { kind: kind, key: key }
+
+          attributes.each do |k, v|
+            next if %w[key targeting_key kind].include? k
+
+            if k == 'name' && v.is_a?(String)
+              context[:name] = v
+            elsif k == 'name'
+              @logger.error("The attribute 'name' must be a string")
+              next
+            elsif k == 'anonymous' && [true, false].include?(v)
+              context[:anonymous] = v
+            elsif k == 'anonymous'
+              @logger.error("The attribute 'anonymous' must be a boolean")
+              next
+            elsif k == 'privateAttributes' && v.is_a?(Array)
+              private_attributes = []
+              v.each do |private_attribute|
+                unless private_attribute.is_a?(String)
+                  @logger.error("'privateAttributes' must be an array of only string values")
+                  next
+                end
+
+                private_attributes << private_attribute
+              end
+
+              context[:_meta] = { privateAttributes: private_attributes } unless private_attributes.empty?
+            elsif k == 'privateAttributes'
+              @logger.error("The attribute 'privateAttributes' must be an array")
+            else
+              context[k.to_sym] = v
+            end
+          end
+
+          LaunchDarkly::LDContext.create(context)
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-openfeature/impl/details_converter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'ldclient-rb'
+require 'open_feature/sdk'
+
+module LaunchDarkly
+  module OpenFeature
+    module Impl
+      class ResolutionDetailsConverter
+        #
+        # @param detail [LaunchDarkly::EvaluationDetail]
+        #
+        # @return [OpenFeature::SDK::ResolutionDetails]
+        #
+        def to_resolution_details(detail)
+          value = detail.value
+          is_default = detail.variation_index.nil?
+          variation_index = detail.variation_index
+
+          reason = detail.reason
+          reason_kind = reason.kind
+
+          openfeature_reason = kind_to_reason(reason_kind)
+
+          openfeature_error_code = nil
+          if reason_kind == LaunchDarkly::EvaluationReason::ERROR
+            openfeature_error_code = error_kind_to_code(reason.error_kind)
+          end
+
+          openfeature_variant = nil
+          openfeature_variant = variation_index.to_s unless is_default
+
+          ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+            value: value,
+            error_code: openfeature_error_code,
+            error_message: nil,
+            reason: openfeature_reason,
+            variant: openfeature_variant
+          )
+        end
+
+        #
+        # @param kind [Symbol]
+        #
+        # @return [String]
+        #
+        private def kind_to_reason(kind)
+          case kind
+          when LaunchDarkly::EvaluationReason::OFF
+            ::OpenFeature::SDK::Provider::Reason::DISABLED
+          when LaunchDarkly::EvaluationReason::TARGET_MATCH
+            ::OpenFeature::SDK::Provider::Reason::TARGETING_MATCH
+          when LaunchDarkly::EvaluationReason::ERROR
+            ::OpenFeature::SDK::Provider::Reason::ERROR
+          else
+            # NOTE: FALLTHROUGH, RULE_MATCH, PREREQUISITE_FAILED intentionally
+            kind.to_s
+          end
+        end
+
+        #
+        # @param error_kind [Symbol]
+        #
+        # @return [String]
+        #
+        private def error_kind_to_code(error_kind)
+          return ::OpenFeature::SDK::Provider::ErrorCode::GENERAL if error_kind.nil?
+
+          case error_kind
+          when LaunchDarkly::EvaluationReason::ERROR_CLIENT_NOT_READY
+            ::OpenFeature::SDK::Provider::ErrorCode::PROVIDER_NOT_READY
+          when LaunchDarkly::EvaluationReason::ERROR_FLAG_NOT_FOUND
+            ::OpenFeature::SDK::Provider::ErrorCode::FLAG_NOT_FOUND
+          when LaunchDarkly::EvaluationReason::ERROR_MALFORMED_FLAG
+            ::OpenFeature::SDK::Provider::ErrorCode::PARSE_ERROR
+          when LaunchDarkly::EvaluationReason::ERROR_USER_NOT_SPECIFIED
+            ::OpenFeature::SDK::Provider::ErrorCode::TARGETING_KEY_MISSING
+          else
+            # NOTE: EXCEPTION_ERROR intentionally omitted
+            ::OpenFeature::SDK::Provider::ErrorCode::GENERAL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-openfeature/impl.rb

@@ -0,0 +1,13 @@
+module LaunchDarkly
+  module OpenFeature
+    #
+    # Internal implementation classes. Everything in this module should be considered unsupported
+    # and subject to change.
+    #
+    # @private
+    #
+    module Impl
+      # code is in ldclient-openfeature/impl/
+    end
+  end
+end

data/lib/ldclient-openfeature/provider.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'ldclient-rb'
+require 'open_feature/sdk'
+
+module LaunchDarkly
+  module OpenFeature
+    class Provider
+      #
+      # Retrieve metadata information describing this provider.
+      #
+      # @return [::OpenFeature::SDK::Provider::ProviderMetadata]
+      #
+      attr_reader :metadata
+
+      #
+      # Access the underlying LaunchDarky client instance backing this provider.
+      #
+      # This is useful for accessing additional functionality not exposed by the provider.
+      #
+      # @return [LaunchDarkly::LDClient]
+      #
+      attr_reader :client
+
+      NUMERIC_TYPES = %i[integer float number].freeze
+      private_constant :NUMERIC_TYPES
+
+      #
+      # @param sdk_key [String]
+      # @param config [LaunchDarkly::Config]
+      # @param wait_for_seconds [Float]
+      #
+      def initialize(sdk_key, config = LaunchDarkly::Config.default, wait_for_seconds = 5)
+        @client = LaunchDarkly::LDClient.new(sdk_key, config, wait_for_seconds)
+
+        @context_converter = Impl::EvaluationContextConverter.new(config.logger)
+        @details_converter = Impl::ResolutionDetailsConverter.new
+
+        @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: "launchdarkly-openfeature-server").freeze
+      end
+
+      def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:boolean, flag_key, default_value, evaluation_context)
+      end
+
+      def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:string, flag_key, default_value, evaluation_context)
+      end
+
+      def fetch_number_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:number, flag_key, default_value, evaluation_context)
+      end
+
+      def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:integer, flag_key, default_value, evaluation_context)
+      end
+
+      def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:float, flag_key, default_value, evaluation_context)
+      end
+
+      def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
+        resolve_value(:object, flag_key, default_value, evaluation_context)
+      end
+
+      #
+      # @param flag_type [Symbol]
+      # @param flag_key [String]
+      # @param default_value [any]
+      # @param evaluation_context [::OpenFeature::SDK::EvaluationContext, nil]
+      #
+      # @return [::OpenFeature::SDK::Provider::ResolutionDetails]
+      #
+      private def resolve_value(flag_type, flag_key, default_value, evaluation_context)
+        if evaluation_context.nil?
+          return ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+            value: default_value,
+            reason: ::OpenFeature::SDK::Provider::Reason::ERROR,
+            error_code: ::OpenFeature::SDK::Provider::ErrorCode::TARGETING_KEY_MISSING
+          )
+        end
+
+        ld_context = @context_converter.to_ld_context(evaluation_context)
+        evaluation_detail = @client.variation_detail(flag_key, ld_context, default_value)
+
+        if flag_type == :boolean && ![true, false].include?(evaluation_detail.value)
+          return mismatched_type_details(default_value)
+        elsif flag_type == :string && !evaluation_detail.value.is_a?(String)
+          return mismatched_type_details(default_value)
+        elsif NUMERIC_TYPES.include?(flag_type) && !evaluation_detail.value.is_a?(Numeric)
+          return mismatched_type_details(default_value)
+        elsif flag_type == :object && !evaluation_detail.value.is_a?(Hash) && !evaluation_detail.value.is_a?(Array)
+          return mismatched_type_details(default_value)
+        end
+
+        if flag_type == :integer
+          evaluation_detail = LaunchDarkly::EvaluationDetail.new(
+            evaluation_detail.value.to_i,
+            evaluation_detail.variation_index,
+            evaluation_detail.reason
+          )
+        elsif flag_type == :float
+          evaluation_detail = LaunchDarkly::EvaluationDetail.new(
+            evaluation_detail.value.to_f,
+            evaluation_detail.variation_index,
+            evaluation_detail.reason
+          )
+        end
+
+        @details_converter.to_resolution_details(evaluation_detail)
+      end
+
+      #
+      # @param default_value [any]
+      #
+      # @return [::OpenFeature::SDK::Provider::ResolutionDetails]
+      #
+      private def mismatched_type_details(default_value)
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: default_value,
+          reason: ::OpenFeature::SDK::Provider::Reason::ERROR,
+          error_code: ::OpenFeature::SDK::Provider::ErrorCode::TYPE_MISMATCH
+        )
+      end
+    end
+  end
+end

data/lib/ldclient-openfeature/version.rb

@@ -2,6 +2,6 @@
 
 module LaunchDarkly
   module OpenFeature
-    VERSION = "0.0.0"
+    VERSION = "0.1.0" # x-release-please-version
   end
 end

data/lib/ldclient-openfeature.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "ldclient-openfeature/impl/context_converter"
+require_relative "ldclient-openfeature/impl/details_converter"
+require_relative "ldclient-openfeature/provider"
 require_relative "ldclient-openfeature/version"
 
 require "logger"

data/release-please-config.json

@@ -0,0 +1,12 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "bump-minor-pre-major": true,
+      "versioning": "default",
+      "include-component-in-tag": false,
+      "include-v-in-tag": false,
+      "extra-files": ["PROVENANCE.md", "lib/ldclient-openfeature/version.rb"]
+    }
+  }
+}

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-openfeature-server-sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - LaunchDarkly
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-19 00:00:00.000000000 Z
-dependencies: []
+date: 2024-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: launchdarkly-server-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.4.0
+- !ruby/object:Gem::Dependency
+  name: openfeature-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 description: A LaunchDarkly provider for use with the OpenFeature SDK
 email:
 - team@launchdarkly.com
@@ -20,20 +48,32 @@ files:
 - ".release-please-manifest.json"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
+- CODEOWNERS
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
+- PROVENANCE.md
 - README.md
 - Rakefile
+- SECURITY.md
+- docs/Makefile
+- docs/index.md
 - launchdarkly-openfeature-server-sdk.gemspec
 - lib/ldclient-openfeature.rb
+- lib/ldclient-openfeature/impl.rb
+- lib/ldclient-openfeature/impl/context_converter.rb
+- lib/ldclient-openfeature/impl/details_converter.rb
+- lib/ldclient-openfeature/provider.rb
 - lib/ldclient-openfeature/version.rb
+- release-please-config.json
 homepage: https://github.com/launchdarkly/openfeature-ruby-server
 licenses: []
 metadata:
   homepage_uri: https://github.com/launchdarkly/openfeature-ruby-server
   source_code_uri: https://github.com/launchdarkly/openfeature-ruby-server
   changelog_uri: https://github.com/launchdarkly/openfeature-ruby-server/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -48,8 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.3.27
+signing_key: 
 specification_version: 4
 summary: LaunchDarkly OpenFeature Server SDK
 test_files: []