Engineering Concepts

How to gracefully handle cache expiration

Fri, 03 May 2013 12:55:46 -0400

I received few inquires for a technical run down of how Memcached wrapper handles expiration of keys.

When I first read about this concept, it was pretty hard to understand since most of the sources were way too technical (the fact that English is my second language probably did not help either) for somebody who just entered word of ‘holy crap! you can store stuff in memory’.

I will try my best to explain the problem with just caching and one of the ways you can avoid it without using too much of technical jargon.

Concept of Caching

Caching, to a less experienced developer is viewed as a tool that solves all of the performance problems. When Memcache was first introduced , developers would simply wrap a chunk of code in a block that does the following:

Look up a key from cache
If key does not exist in cache, call a random method to generate data that needs to be associated with that key
Store that data under the key in cache

And when same code block was executed again it would find the data associated with that key within the cache pool and give you the data… extremely fast.

To a developer that’s a wow factor by it self, I remember how impressed I was when I implemented something like this for the first time.

Such reaction is enough to simply put your tools down and call it a job well done. You can go home and celebrate your achievement and dream about handling thousands of users at any given time because this caching thing is awesome.

Rain on Your Parade

While you are still thinking that you solved all of the scalability problems you will ever have, your website get’s a tsunami of new visitors from a TV PR campaign your marketing team launched.

Everything looks great, you are smirking at how well the cache is working.

Then the site goes down.

You scrambles to find a solution, it can’t be the caching you just implemented. It’s just too fast to fail.

Usually (from what I seen) people will point fingers at the database or whatever complex/slow pieces of code you were hiding behind a cache.

(And while the database might be the slowest part of your application, that’s not the reason why your web site went down.)

Since cache is sooo fast, and your logs are telling you that your database simply died as soon as it started to see a little bit of requests you naturally assume that’s the main issue and it should be addressed.

So in a moment of panic you scream for more database slaves, a better tune of your cluster and perhaps a crazy last second sharding implementation.

That works out great, you are back in business and things are looking up.

Paradise in a Desert

Just like a paradise you might discover after walking under a burning sun in a desert, the solution you put in place to prevent another downtime due to a massive amount of traffic was simply an illusion.

The web site will still go down under the same conditions (unless of-course you invested in a small data center that hosts dozens of database clusters, then it’s debatable).

The reason for such mistakes is overlooking the fact that once you cache something that takes more than x seconds to execute, it will eventually expire from cache.

Either from having a short time to live (TTL) or by being pushed out the caching pool to make space for fresher data.

Breaking it Down

Let’s say you have 35 queries on your web site that you put behind a caching layer. You request the page and it flies. Absolutely no issues.

Even when cache expires and you grab the page it loads pretty damn fast, you can add 10 more concurrent visitors and there will be no problems. The database picks it all up easily and puts in back in the cache.

Now, if you multiply those 10 concurrent requests by let’s say 20. If all of the queries are cached, cache pool can process 200 requests without any issues.

But once the data in the cache expires all of a sudden all 200 requests to cache pool return ‘resource not found’ and sends all of those requests directly to the database at once.

And then the alarms go off.

The chain reaction is usually something along these lines:

Database becomes overloaded and clients stall waiting for data to be returned back from the database.
As the clients wait for a possibly dead database, http server keeps those clients in it’s pool while attempting to serve new clients using resources it has left.
The http server has ran out of resources since it can’t process clients as fast as it usually does because everything is being used up by requests that are waiting for database.

That sucks, right? If only there was a way to prevent this from happening.

Caching Just Got Smarter

One of the approaches to this problem is fairy simple. The concept is to wrap the original resource you are caching in an array that contains a time stamp that is set to a time that is just a few minutes short of the time when the item is actually set to expire.

And when your application unpacks cached resource it will check that time stamp and if current time greater it means that item it just retrieved is going to expire relatively soon.

Once it knows that item is going to expire, it will update the cached record with a new one that contains the exacly the same data it just recieved but with a longer expiration time.

Essentially telling anybody else who is pulling the data that the item is not going to expire any time soon.

