Categorie: PHP

Bij Pronamic ontwikkel ik veel complexe WordPress oplossingen. Voor het snel monitoren van bijvoorbeeld database queries maak ik gebruik van de Query Monitor plugin. Vandaag kwam ik er achter dat de Query Monitor plugin ook een logging en profiling functionaliteit heeft. Hiermee is het mogelijk om in je eigen code zaken te loggen en de benodigde tijd te meten. Deze functionaliteit werd in 2018 (17 juli) al aangekondigd door John Blackbourn in het blog bericht “Profiling and Logging in Query Monitor“.

Profiling

// Start the 'foo' timer:
do_action( 'qm/start', 'foo' );

// Run some code
my_potentially_slow_function();

// Stop the 'foo' timer:
do_action( 'qm/stop', 'foo' );

https://github.com/johnbillion/query-monitor#profiling

Logging

do_action( 'qm/debug', 'This happened!' );

https://github.com/johnbillion/query-monitor#logging

😍

Het lijkt er op dat er steeds meer PHP-ontwikkelaars binnen namespaces gebruik gaan maken van zogenaamde ‘fully qualified name’ definities. Aan het gebruik van bijvoorbeeld globale PHP-functies zonder use function of \-prefix kleven namelijk een aantal nadelen. In het artikel “Optimizing PHP performance by using fully-qualified function calls” van Toon Verwerft is hier meer over te lezen. En ook op de website van DEV Community staat meer informatie:

Normally your code is namespaced (right?). So what happens when you call a function from the standard PHP library? The “compiler” (opcode producer) will look into the current namespace, then go up, and eventually use the global namespace. This means that if you add a “\” in front of standard functions (so effectively namespacing it in the global namespace explicitely), it will result in less opcode instructions, and that means faster code execution. Think it’s one of those useless micro-optimization like the use of single vs. double quotes? Think again.

DEV Community – https://dev.to/elabftw/optimizing-your-php-app-speed-3hd4

Ook op de website van PHP zelf is meer informatie te vinden over hoe PHP-namespaces werken qua naamgeving van classes, functies, constanten, etc. In de FAQ staan een groot aantal voorbeelden van hoe PHP omgaat met de naamgeving binnen namespaces.

• https://www.php.net/manual/en/language.namespaces.importing.php
• https://www.php.net/manual/en/language.namespaces.fallback.php
• https://www.php.net/manual/en/language.namespaces.rules.php
• https://www.php.net/manual/en/language.namespaces.faq.php

Inmiddels zijn er ook enkele tools beschikbaar die kunnen helpen bij het gebruik van ‘fully qualified name’ definities. Zo kun je bijvoorbeeld met “PHP Coding Standards Fixer” het volgende doen:

➜  ~ php-cs-fixer fix test.php --rules=native_function_invocation,native_constant_invocation

Bron: https://stackoverflow.com/questions/55419673/php7-adding-a-slash-to-all-standard-php-functions-php-cs-fixer-rule

Naast php-cs-fixer kwam ik ook de volgende tools geven:

• https://github.com/Roave/FunctionFQNReplacer
• https://github.com/dg/composer-backslasher
• https://github.com/kelunik/fqn-check
• https://github.com/slevomat/coding-standard

Waar ik echter geen goed antwoord op kon vinden was of je nou beter kunt prefixen met een \ of use statements kunt gebruiken. In de TYPO3 decision topic “Should we use fully qualified function (FQN) calls like \is_array in the core?” kwam ik uiteindelijk de volgende vraag tegen:

do I read you correctly that you prefer having slashes over “use…” imports?

why?

Tymoteusz Motylewski

Deze vraag werd als volgt beantwoord:

Because we use the same PHP function within a file mostly not more than one or two times. Hence, it’s a waste of space up there to have 10 lines for 10 different functions.

(and I do not consider PHP core functions as “dependencies” like other classes, which should be easily readable at the top of a file)

Markus Klein

Op basis van deze argumenten en de momenteel beschikbare tools lijkt het prefixen met \ de voorkeur te hebben. Het was me ook zelf opgevallen dat je al snel veel use function definities kunt krijgen:

