Read it on my Turbocharged blog: Building a true home page into your WordPress blog

While doing routine tuning and checking of my weblog, I discovered a rather nasty slowdown with WordPress page generation. Taking the “scientific” route, I deactivated nearly all non-essential plugins in my Supercharged weblog (more than 40) and proceeded to activate them one by one, interspersing activations with ApacheBench tests.

A short plug: This post is brought to you by Supercharged. If you want to get these plugins in one package, consider getting Supercharged for your blog.

Really quick conclusions:

• WordPress (with the baseline plugins installed) is slow. On my server (not exactly the fastest thing in the planet, but dedicated to Web and database serving, and not bound by swapping or memory limits), it can’t pipe more than 1.5 front page views per second. I don’t think the load from ApacheBench accounts for more than 10% of the CPU usage.
• Do not install My Tube under any circumstances. Further investigation is pending.
• These plugins add negligible amounts of overhead. None of the plugins (except for My Tube) added detectable performance losses.
• bsuite seems to introduce a small slowdown.

The chart above shows the (rather unscientific, but effective) results of my short benchmark, in a nice bar chart (the taller, the better). This table represents the average KB/s for page generation after activating each plugin. Note that plugins were never deactivated after beig activated (except for My Tube, which I kicked out of the circuit). Thus, in a perfectly repeatable test scenario, you should see a ladder in the bar chart. Since you don’t see one, I can conclude that stacking my 40 plugins introduces negligible page generation performance overhead.

Caveats:

• I started with a plugin baseline of Akismet, Fold Page List, Fold Category List, PHP Markdown Extra, Redirectify, Software shop for WordPress, del.icio.us widget, Sidebar Widgets, WordPress allow dashes, WordPress AutoLink, Permalink redirect. There’s simply no way I can afford to turn these off in my live site.
• I hit my site with 100 requests using ab -n 1000 http://rudd-o.com/ executing on the Web host. Whenever I saw dramatic performance drops, I checked to see whether the load average was high, then waited for all other running processes to finish, and then re-tested
• As you can see, I only tested front page views.
• The base WordPress installation is a vanilla 2.0.3 + bug fixes setup. No caching options were modified or set.
• This is not a scientific test. Standard deviation is not reported. Since I was only looking major performance drops, minor differences (+/- 0.1 requests per second) can be accounted for the fact that tests were performed on the live site. Yes, that includes apparent “performance boosts” with some plugins active.
• Plugins that add template tags or widgets were added to the template/widget configuration for accurate representation.
• This benchmark does not measure page responsiveness or ancillary object loading times (JavaScript, images)

Here is the collected data:

