Make any PHP Exception serializable by flattening complex values in backtrace.

flattenExceptionBacktrace.php

<?php
    function flattenExceptionBacktrace(\Exception $exception) {
        $traceProperty = (new \ReflectionClass('Exception'))->getProperty('trace');
        $traceProperty->setAccessible(true);

        $flatten = function(&$value, $key) {
            if ($value instanceof \Closure) {
                $closureReflection = new \ReflectionFunction($value);
                $value = sprintf(
                    '(Closure at %s:%s)',
                    $closureReflection->getFileName(),
                    $closureReflection->getStartLine()
                );
            } elseif (is_object($value)) {
                $value = sprintf('object(%s)', get_class($value));
            } elseif (is_resource($value)) {
                $value = sprintf('resource(%s)', get_resource_type($value));
            }
        };

        do {
            $trace = $traceProperty->getValue($exception);
            foreach($trace as &$call) {
                array_walk_recursive($call['args'], $flatten);
            }
            $traceProperty->setValue($exception, $trace);
        } while($exception = $exception->getPrevious());

        $traceProperty->setAccessible(false);
    }

Demo:

<?php
class Foo {
    public function bar(callable $param, $baz) {
        throw new Exception();
    }
}

try {
    $foo = new Foo;
    $foo->bar(function(){}, new Foo);
} catch (Exception $exception) {
    flattenExceptionBacktrace($exception);
    $serialized = serialize($exception);
    $unserialized = unserialize($serialized);
    print_r($unserialized->getTraceAsString());
}

Shouldn't it unset $call after the foreach-by-reference?

I have found that with the way that PHP 7 handles errors now, treating them as exceptions, my error handlers receive Error type throwables too. As per PHP's reccomendation, we must now expect to receive Throwables, rather than just Exceptions.

Unfortunately, while we can change the type hint to throwable, we cannot just change the reflection class type to Throwable as it does not contain the property trace, but if we check if the throwable is an instance of Error or Exception, we can then get the trace property as expected.

If we do not do this, then any throwable type errors sent to this function will raise an exception that they are not an instance of the object type exception (in a more cryptic manner). For the PHP 7 ready modifications, see my fork.

Be aware to use this function.
As it changes real method arguments passed by reference.

function foo(&$bar)
{
    flattenExceptionBacktrace(new \Exception());
}

$bar = new \DateTime();
foo($bar);
var_dump($bar); // outputs: string(16) "object(DateTime)"