Configuration.php

<?php

declare (strict_types=1);
namespace OpenTelemetry\SDK\Common\Configuration;

use InvalidArgumentException;
use OpenTelemetry\API\Behavior\LogsMessagesTrait;
use OpenTelemetry\SDK\Common\Configuration\Parser\BooleanParser;
use OpenTelemetry\SDK\Common\Configuration\Parser\ListParser;
use OpenTelemetry\SDK\Common\Configuration\Parser\MapParser;
use OpenTelemetry\SDK\Common\Configuration\Parser\RatioParser;
use OpenTelemetry\SDK\Common\Configuration\Resolver\CompositeResolver;
use OpenTelemetry\SDK\Common\Util\ClassConstantAccessor;
use UnexpectedValueException;

/**
 * Configuration can come from one or more of the following sources (from highest to lowest priority):
 * - values defined in php.ini
 * - environment variable ($_SERVER)
 * - configuration file (todo)
 */
class Configuration {
    use LogsMessagesTrait;
    public static function has(string $name) : bool {
        return CompositeResolver::instance()->hasVariable($name);
    }
    public static function getInt(string $key, ?int $default = null) : int {
        return (int) self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::INTEGER), $default), FILTER_VALIDATE_INT);
    }
    public static function getString(string $key, ?string $default = null) : string {
        return (string) self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::STRING), $default));
    }
    public static function getBoolean(string $key, ?bool $default = null) : bool {
        $resolved = self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::BOOL), null === $default ? $default : ($default ? 'true' : 'false')));
        try {
            return BooleanParser::parse($resolved);
        } catch (InvalidArgumentException) {
            self::logWarning(sprintf('Invalid boolean value "%s" interpreted as "false" for %s', $resolved, $key));
            return false;
        }
    }
    public static function getMixed(string $key, $default = null) {
        return self::validateVariableValue(CompositeResolver::instance()->resolve($key, $default));
    }
    public static function getMap(string $key, ?array $default = null) : array {
        return MapParser::parse(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::MAP), $default));
    }
    public static function getList(string $key, ?array $default = null) : array {
        return ListParser::parse(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::LIST), $default));
    }
    public static function getEnum(string $key, ?string $default = null) : string {
        return (string) self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::ENUM), $default));
    }
    public static function getFloat(string $key, ?float $default = null) : float {
        return (double) self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::FLOAT), $default), FILTER_VALIDATE_FLOAT);
    }
    public static function getRatio(string $key, ?float $default = null) : float {
        return RatioParser::parse(self::validateVariableValue(CompositeResolver::instance()->resolve(self::validateVariableType($key, VariableTypes::RATIO), $default)));
    }
    public static function getKnownValues(string $variableName) : ?array {
        return ClassConstantAccessor::getValue(KnownValues::class, $variableName);
    }
    public static function getDefault(string $variableName) {
        return ClassConstantAccessor::getValue(Defaults::class, $variableName);
    }
    public static function getType(string $variableName) : ?string {
        return ClassConstantAccessor::getValue(ValueTypes::class, $variableName);
    }
    public static function isEmpty($value) : bool {
        // don't use 'empty()', since '0' is not considered to be empty
        return $value === null || $value === '';
    }
    private static function validateVariableType(string $variableName, string $type) : string {
        $variableType = self::getType($variableName);
        if ($variableType !== null && $variableType !== $type && $variableType !== VariableTypes::MIXED) {
            throw new UnexpectedValueException(sprintf('Variable "%s" is not supposed to be of type "%s" but type "%s"', $variableName, $type, $variableType));
        }
        return $variableName;
    }
    private static function validateVariableValue($value, ?int $filterType = null) {
        if ($filterType !== null && filter_var($value, $filterType) === false) {
            throw new UnexpectedValueException(sprintf('Value has invalid type "%s"', gettype($value)));
        }
        if ($value === null || $value === '') {
            throw new UnexpectedValueException('Variable must not be null or empty');
        }
        return $value;
    }

}