*/ private static $isDtoObjectCache = []; /** * @param array $value * @param int $depth * * @return array */ public static function convertArrayForMaxDepth(array $value, int $depth): array { return [LogConsts::MAX_DEPTH_REACHED => $depth, LogConsts::TYPE_KEY => DbgUtil::getType($value), LogConsts::ARRAY_COUNT_KEY => count($value)]; } /** * @param object $value * @param int $depth * * @return array */ public static function convertObjectForMaxDepth(object $value, int $depth): array { return [LogConsts::MAX_DEPTH_REACHED => $depth, LogConsts::TYPE_KEY => DbgUtil::getType($value)]; } /** * @param mixed $value * * @return mixed */ public static function convert($value, int $depth) { if ($value === null) { return null; } // Scalar variables are those containing an int, float, string or bool. // Types array, object and resource are not scalar. if (is_scalar($value)) { return $value; } if (is_array($value)) { if ($depth >= self::$maxDepth) { return self::convertArrayForMaxDepth($value, $depth); } return self::convertArray($value, $depth + 1); } if (is_resource($value)) { return self::convertOpenResource($value); } if (is_object($value)) { if ($depth >= self::$maxDepth) { return self::convertObjectForMaxDepth($value, $depth); } return self::convertObject($value, $depth); } /** @phpstan-ignore-next-line */ return [LogConsts::TYPE_KEY => DbgUtil::getType($value), LogConsts::VALUE_AS_STRING_KEY => strval($value)]; } /** * @param array $array * * @return array */ private static function convertArray(array $array, int $depth): array { return self::convertArrayImpl($array, ArrayUtil::isList($array), $depth); } /** * @param array $array * @param bool $isListArray * @param int $depth * * @return array */ private static function convertArrayImpl(array $array, bool $isListArray, int $depth): array { $arrayCount = count($array); $smallArrayMaxCount = $isListArray ? LogConsts::SMALL_LIST_ARRAY_MAX_COUNT : LogConsts::SMALL_MAP_ARRAY_MAX_COUNT; if ($arrayCount <= $smallArrayMaxCount) { return self::convertSmallArray($array, $isListArray, $depth); } $result = [LogConsts::TYPE_KEY => LogConsts::LIST_ARRAY_TYPE_VALUE]; $result[LogConsts::ARRAY_COUNT_KEY] = $arrayCount; $halfOfSmallArrayMaxCount = intdiv($smallArrayMaxCount, 2); $firstElements = array_slice($array, 0, $halfOfSmallArrayMaxCount); $result['0-' . intdiv($smallArrayMaxCount, 2)] = self::convertSmallArray($firstElements, $isListArray, $depth); $result[($arrayCount - $halfOfSmallArrayMaxCount) . '-' . $arrayCount] = self::convertSmallArray(array_slice($array, -$halfOfSmallArrayMaxCount), $isListArray, $depth); return $result; } /** * @param array $array * @param bool $isListArray * @param int $depth * * @return array */ private static function convertSmallArray(array $array, bool $isListArray, int $depth): array { return $isListArray ? self::convertSmallListArray($array, $depth) : self::convertSmallMapArray($array, $depth); } /** * @param array $listArray * * @return array */ private static function convertSmallListArray(array $listArray, int $depth): array { $result = []; foreach ($listArray as $value) { $result[] = self::convert($value, $depth); } return $result; } /** * @param array $mapArrayValue * * @return array */ private static function convertSmallMapArray(array $mapArrayValue, int $depth): array { return self::isStringKeysMapArray($mapArrayValue) ? self::convertSmallStringKeysMapArray($mapArrayValue, $depth) : self::convertSmallMixedKeysMapArray($mapArrayValue, $depth); } /** * @param array $mapArrayValue * * @return bool */ private static function isStringKeysMapArray(array $mapArrayValue): bool { foreach ($mapArrayValue as $key => $_) { if (!is_string($key)) { return false; } } return true; } /** * @param array $mapArrayValue * * @return array */ private static function convertSmallStringKeysMapArray(array $mapArrayValue, int $depth): array { $result = []; foreach ($mapArrayValue as $key => $value) { $result[$key] = self::convert($value, $depth); } return $result; } /** * @param array $mapArrayValue * @param int $depth * * @return array */ private static function convertSmallMixedKeysMapArray(array $mapArrayValue, int $depth): array { $result = []; foreach ($mapArrayValue as $key => $value) { $result[] = ['key' => self::convert($key, $depth), 'value' => self::convert($value, $depth)]; } return $result; } /** * @param resource $resource * * @return array */ private static function convertOpenResource($resource): array { return [ LogConsts::TYPE_KEY => LogConsts::RESOURCE_TYPE_VALUE, LogConsts::RESOURCE_TYPE_KEY => get_resource_type($resource), LogConsts::RESOURCE_ID_KEY => intval($resource), ]; } /** * @param object $object * @param int $depth * * @return mixed */ private static function convertObject(object $object, int $depth) { if ($object instanceof LoggableInterface) { return self::convertLoggable($object, $depth); } if ($object instanceof Throwable) { return self::convertThrowable($object, $depth); } $fqClassName = get_class($object); $isFromElasticNamespace = TextUtil::isPrefixOf('Elastic\\Apm\\', $fqClassName) || TextUtil::isPrefixOf('ElasticApmTests\\', $fqClassName); if ($isFromElasticNamespace && self::isDtoObject($object)) { return self::convertDtoObject($object, $depth); } if (method_exists($object, '__debugInfo')) { return [ LogConsts::TYPE_KEY => get_class($object), LogConsts::VALUE_AS_DEBUG_INFO_KEY => self::convert($object->__debugInfo(), $depth), ]; } if (method_exists($object, '__toString')) { return [ LogConsts::TYPE_KEY => get_class($object), LogConsts::VALUE_AS_STRING_KEY => self::convert($object->__toString(), $depth), ]; } return [ LogConsts::TYPE_KEY => get_class($object), LogConsts::OBJECT_ID_KEY => spl_object_id($object), LogConsts::OBJECT_HASH_KEY => spl_object_hash($object), ]; } /** * @param LoggableInterface $loggable * @param int $depth * * @return mixed */ private static function convertLoggable(LoggableInterface $loggable, int $depth) { $logStream = new LogStream(); $loggable->toLog($logStream); return self::convert($logStream->value, $depth); } /** * @param Throwable $throwable * @param int $depth * * @return array */ private static function convertThrowable(Throwable $throwable, int $depth): array { return [ LogConsts::TYPE_KEY => get_class($throwable), LogConsts::VALUE_AS_STRING_KEY => self::convert($throwable->__toString(), $depth), ]; } /** * @param object $object * @param int $depth * * @return string|array * @phpstan-return array */ private static function convertDtoObject(object $object, int $depth) { $class = get_class($object); try { $currentClass = new ReflectionClass($class); /** @phpstan-ignore-next-line */ } catch (ReflectionException $ex) { return LoggingSubsystem::onInternalFailure('Failed to reflect', ['class' => $class], $ex); } $nameToValue = []; while (true) { foreach ($currentClass->getProperties() as $reflectionProperty) { if ($reflectionProperty->isStatic()) { continue; } $propName = $reflectionProperty->name; $propValue = $reflectionProperty->getValue($object); $nameToValue[$propName] = self::convert($propValue, $depth); } $currentClass = $currentClass->getParentClass(); if ($currentClass === false) { break; } } return $nameToValue; } private static function isDtoObject(object $object): bool { $class = get_class($object); $valueInCache = ArrayUtil::getValueIfKeyExistsElse($class, self::$isDtoObjectCache, null); if ($valueInCache !== null) { return $valueInCache; } $value = self::detectIfDtoObject($class); self::addToIsDtoObjectCache($class, $value); return $value; } /** * @template T of object * * @param class-string $className * * @return bool */ private static function detectIfDtoObject(string $className): bool { try { $currentClass = new ReflectionClass($className); /** @phpstan-ignore-next-line */ } catch (ReflectionException $ex) { LoggingSubsystem::onInternalFailure('Failed to reflect', ['className' => $className], $ex); return false; } while (true) { foreach ($currentClass->getProperties() as $reflectionProperty) { if ($reflectionProperty->isStatic()) { continue; } if (!$reflectionProperty->isPublic()) { return false; } } $currentClass = $currentClass->getParentClass(); if ($currentClass === false) { break; } } return true; } private static function addToIsDtoObjectCache(string $class, bool $value): void { $isDtoObjectCacheCount = count(self::$isDtoObjectCache); if ($isDtoObjectCacheCount >= self::IS_DTO_OBJECT_CACHE_MAX_COUNT_HIGH_WATER_MARK) { self::$isDtoObjectCache = array_slice( self::$isDtoObjectCache, $isDtoObjectCacheCount - self::IS_DTO_OBJECT_CACHE_MAX_COUNT_LOW_WATER_MARK ); } self::$isDtoObjectCache[$class] = $value; } }