Then you simply lie to your application and tell them that this request did not get anything back from cache. It will now execute a database query you were caching and save it back into the database with a new expiration date.

All of the new requests will now have an updated version of cached data.

While it’s possible that more than one request will slip through the flood gates, this is usually really rare. When I tested with 200 concurrent connections the key was updated by a single request.

Since you are caching everything, your database and apache should be pumping out requests fairly fast so you can probably afford more than a single person slipping through this barrier one in a while without creating an unrecoverable request queue of death.

Walk the Talk

Let’s get a little bit more technical and try to implement this solution in our code. First we need to come up with a time interval that we will subtract from the original expiration date.

This time interval depends on your caching strategy, basic rule of thumb take a median expiration intervals for the most important keys in cache that represent data from really slow database queries.

If that number is let’s say an hour and you can guarantee that on average, during a relatively busy day you get more than one request every 10 minutes, it’s safe to set time interval to 10 minutes.

If you have cached data that needs to be updated at a faster rate, always make sure that you are guaranteed that there will be a single request between original expiration time and the fake expiration time (ie: your safety net).

So since we now have a number in mind, let’s write a simple wrapper for Memcached extension so we can override set() method and wrap a resource we are caching in an array containing our ‘fake’ expiration date:


use \Memcached;

class Wrapper
{
    /**
     * Time to substract from original expiration date
     *
     * @var int
     */

    const DELAY = 600;

    /**
     * Instance of Memcached
     *
     * @var Memcached
     */
    protected $memcached;

    /**
     * Indicates that current look-up will expire shortly (dog-pile)
     *
     * @var bool
     */
    protected $isResourceExpired = false;

    /**
     * Class constructor
     */
    public function __construct()
    {
        $this->memcached = new Memcached();
    }

    /**
     * Add a new cached record using passed resource and key association
     *
     * @param string $key key to store passed resource under
     * @param mixed $resource resource you want to cache
     * @param int $ttl when should this key expire in seconds
     * @return bool
     */
    public function set($key, $resource, $ttl)
    {
        return (bool)$this->memcached->set($key, $this->wrap($resource, $ttl), $ttl);
    }

    /**
     * Wrap new cached resource into an array containing TTL stamp
     *
     * @param mixed $resource resource that is getting cached
     * @param int $ttl internal extended expiration
     * @return mixed[] returns packed resource with TTL stamp to store in cache
     */
    protected function wrap($resource, $ttl)
    {
        // Set meta expiration date 10 minutes before the actual date
        $ttl -= self::DELAY;

        return array(
            'ttl' => $ttl,
            'resource' => $resource
        );
    }
}

As you can see, we simply intercept set() method on original extension so we can call wrap() method on a resource we are caching. In return that method will take original expiration time we are attempting to set and subtract 10 minutes from it prior to adding it to our array.

Now, we need to intercept a get() method so we can unwrap the previously wrapped data and check the fake expiration date we set in order to determine if we should pretend the result is no longer cached.

To do so let’s add following methods to our wrapper:


/**
 * Override get method so we can wrap resource that is being cached
 * in an array containing additional metadata
 *
 * @param $string $key
 * @param mixed $resource where to store retrieved resource
 * @return bool
 */
protected function get($key, &$resource)
{
    // Attempt to retrieve record within cache pool
    $response = $this->memcached->get($key);
    if ($this->memcached->getResultCode() == Memcached::RES_SUCCESS) {
        // Pass record to unwrap method
        $resource = $this->unwrap($key, $response);

        // If key is marked as expired (needs to be updated within this request)
        // we will not return true, but instead fake a failure
        if (!$this->isResourceExpired) {
            return true;
        }
    }

    return false;
}

/**
 * Get requested data back into memory while setting a delayed cache entry
 * if data is expiring soon
 *
 * @param string $key key that you are retrieving
 * @param mixed[] packed data that we got back from cache pool
 * @return mixed|bool returns cached resource or false if invalid data was
 * passed for unwrapping
 */