baseline: Akismet, Fold Page List, Fold Category List, PHP Markdown Extra, Redirectify, Software shop for WordPress, del.icio.us widget, Sidebar Widgets, WordPress allow dashes, WordPress AutoLink, Permalink redirect:
Requests per second: 1.56 [#/sec] (mean)
Time per request: 642.467 [ms] (mean)
Transfer rate: 50.06 [Kbytes/sec] received

add: Canary Comment
Requests per second: 1.54 [#/sec] (mean)
Time per request: 649.238 [ms] (mean)
Transfer rate: 52.48 [Kbytes/sec] received

add Cache-Flush
Requests per second: 1.58 [#/sec] (mean)
Time per request: 634.240 [ms] (mean)
Transfer rate: 53.72 [Kbytes/sec] received

add Creative Commons Configurator
Requests per second: 1.54 [#/sec] (mean)
Time per request: 648.789 [ms] (mean)
Transfer rate: 54.52 [Kbytes/sec] received

add: Digg This
Requests per second: 1.47 [#/sec] (mean)
Time per request: 678.475 [ms] (mean)
Transfer rate: 52.13 [Kbytes/sec] received

add: Days Since Birth and Gravatars
Requests per second: 1.49 [#/sec] (mean)
Time per request: 669.963 [ms] (mean)
Transfer rate: 52.82 [Kbytes/sec] received

add: Inline ajax more
Requests per second: 1.67 [#/sec] (mean)
Time per request: 597.525 [ms] (mean)
Transfer rate: 61.60 [Kbytes/sec] received

add: In Series
Requests per second: 1.41 [#/sec] (mean)
Time per request: 707.612 [ms] (mean)
Transfer rate: 52.02 [Kbytes/sec] received

add: iG:CoComment
Requests per second: 1.61 [#/sec] (mean)
Time per request: 621.901 [ms] (mean)
Transfer rate: 59.19 [Kbytes/sec] received

add: Bread Crumb Trail Generator
Requests per second: 1.60 [#/sec] (mean)
Time per request: 623.195 [ms] (mean)
Transfer rate: 59.47 [Kbytes/sec] received

add: LMB^Box FilePress
Requests per second: 1.55 [#/sec] (mean)
Time per request: 646.917 [ms] (mean)
Transfer rate: 57.29 [Kbytes/sec] received

add: LMB^Box Comment Quicktags
Requests per second: 1.73 [#/sec] (mean)
Time per request: 577.145 [ms] (mean)
Transfer rate: 64.21 [Kbytes/sec] received

add: My Tube
Requests per second: 0.49 [#/sec] (mean)
Time per request: 2025.577 [ms] (mean)
Transfer rate: 18.39 [Kbytes/sec] received (at this point, I’m disabling My Tube)

remove: My Tube
Requests per second: 1.71 [#/sec] (mean)
Time per request: 585.946 [ms] (mean)
Transfer rate: 63.25 [Kbytes/sec] received

add: Optimal Title
Requests per second: 1.49 [#/sec] (mean)
Time per request: 671.295 [ms] (mean)
Transfer rate: 55.21 [Kbytes/sec] received

add: Related Posts
Requests per second: 1.73 [#/sec] (mean)
Time per request: 577.798 [ms] (mean)
Transfer rate: 64.14 [Kbytes/sec] received

add: Taragana’s Del.icio.us mp3 Player Plugin
Requests per second: 1.55 [#/sec] (mean)
Time per request: 646.751 [ms] (mean)
Transfer rate: 57.41 [Kbytes/sec] received

add: FancyTooltips
Requests per second: 1.51 [#/sec] (mean)
Time per request: 660.859 [ms] (mean)
Transfer rate: 56.59 [Kbytes/sec] received

add: Recent Comments (my edition adds a ‘Recent comments with excerpts’ widget)
Requests per second: 1.51 [#/sec] (mean)
Time per request: 664.122 [ms] (mean)
Transfer rate: 58.38 [Kbytes/sec] received

add: Sociable
Requests per second: 1.53 [#/sec] (mean)
Time per request: 652.300 [ms] (mean)
Transfer rate: 59.62 [Kbytes/sec] received

add: Subscribe me
Requests per second: 1.52 [#/sec] (mean)
Time per request: 659.224 [ms] (mean)
Transfer rate: 61.01 [Kbytes/sec] received

add: Search Meter
Requests per second: 1.49 [#/sec] (mean)
Time per request: 670.161 [ms] (mean)
Transfer rate: 60.02 [Kbytes/sec] received

add: Search Reloaded
Requests per second: 1.43 [#/sec] (mean)
Time per request: 699.615 [ms] (mean)
Transfer rate: 57.49 [Kbytes/sec] received

add: Text Link Ads
Requests per second: 1.43 [#/sec] (mean)
Time per request: 699.958 [ms] (mean)
Transfer rate: 57.46 [Kbytes/sec] received

add: WP Lightbox 2
Requests per second: 1.41 [#/sec] (mean)
Time per request: 706.736 [ms] (mean)
Transfer rate: 57.67 [Kbytes/sec] received

add: Write Post Find and Rudd-O’s Wordspew
Requests per second: 1.44 [#/sec] (mean)
Time per request: 695.128 [ms] (mean)
Transfer rate: 59.01 [Kbytes/sec] received

add: BlogSpy for WordPress
Requests per second: 1.45 [#/sec] (mean)
Time per request: 688.703 [ms] (mean)
Transfer rate: 59.66 [Kbytes/sec] received

add: XFish Meta
Requests per second: 1.40 [#/sec] (mean)
Time per request: 714.832 [ms] (mean)
Transfer rate: 57.57 [Kbytes/sec] received

add: WP-SlimStat
Requests per second: 1.41 [#/sec] (mean)
Time per request: 708.787 [ms] (mean)
Transfer rate: 58.06 [Kbytes/sec] received

add: AutoMeta
Requests per second: 1.38 [#/sec] (mean)
Time per request: 725.395 [ms] (mean)
Transfer rate: 56.73 [Kbytes/sec] received

add: bsuite (my edition has some bug fixes by me)
Requests per second: 1.21 [#/sec] (mean)
Time per request: 827.565 [ms] (mean)
Transfer rate: 49.72 [Kbytes/sec] received

<?php

/* Plugin Name: BlogSpy for WordPress Version: 0.0.1 Plugin URI: http://rudd-o.com/ Description: Automates inclusion in the BlogSpy network Author: Manuel Amador (Rudd-O) Author URI: http://rudd-o.com/ */

/* Code licensed under the GNU GPL v2 */

function blogspy_footer() { print '<script src="http://spy.foxcorp.org/spy.js" type="text/javascript"></script>'; }

add_action("wp_footer","blogspy_footer");

?>

Graba este código en un archivo llamado blogspy.php y colócalo en tu directorio wp-content/plugins en tu Web host de WordPress. Actívalo a través de la pantalla de administración de plugins de WordPress, and that’s it! Ya estás en BlogSpy.

En algún momento lo haré un plugin propiamente dicho, disponible para descargar. Por lo pronto, que te aproveche.

In lieu of that problem, I decided to explore alternatives. The final, usable alternative seems to be:

function inherits_from($destClassName,$srcClassNameList) {
    foreach ($srcClassNameList as $s) {
        runkit_class_adopt($destClassName,$s);
    }
}

And this version does work without the memory exhaustion problem. In short:

<?php

class A { ...A's methods here... }

class B { ...B's methods here... }

class C { ...C's methods here... }

class MultipleInheritedClass { ...this class' methods here... } inherits_from( 'MultipleInheritedClass', array('A','B','C') ); ?>

The inherits_from construct does the magic. All you need to type there is:

• The name of the “child” class
• An array containing the names of the “parent” classes

Of course, this technique works only in PHP 5, with the runkit extension.

Despite the cutting-edge requirements, I’ve just shown there’s a practical way to build multiple inheritance in PHP. Mixin classes, aggregate classes, they’re a few keystrokes away. Long live PHP!

Oh, by the way, did I mention that I built convenient RPM packages of runkit?

They should work on any Fedora Core 5 system (it may just work on a Fedora Core 4 system with PHP 5.1, but other than that, you’ll have to edit the spec file).

Download the PHP runkit RPMs (source and i386 packages)

Here’s some code that will help you simulate multiple inheritance in PHP 5 with maximum portability. This requires the runkit extension for PHP, regrettably. Hope runkit gets rolled into baseline PHP 5.

This code also emulates the aggregate_methods function from the Object aggregation functions in PHP 4.

Say you have:

<?php
class Foo {
   function example() {
       return "foo!\n";
   }
}

class Bar { // initially, no methods }

// copy the example() method from the Foo class to the Bar class, as baz() runkit_method_copy('Bar', 'baz', 'Foo', 'example');

// output copied function echo Bar::baz(); ?>

We can generalize the runkit_method_copy to work with all classes:

<?php

function aggregate_methods($destClassName,$srcClassName) { $methods = get_class_methods($srcClassName); foreach ($methods as $m) { runkit_method_copy($destClassName,$m,$srcClassName,$m); } }

function inherits_from($destClassName,$srcClassNameList) { foreach ($srcClassNameList as $s) { aggregate_methods($destClassName,$s); } }

?>

Now, the function call will work for all classes without modification (honorable exception made of classes whose method namespaces clash). This little bit of magic lets you ‘inherit’ from multiple classes, taking full advantage of methods defined in other classes (such as classes written explicitly to work as mix-ins). Most of the introspection machinery won’t exactly work, but those are the breaks.

In practical terms:

<?php

class A { ...A' methods here... }

class B { ...B' methods here... }

class C { ...C's methods here... }

class MultipleInheritedClass { ...this class' methods here... } inherits_from('MultipleInheritedClass',array('A','B','C'));

?>

So there you go: there is multiple inheritance available in PHP!

Since all you have is 5 minutes (which is one of the tenets of this Server management series, and quite possibly the only simple truth in your case), in this installment, we’ll unlock the secret of server log foraging.

All you need is grep.

I don’t know what the Beatles would say about this heading, but, indeed, grep is all you need.

This guide is laid out in two distinct sections:

• Configuring PHP to report errors
• Actually mulling over the server logs

I’m assuming you’re using Apache on Linux, of course. I will also assume you have access to your server logs and write permission to the PHP configuration file (usually /etc/php.ini).

Configuring PHP to report errors

Okay, fire up your trusty editor of choice (I use nano, and that’s only because I’m accustomed to pico — no longer shipped with any Free Software distro — and please let’s not get into an editor flamefest here) while being root. Open /etc/php.ini and look for the following configuration keys:

display_errors = On

Set it to Off. Production PHP applications should not reveal any bugs to the outside world. For the true hacker, the log files will say all that’s needed. And, for that, change the following configuration key:

error_reporting = E_ALL

Set it to E_ALL, because you’re interested in warnings, notices and errors. Finally, look for the following configuration key:

log_errors = Off

and set it to On. Save the file, and restart Apache (here’s how).

Let the application run for a couple of minutes (or hours, depending on your visitor volume).

grepping the logs

Now it’s time to start working on those logs. Locate your Apache error log file (usually at /var/log/httpd/error_log. Then use the following command to find all PHP-related error messages:

grep PHP /var/log/httpd/error_log

That may spit out a hefty amount of messages, so you’ll probably want to redirect it into a file:

grep PHP /var/log/httpd/error_log > /root/phperrors

The greater-than symbol directs the output of grep into the file /root/phperrors.

Inspect the newly created file with your favorite editor and look for messages. Does any of them say PHP Fatal Error or PHP Error? If so, you’ve got a real problem between hands. Warnings are also a cause for concern, because they usually mean an error occurred in your application, but the application just kept going like nothing happened. Notices aren’t so much a concern, but they should be dealt with individually, because they usually point to common programming mistakes that must be fixed.

The PHP log messages provide you with another useful tidbit of information: they say the file and line number of the error, notice or warning:

PHP Warning: strtotime() [client 157.100.84.91] PHP Warning: strtotime(): Called with an empty time parameter. in /home/rudd-o/public_html/links.php on line 53, referer: http://rudd-o.com/index.php

That information is very useful to find the source of the problem.

Conclusions

Whether you have to fix errors yourself, or there’s a dedicated team behind the Web applications you’re overseeing, any PHP-related messages usually pinpoint to issues that need to be paid attention to.

It’s also a good idea to automate this procedure into a shell or CGI script for the developers of the applications you oversee. That way, they’ll have a way to get early notice of any issues, and you won’t need to be involved in the process. Here’s an example shell script that would send those messages to someone at your company, to be run through cron:

#!/bin/bash

grep PHP /var/log/httpd/error_log | \ mail -s 'PHP messages' someone@yourcompany.com

Finally, this procedure should also be standard on testing and staging servers. Finding a problem early on the development stage is invaluable. You really don’t know how many customers you may lose to bugs that slip into production.

And that’s it for today! Remember, keep your Web applications bug-free, and they’ll give lots of value in return. Happy hacking!

Please beware that my blogging software adds a backslash for every quote mark. You should promptly remove these before attempting to use this code.

require_once("xml_domit_parser.php");

function get_currency_exchange_array($location) {

global $_get_currencies_cache; if ($_get_currencies_cache) { return $_get_currencies_cache; } $data = file_get_contents($location); $doc = new DOMIT_Document(); $doc->parseXML($data, true);

//crear un array vacio $moneda; $moneda = array(); //traerme todos los frbny:series en una lista $list $list = $doc->getElementsByTagName("frbny:Series");

//para cada elemento de $list: foreach ($list->arNodeList as $element) { $UNIT = $element->getAttribute("UNIT"); if (!$UNIT) continue;

$frbny_CURR = $element->getElementsByTagName("frbny:CURR");
if (!$frbny_CURR) continue;
$frbny_CURR = $frbny_CURR->arNodeList;
if (!$frbny_CURR) continue;
$frbny_CURR = $frbny_CURR[0];
if (!$frbny_CURR) continue;
$frbny_CURR = $frbny_CURR->firstChild;
if (!$frbny_CURR) continue;
$frbny_CURR = $frbny_CURR->nodeValue;
if (!$frbny_CURR) continue;

$frbny_OBS_VALUE = $element->getElementsByTagName("frbny:OBS_VALUE");
if (!$frbny_OBS_VALUE) continue;
$frbny_OBS_VALUE = $frbny_OBS_VALUE->arNodeList;
if (!$frbny_OBS_VALUE) continue;
$frbny_OBS_VALUE = $frbny_OBS_VALUE[0];
if (!$frbny_OBS_VALUE) continue;
$frbny_OBS_VALUE = $frbny_OBS_VALUE->firstChild;
if (!$frbny_OBS_VALUE) continue;
$frbny_OBS_VALUE = $frbny_OBS_VALUE->nodeValue;
if (!$frbny_OBS_VALUE) continue;

// si el array $moneda no contiene un elemento (array) de nombre UNIT, crearlo como array vacio
if (!array_key_exists($UNIT,$moneda)) $moneda[$UNIT] = array();
// ahora si, le metemos el valúe al array
$moneda[$UNIT][$frbny_CURR] = floatval( $frbny_OBS_VALUE );

}

$_get_currencies_cache = $moneda; return $moneda;

}

function exchange_rate($file,$from_descriptor,$to_descriptor,$donotrecurse=false) {

returns null if no exchange rate found

$moneda = get_currency_exchange_array($file);

if (array_key_exists($from_descriptor,$moneda)    array_key_exists($to_descriptor,$moneda[$from_descriptor])) { return $moneda[$from_descriptor][$to_descriptor]; } elseif ($donotrecurse == false) { $value = exchange_rate($file,$to_descriptor,$from_descriptor,true); if (!$value) return; return 1.0/$value; }

return;

}

Be nice to the Federal Reserve server, and do not fetch their XML feed each time you want to obtain exchange rates.