PHP

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$unleash = UnleashBuilder::create()
6
    ->withAppName('Some app name')
7
    ->withAppUrl('https://some-app-url.com')
8
    ->withInstanceId('Some instance id')
9
    ->build();
10
11
if ($unleash->isEnabled('some-feature-name')) {
12
    // do something
13
}

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Configuration\UnleashContext;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->build();
11
12
$context = new UnleashContext(
13
    currentUserId: 'some-user-id-from-app',
14
    ipAddress: '127.0.0.1', // will be populated automatically from $_SERVER if needed
15
    sessionId: 'sess-123456', // will be populated automatically via session_id() if needed
16
);
17
18
// or using pre php 8 style:
19
20
$context = (new UnleashContext())
21
    ->setCurrentUserId('some-user-id-from-app')
22
    ->setIpAddress('127.0.0.1')
23
    ->setSessionId('sess-123456');
24
25
if ($unleash->isEnabled('some-feature', $context)) {
26
    // do something
27
}
28
29
// changing the default value for non-existent features
30
if ($unleash->isEnabled('nonexistent-feature', $context, true)) {
31
    // do something
32
}

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
// both are the same
6
$builder = new UnleashBuilder();
7
$builder = UnleashBuilder::create();

1
<?php
2
3
use Unleash\Client\Helper\Builder\ConfigurationAware;
4
use Unleash\Client\Metrics\MetricsHandler;
5
use Unleash\Client\Configuration\UnleashConfiguration;
6
use Unleash\Client\DTO\Feature;
7
use Unleash\Client\DTO\Variant;
8
use Unleash\Client\UnleashBuilder;
9
10
final class CustomMetricsHandler implements MetricsHandler, ConfigurationAware
11
{
12
    private UnleashConfiguration $configuration;
13
14
    public function setConfiguration(UnleashConfiguration $configuration): void
15
    {
16
        // this method gets called automatically by the builder
17
        $this->configuration = $configuration;
18
    }
19
20
    public function handleMetrics(Feature $feature, bool $successful, Variant $variant = null): void
21
    {
22
        // the configuration object is available here
23
        if ($this->configuration->getInstanceId() === '...') {
24
            // do something
25
        }
26
    }
27
}
28
29
$instance = UnleashBuilder::create()
30
    ->withMetricsHandler(new CustomMetricsHandler())
31
    ->build();

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$builder = UnleashBuilder::create()
6
    ->withAppName('Some app name')
7
    ->withAppUrl('https://some-app-url.com')
8
    ->withInstanceId('Some instance id');

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$builder = UnleashBuilder::create()
6
    ->withAppName('Some app name')
7
    ->withAppUrl('https://some-app-url.com')
8
    ->withInstanceId('Some instance id')
9
    ->withHeader('Authorization', 'my-api-key');

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Helper\Url;
5
6
$builder = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl(new Url('https://some-app-url.com', namePrefix: 'somePrefix.', tags: [
9
        'myTag' => 'myValue',
10
    ]))
11
    ->withInstanceId('Some instance id');

1
<?php
2
3
use Cache\Adapter\Filesystem\FilesystemCachePool;
4
use League\Flysystem\Adapter\Local;
5
use League\Flysystem\Filesystem;
6
use GuzzleHttp\Client;
7
use GuzzleHttp\Psr7\HttpFactory;
8
use Unleash\Client\Stickiness\MurmurHashCalculator;
9
use Unleash\Client\Strategy\DefaultStrategyHandler;
10
use Unleash\Client\Strategy\GradualRolloutStrategyHandler;
11
use Unleash\Client\Strategy\IpAddressStrategyHandler;
12
use Unleash\Client\Strategy\UserIdStrategyHandler;
13
use Unleash\Client\UnleashBuilder;
14
use Unleash\Client\Helper\Url;
15
16
$builder = UnleashBuilder::create()
17
    ->withAppName('Some app name')
18
    ->withAppUrl('https://some-app-url.com') // as a string
19
    ->withAppUrl(new Url('https://some-app-url.com', tags: ['myTag' => 'myValue'])) // or as Url instance
