Slow I/O: Filesystem

Bad:

echo file_get_contents('http://example.org/remote-page.html');
                

Better, with knplabs/Gaufrette

use Gaufrette\Filesystem;
use Gaufrette\Adapter\Ftp as FtpAdapter;
use Gaufrette\Adapter\Local as LocalAdapter;
use Gaufrette\Adapter\Cache as CacheAdapter;

$local = new LocalAdapter($cacheDirectory, true);
$ftp = new FtpAdapter($path, $host, $username, $password, $port);

// Cached Adapter with 3600 seconds time to live
$cachedFtp = new CacheAdapter($ftp, $local, 3600);

$filesystem = new Filesystem($cachedFtp);
                

It could use a pull request for an APC adapter (hint hint)

Slow I/O: DB

Bad:

mysqli_query('SELECT * FROM lala
    WHERE foo LIKE '%foo%'
    OR foo LIKE '%bar%'
    OR bar LIKE '%baz%'
    OR bar LIKE '%foo%'
');
                

Better:

• Use Redis or Memcached to cache results
• If you do use MySQL, enable the slow query log to spot problems
• Offload search to Solr, ElasticSearch or other Lucene

Slow I/O: Emails

Build a queue if you need any kind of reliability, run it with Supervisord:

# /etc/supervisor/conf.d/email-dispatcher.conf

[program:email-dispatcher]
numprocs=1
autostart=true
autorestart=true
startretries=100
user=root
directory=/path/to/symfony/
stdout_logfile=/path/to/symfony/app/logs/email-dispatcher.log
command=/usr/local/bin/php /path/to/symfony/app/console email:send
                

More details in a talk from Jon Wage

Slow I/O: Emails

Best leave the actual sending to a third party (sendgrid, postmark, mailchimp, ..)

General Performance Advice

• Delegate slow operations to background tasks with Redis/Gearman/*MQ
• Profile regularly to see trends and spot problems early

General Performance Advice

Service-Oriented Architecture

What is it?

• The anti-thesis of a monolithic application.
• Build up a platform out of many small applications that talk via APIs
• Services should not trust one another, and be completely sandboxed

General Performance Advice

Service-Oriented Architecture

Why is it good?

• Allows for easy horizontal scaling by scaling every service individually
• Eases up the process of opening APIs to the outside since you already have them for internal use

General Performance Advice

Cache, cache, cache

• Always be careful, invalidation and avoiding conflicts is hard

  $cacheKey = "foo-".$id."-".$lang."-".$isAdmin;
                          

• The less caching layers you have the better, avoid adding complexity
• See microcaching too, 1sec cache + 2sec cookie on POST to avoid stale content after POST issues

Logging considerations

Default configuration

# PROD
monolog:
    handlers:
        main:
            type:         fingers_crossed
            action_level: error
            handler:      nested
        nested:
            type:  stream
            path:  %kernel.logs_dir%/%kernel.environment%.log
            level: debug

# DEV
monolog:
    handlers:
        main:
            type:  stream
            path:  %kernel.logs_dir%/%kernel.environment%.log
            level: debug
        firephp:
            type:  firephp # <-- Did you know?
            level: info
                

Fingers crossed is good for detailed reports in case of errors, but is still wasteful

Logging considerations

Solutions if this is a problem for you:

• Disable MonologBundle in production
• Use a Redis logger (pull request hint)

The Memory Monster: Symfony Profiler

It is disabled in production for a good reason

• If you need it in production, restrict it to some IPs or URLs:

  framework:
      profiler:
          matcher:
              ip: 10.10.10.10 # your static ip
              path: /foo(?:/bar)? # some urls only
                          

The Memory Monster: Symfony Profiler

You can also enable with custom rules by writing your own service:

framework:
    profiler:
        matcher:
            service: my_request_matcher # custom
                

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestMatcherInterface;

class MyMatcher implements RequestMatcherInterface
{
    public function matches(Request $request)
    {
        // custom logic here
    }
}
                

The Memory Monster: Symfony Profiler

• Beware of data collection in cron jobs, make sure you run as:

  $ app/console --env=prod exec:stuff
                          

The Memory Monster: Symfony Profiler

• You could also reconfigure monolog for long-running jobs:

  $ app/console --env=cli exec:lots-of-stuff
  
  # app/config_cli.yml
  monolog:
      handlers:
          main:
              type:         fingers_crossed
              action_level: error
              handler:      nested
              buffer_size:  100 # <--
          nested:
              type:  stream
              path:  %kernel.logs_dir%/%kernel.environment%.log
              level: debug
                          

  CLI has its own log file now, and no more memory issues

Autoload faster with ApcUniversalClassLoader

// app/autoload.php

require __DIR__.'/../vendor/symfony/src/Symfony/'.
    'Component/ClassLoader/ApcUniversalClassLoader.php';

use Symfony\Component\ClassLoader\ApcUniversalClassLoader;

$loader = new ApcUniversalClassLoader('autoloader.');
                

~75% savings, possibly more on complex setups

Note: Make sure the prefix is unique if there are multiple apps on the server

Note: Using the same prefix could be better (less copies of the same files in APC), but risky

Autoload faster with MapClassLoader

// app/autoload.php

require __DIR__.'/../vendor/symfony/src/Symfony/'.
    'Component/ClassLoader/MapClassLoader.php';

use Symfony\Component\ClassLoader\MapClassLoader;

$loader = new MapClassLoader(array(
    'class' => '/path/to/class.php',
));
                

Fastest method, but requires more maintenance

Note: we'd need a pull request for a dumper script symfony/symfony#2407

Dependency Injection gotchas

Make sure instantiation is a cheap as possible

public function __construct($a, $b) {
    $this->a = $a;
    $this->b = $b;
    $this->init();
}

public function getStuff() {
    return $this->stuff;
}
                

public function __construct($a, $b) {
    $this->a = $a;
    $this->b = $b;
}

public function getStuff() {
    if (!$this->initialized) {
        $this->init();
    }

    return $this->stuff;
}
                

Be careful, if you forget to call init() in one of your method, you will likely get weird results

Dependency Injection gotchas

Until it's fixed, SwiftMailer is pretty expensive to inject. Another reason to offload email sending to a CLI worker.

Cache Warming

app/console cache:clear --env=prod --no-debug
                

The above builds a new cache, then swaps it off with the current one and finally removes the old cache.

app/console cache:clear --env=prod --no-debug --no-warmup
                    

Event listener best practices

Listeners can be configured at runtime.

The DIC config is not the right place for conditional listeners.

<tag name="kernel.event_listener" event="security.interactive_login" method="onSecurityInteractiveLogin" />
<tag name="kernel.event_listener" event="kernel.response" method="onKernelResponse" />
                    

public function onSecurityInteractiveLogin(InteractiveLoginEvent $event)
{
    if ($event->getRequest()->checkSomething()) {
        $this->doSomething = true;
    }
}

public function onKernelResponse(FilterResponseEvent $event)
{
    if ($this->doSomething) {
        $event->setResponse(new Response('lala'));
    }
}
                    

Event listener best practices

Wire things at runtime instead:

<tag name="kernel.event_listener" event="security.interactive_login" method="onSecurityInteractiveLogin" />
                

public function onSecurityInteractiveLogin(InteractiveLoginEvent $event)
{
    if ($event->getRequest()->checkSomething()) {
        $this->eventDispatcher->addListener(
            KernelEvents::RESPONSE,
            array($this, 'onKernelResponse')
        );
    }
}

public function onKernelResponse(FilterResponseEvent $event)
{
    $event->setResponse(new Response('lala'));
}
                    

Enable Doctrine Caches

doctrine:
    orm:
        metadata_cache_driver: apc
        query_cache_driver: apc
        result_cache_driver:
            type: memcache
            host: localhost
            port: 1234
                

Using the result cache

$query = $entityManager->createQuery('SELECT * FROM \Entity\Foo f');
$query->useResultCache(true, 86400, 'optional_query_id');
                

Sending proper Cache-Control headers

• public vs private
• s-maxage vs max-age

Cache-Control: public, max-age=3600
Cache-Control: private, max-age=3600, must-revalidate
                

Going further with ESI

Purging cached entries in Varnish:

acl purge {
    "localhost";
    "192.168.0.0/24";
}

sub vcl_recv {
    if (req.request == "PURGE") {
        if (!client.ip ~ purge) {
            error 405 "Not allowed.";
        }
        return (lookup);
    }
}

sub vcl_hit {
    if (req.request == "PURGE") {
        purge;
        error 200 "Purged.";
    }
}

sub vcl_miss {
    if (req.request == "PURGE") {
        purge;
        error 200 "Purged.";
    }
}