Sdk Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require open-feature/sdk
   

   Add to composer.json if using Laravel:

   "require": {
       "open-feature/sdk": "^2.1"
   }
   

2. Basic Initialization In your Laravel service provider (e.g., AppServiceProvider):

   use OpenFeature\API;
   use OpenFeature\NoOpProvider;
   
   public function boot()
   {
       API::setProvider(new NoOpProvider()); // Fallback provider
   }
   

3. First Feature Flag Evaluation

   $flagValue = API::getBooleanValue('feature.my-flag', false);
   // Use $flagValue in your logic
   

Where to Look First

• OpenFeature PHP SDK Docs (Official documentation)
• Laravel Integration Guide (If available)
• examples/ directory in the SDK repo for quick-start patterns.

Implementation Patterns

Core Workflows

1. Feature Flag Evaluation

   // Boolean flag
   $isEnabled = API::getBooleanValue('feature.toggle', false);
   
   // String flag (e.g., A/B test variants)
   $variant = API::getStringValue('feature.variant', 'default');
   
   // JSON flag (for complex configurations)
   $config = API::getObjectValue('feature.config', []);
   

2. Provider Chaining (Multi-Provider Strategy)

   use OpenFeature\ProviderRegistry;
   
   $registry = new ProviderRegistry();
   $registry->addProvider(new MyCustomProvider());
   $registry->addProvider(new RemoteProvider());
   
   API::setProvider($registry);
   

3. Context Management

   use OpenFeature\Context;
   
   $context = Context::build()
       ->withTargetingKey('user-123')
       ->withAttribute('country', 'US')
       ->build();
   
   API::setContext($context);
   

Laravel-Specific Patterns

1. Middleware for Context Injection

   namespace App\Http\Middleware;
   
   use Closure;
   use OpenFeature\API;
   use OpenFeature\Context;
   
   class SetOpenFeatureContext
   {
       public function handle($request, Closure $next)
       {
           $context = Context::build()
               ->withTargetingKey($request->user()->id)
               ->withAttribute('user_role', $request->user()->role)
               ->build();
   
           API::setContext($context);
           return $next($request);
       }
   }
   

   Register in app/Http/Kernel.php:

   protected $middleware = [
       \App\Http\Middleware\SetOpenFeatureContext::class,
   ];
   

2. Service Container Binding

   public function register()
   {
       $this->app->singleton(\OpenFeature\API::class, function ($app) {
           return \OpenFeature\API::getInstance();
       });
   }
   

3. Dynamic Provider Switching

   // In a config file (e.g., config/openfeature.php)
   'providers' => [
       'default' => \App\Providers\LocalProvider::class,
       'staging' => \App\Providers\RemoteProvider::class,
   ],
   

   Load dynamically in a service provider:

   $providerClass = config('openfeature.providers.' . env('APP_ENV'));
   API::setProvider(new $providerClass());
   

4. Event-Driven Flag Updates Use Laravel events to trigger flag refreshes:

   // Listen for user role changes
   event(new UserRoleUpdated($user));
   

   In your provider:

   public function evaluate($flagKey, $defaultValue)
   {
       if ($flagKey === 'feature.admin-dashboard') {
           return auth()->user()->isAdmin();
       }
       return $defaultValue;
   }
   

Gotchas and Tips

Common Pitfalls

1. Context Leaks

   • Issue: Forgetting to reset context between requests (e.g., in tests or CLI commands).
   • Fix: Use API::clearContext() or wrap logic in a context block:

     API::setContext($context);
     try {
         $result = API::getBooleanValue('flag', false);
     } finally {
         API::clearContext();
     }
     

2. Provider Initialization Order

   • Issue: Multiple providers may conflict if not chained properly.
   • Fix: Use ProviderRegistry to define fallback behavior:

     $registry = new ProviderRegistry();
     $registry->addProvider(new RemoteProvider(), ProviderRegistry::PRIORITY_HIGH);
     $registry->addProvider(new LocalProvider(), ProviderRegistry::PRIORITY_LOW);
     API::setProvider($registry);
     

3. Thread Safety

   • Issue: OpenFeature SDK is not thread-safe by default (relevant for Laravel queues/jobs).
   • Fix: Initialize a separate API instance per thread or use a singleton with caution:

     // In a job
     $api = new \OpenFeature\API(new NoOpProvider());
     $api->setContext($context);
     

4. Flag Key Collisions

   • Issue: Overwriting flag keys in different providers.
   • Fix: Use namespacing (e.g., feature.auth.2fa, feature.marketing.banner).

5. Caching Headaches

   • Issue: Remote providers may cache aggressively, causing stale flags.
   • Fix: Implement a short TTL (e.g., 5 minutes) for remote flags:

     $provider = new RemoteProvider();
     $provider->setCacheTTL(300); // 5 minutes
     

Debugging Tips

1. Enable Logging

   use OpenFeature\Log;
   
   Log::setLogger(new \Monolog\Logger('openfeature', [
       new \Monolog\Handler\StreamHandler(storage_path('logs/openfeature.log')),
   ]));
   

2. Inspect Provider Chain

   $provider = API::getProvider();
   if ($provider instanceof ProviderRegistry) {
       foreach ($provider->getProviders() as $p) {
           dump(get_class($p));
       }
   }
   

3. Test with NoOpProvider

   API::setProvider(new NoOpProvider());
   

   Ensures your logic works without external dependencies.

Extension Points

1. Custom Providers Implement ProviderInterface:

   class DatabaseProvider implements ProviderInterface
   {
       public function evaluate($flagKey, $defaultValue)
       {
           return DB::table('feature_flags')
               ->where('key', $flagKey)
               ->value('value') ?? $defaultValue;
       }
       // ... other methods
   }
   

2. Hooks for Flag Evaluation Use Hooks to intercept evaluations:

   use OpenFeature\Hooks;
   
   Hooks::addHook(Hooks::EVALUATE, function ($hook) {
       if ($hook->getFlagKey() === 'feature.sensitive') {
           $hook->setValue(false); // Override
       }
   });
   

3. Laravel Service Provider Integration Extend the SDK with Laravel-specific features:

   public function boot()
   {
       API::setProvider(new class implements ProviderInterface {
           public function evaluate($flagKey, $defaultValue)
           {
               return config("openfeature.flags.{$flagKey}", $defaultValue);
           }
           // ... other methods
       });
   }
   

4. Dynamic Flag Evaluation Combine with Laravel’s config or cache:

   public function evaluate($flagKey, $defaultValue)
   {
       $cacheKey = "openfeature:{$flagKey}";
       return Cache::remember($cacheKey, now()->addMinutes(5), function () use ($flagKey, $defaultValue) {
           return DB::table('flags')->where('key', $flagKey)->value('value') ?? $defaultValue;
       });
   }
   

Performance Tips

1. Batch Evaluations

   $flags = [
       'feature.a' => false,
       'feature.b' => 'default',
   ];
   $results = API::getValues($flags);
   

2. Lazy-Load Providers Load remote providers only when needed:

   $provider = new LazyRemoteProvider(function () {
       return new RemoteProvider(config('services.openfeature'));
   });
   

3. Avoid Context Overhead Use minimal context attributes:

   $context = Context::build()
       ->withTargetingKey($userId) // Required for most providers
       ->build();