20
    ->withInstanceId('Some instance id')
21
    // now the optional ones
22
    ->withHttpClient(new Client())
23
    ->withRequestFactory(new HttpFactory())
24
    ->withCacheHandler(new FilesystemCachePool( // example with using cache/filesystem-adapter
25
        new Filesystem(
26
            new Local(sys_get_temp_dir()),
27
        ),
28
    ), 30) // the second parameter is time to live in seconds
29
    ->withCacheTimeToLive(60) // you can also set the cache time to live separately
30
    // if you don't add any strategies, by default all strategies are added
31
    ->withStrategies( // this example includes all available strategies
32
        new DefaultStrategyHandler(),
33
        new GradualRolloutStrategyHandler(new MurmurHashCalculator()),
34
        new IpAddressStrategyHandler(),
35
        new UserIdStrategyHandler(),
36
    )
37
    // add headers one by one, if you specify a header with the same name multiple times it will be replaced by the
38
    // latest value
39
    ->withHeader('My-Custom-Header', 'some-value')
40
    ->withHeader('Some-Other-Header', 'some-other-value')
41
    // you can specify multiple headers at the same time, be aware that this REPLACES all the headers
42
    ->withHeaders([
43
        'Yet-Another-Header' => 'and-another-value',
44
    ]);

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Helper\Url;
5
6
$repository = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl(new Url('https://some-app-url.com', namePrefix: 'somePrefix.', tags: [
9
        'myTag' => 'myValue',
10
    ]))
11
    ->withInstanceId('Some instance id')
12
    ->buildRepository();
13
$repository->refreshCache();

1
<?php
2
$builder = UnleashBuilder::create()
3
    ->withAppName('Some app name')
4
    ->withAppUrl('https://some-app-url.com/api/frontend')
5
    ->withInstanceId('Some instance id')
6
    ->withProxy("some-proxy-key"); // <-- This is the only difference
7
8
$unleash = $builder->build();
9
10
$unleash->isEnabled("some-feature");

1
<?php
2
3
use Cache\Adapter\Filesystem\FilesystemCachePool;
4
use League\Flysystem\Adapter\Local;
5
use League\Flysystem\Filesystem;
6
use Unleash\Client\UnleashBuilder;
7
8
$builder = UnleashBuilder::create()
9
    ->withCacheHandler(new FilesystemCachePool( // example with using cache/filesystem-adapter
10
        new Filesystem(
11
            new Local(sys_get_temp_dir()),
12
        ),
13
    ))
14
    ->withCacheTimeToLive(120)
15
    ->withStaleTtl(300)
16
;
17
18
// you can set the cache handler explicitly to null to revert back to autodetection
19
20
$builder = $builder
21
    ->withCacheHandler(null);

1
<?php
2
3
use Cache\Adapter\Filesystem\FilesystemCachePool;
4
use League\Flysystem\Adapter\Local;
5
use League\Flysystem\Filesystem;
6
use Unleash\Client\UnleashBuilder;
7
use Symfony\Component\Cache\Psr16Cache;
8
use Symfony\Component\Cache\Adapter\ArrayAdapter;
9
10
$builder = UnleashBuilder::create()
11
    ->withCacheHandler(new FilesystemCachePool( // example with using cache/filesystem-adapter
12
        new Filesystem(
13
            new Local(sys_get_temp_dir()),
14
        ),
15
    ))
16
    ->withStaleCacheHandler(new Psr16Cache(new ArrayAdapter()))
17
    ->withCacheTimeToLive(120)
18
    ->withStaleTtl(300)
