Repository: open-feature/go-sdk
Pull request #75 (2022-09-22 14:47:12)

feat!: introduced context.Context to client and provider api
Signed-off-by: Skye Gill <gill.skye95@gmail.com>

toddbaert: I just want to chime in and say I think this is a good change, as evidenced by the fact some of vendors take the context as well, so it will make integration with them easier.
codecov-commenter: # [Codecov](https://codecov.io/gh/open-feature/go-sdk/pull/75?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature) Report
> Merging [#75](https://codecov.io/gh/open-feature/go-sdk/pull/75?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature) (d124ff7) into [main](https://codecov.io/gh/open-feature/go-sdk/commit/aa59b35d7be363736a29b4101b5c85e00baed919?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature) (aa59b35) will **decrease** coverage by `0.04%`.
> The diff coverage is `100.00%`.

```diff
@@            Coverage Diff             @@
##             main      #75      +/-   ##
==========================================
- Coverage   84.30%   84.26%   -0.05%     
==========================================
  Files           6        6              
  Lines         376      375       -1     
==========================================
- Hits          317      316       -1     
  Misses         54       54              
  Partials        5        5              
```


| [Impacted Files](https://codecov.io/gh/open-feature/go-sdk/pull/75?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature) | Coverage Δ | |
|---|---|---|
| [pkg/openfeature/provider.go](https://codecov.io/gh/open-feature/go-sdk/pull/75/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature#diff-cGtnL29wZW5mZWF0dXJlL3Byb3ZpZGVyLmdv) | `100.00% <ø> (ø)` | |
| [pkg/openfeature/client.go](https://codecov.io/gh/open-feature/go-sdk/pull/75/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature#diff-cGtnL29wZW5mZWF0dXJlL2NsaWVudC5nbw==) | `84.00% <100.00%> (-0.07%)` | :arrow_down: |
| [pkg/openfeature/noop\_provider.go](https://codecov.io/gh/open-feature/go-sdk/pull/75/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature#diff-cGtnL29wZW5mZWF0dXJlL25vb3BfcHJvdmlkZXIuZ28=) | `100.00% <100.00%> (ø)` | |

:mega: We’re building smart automated test selection to slash your CI/CD build times. [Learn more](https://about.codecov.io/iterative-testing/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=open-feature)


Patch:
diff --git a/README.md b/README.md
index 532f7d3..3938854 100644
--- a/README.md
+++ b/README.md
@@ -23,13 +23,16 @@ While you'll likely want a provider for your specific backend, we've provided a
 package main
 
 import (
+	"context"
 	"github.com/open-feature/go-sdk/pkg/openfeature"
 )
 
 func main() {
 	openfeature.SetProvider(openfeature.NoopProvider{})
 	client := openfeature.NewClient("app")
-	value, err := client.BooleanValue("v2_enabled", false, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{})
+	value, err := client.BooleanValue(
+		context.Background(), "v2_enabled", false, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{}, 
+	)
 }
 ```
 
diff --git a/pkg/openfeature/client.go b/pkg/openfeature/client.go
index f63e4b5..1e3dd57 100644
--- a/pkg/openfeature/client.go
+++ b/pkg/openfeature/client.go
@@ -1,6 +1,7 @@
 package openfeature
 
 import (
+	"context"
 	"errors"
 	"fmt"
 
@@ -13,16 +14,16 @@ type IClient interface {
 	AddHooks(hooks ...Hook)
 	SetEvaluationContext(evalCtx EvaluationContext)
 	EvaluationContext() EvaluationContext
-	BooleanValue(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
-	StringValue(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
-	FloatValue(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
-	IntValue(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
-	ObjectValue(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
-	BooleanValueDetails(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-	StringValueDetails(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-	FloatValueDetails(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-	IntValueDetails(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-	ObjectValueDetails(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+	BooleanValue(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
+	StringValue(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
+	FloatValue(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
+	IntValue(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
+	ObjectValue(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
+	BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+	StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+	FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+	IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+	ObjectValueDetails(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
 }
 
 // ClientMetadata provides a client's metadata
@@ -112,10 +113,16 @@ type EvaluationDetails struct {
 	InterfaceResolutionDetail
 }
 
-// BooleanValue return boolean evaluation for flag
-func (c Client) BooleanValue(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error) {
-
-	evalDetails, err := c.evaluate(flag, Boolean, defaultValue, evalCtx, options)
+// BooleanValue performs a flag evaluation that returns a boolean.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) BooleanValue(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error) {
+	evalDetails, err := c.evaluate(ctx, flag, Boolean, defaultValue, evalCtx, options)
 	if err != nil {
 		return defaultValue, err
 	}
@@ -133,9 +140,16 @@ func (c Client) BooleanValue(flag string, defaultValue bool, evalCtx EvaluationC
 	return value, nil
 }
 
-// StringValue return string evaluation for flag
-func (c Client) StringValue(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error) {
-	evalDetails, err := c.evaluate(flag, String, defaultValue, evalCtx, options)
+// StringValue performs a flag evaluation that returns a string.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) StringValue(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error) {
+	evalDetails, err := c.evaluate(ctx, flag, String, defaultValue, evalCtx, options)
 	if err != nil {
 		return defaultValue, err
 	}
@@ -153,9 +167,16 @@ func (c Client) StringValue(flag string, defaultValue string, evalCtx Evaluation
 	return value, nil
 }
 
-// FloatValue return float evaluation for flag
-func (c Client) FloatValue(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error) {
-	evalDetails, err := c.evaluate(flag, Float, defaultValue, evalCtx, options)
+// FloatValue performs a flag evaluation that returns a float64.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) FloatValue(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error) {
+	evalDetails, err := c.evaluate(ctx, flag, Float, defaultValue, evalCtx, options)
 	if err != nil {
 		return defaultValue, err
 	}
@@ -173,9 +194,16 @@ func (c Client) FloatValue(flag string, defaultValue float64, evalCtx Evaluation
 	return value, nil
 }
 
-// IntValue return int evaluation for flag
-func (c Client) IntValue(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error) {
-	evalDetails, err := c.evaluate(flag, Int, defaultValue, evalCtx, options)
+// IntValue performs a flag evaluation that returns an int64.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) IntValue(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error) {
+	evalDetails, err := c.evaluate(ctx, flag, Int, defaultValue, evalCtx, options)
 	if err != nil {
 		return defaultValue, err
 	}
@@ -193,39 +221,81 @@ func (c Client) IntValue(flag string, defaultValue int64, evalCtx EvaluationCont
 	return value, nil
 }
 
-// ObjectValue return object evaluation for flag
-func (c Client) ObjectValue(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error) {
-	evalDetails, err := c.evaluate(flag, Object, defaultValue, evalCtx, options)
+// ObjectValue performs a flag evaluation that returns an object.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) ObjectValue(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error) {
+	evalDetails, err := c.evaluate(ctx, flag, Object, defaultValue, evalCtx, options)
 	return evalDetails.Value, err
 }
 
-// BooleanValueDetails return boolean evaluation for flag
-func (c Client) BooleanValueDetails(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
-	return c.evaluate(flag, Boolean, defaultValue, evalCtx, options)
+// BooleanValueDetails performs a flag evaluation that returns an evaluation details struct.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
+	return c.evaluate(ctx, flag, Boolean, defaultValue, evalCtx, options)
 }
 
-// StringValueDetails return string evaluation for flag
-func (c Client) StringValueDetails(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
-	return c.evaluate(flag, String, defaultValue, evalCtx, options)
+// StringValueDetails performs a flag evaluation that returns an evaluation details struct.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
+	return c.evaluate(ctx, flag, String, defaultValue, evalCtx, options)
 }
 
-// FloatValueDetails return float evaluation for flag
-func (c Client) FloatValueDetails(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
-	return c.evaluate(flag, Float, defaultValue, evalCtx, options)
+// FloatValueDetails performs a flag evaluation that returns an evaluation details struct.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
+	return c.evaluate(ctx, flag, Float, defaultValue, evalCtx, options)
 }
 
-// IntValueDetails return int evaluation for flag
-func (c Client) IntValueDetails(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
-	return c.evaluate(flag, Int, defaultValue, evalCtx, options)
+// IntValueDetails performs a flag evaluation that returns an evaluation details struct.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
+	return c.evaluate(ctx, flag, Int, defaultValue, evalCtx, options)
 }
 
-// ObjectValueDetails return object evaluation for flag
-func (c Client) ObjectValueDetails(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
-	return c.evaluate(flag, Object, defaultValue, evalCtx, options)
+// ObjectValueDetails performs a flag evaluation that returns an evaluation details struct.
+//
+// Parameters:
+// - ctx is the standard go context struct used to manage requests (e.g. timeouts)
+// - flag is the key that uniquely identifies a particular flag
+// - defaultValue is returned if an error occurs
+// - evalCtx is the evaluation context used in a flag evaluation (not to be confused with ctx)
+// - options are optional additional evaluation options
+func (c Client) ObjectValueDetails(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error) {
+	return c.evaluate(ctx, flag, Object, defaultValue, evalCtx, options)
 }
 
 func (c Client) evaluate(
-	flag string, flagType Type, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions,
+	ctx context.Context, flag string, flagType Type, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions,
 ) (EvaluationDetails, error) {
 	c.logger().V(debug).Info(
 		"evaluating flag", "flag", flag, "type", flagType.String(), "defaultValue", defaultValue,
@@ -272,25 +342,25 @@ func (c Client) evaluate(
 	var resolution InterfaceResolutionDetail
 	switch flagType {
 	case Object:
-		resolution = api.provider.ObjectEvaluation(flag, defaultValue, flatCtx)
+		resolution = api.provider.ObjectEvaluation(ctx, flag, defaultValue, flatCtx)
 	case Boolean:
 		defValue := defaultValue.(bool)
-		res := api.provider.BooleanEvaluation(flag, defValue, flatCtx)
+		res := api.provider.BooleanEvaluation(ctx, flag, defValue, flatCtx)
 		resolution.ResolutionDetail = res.ResolutionDetail
 		resolution.Value = res.Value
 	case String:
 		defValue := defaultValue.(string)
-		res := api.provider.StringEvaluation(flag, defValue, flatCtx)
+		res := api.provider.StringEvaluation(ctx, flag, defValue, flatCtx)
 		resolution.ResolutionDetail = res.ResolutionDetail
 		resolution.Value = res.Value
 	case Float:
 		defValue := defaultValue.(float64)
-		res := api.provider.FloatEvaluation(flag, defValue, flatCtx)
+		res := api.provider.FloatEvaluation(ctx, flag, defValue, flatCtx)
 		resolution.ResolutionDetail = res.ResolutionDetail
 		resolution.Value = res.Value
 	case Int:
 		defValue := defaultValue.(int64)
-		res := api.provider.IntEvaluation(flag, defValue, flatCtx)
+		res := api.provider.IntEvaluation(ctx, flag, defValue, flatCtx)
 		resolution.ResolutionDetail = res.ResolutionDetail
 		resolution.Value = res.Value
 	}
diff --git a/pkg/openfeature/noop_provider.go b/pkg/openfeature/noop_provider.go
index bc3a62b..90500f4 100644
--- a/pkg/openfeature/noop_provider.go
+++ b/pkg/openfeature/noop_provider.go
@@ -1,5 +1,7 @@
 package openfeature
 
+import "context"
+
 // NoopProvider implements the FeatureProvider interface and provides functions for evaluating flags
 type NoopProvider struct{}
 
@@ -9,7 +11,7 @@ func (e NoopProvider) Metadata() Metadata {
 }
 
 // BooleanEvaluation returns a boolean flag.
-func (e NoopProvider) BooleanEvaluation(flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail {
+func (e NoopProvider) BooleanEvaluation(ctx context.Context, flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail {
 	return BoolResolutionDetail{
 		Value: defaultValue,
 		ResolutionDetail: ResolutionDetail{
@@ -20,7 +22,7 @@ func (e NoopProvider) BooleanEvaluation(flag string, defaultValue bool, evalCtx
 }
 
 // StringEvaluation returns a string flag.
-func (e NoopProvider) StringEvaluation(flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail {
+func (e NoopProvider) StringEvaluation(ctx context.Context, flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail {
 	return StringResolutionDetail{
 		Value: defaultValue,
 		ResolutionDetail: ResolutionDetail{
@@ -31,7 +33,7 @@ func (e NoopProvider) StringEvaluation(flag string, defaultValue string, evalCtx
 }
 
 // FloatEvaluation returns a float flag.
-func (e NoopProvider) FloatEvaluation(flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail {
+func (e NoopProvider) FloatEvaluation(ctx context.Context, flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail {
 	return FloatResolutionDetail{
 		Value: defaultValue,
 		ResolutionDetail: ResolutionDetail{
@@ -42,7 +44,7 @@ func (e NoopProvider) FloatEvaluation(flag string, defaultValue float64, evalCtx
 }
 
 // IntEvaluation returns an int flag.
-func (e NoopProvider) IntEvaluation(flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail {
+func (e NoopProvider) IntEvaluation(ctx context.Context, flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail {
 	return IntResolutionDetail{
 		Value: defaultValue,
 		ResolutionDetail: ResolutionDetail{
@@ -53,7 +55,7 @@ func (e NoopProvider) IntEvaluation(flag string, defaultValue int64, evalCtx map
 }
 
 // ObjectEvaluation returns an object flag
-func (e NoopProvider) ObjectEvaluation(flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail {
+func (e NoopProvider) ObjectEvaluation(ctx context.Context, flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail {
 	return InterfaceResolutionDetail{
 		Value: defaultValue,
 		ResolutionDetail: ResolutionDetail{
diff --git a/pkg/openfeature/provider.go b/pkg/openfeature/provider.go
index 150d951..a5ff81f 100644
--- a/pkg/openfeature/provider.go
+++ b/pkg/openfeature/provider.go
@@ -1,6 +1,9 @@
 package openfeature
 
-import "errors"
+import (
+	"context"
+	"errors"
+)
 
 const (
 	DISABLED        string = "disabled"     // variant returned because feature is disabled
@@ -17,11 +20,11 @@ const (
 // vendors should implement
 type FeatureProvider interface {
 	Metadata() Metadata
-	BooleanEvaluation(flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail
-	StringEvaluation(flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail
-	FloatEvaluation(flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail
-	IntEvaluation(flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail
-	ObjectEvaluation(flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail
+	BooleanEvaluation(ctx context.Context, flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail
+	StringEvaluation(ctx context.Context, flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail
+	FloatEvaluation(ctx context.Context, flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail
+	IntEvaluation(ctx context.Context, flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail
+	ObjectEvaluation(ctx context.Context, flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail
 	Hooks() []Hook
 }
 


Test patch:
diff --git a/pkg/openfeature/client_example_test.go b/pkg/openfeature/client_example_test.go
index c69e0f9..fba2dd0 100644
--- a/pkg/openfeature/client_example_test.go
+++ b/pkg/openfeature/client_example_test.go
@@ -1,6 +1,7 @@
 package openfeature_test
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -17,7 +18,7 @@ func ExampleNewClient() {
 func ExampleClient_BooleanValue() {
 	client := openfeature.NewClient("example-client")
 	value, err := client.BooleanValue(
-		"test-flag", true, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
+		context.Background(), "test-flag", true, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
 	)
 	if err != nil {
 		log.Fatal("error while getting boolean value : ", err)
@@ -30,7 +31,7 @@ func ExampleClient_BooleanValue() {
 func ExampleClient_StringValue() {
 	client := openfeature.NewClient("example-client")
 	value, err := client.StringValue(
-		"test-flag", "openfeature", openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
+		context.Background(), "test-flag", "openfeature", openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
 	)
 	if err != nil {
 		log.Fatal("error while getting string value : ", err)
@@ -43,7 +44,7 @@ func ExampleClient_StringValue() {
 func ExampleClient_FloatValue() {
 	client := openfeature.NewClient("example-client")
 	value, err := client.FloatValue(
-		"test-flag", 0.55, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
+		context.Background(), "test-flag", 0.55, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
 	)
 	if err != nil {
 		log.Fatalf("error while getting float value: %v", err)
@@ -56,7 +57,7 @@ func ExampleClient_FloatValue() {
 func ExampleClient_IntValue() {
 	client := openfeature.NewClient("example-client")
 	value, err := client.IntValue(
-		"test-flag", 3, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
+		context.Background(), "test-flag", 3, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
 	)
 	if err != nil {
 		log.Fatalf("error while getting int value: %v", err)
@@ -69,7 +70,7 @@ func ExampleClient_IntValue() {
 func ExampleClient_ObjectValue() {
 	client := openfeature.NewClient("example-client")
 	value, err := client.ObjectValue(
-		"test-flag", map[string]string{"foo": "bar"}, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
+		context.Background(), "test-flag", map[string]string{"foo": "bar"}, openfeature.EvaluationContext{}, openfeature.EvaluationOptions{},
 	)
 	if err != nil {
 		log.Fatal("error while getting object value : ", err)
diff --git a/pkg/openfeature/client_test.go b/pkg/openfeature/client_test.go
index e69b373..e6c8a0c 100644
--- a/pkg/openfeature/client_test.go
+++ b/pkg/openfeature/client_test.go
@@ -1,6 +1,7 @@
 package openfeature
 
 import (
+	"context"
 	"reflect"
 	"testing"
 
@@ -60,11 +61,11 @@ func TestRequirements_1_3(t *testing.T) {
 	client := NewClient("test-client")
 
 	type requirements interface {
-		BooleanValue(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
-		StringValue(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
-		FloatValue(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
-		IntValue(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
-		ObjectValue(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
+		BooleanValue(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
+		StringValue(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
+		FloatValue(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
+		IntValue(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
+		ObjectValue(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
 	}
 
 	var clientI interface{} = client
@@ -81,11 +82,11 @@ func TestRequirement_1_4_1(t *testing.T) {
 	client := NewClient("test-client")
 
 	type requirements interface {
-		BooleanValueDetails(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-		StringValueDetails(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-		FloatValueDetails(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-		IntValueDetails(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-		ObjectValueDetails(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+		BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+		StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+		FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+		IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+		ObjectValueDetails(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
 	}
 
 	var clientI interface{} = client
@@ -110,7 +111,7 @@ func TestRequirement_1_4_4(t *testing.T) {
 	flagKey := "foo"
 
 	t.Run("BooleanValueDetails", func(t *testing.T) {
-		evDetails, err := client.BooleanValueDetails(flagKey, true, EvaluationContext{}, EvaluationOptions{})
+		evDetails, err := client.BooleanValueDetails(context.Background(), flagKey, true, EvaluationContext{}, EvaluationOptions{})
 		if err != nil {
 			t.Error(err)
 		}
@@ -123,7 +124,7 @@ func TestRequirement_1_4_4(t *testing.T) {
 	})
 
 	t.Run("StringValueDetails", func(t *testing.T) {
-		evDetails, err := client.StringValueDetails(flagKey, "", EvaluationContext{}, EvaluationOptions{})
+		evDetails, err := client.StringValueDetails(context.Background(), flagKey, "", EvaluationContext{}, EvaluationOptions{})
 		if err != nil {
 			t.Error(err)
 		}
@@ -136,7 +137,7 @@ func TestRequirement_1_4_4(t *testing.T) {
 	})
 
 	t.Run("FloatValueDetails", func(t *testing.T) {
-		evDetails, err := client.FloatValueDetails(flagKey, 1, EvaluationContext{}, EvaluationOptions{})
+		evDetails, err := client.FloatValueDetails(context.Background(), flagKey, 1, EvaluationContext{}, EvaluationOptions{})
 		if err != nil {
 			t.Error(err)
 		}
@@ -149,7 +150,7 @@ func TestRequirement_1_4_4(t *testing.T) {
 	})
 
 	t.Run("IntValueDetails", func(t *testing.T) {
-		evDetails, err := client.IntValueDetails(flagKey, 1, EvaluationContext{}, EvaluationOptions{})
+		evDetails, err := client.IntValueDetails(context.Background(), flagKey, 1, EvaluationContext{}, EvaluationOptions{})
 		if err != nil {
 			t.Error(err)
 		}
@@ -162,7 +163,7 @@ func TestRequirement_1_4_4(t *testing.T) {
 	})
 
 	t.Run("ObjectValueDetails", func(t *testing.T) {
-		evDetails, err := client.ObjectValueDetails(flagKey, 1, EvaluationContext{}, EvaluationOptions{})
+		evDetails, err := client.ObjectValueDetails(context.Background(), flagKey, 1, EvaluationContext{}, EvaluationOptions{})
 		if err != nil {
 			t.Error(err)
 		}
@@ -222,7 +223,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 		defaultValue := true
 		mockProvider.EXPECT().Metadata().AnyTimes()
 		mockProvider.EXPECT().Hooks().AnyTimes()
-		mockProvider.EXPECT().BooleanEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().BooleanEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 			Return(BoolResolutionDetail{
 				Value: false,
 				ResolutionDetail: ResolutionDetail{
@@ -232,7 +233,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			}).Times(2)
 		SetProvider(mockProvider)
 
-		value, err := client.BooleanValue(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		value, err := client.BooleanValue(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected BooleanValue to return an error, got nil")
 		}
@@ -241,7 +242,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			t.Errorf("expected default value from BooleanValue, got %v", value)
 		}
 
-		valueDetails, err := client.BooleanValueDetails(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		valueDetails, err := client.BooleanValueDetails(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected BooleanValueDetails to return an error, got nil")
 		}
@@ -257,7 +258,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 		defaultValue := "default"
 		mockProvider.EXPECT().Metadata().AnyTimes()
 		mockProvider.EXPECT().Hooks().AnyTimes()
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 			Return(StringResolutionDetail{
 				Value: "foo",
 				ResolutionDetail: ResolutionDetail{
@@ -267,7 +268,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			}).Times(2)
 		SetProvider(mockProvider)
 
-		value, err := client.StringValue(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		value, err := client.StringValue(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected StringValue to return an error, got nil")
 		}
@@ -276,7 +277,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			t.Errorf("expected default value from StringValue, got %v", value)
 		}
 
-		valueDetails, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		valueDetails, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected StringValueDetails to return an error, got nil")
 		}
@@ -292,7 +293,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 		defaultValue := 3.14159
 		mockProvider.EXPECT().Metadata().AnyTimes()
 		mockProvider.EXPECT().Hooks().AnyTimes()
-		mockProvider.EXPECT().FloatEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().FloatEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 			Return(FloatResolutionDetail{
 				Value: 0,
 				ResolutionDetail: ResolutionDetail{
@@ -302,7 +303,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			}).Times(2)
 		SetProvider(mockProvider)
 
-		value, err := client.FloatValue(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		value, err := client.FloatValue(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected FloatValue to return an error, got nil")
 		}
@@ -311,7 +312,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			t.Errorf("expected default value from FloatValue, got %v", value)
 		}
 
-		valueDetails, err := client.FloatValueDetails(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		valueDetails, err := client.FloatValueDetails(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected FloatValueDetails to return an error, got nil")
 		}
@@ -327,7 +328,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 		var defaultValue int64 = 3
 		mockProvider.EXPECT().Metadata().AnyTimes()
 		mockProvider.EXPECT().Hooks().AnyTimes()
-		mockProvider.EXPECT().IntEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().IntEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 			Return(IntResolutionDetail{
 				Value: 0,
 				ResolutionDetail: ResolutionDetail{
@@ -337,7 +338,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			}).Times(2)
 		SetProvider(mockProvider)
 
-		value, err := client.IntValue(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		value, err := client.IntValue(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected IntValue to return an error, got nil")
 		}
@@ -346,7 +347,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			t.Errorf("expected default value from IntValue, got %v", value)
 		}
 
-		valueDetails, err := client.IntValueDetails(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		valueDetails, err := client.IntValueDetails(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected FloatValueDetails to return an error, got nil")
 		}
@@ -365,7 +366,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 		defaultValue := obj{foo: "bar"}
 		mockProvider.EXPECT().Metadata().AnyTimes()
 		mockProvider.EXPECT().Hooks().AnyTimes()
-		mockProvider.EXPECT().ObjectEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().ObjectEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 			Return(InterfaceResolutionDetail{
 				ResolutionDetail: ResolutionDetail{
 					ErrorCode: "GENERAL",
@@ -374,7 +375,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			}).Times(2)
 		SetProvider(mockProvider)
 
-		value, err := client.ObjectValue(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		value, err := client.ObjectValue(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected ObjectValue to return an error, got nil")
 		}
@@ -383,7 +384,7 @@ func TestRequirement_1_4_9(t *testing.T) {
 			t.Errorf("expected default value from ObjectValue, got %v", value)
 		}
 
-		valueDetails, err := client.ObjectValueDetails(flagKey, defaultValue, evalCtx, EvaluationOptions{})
+		valueDetails, err := client.ObjectValueDetails(context.Background(), flagKey, defaultValue, evalCtx, EvaluationOptions{})
 		if err == nil {
 			t.Error("expected ObjectValueDetails to return an error, got nil")
 		}
@@ -505,10 +506,10 @@ func TestBeforeHookNilContext(t *testing.T) {
 	client := NewClient("test")
 	attributes := map[string]interface{}{"should": "persist"}
 	evalCtx := EvaluationContext{Attributes: attributes}
-	mockProvider.EXPECT().BooleanEvaluation(gomock.Any(), gomock.Any(), attributes)
+	mockProvider.EXPECT().BooleanEvaluation(gomock.Any(), gomock.Any(), gomock.Any(), attributes)
 
 	_, err := client.BooleanValue(
-		"foo", false, evalCtx, NewEvaluationOptions([]Hook{hookNilContext}, HookHints{}),
+		context.Background(), "foo", false, evalCtx, NewEvaluationOptions([]Hook{hookNilContext}, HookHints{}),
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -534,7 +535,7 @@ func TestClientLoggerUsesLatestGlobalLogger(t *testing.T) {
 
 	client := NewClient("test")
 	SetLogger(logr.New(l))
-	_, err := client.BooleanValue("foo", false, EvaluationContext{}, EvaluationOptions{})
+	_, err := client.BooleanValue(context.Background(), "foo", false, EvaluationContext{}, EvaluationOptions{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -554,7 +555,7 @@ func TestErrorCodeFromProviderReturnedInEvaluationDetails(t *testing.T) {
 	mockProvider.EXPECT().Metadata().AnyTimes()
 	mockProvider.EXPECT().Hooks().AnyTimes()
 	SetProvider(mockProvider)
-	mockProvider.EXPECT().BooleanEvaluation(gomock.Any(), gomock.Any(), gomock.Any()).
+	mockProvider.EXPECT().BooleanEvaluation(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(BoolResolutionDetail{
 			Value: true,
 			ResolutionDetail: ResolutionDetail{
@@ -565,7 +566,9 @@ func TestErrorCodeFromProviderReturnedInEvaluationDetails(t *testing.T) {
 		})
 
 	client := NewClient("test")
-	evalDetails, err := client.evaluate("foo", Boolean, true, EvaluationContext{}, EvaluationOptions{})
+	evalDetails, err := client.evaluate(
+		context.Background(), "foo", Boolean, true, EvaluationContext{}, EvaluationOptions{},
+	)
 	if err == nil {
 		t.Error("expected err, got nil")
 	}
diff --git a/pkg/openfeature/evaluation_context_test.go b/pkg/openfeature/evaluation_context_test.go
index 7af3a03..d349357 100644
--- a/pkg/openfeature/evaluation_context_test.go
+++ b/pkg/openfeature/evaluation_context_test.go
@@ -1,6 +1,7 @@
 package openfeature
 
 import (
+	"context"
 	"reflect"
 	"testing"
 
@@ -63,16 +64,16 @@ func TestRequirement_3_2_1(t *testing.T) {
 		client := NewClient("test")
 
 		type requirement interface {
-			BooleanValue(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
-			StringValue(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
-			FloatValue(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
-			IntValue(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
-			ObjectValue(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
-			BooleanValueDetails(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			StringValueDetails(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			FloatValueDetails(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			IntValueDetails(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			ObjectValueDetails(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			BooleanValue(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
+			StringValue(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
+			FloatValue(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
+			IntValue(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
+			ObjectValue(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
+			BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			ObjectValueDetails(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
 		}
 
 		var clientI interface{} = client
@@ -133,9 +134,9 @@ func TestRequirement_3_2_2(t *testing.T) {
 		},
 	}
 	flatCtx := flattenContext(expectedMergedEvalCtx)
-	mockProvider.EXPECT().StringEvaluation(gomock.Any(), gomock.Any(), flatCtx)
+	mockProvider.EXPECT().StringEvaluation(gomock.Any(), gomock.Any(), gomock.Any(), flatCtx)
 
-	_, err := client.StringValue("foo", "bar", invocationEvalCtx, EvaluationOptions{})
+	_, err := client.StringValue(context.Background(), "foo", "bar", invocationEvalCtx, EvaluationOptions{})
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/pkg/openfeature/hooks_test.go b/pkg/openfeature/hooks_test.go
index ae27567..d72de6f 100644
--- a/pkg/openfeature/hooks_test.go
+++ b/pkg/openfeature/hooks_test.go
@@ -1,6 +1,7 @@
 package openfeature
 
 import (
+	"context"
 	"errors"
 	"reflect"
 	"testing"
@@ -167,12 +168,12 @@ func TestRequirement_4_3_2(t *testing.T) {
 		mockProvider.EXPECT().Hooks().AnyTimes()
 
 		// assert that the Before hooks are executed prior to the flag evaluation
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx).
+		mockProvider.EXPECT().StringEvaluation(gomock.Any(), flagKey, defaultValue, flatCtx).
 			After(mockHook.EXPECT().Before(gomock.Any(), gomock.Any()))
 		mockHook.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any())
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err != nil {
 			t.Errorf("unexpected err: %v", err)
 		}
@@ -222,7 +223,7 @@ func TestRequirement_4_3_3(t *testing.T) {
 	hook1EvalCtxResult := &EvaluationContext{TargetingKey: "mockHook1"}
 	hook1EvalCtxResultFlat := flattenContext(*hook1EvalCtxResult)
 	mockHook1.EXPECT().Before(hook1Ctx, gomock.Any()).Return(hook1EvalCtxResult, nil)
-	mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, hook1EvalCtxResultFlat)
+	mockProvider.EXPECT().StringEvaluation(gomock.Any(), flagKey, defaultValue, hook1EvalCtxResultFlat)
 
 	// assert that the evaluation context returned by the first hook is passed into the second hook
 	hook2Ctx := hook1Ctx
@@ -234,7 +235,7 @@ func TestRequirement_4_3_3(t *testing.T) {
 	mockHook2.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any())
 	mockHook2.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-	_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+	_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 	if err != nil {
 		t.Errorf("unexpected err: %v", err)
 	}
@@ -301,11 +302,11 @@ func TestRequirement_4_3_4(t *testing.T) {
 			"beatsClient":    true,
 		},
 	}
-	mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flattenContext(expectedMergedContext))
+	mockProvider.EXPECT().StringEvaluation(gomock.Any(), flagKey, defaultValue, flattenContext(expectedMergedContext))
 	mockHook.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any())
 	mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-	_, err := client.StringValueDetails(flagKey, defaultValue, invEvalCtx, evalOptions)
+	_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, invEvalCtx, evalOptions)
 	if err != nil {
 		t.Errorf("unexpected err: %v", err)
 	}
@@ -335,10 +336,10 @@ func TestRequirement_4_3_5(t *testing.T) {
 		mockHook.EXPECT().Before(gomock.Any(), gomock.Any())
 		// assert that the After hooks are executed after the flag evaluation
 		mockHook.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any()).
-			After(mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx))
+			After(mockProvider.EXPECT().StringEvaluation(gomock.Any(), flagKey, defaultValue, flatCtx))
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err != nil {
 			t.Errorf("unexpected err: %v", err)
 		}
@@ -385,7 +386,7 @@ func TestRequirement_4_3_6(t *testing.T) {
 			After(mockHook.EXPECT().Before(gomock.Any(), gomock.Any()).Return(nil, errors.New("forced")))
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
@@ -405,12 +406,12 @@ func TestRequirement_4_3_6(t *testing.T) {
 		// assert that the Error hooks are executed after the failed flag evaluation
 		mockHook.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any()).
 			After(
-				mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx).
+				mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx).
 					Return(StringResolutionDetail{ResolutionDetail: ResolutionDetail{ErrorCode: "forced"}}),
 			)
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
@@ -427,13 +428,13 @@ func TestRequirement_4_3_6(t *testing.T) {
 		mockProvider.EXPECT().Hooks().AnyTimes()
 
 		mockHook.EXPECT().Before(gomock.Any(), gomock.Any())
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx)
+		mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx)
 		// assert that the Error hooks are executed after the failed After hooks
 		mockHook.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any()).
 			After(mockHook.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("forced")))
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
@@ -478,9 +479,9 @@ func TestRequirement_4_3_7(t *testing.T) {
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any()).
 			After(mockHook.EXPECT().After(gomock.Any(), gomock.Any(), gomock.Any())).
 			After(mockHook.EXPECT().Before(gomock.Any(), gomock.Any()))
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx)
+		mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx)
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err != nil {
 			t.Errorf("unexpected err: %v", err)
 		}
@@ -501,7 +502,7 @@ func TestRequirement_4_3_7(t *testing.T) {
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any()).
 			After(mockHook.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any()))
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
@@ -565,16 +566,16 @@ func TestRequirement_4_4_1(t *testing.T) {
 
 		// EvaluationOptions contains the hooks registered at invocation
 		type requirement interface {
-			BooleanValue(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
-			StringValue(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
-			FloatValue(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
-			IntValue(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
-			ObjectValue(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
-			BooleanValueDetails(flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			StringValueDetails(flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			FloatValueDetails(flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			IntValueDetails(flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
-			ObjectValueDetails(flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			BooleanValue(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (bool, error)
+			StringValue(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (string, error)
+			FloatValue(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (float64, error)
+			IntValue(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (int64, error)
+			ObjectValue(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (interface{}, error)
+			BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
+			ObjectValueDetails(ctx context.Context, flag string, defaultValue interface{}, evalCtx EvaluationContext, options EvaluationOptions) (EvaluationDetails, error)
 		}
 
 		var clientI interface{} = client
@@ -629,9 +630,9 @@ func TestRequirement_4_4_2(t *testing.T) {
 			After(mockInvocationHook.EXPECT().Finally(gomock.Any(), gomock.Any())).
 			After(mockProviderHook.EXPECT().Finally(gomock.Any(), gomock.Any()))
 
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx)
+		mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx)
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err != nil {
 			t.Errorf("unexpected err: %v", err)
 		}
@@ -667,7 +668,7 @@ func TestRequirement_4_4_2(t *testing.T) {
 		mockClientHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 		mockAPIHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
@@ -722,7 +723,7 @@ func TestRequirement_4_4_6(t *testing.T) {
 			mockHook2.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any())
 			mockHook2.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-			_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+			_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 			if err == nil {
 				t.Error("expected error, got nil")
 			}
@@ -751,9 +752,9 @@ func TestRequirement_4_4_6(t *testing.T) {
 			mockHook2.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any())
 			mockHook2.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-			mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx)
+			mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx)
 
-			_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+			_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 			if err == nil {
 				t.Error("expected error, got nil")
 			}
@@ -783,7 +784,7 @@ func TestRequirement_4_4_7(t *testing.T) {
 	mockHook.EXPECT().Error(gomock.Any(), gomock.Any(), gomock.Any())
 	mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-	res, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+	res, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 	if err == nil {
 		t.Error("expected error, got nil")
 	}
@@ -824,9 +825,9 @@ func TestRequirement_4_5_2(t *testing.T) {
 		mockHook.EXPECT().After(gomock.Any(), gomock.Any(), hookHints)
 		mockHook.EXPECT().Finally(gomock.Any(), hookHints)
 
-		mockProvider.EXPECT().StringEvaluation(flagKey, defaultValue, flatCtx)
+		mockProvider.EXPECT().StringEvaluation(context.Background(), flagKey, defaultValue, flatCtx)
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -848,7 +849,7 @@ func TestRequirement_4_5_2(t *testing.T) {
 		mockHook.EXPECT().Error(gomock.Any(), gomock.Any(), hookHints)
 		mockHook.EXPECT().Finally(gomock.Any(), gomock.Any())
 
-		_, err := client.StringValueDetails(flagKey, defaultValue, evalCtx, evalOptions)
+		_, err := client.StringValueDetails(context.Background(), flagKey, defaultValue, evalCtx, evalOptions)
 		if err == nil {
 			t.Error("expected error, got nil")
 		}
diff --git a/pkg/openfeature/provider_mock_test.go b/pkg/openfeature/provider_mock_test.go
index 161d001..bcdb2b1 100644
--- a/pkg/openfeature/provider_mock_test.go
+++ b/pkg/openfeature/provider_mock_test.go
@@ -5,6 +5,7 @@
 package openfeature
 
 import (
+	context "context"
 	reflect "reflect"
 
 	gomock "github.com/golang/mock/gomock"
@@ -34,31 +35,31 @@ func (m *MockFeatureProvider) EXPECT() *MockFeatureProviderMockRecorder {
 }
 
 // BooleanEvaluation mocks base method.
-func (m *MockFeatureProvider) BooleanEvaluation(flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail {
+func (m *MockFeatureProvider) BooleanEvaluation(ctx context.Context, flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BooleanEvaluation", flag, defaultValue, evalCtx)
+	ret := m.ctrl.Call(m, "BooleanEvaluation", ctx, flag, defaultValue, evalCtx)
 	ret0, _ := ret[0].(BoolResolutionDetail)
 	return ret0
 }
 
 // BooleanEvaluation indicates an expected call of BooleanEvaluation.
-func (mr *MockFeatureProviderMockRecorder) BooleanEvaluation(flag, defaultValue, evalCtx interface{}) *gomock.Call {
+func (mr *MockFeatureProviderMockRecorder) BooleanEvaluation(ctx, flag, defaultValue, evalCtx interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BooleanEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).BooleanEvaluation), flag, defaultValue, evalCtx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BooleanEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).BooleanEvaluation), ctx, flag, defaultValue, evalCtx)
 }
 
 // FloatEvaluation mocks base method.
-func (m *MockFeatureProvider) FloatEvaluation(flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail {
+func (m *MockFeatureProvider) FloatEvaluation(ctx context.Context, flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FloatEvaluation", flag, defaultValue, evalCtx)
+	ret := m.ctrl.Call(m, "FloatEvaluation", ctx, flag, defaultValue, evalCtx)
 	ret0, _ := ret[0].(FloatResolutionDetail)
 	return ret0
 }
 
 // FloatEvaluation indicates an expected call of FloatEvaluation.
-func (mr *MockFeatureProviderMockRecorder) FloatEvaluation(flag, defaultValue, evalCtx interface{}) *gomock.Call {
+func (mr *MockFeatureProviderMockRecorder) FloatEvaluation(ctx, flag, defaultValue, evalCtx interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FloatEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).FloatEvaluation), flag, defaultValue, evalCtx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FloatEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).FloatEvaluation), ctx, flag, defaultValue, evalCtx)
 }
 
 // Hooks mocks base method.
@@ -76,17 +77,17 @@ func (mr *MockFeatureProviderMockRecorder) Hooks() *gomock.Call {
 }
 
 // IntEvaluation mocks base method.
-func (m *MockFeatureProvider) IntEvaluation(flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail {
+func (m *MockFeatureProvider) IntEvaluation(ctx context.Context, flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IntEvaluation", flag, defaultValue, evalCtx)
+	ret := m.ctrl.Call(m, "IntEvaluation", ctx, flag, defaultValue, evalCtx)
 	ret0, _ := ret[0].(IntResolutionDetail)
 	return ret0
 }
 
 // IntEvaluation indicates an expected call of IntEvaluation.
-func (mr *MockFeatureProviderMockRecorder) IntEvaluation(flag, defaultValue, evalCtx interface{}) *gomock.Call {
+func (mr *MockFeatureProviderMockRecorder) IntEvaluation(ctx, flag, defaultValue, evalCtx interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).IntEvaluation), flag, defaultValue, evalCtx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).IntEvaluation), ctx, flag, defaultValue, evalCtx)
 }
 
 // Metadata mocks base method.
@@ -104,29 +105,29 @@ func (mr *MockFeatureProviderMockRecorder) Metadata() *gomock.Call {
 }
 
 // ObjectEvaluation mocks base method.
-func (m *MockFeatureProvider) ObjectEvaluation(flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail {
+func (m *MockFeatureProvider) ObjectEvaluation(ctx context.Context, flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ObjectEvaluation", flag, defaultValue, evalCtx)
+	ret := m.ctrl.Call(m, "ObjectEvaluation", ctx, flag, defaultValue, evalCtx)
 	ret0, _ := ret[0].(InterfaceResolutionDetail)
 	return ret0
 }
 
 // ObjectEvaluation indicates an expected call of ObjectEvaluation.
-func (mr *MockFeatureProviderMockRecorder) ObjectEvaluation(flag, defaultValue, evalCtx interface{}) *gomock.Call {
+func (mr *MockFeatureProviderMockRecorder) ObjectEvaluation(ctx, flag, defaultValue, evalCtx interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).ObjectEvaluation), flag, defaultValue, evalCtx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).ObjectEvaluation), ctx, flag, defaultValue, evalCtx)
 }
 
 // StringEvaluation mocks base method.
-func (m *MockFeatureProvider) StringEvaluation(flag, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail {
+func (m *MockFeatureProvider) StringEvaluation(ctx context.Context, flag, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StringEvaluation", flag, defaultValue, evalCtx)
+	ret := m.ctrl.Call(m, "StringEvaluation", ctx, flag, defaultValue, evalCtx)
 	ret0, _ := ret[0].(StringResolutionDetail)
 	return ret0
 }
 
 // StringEvaluation indicates an expected call of StringEvaluation.
-func (mr *MockFeatureProviderMockRecorder) StringEvaluation(flag, defaultValue, evalCtx interface{}) *gomock.Call {
+func (mr *MockFeatureProviderMockRecorder) StringEvaluation(ctx, flag, defaultValue, evalCtx interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StringEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).StringEvaluation), flag, defaultValue, evalCtx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StringEvaluation", reflect.TypeOf((*MockFeatureProvider)(nil).StringEvaluation), ctx, flag, defaultValue, evalCtx)
 }
diff --git a/pkg/openfeature/provider_test.go b/pkg/openfeature/provider_test.go
index 80e54a3..5c1983e 100644
--- a/pkg/openfeature/provider_test.go
+++ b/pkg/openfeature/provider_test.go
@@ -1,6 +1,7 @@
 package openfeature
 
 import (
+	"context"
 	"reflect"
 	"testing"
 
@@ -41,11 +42,11 @@ func TestRequirement_2_2(t *testing.T) {
 	mockProvider := NewMockFeatureProvider(ctrl)
 
 	type requirements interface {
-		BooleanEvaluation(flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail
-		StringEvaluation(flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail
-		FloatEvaluation(flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail
-		IntEvaluation(flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail
-		ObjectEvaluation(flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail
+		BooleanEvaluation(ctx context.Context, flag string, defaultValue bool, evalCtx map[string]interface{}) BoolResolutionDetail
+		StringEvaluation(ctx context.Context, flag string, defaultValue string, evalCtx map[string]interface{}) StringResolutionDetail
+		FloatEvaluation(ctx context.Context, flag string, defaultValue float64, evalCtx map[string]interface{}) FloatResolutionDetail
+		IntEvaluation(ctx context.Context, flag string, defaultValue int64, evalCtx map[string]interface{}) IntResolutionDetail
+		ObjectEvaluation(ctx context.Context, flag string, defaultValue interface{}, evalCtx map[string]interface{}) InterfaceResolutionDetail
 	}
 
 	var mockProviderI interface{} = mockProvider