use function apply_filters;
use function implode;
use function is_object;
use function json_decode;
use function sprintf;
use function wp_json_encode;
use function wp_remote_request;
use function wp_remote_retrieve_body;
use function wp_remote_retrieve_response_code;
use function wp_remote_retrieve_response_message;

Het toevoegen van een prefix \ is in veel gevallen korter.

Bekijk ook eens de presentatie “For the love of code: Modernizing WordPress, plugins, and themes” van Juliette Reinders Folmer. Ze geeft in de presentatie aan op welke manier je PHP-code nog verder kunt moderniseren. Ze geeft ook nog een aantal goede ‘best practices’:

• Focus on function, not syntax
• Don’t attempt to do everything at once

Iedereen die met de WordPress Coding Standards weet waarschijnlijk ook dat deze kan controleren op hoe goed de code is gedocumenteerd. Hiervoor wordt gebruik gemaakt van de Squiz.Commenting sniffs. Bij Pronamic schakelen we deze sniffs vaak uit, omdat het voor maatwerk trajecten vaak niet uit kan om ook de documentatie tip top in orde te hebben. Voor de Pronamic Pay plugin willen we echter toewerken naar beter gedocumenteerde code. Daarom hebben we binnen deze plugin de Squiz.Commenting sniffs weer ingeschakeld. Dit resulteert momenteel nog in veel PHP_CodeSniffer fouten, zoals bijvoorbeeld:

   1 | ERROR | [ ] Missing file doc comment
     |       |     (Squiz.Commenting.FileComment.Missing)

Het is niet altijd even duidelijk wat PHP_CodeSnifer precies verwacht bij dergelijke fouten. De foutmelding geeft wel aan dat er een FileComment ontbreekt. Hoe deze FileComment er uit moet komen te zien wordt er echter niet bij vermeld. Na een kleine zoektocht kwam ik gelukkig wat resources tegen met meer informatie hierover:

• https://github.com/phpDocumentor/phpDocumentor2
• http://docs.phpdoc.org/references/phpdoc/basic-syntax.html
• https://github.com/phpDocumentor/fig-standards/blob/master/proposed/phpdoc.md

Verschillende WordPress plugins die we ontwikkelen bij Pronamic testen we automatisch. Hiervoor maken we gebruik van de WordPress test repository https://develop.svn.wordpress.org/ en PHPUnit. Voor onder andere de Pronamic iDEAL plugin maken we hier al een aantal jaren gebruik maken. Echter na het bijwerken naar de laatste versie van de WordPress test repository https://develop.svn.wordpress.org/ liep ik tegen de volgende foutmelding aan:

mysqli_query(): Couldn't fetch mysqli

In eerste instantie kon ik niet achterhalen waar wat fout ging, maar na lang zoeken en overleg met mijn collega Reüel heb ik hier wat meer informatie over kunnen vinden. In een WordPress.org support topic van 1½ maand geleden werd dezelfde foutmelding genoemd: https://wordpress.org/support/topic/wp_unittestcaseteardown-causes-mysqli_query-couldnt-fetch-mysqli/. Ryan McCue verwijst daar weer naar WordPress Trac ticket 39327. Hij beschrijft hier ook direct een oplossing:

Tracked this down a bit with @pento; it turns out to be a problem with PHPUnit’s global backups, and can be fixed by setting protected $backupGlobals = true in the test class. The key is that PHPUnit serialises the data and unserialises it to restore it.

Vervolgens geeft @pento later in een reactie ook aan hoe dit probleem het beste opgelost kan worden:

For an immediate plugin fix, the best option is to add backupGlobals=”false” to your phpunit.xms.dist.

Plugins zoals bijvoorbeeld Easy Digital Downloads hebben dit ook opgenomen in hun phpunit.xml  bestand: https://github.com/easydigitaldownloads/easy-digital-downloads/blob/master/phpunit.xml. Na het toevoegen van backupGlobals="false" is het probleem ook daadwerkelijk opgelost.