19
;

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$bootstrapJson = '{"features": []}';
6
$bootstrapFile = 'path/to/my/file.json';
7
$bootstrapSplFile = new SplFileInfo('path/to/my/file.json');
8
$bootstrapUrl = 'https://example.com/unleash-bootstrap.json';
9
$bootstrapStreamWrapper = 's3://my-bucket/bootstrap.json'; // assuming you have a custom stream wrapper called 's3'
10
$bootstrapArray = [
11
    'features' => [
12
        [
13
            'enabled' => true,
14
            'name' => 'BootstrapDemo',
15
            'description' => '',
16
            'project' => 'default',
17
            'stale' => false,
18
            'type' => 'release',
19
            'variants' => [],
20
            'strategies' => [[ 'name' => 'default' ]],
21
        ],
22
    ],
23
];
24
$bootstrapTraversable = new class implements Iterator {
25
    public function current(): mixed
26
    {
27
        // todo implement method
28
    }
29
30
    public function next(): void
31
    {
32
        // todo implement method
33
    }
34
35
    public function key(): mixed
36
    {
37
        // todo implement method
38
    }
39
40
    public function valid(): bool
41
    {
42
        // todo implement method
43
    }
44
45
    public function rewind(): void
46
    {
47
        // todo implement method
48
    }
49
};
50
$bootstrapJsonSerializable = new class implements JsonSerializable {
51
    public function jsonSerialize(): array {
52
        // TODO: Implement jsonSerialize() method.
53
    }
54
}
55
56
// now assign them to the builder, note that each withBootstrap* method call overrides the bootstrap
57
58
$builder = UnleashBuilder::create()
59
    ->withBootstrap($bootstrapJson)
60
    ->withBootstrapFile($bootstrapFile)
61
    ->withBootstrapFile($bootstrapSplFile)
62
    ->withBootstrapUrl($bootstrapUrl)
63
    ->withBootstrapFile($bootstrapStreamWrapper)
64
    ->withBootstrap($bootstrapArray)
65
    ->withBootstrap($bootstrapTraversable)
66
    ->withBootstrap($bootstrapJsonSerializable)
67
    ->withBootstrap(null) // empty bootstrap
68
;

1
<?php
2
3
use Unleash\Client\Bootstrap\EmptyBootstrapProvider;
4
use Unleash\Client\Bootstrap\FileBootstrapProvider;
5
use Unleash\Client\Bootstrap\JsonBootstrapProvider;
6
use Unleash\Client\Bootstrap\JsonSerializableBootstrapProvider;
7
use Unleash\Client\UnleashBuilder;
8
9
// using variables defined in previous example, again each call overrides the last bootstrap provider
10
11
$builder = UnleashBuilder::create()
12
    ->withBootstrapProvider(new JsonBootstrapProvider($bootstrapJson))
13
    ->withBootstrapProvider(new FileBootstrapProvider($bootstrapFile))
14
    ->withBootstrapProvider(new FileBootstrapProvider($bootstrapSplFile))
15
    ->withBootstrapProvider(new FileBootstrapProvider($bootstrapUrl))
16
    ->withBootstrapProvider(new FileBootstrapProvider($bootstrapStreamWrapper))
17
    ->withBootstrapProvider(new JsonSerializableBootstrapProvider($bootstrapArray))
18
    ->withBootstrapProvider(new JsonSerializableBootstrapProvider($bootstrapTraversable))
19
    ->withBootstrapProvider(new JsonSerializableBootstrapProvider($bootstrapJsonSerializable))
20
    ->withBootstrapProvider(new EmptyBootstrapProvider()) // equivalent to ->withBootstrap(null)
21
;

