openfeature-sdk 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af657f35506e7f76184269c57877bbe87cb75f03a2e697e228e9b48f0b2bb17c
-  data.tar.gz: 57944d4c3a74838e73a1f55b4f06e9b82ec4b5186c76ad000577504b30d72d88
+  metadata.gz: 304772054cf10c0cc02870fdeb7a1a7412342912e3f8a08d80c33fe25bd99849
+  data.tar.gz: 6a27c2a8bf23074292594f4eec0ecd4dd9df11ddc1e3e48c4c7ff245e76a6381
 SHA512:
-  metadata.gz: 8dc359e5bb318d79e2fcb48bc0c393c055578cf0a331b02bc61f82910b3da973eaf487457db80d9cd73f12303b15a77cbef9062481933c3d7b4c305de0ed1cc2
-  data.tar.gz: c733ce2f12dbd64ad9fd4e42a5c6cd17c805aa0ab746408c222aee42e6af5ba385ff92baf6cffbf79e4e949dbd7e6b5b2c67937694717ef5b41396353b9f9391
+  metadata.gz: bcaacd882ecdf0ebd0643e1a839bae3d4efb02deb30f2128c5feca91c93e85bee65b755147cf4bef6edabc010875746b777cd4570f26161451a620db396e02e8
+  data.tar.gz: 5a6ba82992f4d8e960d350a573e48a5e015c9b8eb953737354a4573d0a9f89ca6c4615553d0240a91c1490aad8fc3e1c2ca4bfeddc64d0b1203835ede55e1c77

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.6.0"
+  ".": "0.6.2"
 }

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.6.2](https://github.com/open-feature/ruby-sdk/compare/v0.6.1...v0.6.2) (2026-03-07)
+
+
+### Features
+
+* add logging hook (spec Appendix A) ([#229](https://github.com/open-feature/ruby-sdk/issues/229)) ([2f681c9](https://github.com/open-feature/ruby-sdk/commit/2f681c910198d2bfa16389018f42ca9dc3270936))
+* add transaction context propagation (spec 3.3) ([#230](https://github.com/open-feature/ruby-sdk/issues/230)) ([0aff30f](https://github.com/open-feature/ruby-sdk/commit/0aff30f77a0b680341cfd3d1f43e9d1f0ede1b75))
+
+## [0.6.1](https://github.com/open-feature/ruby-sdk/compare/v0.6.0...v0.6.1) (2026-03-05)
+
+
+### Features
+
+* add flag metadata defaulting and immutability ([#221](https://github.com/open-feature/ruby-sdk/issues/221)) ([a300fc5](https://github.com/open-feature/ruby-sdk/commit/a300fc559293169f22eb1ce26f738cdee664cd26))
+* add hook data per-hook mutable state ([#222](https://github.com/open-feature/ruby-sdk/issues/222)) ([28518a0](https://github.com/open-feature/ruby-sdk/commit/28518a0e08143d167b9d34c86e57a583fe5ee0de))
+* add InMemoryProvider context callbacks and event emission ([#224](https://github.com/open-feature/ruby-sdk/issues/224)) ([0a148f6](https://github.com/open-feature/ruby-sdk/commit/0a148f66abc815fc2ec9fd70027075125dbd504a))
+* add shutdown API, provider status, and status short-circuit ([#223](https://github.com/open-feature/ruby-sdk/issues/223)) ([f9c32ad](https://github.com/open-feature/ruby-sdk/commit/f9c32ad1b467af25697423a542bc568597f39743))
+* implement Tracking API (spec section 6) ([#227](https://github.com/open-feature/ruby-sdk/issues/227)) ([5576fce](https://github.com/open-feature/ruby-sdk/commit/5576fce1c3bcf6e7510d8957c7e40e85c4b83b6f))
+* populate event details payload with error_code and message ([#225](https://github.com/open-feature/ruby-sdk/issues/225)) ([a185003](https://github.com/open-feature/ruby-sdk/commit/a185003dc09a69b2dda1fe569d1f82c45979cdad))
+
 ## [0.6.0](https://github.com/open-feature/ruby-sdk/compare/v0.5.1...v0.6.0) (2026-03-05)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    openfeature-sdk (0.6.0)
+    openfeature-sdk (0.6.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -17,8 +17,8 @@
   </a>
   <!-- x-release-please-start-version -->
 
-  <a href="https://github.com/open-feature/ruby-sdk/releases/tag/v0.6.0">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.6.0&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/ruby-sdk/releases/tag/v0.6.2">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.6.2&color=blue&style=for-the-badge" />
   </a>
 
   <!-- x-release-please-end -->
@@ -100,13 +100,14 @@ object = client.fetch_object_value(flag_key: 'object_value', default_value: { na
 | ------ | --------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | ✅      | [Providers](#providers)                                             | Integrate with a commercial, open source, or in-house feature management tool.                                                                               |
 | ✅      | [Targeting](#targeting)                                             | Contextually-aware flag evaluation using [evaluation context](https://openfeature.dev/docs/reference/concepts/evaluation-context).                           |
-| ⚠️      | [Hooks](#hooks)                                                     | Add functionality to various stages of the flag evaluation life-cycle.                                                                                       |
-| ❌      | [Logging](#logging)                                                 | Integrate with popular logging packages.                                                                                                                     |
+| ✅      | [Hooks](#hooks)                                                     | Add functionality to various stages of the flag evaluation life-cycle.                                                                                       |
+| ✅      | [Logging](#logging)                                                 | Integrate with popular logging packages.                                                                                                                     |
 | ✅      | [Domains](#domains)                                                 | Logically bind clients with providers.                                                                                                                       |
 | ✅      | [Eventing](#eventing)                                               | React to state changes in the provider or flag management system.                                                                                            |
-| ⚠️      | [Shutdown](#shutdown)                                               | Gracefully clean up a provider during application shutdown.                                                                                                  |
-| ❌      | [Transaction Context Propagation](#transaction-context-propagation) | Set a specific [evaluation context](https://openfeature.dev/docs/reference/concepts/evaluation-context) for a transaction (e.g. an HTTP request or a thread) |
-| ⚠️      | [Extending](#extending)                                             | Extend OpenFeature with custom providers and hooks.                                                                                                          |
+| ✅      | [Shutdown](#shutdown)                                               | Gracefully clean up a provider during application shutdown.                                                                                                  |
+| ✅      | [Tracking](#tracking)                                               | Associate user actions with feature flag evaluations for experimentation.                                                                                    |
+| ✅      | [Transaction Context Propagation](#transaction-context-propagation) | Set a specific [evaluation context](https://openfeature.dev/docs/reference/concepts/evaluation-context) for a transaction (e.g. an HTTP request or a thread) |
+| ✅      | [Extending](#extending)                                             | Extend OpenFeature with custom providers and hooks.                                                                                                          |
 
 <sub>Implemented: ✅ | In-progress: ⚠️ | Not implemented yet: ❌</sub>
 
@@ -200,21 +201,73 @@ bool_value = client.fetch_boolean_value(
 
 ### Hooks
 
-Coming Soon! [Issue available](https://github.com/open-feature/ruby-sdk/issues/52) to be worked on.
-
-<!-- [Hooks](https://openfeature.dev/docs/reference/concepts/hooks) allow for custom logic to be added at well-defined points of the flag evaluation life-cycle.
+[Hooks](https://openfeature.dev/docs/reference/concepts/hooks) allow for custom logic to be added at well-defined points of the flag evaluation life-cycle.
 Look [here](https://openfeature.dev/ecosystem/?instant_search%5BrefinementList%5D%5Btype%5D%5B0%5D=Hook&instant_search%5BrefinementList%5D%5Btechnology%5D%5B0%5D=Ruby) for a complete list of available hooks.
 If the hook you're looking for hasn't been created yet, see the [develop a hook](#develop-a-hook) section to learn how to build it yourself.
 
-Once you've added a hook as a dependency, it can be registered at the global, client, or flag invocation level. -->
+Hooks can be registered at the global, client, or flag invocation level.
+
+```ruby
+# Define a hook
+class MyHook
+  include OpenFeature::SDK::Hooks::Hook
+
+  def before(hook_context:, hints:)
+    puts "Evaluating flag: #{hook_context.flag_key}"
+    nil
+  end
+
+  def after(hook_context:, evaluation_details:, hints:)
+    puts "Flag #{hook_context.flag_key} evaluated to: #{evaluation_details.value}"
+  end
+
+  def error(hook_context:, exception:, hints:)
+    puts "Error evaluating #{hook_context.flag_key}: #{exception.message}"
+  end
+
+  def finally(hook_context:, evaluation_details:, hints:)
+    puts "Evaluation complete for #{hook_context.flag_key}"
+  end
+end
 
-<!-- TODO: code example of setting hooks at all levels -->
+# Register at the API (global) level
+OpenFeature::SDK.hooks << MyHook.new
+
+# Register at the client level
+client = OpenFeature::SDK.build_client
+client.hooks << MyHook.new
+
+# Register at the invocation level
+client.fetch_boolean_value(
+  flag_key: "my-flag",
+  default_value: false,
+  hooks: [MyHook.new]
+)
+```
 
 ### Logging
 
-Coming Soon! [Issue available](https://github.com/open-feature/ruby-sdk/issues/148) to work on.
+The SDK includes a built-in `LoggingHook` that provides structured log output for flag evaluations. It logs at the `before`, `after`, and `error` stages of the hook lifecycle.
 
-<!-- TODO: talk about logging config and include a code example -->
+```ruby
+# Use the SDK's default logger (from Configuration)
+OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new
+
+# Or provide your own logger
+logger = Logger.new($stdout)
+OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new(logger: logger)
+
+# Optionally include evaluation context in log output
+OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new(
+  logger: logger,
+  include_evaluation_context: true
+)
+```
+
+Log output uses a structured key=value format:
+- **before** (DEBUG): `stage=before domain=my-domain provider_name=my-provider flag_key=my-flag default_value=false`
+- **after** (DEBUG): includes `reason`, `variant`, and `value`
+- **error** (ERROR): includes `error_code` and `error_message`
 
 ### Domains
 
@@ -276,28 +329,94 @@ OpenFeature::SDK.remove_handler(OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
 
 ### Shutdown
 
-Coming Soon! [Issue available](https://github.com/open-feature/ruby-sdk/issues/149) to be worked on.
-
-<!-- TODO The OpenFeature API provides a close function to perform a cleanup of all registered providers.
+The OpenFeature API provides a `shutdown` method to perform cleanup of all registered providers.
 This should only be called when your application is in the process of shutting down.
 
+```ruby
+# Shut down all registered providers and clear state
+OpenFeature::SDK.shutdown
+```
+
+Individual providers can implement a `shutdown` method to perform cleanup:
+
 ```ruby
 class MyProvider
   def shutdown
     # Perform any shutdown/reclamation steps with flag management system here
-    # Return value is ignored
   end
 end
-``` -->
+```
+
+### Tracking
+
+The tracking API allows you to use OpenFeature abstractions and objects to associate user actions with feature flag evaluations.
+This is essential for robust experimentation powered by feature flags.
+For example, a flag enhancing the appearance of a UI component might drive user engagement to a new feature; to test this hypothesis, telemetry collected by a [hook](#hooks) or [provider](#providers) can be associated with telemetry reported in the client's `track` function.
+
+```ruby
+client = OpenFeature::SDK.build_client
+
+# Simple tracking event
+client.track("checkout_completed")
+
+# With evaluation context
+client.track(
+  "purchase",
+  evaluation_context: OpenFeature::SDK::EvaluationContext.new(targeting_key: "user-123")
+)
+
+# With tracking event details (optional numeric value + custom fields)
+details = OpenFeature::SDK::TrackingEventDetails.new(
+  value: 99.99,
+  plan: "premium",
+  currency: "USD"
+)
+client.track("subscription", tracking_event_details: details)
+```
+
+Note that some providers may not support tracking; if the provider does not implement a `track` method, the call is a no-op.
+Check the documentation for your [provider](#providers) for more information.
 
 ### Transaction Context Propagation
 
-Coming Soon! [Issue available](https://github.com/open-feature/ruby-sdk/issues/150) to be worked on.
+Transaction context is a container for transaction-specific evaluation context (e.g. user id, user agent, IP).
+Transaction context can be set where specific data is available (e.g. an auth service or request handler) and by using the transaction context propagator it will automatically be applied to all flag evaluations within a transaction (e.g. a request or thread).
+
+The SDK ships with a `ThreadLocalTransactionContextPropagator` that stores context in `Thread.current`:
 
-<!-- Transaction context is a container for transaction-specific evaluation context (e.g. user id, user agent, IP).
-Transaction context can be set where specific data is available (e.g. an auth service or request handler) and by using the transaction context propagator it will automatically be applied to all flag evaluations within a transaction (e.g. a request or thread). -->
+```ruby
+# Set up the propagator
+OpenFeature::SDK.set_transaction_context_propagator(
+  OpenFeature::SDK::ThreadLocalTransactionContextPropagator.new
+)
 
-<!-- TODO: code example for global shutdown -->
+# Set transaction context (e.g. in a request middleware)
+OpenFeature::SDK.set_transaction_context(
+  OpenFeature::SDK::EvaluationContext.new(targeting_key: "user-123", "email" => "user@example.com")
+)
+
+# Transaction context is automatically merged during flag evaluation.
+# Merge precedence: invocation > client > transaction > API (global)
+client = OpenFeature::SDK.build_client
+client.fetch_boolean_value(flag_key: "my-flag", default_value: false)
+```
+
+You can implement a custom propagator by including the `TransactionContextPropagator` module:
+
+```ruby
+class MyRequestScopedPropagator
+  include OpenFeature::SDK::TransactionContextPropagator
+
+  def set_transaction_context(evaluation_context)
+    # Store context in your request-scoped storage
+    RequestStore[:openfeature_context] = evaluation_context
+  end
+
+  def get_transaction_context
+    RequestStore[:openfeature_context]
+  end
+end
+```
 
 ## Extending
 
@@ -344,6 +463,12 @@ class MyProvider
   def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
     # Retrieve a hash value from provider source
   end
+
+  # Optional: implement tracking support (spec 6.1.4)
+  # If not defined, Client#track is a no-op
+  def track(tracking_event_name, evaluation_context:, tracking_event_details:)
+    # Record a tracking event with your flag management system
+  end
 end
 ```
 
@@ -351,17 +476,29 @@ end
 
 ### Develop a hook
 
-Coming Soon! [Issue available](https://github.com/open-feature/ruby-sdk/issues/52) to be worked on.
-
-<!-- To develop a hook, you need to create a new project and include the OpenFeature SDK as a dependency.
+To develop a hook, you need to create a new project and include the OpenFeature SDK as a dependency.
 This can be a new repository or included in [the existing contrib repository](https://github.com/open-feature/ruby-sdk-contrib) available under the OpenFeature organization.
-Implement your own hook by conforming to the `Hook interface`.
-To satisfy the interface, all methods (`Before`/`After`/`Finally`/`Error`) need to be defined.
-To avoid defining empty functions, make use of the `UnimplementedHook` struct (which already implements all the empty functions). -->
+Implement your own hook by including the `OpenFeature::SDK::Hooks::Hook` module.
+You only need to define the stages you care about — unimplemented stages are no-ops by default.
 
-<!-- TODO: code example of hook implementation -->
+```ruby
+class MyLoggingHook
+  include OpenFeature::SDK::Hooks::Hook
+
+  def before(hook_context:, hints:)
+    puts "Evaluating #{hook_context.flag_key}"
+    nil # Return nil or an EvaluationContext to merge
+  end
+
+  def after(hook_context:, evaluation_details:, hints:)
+    puts "Result: #{evaluation_details.value}"
+  end
+
+  # error and finally are optional — only define what you need
+end
+```
 
-<!-- > Built a new hook? [Let us know](https://github.com/open-feature/openfeature.dev/issues/new?assignees=&labels=hook&projects=&template=document-hook.yaml&title=%5BHook%5D%3A+) so we can add it to the docs! -->
+> Built a new hook? [Let us know](https://github.com/open-feature/openfeature.dev/issues/new?assignees=&labels=hook&projects=&template=document-hook.yaml&title=%5BHook%5D%3A+) so we can add it to the docs!
 
 <!-- x-hide-in-docs-start -->
 ## ⭐️ Support the project

data/lib/open_feature/sdk/api.rb

@@ -10,6 +10,7 @@ require_relative "evaluation_details"
 require_relative "client_metadata"
 require_relative "hooks"
 require_relative "client"
+require_relative "tracking_event_details"
 require_relative "provider"
 
 module OpenFeature
@@ -68,6 +69,19 @@ module OpenFeature
       def logger=(new_logger)
         configuration.logger = new_logger
       end
+
+      def set_transaction_context_propagator(propagator)
+        configuration.transaction_context_propagator = propagator
+      end
+
+      def set_transaction_context(evaluation_context)
+        propagator = configuration.transaction_context_propagator
+        propagator&.set_transaction_context(evaluation_context)
+      end
+
+      def shutdown
+        configuration.shutdown
+      end
     end
   end
 end

data/lib/open_feature/sdk/client.rb

@@ -28,6 +28,10 @@ module OpenFeature
         @hooks = []
       end
 
+      def provider_status
+        OpenFeature::SDK.configuration.provider_state(@provider)
+      end
+
       def add_handler(event_type, handler = nil, &block)
         actual_handler = handler || block
         OpenFeature::SDK.configuration.add_client_handler(self, event_type, actual_handler)
@@ -38,6 +42,18 @@ module OpenFeature
         OpenFeature::SDK.configuration.remove_client_handler(self, event_type, actual_handler)
       end
 
+      # Tracking API (spec 6.1.1.1) — dynamic-context paradigm
+      #
+      # Records a tracking event. If the provider does not implement
+      # tracking, this is a no-op (spec 6.1.4).
+      def track(tracking_event_name, evaluation_context: nil, tracking_event_details: nil)
+        return unless @provider.respond_to?(:track)
+
+        built_context = build_evaluation_context(evaluation_context)
+
+        @provider.track(tracking_event_name, evaluation_context: built_context, tracking_event_details: tracking_event_details)
+      end
+
       RESULT_TYPE.each do |result_type|
         SUFFIXES.each do |suffix|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -54,11 +70,19 @@ module OpenFeature
       def fetch_details(type:, flag_key:, default_value:, evaluation_context: nil, invocation_hooks: [], hook_hints: nil)
         validate_default_value_type(type, default_value)
 
-        built_context = EvaluationContextBuilder.new.call(
-          api_context: OpenFeature::SDK.evaluation_context,
-          client_context: self.evaluation_context,
-          invocation_context: evaluation_context
-        )
+        if OpenFeature::SDK.configuration.provider_tracked?(@provider)
+          error_code = short_circuit_error_code(provider_status)
+          if error_code
+            resolution = Provider::ResolutionDetails.new(
+              value: default_value,
+              error_code: error_code,
+              reason: Provider::Reason::ERROR
+            )
+            return EvaluationDetails.new(flag_key: flag_key, resolution_details: resolution)
+          end
+        end
+
+        built_context = build_evaluation_context(evaluation_context)
 
         # Assemble ordered hooks: API → Client → Invocation → Provider (spec 4.4.2)
         provider_hooks = @provider.respond_to?(:hooks) ? Array(@provider.hooks) : []
@@ -109,6 +133,25 @@ module OpenFeature
         EvaluationDetails.new(flag_key: flag_key, resolution_details: resolution_details)
       end
 
+      def short_circuit_error_code(state)
+        case state
+        when ProviderState::NOT_READY then Provider::ErrorCode::PROVIDER_NOT_READY
+        when ProviderState::FATAL then Provider::ErrorCode::PROVIDER_FATAL
+        end
+      end
+
+      def build_evaluation_context(invocation_context)
+        propagator = OpenFeature::SDK.configuration.transaction_context_propagator
+        transaction_context = propagator&.get_transaction_context
+
+        EvaluationContextBuilder.new.call(
+          api_context: OpenFeature::SDK.evaluation_context,
+          transaction_context: transaction_context,
+          client_context: evaluation_context,
+          invocation_context: invocation_context
+        )
+      end
+
       def validate_default_value_type(type, default_value)
         expected_classes = TYPE_CLASS_MAP[type]
         unless expected_classes.any? { |klass| default_value.is_a?(klass) }

data/lib/open_feature/sdk/configuration.rb

@@ -17,7 +17,7 @@ module OpenFeature
     class Configuration
       extend Forwardable
 
-      attr_accessor :evaluation_context, :hooks
+      attr_accessor :evaluation_context, :hooks, :transaction_context_propagator
       attr_reader :logger
 
       def initialize
@@ -76,6 +76,26 @@ module OpenFeature
         set_provider_internal(provider, domain: domain, wait_for_init: true)
       end
 
+      def provider_state(provider)
+        @provider_state_registry.get_state(provider)
+      end
+
+      def provider_tracked?(provider)
+        @provider_state_registry.tracked?(provider)
+      end
+
+      def shutdown
+        providers_to_shutdown = @provider_mutex.synchronize { @providers.values.uniq }
+
+        providers_to_shutdown.each do |prov|
+          prov.shutdown if prov.respond_to?(:shutdown)
+        rescue => e
+          @logger&.warn("Error shutting down provider #{prov&.class&.name || "unknown"}: #{e.message}")
+        end
+
+        reset
+      end
+
       private
 
       def reset
@@ -171,10 +191,6 @@ module OpenFeature
         run_handlers_for_provider(provider, event_type, event_details)
       end
 
-      def provider_state(provider)
-        @provider_state_registry.get_state(provider)
-      end
-
       private
 
       def extract_provider_name(provider)
@@ -219,8 +235,7 @@ module OpenFeature
             provider_state = @provider_state_registry.get_state(provider)
 
             if event_type == status_to_event[provider_state]
-              provider_name = extract_provider_name(provider)
-              event_details = {provider_name: provider_name}
+              event_details = build_event_details(provider)
 
               begin
                 handler.call(event_details)
@@ -237,8 +252,7 @@ module OpenFeature
           provider_state = @provider_state_registry.get_state(client_provider)
 
           if event_type == status_to_event[provider_state]
-            provider_name = extract_provider_name(client_provider)
-            event_details = {provider_name: provider_name}
+            event_details = build_event_details(client_provider)
 
             begin
               handler.call(event_details)
@@ -248,6 +262,11 @@ module OpenFeature
           end
         end
       end
+
+      def build_event_details(provider)
+        stored_details = @provider_state_registry.get_details(provider)
+        {provider_name: extract_provider_name(provider)}.merge(stored_details)
+      end
     end
   end
 end

data/lib/open_feature/sdk/evaluation_context_builder.rb

@@ -4,8 +4,8 @@ module OpenFeature
   module SDK
     # Used to combine evaluation contexts from different sources
     class EvaluationContextBuilder
-      def call(api_context:, client_context:, invocation_context:)
-        available_contexts = [api_context, client_context, invocation_context].compact
+      def call(api_context:, client_context:, invocation_context:, transaction_context: nil)
+        available_contexts = [api_context, transaction_context, client_context, invocation_context].compact
 
         return nil if available_contexts.empty?
 

data/lib/open_feature/sdk/hooks/hook_context.rb

@@ -22,6 +22,14 @@ module OpenFeature
           @evaluation_context = evaluation_context
           @client_metadata = client_metadata
           @provider_metadata = provider_metadata
+          @hook_data = {}
+        end
+
+        # Returns a mutable hash scoped to the given hook instance.
+        # The same hash is returned across all hook stages (before, after, error, finally),
+        # allowing hooks to share state across their lifecycle (spec 4.1.5, 4.6.1).
+        def hook_data_for(hook)
+          @hook_data[hook.object_id] ||= {}
         end
       end
     end

data/lib/open_feature/sdk/hooks/logging_hook.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module OpenFeature
+  module SDK
+    module Hooks
+      class LoggingHook
+        include Hook
+
+        def initialize(logger: nil, include_evaluation_context: false)
+          @logger = logger
+          @include_evaluation_context = include_evaluation_context
+        end
+
+        def before(hook_context:, hints:)
+          logger&.debug { build_before_message(hook_context) }
+          nil
+        end
+
+        def after(hook_context:, evaluation_details:, hints:)
+          logger&.debug { build_after_message(hook_context, evaluation_details) }
+          nil
+        end
+
+        def error(hook_context:, exception:, hints:)
+          logger&.error { build_error_message(hook_context, exception) }
+          nil
+        end
+
+        private
+
+        def logger
+          @logger || OpenFeature::SDK.configuration.logger
+        end
+
+        def build_before_message(hook_context)
+          parts = base_parts("before", hook_context)
+          parts << "evaluation_context=#{format_context(hook_context.evaluation_context)}" if @include_evaluation_context
+          parts.join(" ")
+        end
+
+        def build_after_message(hook_context, evaluation_details)
+          parts = base_parts("after", hook_context)
+          parts << "reason=#{sanitize(evaluation_details.reason)}" if evaluation_details.reason
+          parts << "variant=#{sanitize(evaluation_details.variant)}" if evaluation_details.variant
+          parts << "value=#{sanitize(evaluation_details.value)}"
+          parts << "evaluation_context=#{format_context(hook_context.evaluation_context)}" if @include_evaluation_context
+          parts.join(" ")
+        end
+
+        def build_error_message(hook_context, exception)
+          parts = base_parts("error", hook_context)
+          error_code = exception.respond_to?(:error_code) ? exception.error_code : Provider::ErrorCode::GENERAL
+          parts << "error_code=#{sanitize(error_code)}"
+          parts << "error_message=#{sanitize(exception.message)}"
+          parts << "evaluation_context=#{format_context(hook_context.evaluation_context)}" if @include_evaluation_context
+          parts.join(" ")
+        end
+
+        def base_parts(stage, hook_context)
+          domain = hook_context.client_metadata&.domain
+          provider_name = hook_context.provider_metadata&.name
+          [
+            "stage=#{stage}",
+            "domain=#{sanitize(domain)}",
+            "provider_name=#{sanitize(provider_name)}",
+            "flag_key=#{sanitize(hook_context.flag_key)}",
+            "default_value=#{sanitize(hook_context.default_value)}"
+          ]
+        end
+
+        def format_context(evaluation_context)
+          return "" unless evaluation_context
+          fields = evaluation_context.fields.dup
+          fields["targeting_key"] = evaluation_context.targeting_key if evaluation_context.targeting_key
+          fields.map { |k, v| "#{sanitize(k)}=#{sanitize(v)}" }.join(", ")
+        end
+
+        def sanitize(value)
+          value.to_s.gsub(/[\n\r]/, " ")
+        end
+      end
+    end
+  end
+end

data/lib/open_feature/sdk/hooks.rb

@@ -4,3 +4,4 @@ require_relative "hooks/hints"
 require_relative "hooks/hook"
 require_relative "hooks/hook_context"
 require_relative "hooks/hook_executor"
+require_relative "hooks/logging_hook"

data/lib/open_feature/sdk/provider/in_memory_provider.rb

@@ -3,8 +3,9 @@
 module OpenFeature
   module SDK
     module Provider
-      # TODO: Add evaluation context support
       class InMemoryProvider
+        include Provider::EventEmitter
+
         NAME = "In-memory Provider"
 
         attr_reader :metadata
@@ -24,7 +25,12 @@ module OpenFeature
 
         def add_flag(flag_key:, value:)
           flags[flag_key] = value
-          # TODO: Emit PROVIDER_CONFIGURATION_CHANGED event once events are implemented
+          emit_provider_changed([flag_key])
+        end
+
+        def update_flags(new_flags)
+          @flags = new_flags.dup
+          emit_provider_changed(new_flags.keys)
         end
 
         def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -56,13 +62,24 @@ module OpenFeature
         attr_reader :flags
 
         def fetch_value(flag_key:, default_value:, evaluation_context:)
-          value = flags[flag_key]
+          raw_value = flags[flag_key]
 
-          if value.nil?
+          if raw_value.nil?
             return ResolutionDetails.new(value: default_value, error_code: ErrorCode::FLAG_NOT_FOUND, reason: Reason::ERROR)
           end
 
-          ResolutionDetails.new(value:, reason: Reason::STATIC)
+          if raw_value.respond_to?(:call)
+            value = raw_value.call(evaluation_context)
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          else
+            ResolutionDetails.new(value: raw_value, reason: Reason::STATIC)
+          end
+        end
+
+        def emit_provider_changed(flag_keys)
+          return unless configuration_attached?
+
+          emit_event(ProviderEvent::PROVIDER_CONFIGURATION_CHANGED, flags_changed: flag_keys)
         end
       end
     end

data/lib/open_feature/sdk/provider/resolution_details.rb

@@ -3,7 +3,20 @@
 module OpenFeature
   module SDK
     module Provider
-      ResolutionDetails = Struct.new(:value, :reason, :variant, :error_code, :error_message, :flag_metadata, keyword_init: true)
+      EMPTY_FLAG_METADATA = {}.freeze
+
+      ResolutionDetails = Struct.new(:value, :reason, :variant, :error_code, :error_message, :flag_metadata, keyword_init: true) do
+        def flag_metadata
+          raw = self[:flag_metadata]
+          if raw.nil?
+            EMPTY_FLAG_METADATA
+          elsif raw.frozen?
+            raw
+          else
+            raw.dup.freeze
+          end
+        end
+      end
     end
   end
 end

data/lib/open_feature/sdk/provider_state_registry.rb

@@ -17,7 +17,7 @@ module OpenFeature
         return unless provider
 
         @mutex.synchronize do
-          @states[provider.object_id] = state
+          @states[provider.object_id] = {state: state, details: {}}
         end
       end
 
@@ -29,7 +29,7 @@ module OpenFeature
         # Only update state if the event should cause a state change
         if new_state
           @mutex.synchronize do
-            @states[provider.object_id] = new_state
+            @states[provider.object_id] = {state: new_state, details: event_details || {}}
           end
           new_state
         else
@@ -42,7 +42,17 @@ module OpenFeature
         return ProviderState::NOT_READY unless provider
 
         @mutex.synchronize do
-          @states[provider.object_id] || ProviderState::NOT_READY
+          entry = @states[provider.object_id]
+          entry ? entry[:state] : ProviderState::NOT_READY
+        end
+      end
+
+      def get_details(provider)
+        return {} unless provider
+
+        @mutex.synchronize do
+          entry = @states[provider.object_id]
+          entry ? entry[:details] : {}
         end
       end
 
@@ -54,6 +64,14 @@ module OpenFeature
         end
       end
 
+      def tracked?(provider)
+        return false unless provider
+
+        @mutex.synchronize do
+          @states.key?(provider.object_id)
+        end
+      end
+
       def ready?(provider)
         get_state(provider) == ProviderState::READY
       end

data/lib/open_feature/sdk/thread_local_transaction_context_propagator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenFeature
+  module SDK
+    class ThreadLocalTransactionContextPropagator
+      include TransactionContextPropagator
+
+      THREAD_KEY = :openfeature_transaction_context
+
+      def set_transaction_context(evaluation_context)
+        Thread.current[THREAD_KEY] = evaluation_context
+      end
+
+      def get_transaction_context
+        Thread.current[THREAD_KEY]
+      end
+    end
+  end
+end

data/lib/open_feature/sdk/tracking_event_details.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OpenFeature
+  module SDK
+    # Represents tracking event details per spec section 6.2.
+    #
+    # Requirement 6.2.1: MUST define an optional numeric value.
+    # Requirement 6.2.2: MUST support custom fields (string keys,
+    # boolean/string/number/structure values).
+    class TrackingEventDetails
+      attr_reader :value, :fields
+
+      def initialize(value: nil, **fields)
+        if !value.nil? && !value.is_a?(Numeric)
+          raise ArgumentError, "Tracking event value must be Numeric, got #{value.class}"
+        end
+
+        @value = value
+        @fields = fields.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/open_feature/sdk/transaction_context_propagator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OpenFeature
+  module SDK
+    module TransactionContextPropagator
+      def set_transaction_context(evaluation_context)
+        raise NotImplementedError
+      end
+
+      def get_transaction_context
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/open_feature/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module OpenFeature
   module SDK
-    VERSION = "0.6.0"
+    VERSION = "0.6.2"
   end
 end

data/lib/open_feature/sdk.rb

@@ -2,6 +2,8 @@
 
 require_relative "sdk/version"
 require_relative "sdk/api"
+require_relative "sdk/transaction_context_propagator"
+require_relative "sdk/thread_local_transaction_context_propagator"
 
 module OpenFeature
   # TODO: Add documentation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openfeature-sdk
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - OpenFeature Authors
@@ -173,6 +173,7 @@ files:
 - lib/open_feature/sdk/hooks/hook.rb
 - lib/open_feature/sdk/hooks/hook_context.rb
 - lib/open_feature/sdk/hooks/hook_executor.rb
+- lib/open_feature/sdk/hooks/logging_hook.rb
 - lib/open_feature/sdk/provider.rb
 - lib/open_feature/sdk/provider/error_code.rb
 - lib/open_feature/sdk/provider/event_emitter.rb
@@ -185,6 +186,9 @@ files:
 - lib/open_feature/sdk/provider_initialization_error.rb
 - lib/open_feature/sdk/provider_state.rb
 - lib/open_feature/sdk/provider_state_registry.rb
+- lib/open_feature/sdk/thread_local_transaction_context_propagator.rb
+- lib/open_feature/sdk/tracking_event_details.rb
+- lib/open_feature/sdk/transaction_context_propagator.rb
 - lib/open_feature/sdk/version.rb
 - release-please-config.json
 - renovate.json