Client.php

<?php

namespace DDTrace\FeatureFlags;

use DDTrace\FeatureFlags\Internal\NativeEvaluator;
use DDTrace\Log\Logger as GlobalLogger;
use DDTrace\Log\LoggerInterface;
use DDTrace\Log\NonThrowingLogger;

final class Client
{
    private $evaluator;
    /** @var LoggerInterface */
    private $logger;
    private $warnedAboutRuntimeNotReady = false;

    public function __construct($logger = null)
    {
        if ($logger !== null && !$logger instanceof LoggerInterface) {
            throw new \InvalidArgumentException('Expected a LoggerInterface instance');
        }

        $this->evaluator = NativeEvaluator::create();
        $this->logger = new NonThrowingLogger($logger ?: GlobalLogger::get());
    }

    /**
     * @return bool
     */
    public function getBooleanValue($flagKey, $defaultValue, array $context = array())
    {
        return $this->getBooleanDetails($flagKey, $defaultValue, $context)->getValue();
    }

    /**
     * @return string
     */
    public function getStringValue($flagKey, $defaultValue, array $context = array())
    {
        return $this->getStringDetails($flagKey, $defaultValue, $context)->getValue();
    }

    /**
     * @return int
     */
    public function getIntegerValue($flagKey, $defaultValue, array $context = array())
    {
        return $this->getIntegerDetails($flagKey, $defaultValue, $context)->getValue();
    }

    /**
     * @return float
     */
    public function getFloatValue($flagKey, $defaultValue, array $context = array())
    {
        return $this->getFloatDetails($flagKey, $defaultValue, $context)->getValue();
    }

    /**
     * @return array<string, mixed>
     */
    public function getObjectValue($flagKey, array $defaultValue, array $context = array())
    {
        return $this->getObjectDetails($flagKey, $defaultValue, $context)->getValue();
    }

    /**
     * @return EvaluationDetails
     */
    public function getBooleanDetails($flagKey, $defaultValue, array $context = array())
    {
        return $this->evaluate($flagKey, EvaluationType::BOOLEAN, $this->expectBoolean($defaultValue), $context);
    }

    /**
     * @return EvaluationDetails
     */
    public function getStringDetails($flagKey, $defaultValue, array $context = array())
    {
        return $this->evaluate($flagKey, EvaluationType::STRING, $this->expectString($defaultValue), $context);
    }

    /**
     * @return EvaluationDetails
     */
    public function getIntegerDetails($flagKey, $defaultValue, array $context = array())
    {
        return $this->evaluate($flagKey, EvaluationType::INTEGER, $this->expectInteger($defaultValue), $context);
    }

    /**
     * @return EvaluationDetails
     */
    public function getFloatDetails($flagKey, $defaultValue, array $context = array())
    {
        return $this->evaluate($flagKey, EvaluationType::FLOAT, $this->expectFloat($defaultValue), $context);
    }

    /**
     * @return EvaluationDetails
     */
    public function getObjectDetails($flagKey, array $defaultValue, array $context = array())
    {
        return $this->evaluate($flagKey, EvaluationType::OBJECT, $defaultValue, $context);
    }

    private function evaluate($flagKey, $expectedType, $defaultValue, array $context)
    {
        $flagKey = $this->expectFlagKey($flagKey);
        list($targetingKey, $attributes) = $this->normalizeContext($context);

        $details = $this->evaluator->evaluate(
            $flagKey,
            $expectedType,
            $defaultValue,
            $targetingKey,
            $attributes
        );

        $this->warnIfRuntimeNotReady($details);

        return $details;
    }

    private function normalizeContext(array $context)
    {
        $targetingKey = null;
        if (array_key_exists('targetingKey', $context) && $context['targetingKey'] !== null) {
            $targetingKey = (string) $context['targetingKey'];
        }

        $attributes = array();
        if (isset($context['attributes']) && is_array($context['attributes'])) {
            foreach ($context['attributes'] as $key => $value) {
                if (is_bool($value) || is_int($value) || is_float($value) || is_string($value)) {
                    $attributes[(string) $key] = $value;
                }
            }
        }

        return array($targetingKey, $attributes);
    }

    private function warnIfRuntimeNotReady(EvaluationDetails $details)
    {
        if ($this->warnedAboutRuntimeNotReady) {
            return;
        }

        if ($details->getErrorCode() !== EvaluationErrorCode::PROVIDER_NOT_READY) {
            return;
        }

        $message = $details->getErrorMessage();
        if (!is_string($message) || $message === '') {
            $message = 'Datadog-backed PHP feature flag evaluation is not ready. Returning the default value.';
        }

        $this->warnedAboutRuntimeNotReady = true;
        $this->logger->warning($message);
    }

    private function expectFlagKey($flagKey)
    {
        if (!is_string($flagKey) || $flagKey === '') {
            throw new \InvalidArgumentException('Feature flag key must be a non-empty string');
        }

        return $flagKey;
    }

    private function expectBoolean($value)
    {
        if (!is_bool($value)) {
            throw new \InvalidArgumentException('Boolean flag default value must be a bool');
        }

        return $value;
    }

    private function expectString($value)
    {
        if (!is_string($value)) {
            throw new \InvalidArgumentException('String flag default value must be a string');
        }

        return $value;
    }

    private function expectInteger($value)
    {
        if (!is_int($value)) {
            throw new \InvalidArgumentException('Integer flag default value must be an int');
        }

        return $value;
    }

    private function expectFloat($value)
    {
        if (!is_int($value) && !is_float($value)) {
            throw new \InvalidArgumentException('Float flag default value must be a number');
        }

        return (float) $value;
    }
}