1
<?php
2
3
use Unleash\Client\Bootstrap\CompoundBootstrapProvider;
4
use Unleash\Client\Bootstrap\FileBootstrapProvider;
5
use Unleash\Client\Bootstrap\JsonSerializableBootstrapProvider;
6
use Unleash\Client\UnleashBuilder;
7
8
// using variables defined in first example
9
10
$provider = new CompoundBootstrapProvider(
11
    new FileBootstrapProvider($bootstrapUrl),
12
    new FileBootstrapProvider($bootstrapFile),
13
    new JsonSerializableBootstrapProvider($bootstrapArray),
14
);
15
16
// All providers in compound bootstrap provider will be tried one by one in the order they were assigned until
17
// at least one returns something.
18
19
// If no provider returns non-null value, the compound provider itself returns null.
20
21
// If an exception is thrown in any of the inner providers it's ignored and next provider is tried.
22
23
// If an exception was thrown in any of the inner providers and no other provider returned any value, the exceptions
24
// from inner providers are thrown using a CompoundException, you can get the exceptions by calling ->getExceptions()
25
// on it.
26
27
$builder = UnleashBuilder::create()
28
    ->withBootstrapProvider($provider);

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Bootstrap\BootstrapProvider;
5
6
final class MyBootstrapProvider implements BootstrapProvider
7
{
8
    public function getBootstrap() : array|JsonSerializable|Traversable|null
9
    {
10
        // TODO: Implement getBootstrap() method.
11
    }
12
}
13
14
$builder = UnleashBuilder::create()
15
    ->withBootstrapProvider(new MyBootstrapProvider());

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$unleash = UnleashBuilder::create()
6
    ->withBootstrap('{}')
7
    ->withFetchingEnabled(false) // here we disable communication with Unleash server
8
    ->withCacheTimeToLive(0) // disable the caching layer to always get a fresh bootstrap
9
    ->build();

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Configuration\UnleashContext;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->build();
11
12
// without context, using the auto detected IP
13
$enabled = $unleash->isEnabled('some-feature');
14
15
// with context
16
$context = new UnleashContext(ipAddress: $_SERVER['HTTP_X_FORWARDED_FOR']);
17
// or pre php 8 style
18
$context = (new UnleashContext())
19
    ->setIpAddress($_SERVER['HTTP_X_FORWARDED_FOR']);
20
$enabled = $unleash->isEnabled('some-feature', $context);

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Configuration\UnleashContext;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->build();
11
12
$context = new UnleashContext(currentUserId: 'some-user-id');
13
$enabled = $unleash->isEnabled('some-feature', $context);

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Configuration\UnleashContext;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->build();
11
12
// assume the feature uses the default type which means that it will default to either session id (if session is started)
13
// or randomly
14
$unleash->isEnabled('some-feature');
15
16
// still using the default strategy but this time with user id (which is the first to be used if present)
17
$context = new UnleashContext(currentUserId: 'some-user-id');
18
$unleash->isEnabled('some-feature', $context);
19
20
// let's start the session to ensure the session id is used
21
session_start();
22
$unleash->isEnabled('some-feature');
23
24
// or you can provide your own session id
25
$context = new UnleashContext(sessionId: 'sess-123456');
26
$unleash->isEnabled('some-feature', $context);
27
28
// assume the feature is set to use the user id, the first call returns false (no context given), the second
29
// one returns true/false based on the user id
30
$unleash->isEnabled('some-feature');
31
$context = new UnleashContext(currentUserId: 'some-user-id');
32
$unleash->isEnabled('some-feature', $context);
33
34
// the same goes for session, assume the session isn't started yet and the feature is set to use the session type
35
$unleash->isEnabled('some-feature'); // returns false because no session is available
36
37
$context = new UnleashContext(sessionId: 'some-session-id');
38
$unleash->isEnabled('some-feature', $context); // works because you provided the session id manually
39
40
session_start();
41
$unleash->isEnabled('some-feature'); // works because the session is started
42
43
// lastly you can force the feature to use the random type which always works
44
$unleash->isEnabled('some-feature');

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Configuration\UnleashContext;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->build();
11
12
// context with custom hostname
13
$context = new UnleashContext(hostname: 'My-Cool-Hostname');
14
$enabled = $unleash->isEnabled('some-feature', $context);
15
16
// without custom hostname, defaults to gethostname() result or null
17
$enabled = $unleash->isEnabled('some-feature');

1
<?php
2
3
use Unleash\Client\ContextProvider\UnleashContextProvider;
4
use Unleash\Client\Configuration\UnleashContext;
5
use Unleash\Client\UnleashBuilder;
6
7
final class MyContextProvider implements UnleashContextProvider
8
{
9
    public function getContext(): Context
10
    {
11
        $context = new UnleashContext();
12
        $context->setCurrentUserId('user id from my app');
13
14
        return $context;
15
    }
16
}
17
18
$unleash = UnleashBuilder::create()
19
    ->withAppName('Some app name')
