feat: add feature flag go sdk

featureflags/README.md

@@ -0,0 +1,43 @@
+
+# Feature Flags Package
+
+A Go package for managing feature flags using Flagsmith as the provider.
+
+## Prerequisites
+
+Before using this package, ensure you have set the following environment variable:
+
+```bash
+export FLAGSMITH_SERVER_SIDE_ENVIRONMENT_KEY=your-api-key
+```
+
+## Usage Example
+
+Here's a basic example of how to use the feature flags package:
+
+```go
+package main
+
+import (
+    "fmt"
+    "log"
+
+    "github.com/rudderlabs/rudder-go-kit/featureflags"
+)
+
+func main() {
+    // Set default traits (optional)
+    featureflags.SetDefaultTraits(map[string]string{
+        "exampleTrait": "exampleTraitValue",
+    })
+
+    // Check if a feature is enabled
+    isEnabled, err := featureflags.IsFeatureEnabled("testWs", "testFeature")
+    if err != nil {
+        log.Fatal(err)
+    }
+    fmt.Println(isEnabled)
+}
+```
+
+For more detailed examples and implementation details, refer to the example directory.

featureflags/cache/cache.go

@@ -0,0 +1,43 @@
+package cache
+
+import (
+	"time"
+
+	"github.com/rudderlabs/rudder-go-kit/featureflags/provider"
+)
+
+// CacheEntry represents a cached item with its value and last updated timestamp
+type CacheEntry struct {
+	Value       map[string]*provider.FeatureValue
+	LastUpdated time.Time
+}
+
+// CacheGetResult extends CacheEntry with staleness information
+type CacheGetResult struct {
+	*CacheEntry
+	IsStale bool
+}
+
+// Cache defines the interface for cache operations
+type Cache interface {
+	Get(key string) (*CacheGetResult, bool)
+	Set(key string, value map[string]*provider.FeatureValue) (time.Time, error)
+	Delete(key string) error
+	Clear() error
+	IsEnabled() bool
+}
+
+// CacheError represents cache-specific errors
+type CacheError struct {
+	Message string
+}
+
+func (e *CacheError) Error() string {
+	return e.Message
+}
+
+// CacheConfig holds configuration for the cache
+type CacheConfig struct {
+	Enabled      bool
+	TTLInSeconds int64
+}

featureflags/cache/cache_test.go

@@ -0,0 +1,70 @@
+package cache_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/rudderlabs/rudder-go-kit/featureflags/cache"
+	"github.com/rudderlabs/rudder-go-kit/featureflags/provider"
+)
+
+func TestMemoryCache(t *testing.T) {
+	config := cache.CacheConfig{
+		Enabled:      true,
+		TTLInSeconds: 1,
+	}
+
+	c := cache.NewMemoryCache(config)
+
+	testValue := map[string]*provider.FeatureValue{
+		"key1": {
+			Value: "value1",
+		},
+	}
+
+	// Test Set and Get
+	setTime, err := c.Set("key1", testValue)
+	if err != nil {
+		t.Errorf("Failed to set cache: %v", err)
+	}
+
+	result, ok := c.Get("key1")
+	if !ok {
+		t.Error("Expected cache hit, got miss")
+	}
+	if result.LastUpdated != setTime {
+		t.Error("LastUpdated time mismatch")
+	}
+
+	// Test staleness
+	time.Sleep(2 * time.Second)
+	result, ok = c.Get("key1")
+	if !ok {
+		t.Error("Expected stale cache entry")
+	}
+
+	// Test Delete
+	err = c.Delete("key1")
+	if err != nil {
+		t.Errorf("Failed to delete cache: %v", err)
+	}
+
+	result, ok = c.Get("key1")
+	if ok {
+		t.Error("Expected cache miss after delete")
+	}
+
+	// Test Clear
+	c.Set("key1", testValue)
+	c.Set("key2", testValue)
+
+	err = c.Clear()
+	if err != nil {
+		t.Errorf("Failed to clear cache: %v", err)
+	}
+
+	result, ok = c.Get("key1")
+	if ok {
+		t.Error("Expected cache miss after clear")
+	}
+}

featureflags/cache/memory.go

@@ -0,0 +1,91 @@
+package cache
+
+import (
+	"sync"
+	"time"
+
+	"github.com/rudderlabs/rudder-go-kit/featureflags/provider"
+)
+
+type MemoryCache struct {
+	entries map[string]CacheEntry
+	config  CacheConfig
+	mu      sync.RWMutex
+}
+
+func NewMemoryCache(config CacheConfig) *MemoryCache {
+	return &MemoryCache{
+		entries: make(map[string]CacheEntry),
+		config:  config,
+	}
+}
+
+func (c *MemoryCache) Get(key string) (*CacheGetResult, bool) {
+	if !c.IsEnabled() {
+		return nil, false
+	}
+
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	entry, exists := c.entries[key]
+	if !exists {
+		return nil, false
+	}
+
+	isStale := false
+	if c.config.TTLInSeconds > 0 {
+		expirationTime := entry.LastUpdated.Add(time.Duration(c.config.TTLInSeconds) * time.Second)
+		isStale = time.Now().After(expirationTime)
+	}
+
+	return &CacheGetResult{
+		CacheEntry: &entry,
+		IsStale:    isStale,
+	}, true
+}
+
+func (c *MemoryCache) Set(key string, value map[string]*provider.FeatureValue) (time.Time, error) {
+	if !c.IsEnabled() {
+		return time.Time{}, &CacheError{Message: "Cache is disabled"}
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	now := time.Now()
+	c.entries[key] = CacheEntry{
+		Value:       value,	
+		LastUpdated: now,
+	}
+
+	return now, nil
+}
+
+func (c *MemoryCache) Delete(key string) error {
+	if !c.IsEnabled() {
+		return &CacheError{Message: "Cache is disabled"}
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	delete(c.entries, key)
+	return nil
+}
+
+func (c *MemoryCache) Clear() error {
+	if !c.IsEnabled() {
+		return &CacheError{Message: "Cache is disabled"}
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.entries = make(map[string]CacheEntry)
+	return nil
+}
+
+func (c *MemoryCache) IsEnabled() bool {
+	return c.config.Enabled
+}