protected function unwrap($key, array $data)
{
    // If expiration date is not set to never
    if ($data['ttl'] > 0) {
        // If current time is equal or greater than a fake expiration time
        if (time() >= $data['ttl']) {
            // Set the stale value back into cache for a short 'delay' of 10 minutes
            // so no one else tries to write the same data.
            //
            // Note how we are calling our set method that utilizes wrap()
            if ($this->set($key, $this->wrap($data['resource'], self::DELAY), self::DELAY)) {
                // Set flag that tells
                $this->isResourceExpired = true;
            }
        }
    }

    return $this->store($key, $data['resource']);
}

You now have a pretty solid protection that stops random flood of requests that bypass your caching layer at the same time.

As part of my Memcached wrapper, I included a simple proof of concept script that you can use to test this scenario your self.

When I bench marked the script in question with 200 concurrent requests the results did all the talking:

Using technique we implemented:


[30-Apr-2013 01:02:52 UTC] Wrapper database hit: 2013-04-30 03:02:52
[30-Apr-2013 01:07:52 UTC] Wrapper database hit: 2013-04-30 03:07:52
[30-Apr-2013 01:12:51 UTC] Wrapper database hit: 2013-04-30 03:12:51

As you can see only a single request out of 200 got through to query the database and update cache.

Using raw get/set methods:


[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:09 UTC] Memcached database hit: 2013-04-30 03:18:09
[30-Apr-2013 01:18:10 UTC] Memcached database hit: 2013-04-30 03:18:10
[30-Apr-2013 01:18:10 UTC] Memcached database hit: 2013-04-30 03:18:10
[30-Apr-2013 01:18:10 UTC] Memcached database hit: 2013-04-30 03:18:10
[30-Apr-2013 01:18:10 UTC] Memcached database hit: 2013-04-30 03:18:10

…. the Apache could no longer keep up with requests.

Fin.

Store your application files in Memcached pool with MemFS

Tue, 09 Apr 2013 20:49:35 -0400

This package provides a way to store your application files in Memcached pool with automatic parsing using eval() upon retrieval.

I wrote this after trolling a friend of mine how storing files in Memcached is faster than including them from disk, so while there are definite uses for this under right circumstances make sure you understand what you are doing.

Performance

First let’s look at benchmarks running in VirtualBox on MacBook Pro:

Loaded 500 files using regular include() in 0.020308017730713
Loaded 500 files using MemFS in 0.15591597557068
Loaded 500 files using MemFS (10 files at the time) 0.018874883651733
Loaded 500 files using MemFS (250 files at the time) 0.015585899353027
Loaded 500 files using MemFS (500 files at the time) 0.016402959823608

Keep in mind that the laptop in question has SSD drive.

As you can see, when compared directly one for one you might get performance degration but as you scale up and request 10+ files you will see a slight speed increase of about 0.00143313407 seconds.

Not much but this benchmark is not scientific and was performed on a empty machine with SSD drive with no I/O load. Your setup might be different and if you take 0.0014 * requests per seconds your application is processing you might see a benefit of saving 14 seconds per 10000 requests.

Use cases

- Servers that host PHP based applications in a saturated or slow I/O environment. - Distributed applications that constantly update their logic, can be updated by updating memory pool with new code that they will include and evaluate. - Applications that need to load and parse more than 1 file in a consecutive order.

Memcached

For optimal results, make sure server hosting cache pool is hosted on a separate server but shares the LAN with your web servers.

Depending on your load the link between the servers must be greater than 100Mbps.

Make sure to use igBinary with latest version of daemon.

Installation

If you have your own autoloader, simply update namespaces and drop the files into your frameworks library.

For people that do not have that setup, you can visit http://getcomposer.org to install composer on your system. After installation simply run `composer install` in parent directory of this distribution to generate vendor/ directory with a cross system autoloader.

Benchmark

You can benchmark and gauge how much benefit this optimization might bring you by running:

php benchmark/run.php

make sure to run it twice before reading the results so the application can cache files

Grab It

You can grab the source code from my GitHub repository:

https://github.com/AlekseyKorzun/memfs-php

New version of Memcached Wrapper for PHP 5

Fri, 05 Apr 2013 21:55:00 -0400

I updated my Memcached wrapper and moved away from a static approach to a more dynamic approach that supports multiple pools (as some of you requested).