20
    ->withAppUrl('https://some-app-url.com')
21
    ->withInstanceId('Some instance id')
22
    // here we set the custom provider
23
    ->withContextProvider(new MyContextProvider())
24
    ->build();
25
26
if ($unleash->isEnabled('someFeature')) { // this call will use your context provider with the provided user id
27
28
}

1
<?php
2
3
use Unleash\Client\Strategy\AbstractStrategyHandler;
4
use Unleash\Client\DTO\Strategy;
5
use Unleash\Client\Configuration\Context;
6
use Unleash\Client\Strategy\DefaultStrategyHandler;
7
8
class AprilFoolsStrategy extends AbstractStrategyHandler
9
{
10
    public function __construct(private DefaultStrategyHandler $original)
11
    {
12
    }
13
14
    public function getStrategyName() : string
15
    {
16
        return 'aprilFools';
17
    }
18
19
    public function isEnabled(Strategy $strategy, Context $context) : bool
20
    {
21
        $date = new DateTimeImmutable();
22
        if ((int) $date->format('n') === 4 && (int) $date->format('j') === 1) {
23
            return (bool) random_int(0, 1);
24
        }
25
26
        return $this->original->isEnabled($strategy, $context);
27
    }
28
}

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
use Unleash\Client\Strategy\IpAddressStrategyHandler;
5
6
$unleash = UnleashBuilder::create()
7
    ->withAppName('Some app name')
8
    ->withAppUrl('https://some-app-url.com')
9
    ->withInstanceId('Some instance id')
10
    ->withStrategy(new AprilFoolsStrategy()) // this will append your strategy to the existing list
11
    ->build();
12
13
// if you want to replace all strategies, use withStrategies() instead
14
15
$unleash = UnleashBuilder::create()
16
    ->withAppName('Some app name')
17
    ->withAppUrl('https://some-app-url.com')
18
    ->withInstanceId('Some instance id')
19
    ->withStrategies(new AprilFoolsStrategy(), new IpAddressStrategyHandler())
20
    // now the unleash object will have only the two strategies
21
    ->build();

1
<?php
2
3
use Unleash\Client\DTO\DefaultVariant;
4
use Unleash\Client\UnleashBuilder;
5
use Unleash\Client\Configuration\UnleashContext;
6
use Unleash\Client\Enum\VariantPayloadType;
7
use Unleash\Client\DTO\DefaultVariantPayload;
8
9
$unleash = UnleashBuilder::create()
10
    ->withAppName('Some app name')
11
    ->withAppUrl('https://some-app-url.com')
12
    ->withInstanceId('Some instance id')
13
    ->build();
14
15
$variant = $unleash->getVariant('nonexistentFeature');
16
assert($variant->isEnabled() === false);
17
18
// getVariant() does isEnabled() call in the background meaning that it will return the default falsy variant
19
// whenever isEnabled() returns false
20
$variant = $unleash->getVariant('existingFeatureThatThisUserDoesNotHaveAccessTo');
21
assert($variant->isEnabled() === false);
22
23
$variant = $unleash->getVariant('someFeature', new UnleashContext(currentUserId: '123'));
24
if ($variant->isEnabled()) {
25
    $payload = $variant->getPayload();
26
    if ($payload !== null) {
27
        if ($payload->getType() === VariantPayloadType::JSON) {
28
            $jsonData = $payload->fromJson();
29
        }
30
        $stringPayload = $payload->getValue();
31
    }
32
}
33
34
// providing custom default variant
35
36
$variant = $unleash->getVariant('nonexistentFeature', fallbackVariant: new DefaultVariant(
37
    'variantName',
38
    enabled: true,
39
    payload: new DefaultVariantPayload(VariantPayloadType::STRING, 'somePayload'),
40
));
41
assert($variant->getPayload()->getValue() === 'somePayload');

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$unleash = UnleashBuilder::create()
6
    ->withAppName('Some App Name')
