[Feature][Long-Term] Interception of methods in the internal PHP classes

[lisachenko]

Interception of methods in the internal PHP classes is the most complex one, however, it is required for special cases, for example, to intercept mysql->query() invocation:

class MysqliQueryOperationCollectionAspect implements Aspect {

    /**
     * @param MethodInvocation $invocation Invocation
     * @Around(execution(public mysqli->query(*))
     * @return mixed
     */
    public function aroundQueryMethod(MethodInvocation $invocation) {
        $method = $invocation->getMethod();
        $args = $invocation->getArguments();
        $query = $args[1];
        if ($this->logger->isTraceEnabled()) {
            $this->logger->trace($method->getName().'('.$query.')');
        }

        try {
            $result = $invocation->proceed();
            return $result;
        } catch(Exception $e) {
            if ($this->logger->isTraceEnabled()) {
                $this->logger->trace($method->getName().'('.$query.') '.get_class($e).':' .$e->getMessage());
            }
            throw $e;
        }
    }
}

[lgoldstein]

On a related issue - I have read the Intercepting Execution of System Functions in PHP article and was wondering if the above limitation also applies to core functions (e.g., mysql_query(...)). In other words, can I use Go! to intercept this kind of functions ? If not, then while you are considering the core classes issue, can you also consider the core functions one as well ?

[lisachenko]

@lgoldstein you can intercept core functions with Go! AOP, but cache warming will be slower. Check the demo: http://demo.aopphp.com/?showcase=function-interceptor

UPD1: To enable a function interception, you should explicitly enable this functionality via Features::INTERCEPT_FUNCTIONS, see https://github.com/lisachenko/go-aop-php/blob/master/demos/autoload_aspect.php#L24 and then just define an advice with execution(Some\Namespace\func_name(*)), see https://github.com/lisachenko/go-aop-php/blob/master/demos/Demo/Aspect/FunctionInterceptorAspect.php#L23-L32

[lgoldstein]

@lisachenko Great - I will give it a go with mysql functions...

[lisachenko]

Updated my previous answer to include some useful links for you, should be helpful.

[lgoldstein]

Please note that I am talking about core functions (like mysql_query()) - all your examples refer to user functions in some application namespace - this is not the case for core functions...

[lisachenko]

My example is for core functions :) so, if you have a call to the mysqli_query(), then you can intercept it. There are several requirements: function call should be from a namespaced code (won't work for the global namespace), function call should not use backslash like this \mysqli_query()

Typical modern code is satisfies these requirements.

[lgoldstein]

@lisachenko Great - just wanted to make sure that you understood my meaning. I haven't tried it yet (turns out the application I was trying to instrument uses either mysqli or PDO). I will try to locate an application that uses mysql funtioncs and see if I can instrument it.

BTW, I assume that PDO is also non-instrumentable (being a core class...)...

[lisachenko]

Yes, PDO are core classes, so without this feature, framework can't handle them.

[lgoldstein]

@lisachenko Understood - I will follow this issue hoping that a solution can be found...

[lgoldstein]

@lisachenko Does not seem to work for mysql_query functions - the code is issuing queries but the aspect isn't being invoked. I have used this sample application with the following initializations and code:

 $aspectKernel = VMerlinAspectKernel::getInstance();
    // see AspectKernel::getDefaultOptions
    $aspectKernel->init(array(
            'debug' => false,
            // Cache directory
            'cacheDir' => $cacheDir,
            'appDir' => join(DIRECTORY_SEPARATOR, array('C:', 'Projects', 'appwatch', 'xampp', 'htdocs', 'phpcrud')),
            'interceptFunctions' => true
        ));

Followed by this aspect definition (the aspect is registered at the container in the VMerlinAspectKernel::configureAop function):

/**
 * Intercepts <U>functional</U> calls to <code>mysql_*query*</code>
 * @author Lyor Goldstein <lgoldstein@vmware.com>
 * @since Dec 3, 2014 2:57:43 PM
 */
class MysqlFunctionsOperationCollectionAspect extends VMerlinOperationCollectionAspectSupport implements Aspect {
    function __construct(array $config) {
        parent::__construct($config);
    }   
    /**
     * @param FunctionInvocation  $invocation Invocation
     * @Around(execution(mysql_query(*))
     * @return mixed
     */
    public function aroundQueryFunctions(FunctionInvocation $invocation) {
        $method = $invocation->getFunction();
        $args = $invocation->getArguments();
        $query = $args[0];
        if ($this->logger->isTraceEnabled()) {
            $this->logger->trace($method->getName().'('.$query.')');
        }

        $startTime = VMerlinHelper::timestampValue();
        try {
            $result = $invocation->proceed();
            return $result;
        } catch(Exception $e) {
            if ($this->logger->isTraceEnabled()) {
                $this->logger->trace($method->getName().'('.$query.') '.get_class($e).': '.$e->getMessage());
            }
            throw $e;
        }
    }
}

[lisachenko]

@lgoldstein your pointcut will never match anything, correct form is @Around(execution(**\mysql_query(*)) - execution of system mysql_query in all namespaces.

But it's only a minor fix. Framework is not suited for spaghetti code like in your example. http://zaldivar.orgfree.com/php/crud-example-for-php-beginner/ This will result in errors during static parsing and analysing of source code.

Moreover, auto_prepending AOP initalization for such spaghetti code won't do anything. So, is your real source code looks like that? Or there are normal classes with methods?

For auto_prepended file there is only one ugly way to enable AOP, something like this: eval(file_get_contents(FilterInjectorTransformer::rewrite($_SERVER['SCRIPT_FILENAME']));die; But I don't like it at all :)

[lgoldstein]

@lisachenko My purpose is to use Go! in order to instrument any application - in other words, I want to place some code in the auto_prepend PHP script that will intercept API(s) of interest (e.g., mysql). Therefore, I have no control over the "spaghetti code" that you mention - i.e., I am not instrumenting my application but rather any application - one that is written by anyone (so I don't know if they are using "nice" or "spaghetti" code). Furthermore, I don't want to ask the user to change his/her application scripts with ugly code such as the eval statement you mentioned.

In this context, if the application I am trying to instrument contains only pure PHP instead of mixed HTML and PHP would the auto_prepend approach work ? Is there some way to have Go! support mixed HTML + PHP scripts (such as the example) ?

[lisachenko]

@lgoldstein nice questions, you are right that tool should work for any application. Unfortunately, PHP-Token-Reflection library (which is used internally by framework) may not be able to parse any code, because it's assume that code is valid OOP, eg. classes, functions, interfaces, etc.

I think, that userland implementation of AOP is not suitable for your requirements. Have you tried AOP-PHP extension? This tool is working on engine level and you can use it with auto_prepend as well, also it capable to intercept execution of system functions and execution of methods for internal classes. But be aware, that this project is not maintained for 6 monthes and doesn't working for PHP>=5.5

[lgoldstein]

@lisachenko I will look into the AOP-PHP extension - I was aware of it, but I prefer a pure PHP approach (also like you said "project is not maintained for 6 monthes and doesn't working for PHP>=5.5"). In the meanwhile, it would be nice if some solution could be found for Go! to support this kind of applications.

I will continue to follow your project - at least for supporting core classes and/or functions - even if mixed HTML / PHP code is (for now) not supported.

Thanks.