Also the wrapper will now pass any direct methods to the extension, so you get exactly the same functionality as you do using Memcached with a benefit of a smart caching layer.

If you still need a static version of the wrapper you can find it under 0.1 branch.

Change log:

* Abandoned static approach for a cleaner implementation
* Added proper support for multiple pools
* Wrapper for easy interaction with Memcached instance
* Minor documentation and code fixes

Grab your copy here:

http://alekseykorzun.github.io/memcached-wrapper-php

Retrieving default billing and shipping information in Magento

Thu, 28 Feb 2013 12:31:00 -0500

I recently got to play around with Magento (eCommerce platform based on Zend Framework) and had to figure out default billing and shipping information for all of our current clients.

Apparently developer community build around Magento is pretty amateurish judging by technical discussions that are found on their forums.

When I looked up how to retrieve default address information, the answers would all be in a pure PHP code that utilized Magento models to retrieve data.

Thats bloated and frankly plain dumb. Not to mention that some of us do not use PHP for system specific tasks.

In my case I’m using Python so I needed a SQL query that I can run against our Magento database to retrieve required data.

Magento stores data with dozens of relations (very confusing if you are just starting out) and some of relations do not make much sense. They split out entity properties by type (datetime, int, text, etc) and associate each type separately to main entity via id.

Not to mention that address data is considered to be it’s own entity and has it’s indexing outside customers space.

First we have to grab default billing and shipping ids associated to our user accounts:

SELECT 
    `ce`.`email`,
    `default_billing_id`.`value` AS `default_billing`,
    `default_shipping_id`.`value` AS `default_shipping`
FROM
    `customer_entity` AS `ce`
	LEFT JOIN `customer_entity_int` AS `default_billing_id` ON
		(`default_billing_id`.`entity_id` = `ce`.`entity_id`) AND
		(`default_billing_id`.`attribute_id` = '14')
	LEFT JOIN `customer_entity_int` AS `default_shipping_id` ON 
		(`default_shipping_id`.`entity_id` = `ce`.`entity_id`) AND
		(`default_shipping_id`.`attribute_id` = '13')
WHERE
    (`ce`.`entity_type_id` = 1) AND
    (`ce`.`is_active` = 1)

As you can see attribute id of ‘13’ represents default shipping identifier and attribute ‘14’ represents default billing identifier.

Now we need to join across address entity to retrieve actual address information linked to default addresses the user has, in this example I will retrieve default zip code for both billing and shipping address:

SELECT 
    `ce`.`email`,
    `default_billing_id`.`value` AS `default_billing`,
    `default_shipping_id`.`value` AS `default_shipping`,
    `default_billing_zipcode`.`value` AS `default_billing_zipcode`,
    `default_shipping_zipcode`.`value` AS `default_shipping_zipcode`
FROM
    `customer_entity` AS `ce`
	LEFT JOIN `customer_entity_int` AS `default_billing_id` ON
		(`default_billing_id`.`entity_id` = `ce`.`entity_id`) AND
		(`default_billing_id`.`attribute_id` = '14')
	LEFT JOIN `customer_entity_int` AS `default_shipping_id` ON 
		(`default_shipping_id`.`entity_id` = `ce`.`entity_id`) AND
		(`default_shipping_id`.`attribute_id` = '13')
	LEFT JOIN `customer_address_entity_varchar` AS `default_shipping_zipcode` ON 
		(`default_shipping_id`.`value` = `default_shipping_zipcode`.`entity_id`) AND
		(`default_shipping_zipcode`.`attribute_id` = '29')
	LEFT JOIN `customer_address_entity_varchar` AS `default_billing_zipcode` ON 
		(`default_billing_id`.`value` = `default_billing_zipcode`.`entity_id`) AND
		(`default_billing_zipcode`.`attribute_id` = '29')
WHERE
    (`ce`.`entity_type_id` = 1) AND
    (`ce`.`is_active` = 1)

Note that attribute_id’s might vary in your installation. You might consider modifying this query to use attribute labels for a more portable approach.

Feel free to reach out to me if you have any questions.

Simple framework wrapper for Amazon's AWS SDK for PHP 5