7
    ->withAppUrl('https://somewhere.com')
8
    ->withInstanceId('some-instance-id')
9
    ->withAutomaticRegistrationEnabled(false)
10
    ->build();
11
12
// even though the client will not attempt to register, you can still use isEnabled()
13
$unleash->isEnabled('someFeature');
14
15
// if you want to register manually
16
$unleash->register();
17
18
// you can call the register method multiple times, the Unleash server doesn't mind
19
$unleash->register();
20
$unleash->register();

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$unleash = UnleashBuilder::create()
6
    ->withAppName('Some App Name')
7
    ->withAppUrl('https://somewhere.com')
8
    ->withInstanceId('some-instance-id')
9
    ->withMetricsEnabled(false) // turn off metric sending
10
    ->withMetricsEnabled(true) // turn on metric sending
11
    ->withMetricsInterval(60_000) // interval in milliseconds (60 seconds)
12
    ->withMetricsCacheHandler(new Psr16Cache(new RedisAdapter())) // use custom cache handler for metrics, defaults to standard cache handler
13
    ->build();
14
15
// the metric will be collected but not sent immediately
16
$unleash->isEnabled('test');
17
sleep(10);
18
// now the metrics will get sent
19
$unleash->isEnabled('test');

1
<?php
2
3
use GuzzleHttp\Client;
4
use GuzzleHttp\Handler\CurlHandler;
5
use GuzzleHttp\HandlerStack;
6
use GuzzleHttp\Middleware;
7
use Psr\Http\Message\RequestInterface;
8
use Unleash\Client\UnleashBuilder;
9
10
// any callable is valid, it may be a function reference, anonymous function or an invokable class
11
12
// example invokable class
13
final class AddHeaderMiddleware
14
{
15
    public function __construct(
16
        private readonly string $headerName,
17
        private readonly string $value,
18
    ) {
19
    }
20
21
    public function __invoke(RequestInterface $request): RequestInterface
22
    {
23
        return $request->withHeader($this->headerName, $this->value);
24
    }
25
}
26
27
// example anonymous function
28
$addHeaderMiddleware = fn (string $headerName, string $headerValue)
29
    => fn(RequestInterface $request)
30
        => $request->withHeader($headerName, $headerValue);
31
32
// create a handler stack that holds information about all middlewares
33
$stack = HandlerStack::create(new CurlHandler());
34
// mapRequest is a helper that simplifies modifying request
35
$stack->push(Middleware::mapRequest(new AddHeaderMiddleware('X-My-Header', 'Some-Value')));
36
// or with lambda
37
$stack->push(Middleware::mapRequest($addHeaderMiddleware('X-My-Header2', 'Some-Value')));
38
// assign the stack with middlewares as a handler
39
$httpClient = new Client(['handler' => $stack]);
40
41
$unleash = UnleashBuilder::create()
42
    ->withHttpClient($httpClient) // assign the custom http client
43
    ->withAppName('My-App')
44
    ->withInstanceId('My-Instance')
45
    ->withAppUrl('http://localhost:4242')
46
    ->build();
47
48
// now every http request will have X-My-Header header with value Some-Value
49
$unleash->isEnabled('some-feature');

1
<?php
2
3
use Unleash\Client\UnleashBuilder;
4
5
$gitlabUnleash = UnleashBuilder::createForGitlab()
6
    ->withInstanceId('H9sU9yVHVAiWFiLsH2Mo') // generated in GitLab
7
    ->withAppUrl('https://git.example.com/api/v4/feature_flags/unleash/1')
8
    ->withGitlabEnvironment('Production')
9
    ->build();
10
11
// the above is equivalent to
12
$gitlabUnleash = UnleashBuilder::create()
13
    ->withInstanceId('H9sU9yVHVAiWFiLsH2Mo')
14
    ->withAppUrl('https://git.example.com/api/v4/feature_flags/unleash/1')
15
    ->withGitlabEnvironment('Production')
16
    ->withAutomaticRegistrationEnabled(false)
17
    ->withMetricsEnabled(false)
18
    ->build();