Thu, 28 Feb 2013 01:21:00 -0500

If you interact with any of Amazon’s Web Services using PHP you should be using their SDK.

It’s very powerful and pretty simple to get started with.

In my case I did not want to checkout their whole repository into my frameworks namespace and decided to use .phar file they provided as
an alternative.

To me, using a .phar file for third party libraries kind of makes sense if I’m not planning to extend or overwrite any of the available functionality.

Plus if you have your own directory conventions and don’t want to bother re-factoring Amazon’s structure, .phar might come in handy.

The issue I ran into (not really an issue but inconsistency always bothers me as an engineer) is that if you are using namespaces and your own autoloader, requiring .phar file anywhere you need to access AWS is pretty ghetto.

The way I solved it is by using a very simple wrapper that either loads configuration (using \library\configuration as an example) containing your key/secret or takes key/secret as a constructor parameter and simply stores instance of AWS internally while routing all the calls directly to it.

You can check out this approach on my GitHub page located here: https://github.com/AlekseyKorzun/aws-sdk-wrapper

Is this real life?

Tue, 12 Feb 2013 10:13:43 -0500

Is this real life?

Found birthday card I received from my friends at @lot18. Haha...

Mon, 11 Feb 2013 20:24:54 -0500

Found birthday card I received from my friends at @lot18. Haha (at Lot18 HQ)

Thai bag work (by Aleksey Korzun)

Mon, 07 Jan 2013 19:09:04 -0500

Thai bag work (by Aleksey Korzun)

Updated PHP 5 client for Cloud Servers(tm) by Rackspace.

Sat, 18 Aug 2012 17:10:00 -0400

Just a quick announcement that I updated my PHP 5 client for Cloud Servers(tm) API.

Some of the major fixes include retry limiting for authentication requests, support for updated response codes (especially for server/image requests) and better examples.

Code was also updated to conform to PSR-2 and phpDocumentator 2.

Grab the latest version here: http://alekseykorzun.github.io/rackspace-open-cloud-php/

A re-factored plug-n-play PHP 5 client for Twilio's REST API

Fri, 17 Aug 2012 20:14:23 -0400

I have pretty high standards when it comes to code and felt like the current PHP 5 library that Twilio offered did not really fit well with modern frameworks.

So I decided to rewrite it, if you have your own framework and looking for a cleaner Twilio client make sure give this a try.

Features

Direct plug-in-play integration with PHP 5 based frameworks
Namespace utilization, ability to piggy back off your own autoloader
Completely refactored to remove clutter and omit ridiculous constructor inheritance the original package was build with
Various optimizations, no longer pre-loads all of the available actions when an idle instance is created
Cleaner file structure
Single coding standard across all of the components
100% phpDocumentator 2 code coverage
100% PSR2 standard coverage

Find out more at: http://alekseykorzun.github.com/Twilio-PHP-5/

Sorry for not updating my blog, I have been busy doing grown up...

Wed, 28 Dec 2011 12:02:02 -0500

Sorry for not updating my blog, I have been busy doing grown up stuff. Wanted to share some of pictures I recently took of my car with you guys.

Friend and I swapped in 3.15 LSD last month (love it) and minus a leaking power steering line that I will be fixing in a bit the car is flawless mechanically.

The final piece to the puzzle? ESS S/C and a wider stance. Happy holidays!

Q&A: Can you demonstrate how to perform binary search with PHP?

Fri, 29 Jul 2011 20:41:00 -0400

I decided it’s time to start posting (interesting) questions I receive from time to time; today’s question will be about binary search in PHP.

Since it seems that there are multiple of discussions on this subject within Java/C++ community mostly leaving PHP programmers in the dark.

In layman’s terms (using numbers as example) binary search takes an array of sorted numbers, finds the middle number and compares it to the number you want to find.

If middle number is greater then number you passed, it will split array in two take all the numbers on the right of the middle number and use those numbers as a new starting point for splitting until match is found.

Opposite is true if your number is smaller then the middle number within sorted array.

This is pretty fast when dealing with larger data sets and very easy to implement in PHP:

The above is a very basic method for binary searching, you can use it as your own starting point.

By now, you might be thinking: Why should I use this .vs using array_search()?

It’s a very valid concern, the problem with array_search is that it uses a basic O(n) to find matches (http://en.wikipedia.org/wiki/Linear_time#Linear_time).

Which means:

It will perform faster when searching very small data sets.
It might perform faster if you are searching for a value in a begging of your data set.
The larger your data set grows the slower it will be compared to binary search.

As always, benchmarking is the key to figuring out which approach would fit you best when sorting data.

Facebook: Jerry Cain Updated JavaScript SDK and OAuth 2.0 Roadmap

Sun, 24 Jul 2011 14:20:50 -0400

Facebook released updated Roadmap SDK/OAuth 2.0, you can read more about it here: http://developers.facebook.com/blog/post/525/

I will keep a close eye on it, since the change-set will affect my php-sdk patch:

http://alekseykorzun.com/post/6925234287/integrating-facebooks-social-plug-ins-with-facebook-php

Highlights:

July 22:

Updated JavaScript SDK available
Migration setting changes
Renamed “OAuth 2.0 for Canvas” migration to “signed_request for Canvas”
Added new “OAuth Migration” setting
Defaulted all new apps to have “OAuth Migration” setting enabled

July 29:

Updates to PHP SDK to be new-cookie-format aware.

October 1:

All apps to have “OAuth Migration” setting enabled (Revised from Sept. 1)
All apps to have “signed_request for Canvas” setting enabled
SSL Cert required for apps on Facebook (Canvas and Page Tab apps)

We are pleased to announce a set of much anticipated...

Fri, 22 Jul 2011 18:21:00 -0400

New simplified upload form

Ability to combine images into an album

Improved member section

Ability to modify images and albums

Introduction of albums

We are pleased to announce a set of much anticipated improvements.

Upload form UX has been dramatically improved. Upon selection of image a new field will appear for the next selection. By default description/private options are hidden unless decide to upload something. Also when attempting to upload multiple images, the option to combine them into their own album will appear.
A completely new member section, allows image management (edit/deletion), album management (create/edit/delete) and a better interface for your favorites.
URL structure was modified to provide a better linking exprience.
Numerous performance issues and bugs were also addressed.

We welcome your feedback, please send us any bugs or new features you would us to implement.

Like us on Facebook: http://www.facebook.com/imagesocket

Thank you!

High scalability and MySQL's NOW() don't mix

Wed, 20 Jul 2011 16:56:00 -0400

When developers optimize their applications, the usage of NOW() and other dynamic MySQL methods is often overlooked.

The problem with using NOW() (and other identical methods) that the query will always be dynamic, which means that there will be no cache record within the database.

So every single request that invokes dynamic time operations/etc queries will be treated as a completely fresh query.

For example, let’s compare two queries:

SELECT count(1)
  FROM `schedule`
 WHERE `date` <= NOW()

.vs

SELECT count(1)
  FROM `schedule`
 WHERE `date` <= "2011-07-20 16:17:00"

The first query will always be dynamic. So if the first request roughly took 0.03s, the following requests will take exactly the same time.

This is not true for the latter; since the time stamp is static, only initial request will see 0.03s time and you will get a copy of cached result back for every other request.

So that’s great. What is the solution to this? The solution is to have static time stamps that update within specific interval.

For example, if you just replace all NOW()’s with a time stamp that has a hard coded ‘00’ for seconds, you will have a faster web site for any requests (- initial) it receives within a minute.

if (strpos($query, 'NOW()') !== false) {
    $query = str_replace('NOW()', '"'. date('Y-m-d H:i:00') .'"', $query);
}

That works great as a catch all, obviously some queries can (and should) have a longer stamp. For this you can re-use my Interval class:

<?php
namespace Time;

use \DateTime;
use \DateInterval;

/**
 * Provides ability to interval a fluid time stamp.
 *
 * @package Time
 * @license MIT
 * @author Aleksey Korzun <al.ko@webfoundation.net>
 * @link http://alekseykorzun.com/post/7856565665/high-scalability-and-mysqls-now-dont-mix
 * @link http://www.alekseykorzun.com
 */
class Interval
{
	/**
	 * Instance of DateTime
	 *
	 * @var DateTime
	 */
	protected static $date;

	/**
	 * Format used for output, defaults to Y-m-d H:i:s via initialize
	 *
	 * @var string
	 */
	protected static $format;

	/**
	 * Initialize class if it was not previously initialized
	 *
	 * @return void
	 */
	protected static function initialize()
	{
		// Generally we want to base our intervals on a single time stamp
		// per execution. If you have a script that requires a new time stamp
		// for intervals simply remove if wrapper around this code
		if (!self::$date) {
			self::$date = new DateTime();
		}

		if (!self::$format) {
			self::$format = 'Y-m-d H:i:s';
		}
	}

	/**
	 * Switch current time stamp to intervalled version
	 *
	 * @param DateInterval $interval intervals (in minutes) that you wish to break the date out to
	 * @return string processed time stamp
	 */
	public static function minutes(DateInterval $interval)
	{
		self::initialize();

		// Make sure current format supports minutes and interval is valid
		if (!self::hasMinutes() && $interval->i) {
			return false;
		}

		$minutes = (int) (self::$date->format('i') - (self::$date->format('i') % $interval->i));
		if (strlen($minutes) == 1) {
			$minutes = 0 . $minutes;
		}

		// Notice that 's' is converted to 00 within getFormat() method
		return self::$date->format(str_replace('i', $minutes, self::getFormat('s')));
	}

	/**
	 * Return processed version of current time stamp
	 *
	 * @param DateInterval $interval intervals (in seconds) that you wish to break the date out to
	 * @return string processed time stamp
	 */
	public static function seconds(DateInterval $interval)
	{
		self::initialize();

		// Make sure current format supports minutes and interval is valid
		if (!self::hasSeconds() && $interval->s) {
			return false;
		}

		$seconds = (int) (self::$date->format('s') - (self::$date->format('s') % (int) $interval->s));
		if (strlen($seconds) == 1) {
			$seconds = 0 . $seconds;
		}

		return self::$date->format(str_replace('s', $seconds, self::getFormat()));
	}

	/**
	 * Sets new date format
	 *
	 * @see http://www.php.net/manual/en/function.date.php
	 * @param string $format new date format to use
	 * @return void
	 */
	public static function setFormat($format)
	{
		self::$format = (string) $format;
	}

	/**
	 * Retrieves currently set date format with ability to overwrite certain
	 * parts of the date with a static number.
	 *
	 * @param string $swap convert specific format characters to a static '00'
	 * @return string format
	 */
	protected static function getFormat($swap = null)
	{
		if (!is_null($swap)) {
			return str_replace((array) $swap, '00', self::$format);
		}

		return self::$format;
	}

	/**
	 * Checks if current format supports minutes
	 *
	 * @return bool returns true if support is present
	 */
	protected static function hasMinutes()
	{
		return (strpos(self::$format, 'i') !== false);
	}

	/**
	 * Checks if current format supports seconds
	 *
	 * @return bool returns true if seconds are supported
	 */
	protected static function hasSeconds()
	{
		return (bool) (strpos(self::$format, 's') !== false);
	}
}

For example, if you need to update your time stamp every 15 minutes you can do:

$sql = "SELECT count(1)
              FROM `schedule`
           WHERE `date` <= '" . Interval::minutes(new DateInterval('PT15M'))  . "'";

Happy optimizing!

Final revision of Google.com pushed (12:00AM EST)

Thu, 30 Jun 2011 00:19:13 -0400

Google just pushed final revision to their home page and search results. (12:00AM EST)

Integrating Facebook's Social Plug-ins with Facebook's PHP SDK (v.3.0)

Sat, 25 Jun 2011 23:24:47 -0400

I made a quick modification to Facebook’s PHP SDK (v.3.0.0) that seamlessly integrates new token format that Facebook’s social plug-ins utilize.

No need to settle for older (v2.2.x) version of SDK or create dirty work arounds in order to retrieve and pass token data to PHP.

Grab it from: https://github.com/AlekseyKorzun/php-sdk

Here is a diff if you just want to patch v.3.x SDK on your own: https://github.com/AlekseyKorzun/php-sdk/commit/dbb230a8acb9ccfa0b6fa90fcd3caecd3b677dac#L0L315

P.S Facebook will be making changes to authentication system for both JS and PHP SDK’s so keep an eye on their GitHub for further updates.

Why are you still using Facebook's legacy JavaScript SDK?

Sat, 25 Jun 2011 20:23:49 -0400

Usually when developers focus on page load times, things like third party API’s are often overlooked or simply ignored (it works, why should I re-implement this?!).

Today I noticed that one of the web sites I visit still used old Javascript SDK offered by Facebook. To my surprise that seemed to be a very common trend: http://www.google.com/&q=%22Cross-domain+Receiver+Page%22

In some cases, the subjects already use the new SDK (due to integration of social plugins) on top of the legacy SDK.

This is a case of double dipping that will cost you traffic and revenue.

Footprint:

Old SDK loads a total of 5 files in a package that’s roughly 241.93KB in size.

On the other hand the new SDK loads a total of 2 files in a package that’s roughly 125.07KB in size.

That’s almost 50% less data for end user to transfer and 50%+ less requests for their browser to make.

Delivery:

Both versions are hosted on Akamai but there is a difference between the two approaches.

Old:

a1875.g.akamai.net has address 204.0.5.56
a1875.g.akamai.net has address 204.0.5.59

New:

e3821.c.akamaiedge.net has address 184.86.159.139

As you can see the new SDK is hosted on Akamai Edge Platform which is basically a Akamai CDN on steroids.

Akamai’s EdgePlatform is one of the world’s largest distributed computing platforms. It is a network of more than 84,000 secure servers equipped with proprietary software and deployed in 72 countries that relies on applied mathematics and algorithms to help solve congestion and vulnerability problems on the Internet. These servers reside within approximately 1,000 of the world’s networks monitoring the Internet in real time - gathering information about traffic, congestion, and trouble spots. Akamai uses this intelligence to optimize routes and replicate data dynamically to deliver content and applications more quickly, reliably, and securely.

You can read more about it here: http://www.akamai.com/html/technology/edgeplatform.html

Conclusion

Much smaller foot print
Twice as less requests for additional data
Better content delivery platform
Most of the new social plug-ins already use it
The only SDK Facebook actively supports

So go make a switch now, your users will thank you.

phpAudit v1.0

Sat, 25 Jun 2011 02:53:00 -0400

phpAudit is a simple shell script that scans PHP files for possible security risks.

I made this script to speed up verification of third party PHP libraries/code (so a random fork of XYZ API library does not send your credentials to a third-party server via a sneaky method).

Usage:

Make sure script has execution permissions (chmod a+x phpAudit) and simply run: ./phpAudit /path/to/directory/with/php/files/ to begin scanning.

Demo:

./phpAudit library/Facebook/
[:)] Scanning 'library/Facebook/'...
[+] Checking for PHP configuration modifications
[+] Checking for network operations
  [!] Warning: library/Facebook/base_facebook.php
$result = curl_exec($ch); if (curl_errno($ch) == 60) { // CURLE_SSL_CACERT curl_setopt($ch, CURLOPT_CAINFO, $result = curl_exec($ch); 'error_code' => curl_errno($ch), 'message' => curl_error($ch), 'type' => 'CurlException', curl_close($ch); curl_close($ch);
[+] Checking for system operations
  [!]Warning: library/Facebook/base_facebook.php
$result = curl_exec($ch); $result = curl_exec($ch);

Grab the script from here: https://github.com/AlekseyKorzun/phpAudit, might be a little buggy since it was put together at 2 AM :-)

Finally did my first in and out car wash after swapping back my...

Tue, 14 Jun 2011 01:00:25 -0400

Finally did my first in and out car wash after swapping back my Hella tail lights (was missing protective gaskets so I had to settle for my LED’s).

Also I decided to try Armor All wheel protectant (seems to be getting good reviews). A bit pricey but if I don’t have to spend an hour every other weekend to clean my rims it will be a welcome addition to my auto care toolkit.